code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
Object insertByLeftShift(
int ix,
Object new1)
{
Object old1 = leftMostKey();
leftShift(ix);
_nodeKey[ix] = new1;
if (midPoint() > rightMostIndex())
_nodeKey[midPoint()] = rightMostKey();
return old1;
}
|
java
|
private void leftShift(
int ix)
{
for (int j = 0; j < ix; j++)
_nodeKey[j] = _nodeKey[j+1];
}
|
java
|
Object insertByRightShift(
int ix,
Object new1)
{
Object old1 = null;
if (isFull())
{
old1 = rightMostKey();
rightMove(ix+1);
_nodeKey[ix+1] = new1;
}
else
{
rightShift(ix+1);
_nodeKey[ix+1] = new1;
_population++;
if (midPoint() > rightMostIndex())
_nodeKey[midPoint()] = rightMostKey();
}
return old1;
}
|
java
|
Object addRightMostKey(
Object new1)
{
Object old1 = null;
if (isFull()) /* Node is currently full */
{ /* We will overlay right-most key */
old1 = rightMostKey();
_nodeKey[rightMostIndex()] = new1;
}
else
{
_population++;
_nodeKey[rightMostIndex()] = new1;
if (midPoint() > rightMostIndex())
_nodeKey[midPoint()] = rightMostKey();
}
return old1;
}
|
java
|
void fillFromRight()
{
int gapWid = width() - population();
int gidx = population();
GBSNode p = rightChild();
for (int j = 0; j < gapWid; j++)
_nodeKey[j+gidx] = p._nodeKey[j];
int delta = gapWid;
if (p._population < delta)
delta = p._population;
_population += delta;
p._population -= delta;
for (int j = 0; j < gidx; j++)
p._nodeKey[j] = p._nodeKey[j+gapWid];
}
|
java
|
GBSNode rightMostChild()
{
GBSNode q = this;
GBSNode p = rightChild();
while (p != null)
{
q = p;
p = p.rightChild();
}
return q;
}
|
java
|
private void rightShift(
int ix)
{
for (int j = rightMostIndex(); j >= ix; j--)
_nodeKey[j+1] = _nodeKey[j];
}
|
java
|
private void rightMove(
int ix)
{
for (int j = rightMostIndex()-1; j >= ix; j--)
_nodeKey[j+1] = _nodeKey[j];
}
|
java
|
void overlayLeftShift(
int ix)
{
for (int j = ix; j < rightMostIndex(); j++)
_nodeKey[j] = _nodeKey[j+1];
}
|
java
|
private void overlayRightShift(
int ix)
{
for (int j = ix; j > 0; j--)
_nodeKey[j] = _nodeKey[j-1];
}
|
java
|
GBSNode lowerPredecessor(
NodeStack stack)
{
GBSNode r = leftChild();
GBSNode lastr = r;
if (r != null)
stack.push(NodeStack.PROCESS_CURRENT, this);
while (r != null) /* Find right-most child of left child */
{
if (r.rightChild() != null)
stack.push(NodeStack.DONE_VISITS, r);
lastr = r;
r = r.rightChild();
}
return lastr;
}
|
java
|
public boolean validate()
{
boolean correct = true;
if (population() > 1)
{
java.util.Comparator comp = index().insertComparator();
int xcc = 0;
for (int i = 0; i < population()-1; i++)
{
xcc = comp.compare(_nodeKey[i], _nodeKey[i+1]);
if ( !(xcc < 0) )
{
System.out.println("Entry " + i + " not less than entry " + i+1);
correct = false;
}
}
}
return correct;
}
|
java
|
@Override
public Set<String> getExtensionClasses() {
Set<String> serviceClazzes = new HashSet<>();
if (getType() == ArchiveType.WEB_MODULE) {
Resource webInfClassesMetaInfServicesEntry = getResource(CDIUtils.WEB_INF_CLASSES_META_INF_SERVICES_CDI_EXTENSION);
serviceClazzes.addAll(CDIUtils.parseServiceSPIExtensionFile(webInfClassesMetaInfServicesEntry));
}
Resource metaInfServicesEntry = getResource(CDIUtils.META_INF_SERVICES_CDI_EXTENSION);
serviceClazzes.addAll(CDIUtils.parseServiceSPIExtensionFile(metaInfServicesEntry));
return serviceClazzes;
}
|
java
|
public BeanDiscoveryMode getBeanDiscoveryMode(CDIRuntime cdiRuntime, BeansXml beansXml) {
BeanDiscoveryMode mode = BeanDiscoveryMode.ANNOTATED;
if (beansXml != null) {
mode = beansXml.getBeanDiscoveryMode();
} else if (cdiRuntime.isImplicitBeanArchivesScanningDisabled(this)) {
// If the server.xml has the configuration of enableImplicitBeanArchives sets to false, we will not scan the implicit bean archives
mode = BeanDiscoveryMode.NONE;
}
return mode;
}
|
java
|
@AfterClass
public static void teardownClass() throws Exception {
try {
if (libertyServer != null) {
libertyServer.stopServer("CWIML4537E");
}
} finally {
if (ds != null) {
ds.shutDown(true);
}
}
libertyServer.deleteFileFromLibertyInstallRoot("lib/features/internalfeatures/securitylibertyinternals-1.0.mf");
}
|
java
|
private static void setupLibertyServer() throws Exception {
/*
* Add LDAP variables to bootstrap properties file
*/
LDAPUtils.addLDAPVariables(libertyServer);
Log.info(c, "setUp", "Starting the server... (will wait for userRegistry servlet to start)");
libertyServer.copyFileToLibertyInstallRoot("lib/features", "internalfeatures/securitylibertyinternals-1.0.mf");
libertyServer.addInstalledAppForValidation("userRegistry");
libertyServer.startServer(c.getName() + ".log");
/*
* Make sure the application has come up before proceeding
*/
assertNotNull("Application userRegistry does not appear to have started.",
libertyServer.waitForStringInLog("CWWKZ0001I:.*userRegistry"));
assertNotNull("Security service did not report it was ready",
libertyServer.waitForStringInLog("CWWKS0008I"));
assertNotNull("Server did not came up",
libertyServer.waitForStringInLog("CWWKF0011I"));
Log.info(c, "setUp", "Creating servlet connection the server");
servlet = new UserRegistryServletConnection(libertyServer.getHostname(), libertyServer.getHttpDefaultPort());
if (servlet.getRealm() == null) {
Thread.sleep(5000);
servlet.getRealm();
}
/*
* The original server configuration has no registry or Federated Repository configuration.
*/
emptyConfiguration = libertyServer.getServerConfiguration();
}
|
java
|
private static void setupldapServer() throws Exception {
ds = new InMemoryLDAPServer(SUB_DN);
Entry entry = new Entry(SUB_DN);
entry.addAttribute("objectclass", "top");
entry.addAttribute("objectclass", "domain");
ds.add(entry);
/*
* Add the partition entries.
*/
entry = new Entry("ou=Test,o=ibm,c=us");
entry.addAttribute("objectclass", "organizationalunit");
entry.addAttribute("ou", "Test");
ds.add(entry);
entry = new Entry(USER_BASE_DN);
entry.addAttribute("objectclass", "organizationalunit");
entry.addAttribute("ou", "Test");
entry.addAttribute("ou", "TestUsers");
ds.add(entry);
entry = new Entry(BAD_USER_BASE_DN);
entry.addAttribute("objectclass", "organizationalunit");
entry.addAttribute("ou", "BadUsers");
ds.add(entry);
entry = new Entry("ou=Dev,o=ibm,c=us");
entry.addAttribute("objectclass", "organizationalunit");
entry.addAttribute("ou", "Dev");
ds.add(entry);
entry = new Entry(GROUP_BASE_DN);
entry.addAttribute("objectclass", "organizationalunit");
entry.addAttribute("ou", "Dev");
entry.addAttribute("ou", "DevGroups");
ds.add(entry);
/*
* Create the user and group.
*/
entry = new Entry(USER_DN);
entry.addAttribute("objectclass", "inetorgperson");
entry.addAttribute("uid", USER);
entry.addAttribute("sn", USER);
entry.addAttribute("cn", USER);
entry.addAttribute("userPassword", "password");
ds.add(entry);
entry = new Entry(BAD_USER_DN);
entry.addAttribute("objectclass", "inetorgperson");
entry.addAttribute("uid", BAD_USER);
entry.addAttribute("sn", BAD_USER);
entry.addAttribute("cn", BAD_USER);
entry.addAttribute("userPassword", "password");
ds.add(entry);
entry = new Entry(GROUP_DN);
entry.addAttribute("objectclass", "groupofnames");
entry.addAttribute("cn", GROUP);
entry.addAttribute("member", USER_DN);
entry.addAttribute("member", BAD_USER_DN);
ds.add(entry);
}
|
java
|
private Object syncGetValueFromBucket(FastSyncHashBucket hb, int key, boolean remove) {
FastSyncHashEntry e = null;
FastSyncHashEntry last = null;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "syncGetValueFromBucket: key, remove " + key + " " + remove);
}
synchronized (hb) {
e = hb.root;
while (e != null) {
if (e.key == key) {
if (remove) {
if (last == null) {
// this is root
hb.root = e.next;
} else {
last.next = e.next;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "syncGetValueFromBucket: found value in bucket");
}
return e.value;
}
last = e;
e = e.next;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "syncGetValueFromBucket-returned null");
}
return null;
}
|
java
|
public Object put(int key, Object value) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "put");
}
if (value == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "value == null");
}
throw new NullPointerException("Missing value");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "key " + key);
}
// check the table
FastSyncHashBucket bucket = getBucket(key);
Object retVal = syncGetValueFromBucket(bucket, key, false);
if (retVal != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "put: key is already defined in bucket...returning value from bucket and new key value will be discarded.");
return retVal;
}
// new entry
FastSyncHashEntry e = new FastSyncHashEntry(key, value);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "put: put new key and value into bucket");
}
return syncPutIntoBucket(bucket, e);
}
|
java
|
private Object syncPutIntoBucket(FastSyncHashBucket hb, FastSyncHashEntry newEntry) {
FastSyncHashEntry e = null;
FastSyncHashEntry last = null;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "syncPutIntoBucket");
}
synchronized (hb) {
e = hb.root;
// already in there?
while (e != null) {
if (e.key == newEntry.key) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "syncPutIntoBucket: key/hash pair is already in the bucket");
}
return e.value;
}
last = e;
e = e.next;
}
if (last == null) {
if (hb.root == null) {
// this is root
hb.root = newEntry;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "syncPutIntoBucket: Adding new entry at the beginning (root)");
}
return newEntry.value;
}
last = hb.root;
while (last.next != null) {
last = last.next;
}
}
last.next = newEntry;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "syncPutIntoBucket: Adding new entry at the end");
}
return newEntry.value;
} // end-sync
}
|
java
|
public Object[] getAllEntryValues() {
List<Object> values = new ArrayList<Object>();
FastSyncHashBucket hb = null;
FastSyncHashEntry e = null;
for (int i = 0; i < xVar; i++) {
for (int j = 0; j < yVar; j++) {
hb = mainTable[i][j];
synchronized (hb) {
e = hb.root;
while (e != null) {
values.add(e.value);
e = e.next;
}
}
}
}
return values.toArray();
}
|
java
|
void removeSession(JmsSessionImpl sess) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "removeSession", sess);
synchronized (stateLock) {
// Remove the Session
// Note that this is a synchronized collection.
boolean res = sessions.remove(sess);
// Release the ordering context associated with the session
unusedOrderingContexts.add(sess.getOrderingContext());
if (!res && TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "session not found in list");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "removeSession");
}
|
java
|
protected int getState() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getState");
int tempState;
synchronized (stateLock) {
tempState = state;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getState", state);
return tempState;
}
|
java
|
protected void setState(int newState) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setState", newState);
synchronized (stateLock) {
if ((newState == JmsInternalConstants.CLOSED)
|| (newState == JmsInternalConstants.STOPPED)
|| (newState == JmsInternalConstants.STARTED)) {
state = newState;
stateLock.notifyAll();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setState");
}
|
java
|
protected void checkClosed() throws JMSException {
if (getState() == CLOSED) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "This Connection is closed.");
throw (javax.jms.IllegalStateException) JmsErrorUtils.newThrowable(javax.jms.IllegalStateException.class,
"CONNECTION_CLOSED_CWSIA0021",
null, tc);
}
}
|
java
|
protected void fixClientID() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "fixClientID");
synchronized (stateLock) {
clientIDFixed = true;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "fixClientID");
}
|
java
|
void unfixClientID() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "unfixClientID");
synchronized (stateLock) {
clientIDFixed = false;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "unfixClientID");
}
|
java
|
protected JmsJcaSession createJcaSession(boolean transacted) throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "createJcaSession", transacted);
JmsJcaSession jcaSess = null;
// If we have a JCA connection, then make a JCA session
if (jcaConnection != null) {
try {
jcaSess = jcaConnection.createSession(transacted);
} catch (Exception e) { // ResourceE, IllegalStateE, SIE, SIErrorE
// No FFDC code needed
// d238447 Generate FFDC for these cases.
throw (JMSException) JmsErrorUtils.newThrowable(
JMSException.class,
"JCA_CREATE_SESS_CWSIA0024",
null,
e,
"JmsConnectionImpl.createSession#1",
this,
tc);
}
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "jcaConnection is null, returning null jcaSess");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "createJcaSession", jcaSess);
return jcaSess;
}
|
java
|
protected void addTemporaryDestination(JmsTemporaryDestinationInternal tempDest) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "addTemporaryDestination", System.identityHashCode(tempDest));
synchronized (temporaryDestinations) { // synchronize against removeTemporaryDestination
temporaryDestinations.add(tempDest);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "addTemporaryDestination");
}
|
java
|
protected void removeTemporaryDestination(JmsTemporaryDestinationInternal tempDest) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "removeTemporaryDestination", System.identityHashCode(tempDest));
synchronized (temporaryDestinations) { // synchronize against addTemporaryDestination
temporaryDestinations.remove(tempDest);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "removeTemporaryDestination");
}
|
java
|
public OrderingContext allocateOrderingContext() throws SIConnectionDroppedException, SIConnectionUnavailableException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "allocateOrderingContext");
// Synchronize on the state lock, and either re-use an existing
// unused and open OrderingContext, or create a new one.
OrderingContext oc = null;
synchronized (stateLock) {
while (oc == null && !unusedOrderingContexts.isEmpty()) {
oc = unusedOrderingContexts.remove(0);
if (oc.isProxyConnectionClosed()) {
// Abandon this one.
oc = null;
}
}
if (oc == null) {
oc = coreConnection.createOrderingContext();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "allocateOrderingContext", oc);
return oc;
}
|
java
|
private static void initExceptionThreadPool() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "initExceptionThreadPool");
// Do a synchronous check to ensure once-only creation
synchronized (exceptionTPCreateSync) {
if (exceptionThreadPool == null) {
// Get the maximum size for the thread pool, defaulting if
// not specified or if the value cannot be parsed
int maxThreads = Integer.parseInt(ApiJmsConstants.EXCEPTION_MAXTHREADS_DEFAULT_INT);
String maxThreadsStr = RuntimeInfo.getProperty(ApiJmsConstants.EXCEPTION_MAXTHREADS_NAME_INT,
ApiJmsConstants.EXCEPTION_MAXTHREADS_DEFAULT_INT);
try {
maxThreads = Integer.parseInt(maxThreadsStr);
} catch (NumberFormatException e) {
// No FFDC code needed, but we will exception this
SibTr.exception(tc, e);
}
// Trace the value we will use
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, ApiJmsConstants.EXCEPTION_MAXTHREADS_NAME_INT + ": " + Integer.toString(maxThreads));
// Create the thread pool
exceptionThreadPool = new ThreadPool(ApiJmsConstants.EXCEPTION_THREADPOOL_NAME_INT, 0, maxThreads);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "initExceptionThreadPool");
}
|
java
|
private void addClientId(String clientId) {
//Sometimes the client Id will be null. For instance in the case QueueConnectionFactory, there is no default client Id specified in metatype.xml.
if (clientId == null)
return; //do nothing
ConcurrentHashMap<String, Integer> clientIdTable = JmsFactoryFactoryImpl.getClientIdTable();
if (clientIdTable.containsKey(clientId)) {
clientIdTable.put(clientId, clientIdTable.get(clientId).intValue() + 1);
} else {
clientIdTable.put(clientId, 1);
}
}
|
java
|
private void removeClientId(String clientId) {
//Sometimes the client Id will be null. For instance in the case QueueConnectionFactory, there is no default client Id specified in metatype.xml.
if (clientId == null)
return; //do nothing
ConcurrentHashMap<String, Integer> clientIdTable = JmsFactoryFactoryImpl.getClientIdTable();
if (clientIdTable.containsKey(clientId)) {
int referenceCount = clientIdTable.get(clientId).intValue();
if (referenceCount == 1) {
clientIdTable.remove(clientId);
} else {
clientIdTable.put(clientId, clientIdTable.get(clientId).intValue() - 1);
}
}
}
|
java
|
public void initializeForAroundConstruct(ManagedObjectContext managedObjectContext,
Object[] interceptors, InterceptorProxy[] proxies) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "initializeForAroundConstruct : context = " + managedObjectContext +
" interceptors = " + Arrays.toString(interceptors) + ", proxies = " + Arrays.toString(proxies));
ivBean = null;
ivManagedObjectContext = managedObjectContext;
ivInterceptors = interceptors;
ivInterceptorProxies = proxies;
ivTimer = null;
}
|
java
|
public Object doAroundInvoke(InterceptorProxy[] proxies, Method businessMethod, Object[] parameters, EJSDeployedSupport s) //LIDB3294-41
throws Exception {
ivMethod = businessMethod;
ivParameters = parameters;
ivEJSDeployedSupport = s; //LIDB3294-41
ivInterceptorProxies = proxies;
ivIsAroundConstruct = false;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) // d367572.7
{
Tr.entry(tc, "doAroundInvoke for business method: " + ivMethod.getName());
}
try {
return doAroundInterceptor();
} finally // d367572.8
{
// Let the mapping strategy handle checked and unchecked exceptions
// that occurs since it knows whether to treat unchecked exceptions
// as an application exception or as a system exception.
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) // d415968
{
Tr.exit(tc, "doAroundInvoke for business method: " + ivMethod.getName());
}
ivMethod = null;
ivParameters = null;
}
}
|
java
|
private Object doAroundInterceptor() throws Exception {
// Note, we do not call setParameters since the assumption is the
// wrapper code passes an Object array that always contains the
// correct type. If we want type checking to ensure wrapper
// code is correct, we could call setParameters(parameters) instead
// of just doing assignment here.
ivNextIndex = 0;
ivNumberOfInterceptors = ivInterceptorProxies == null ? 0 : ivInterceptorProxies.length;
ivParametersModified = false; //LIDB3294-41
return proceed();
}
|
java
|
public void doLifeCycle(InterceptorProxy[] proxies, EJBModuleMetaDataImpl mmd) // F743-14982
{
ivMethod = null;
ivParameters = null; // d367572.8
ivInterceptorProxies = proxies;
ivNumberOfInterceptors = ivInterceptorProxies.length;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) // d367572.7
{
Tr.entry(tc, "doLifeCycle, number of interceptors = " + ivNumberOfInterceptors);
}
if (ivNumberOfInterceptors > 0) {
ivNextIndex = 0;
try {
proceed();
} catch (Throwable t) // d415968
{
// FFDCFilter.processException( t, CLASS_NAME + ".doLifeCycle", "260", this );
lifeCycleExceptionHandler(t, mmd); // d367572.7, F743-14982
} finally {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) // d415968
{
Tr.exit(tc, "doLifeCycle");
}
}
}
}
|
java
|
private void lifeCycleExceptionHandler(Throwable t, EJBModuleMetaDataImpl mmd) // F743-14982
{
if (t instanceof RuntimeException) {
// Is the RuntimeException an application exception?
RuntimeException rtex = (RuntimeException) t;
if (mmd.getApplicationExceptionRollback(rtex) != null) // F743-14982
{
// Yes it is, which is not valid for lifecycle callback
// methods. So turn this into a system runtime exception.
InterceptorProxy w = ivInterceptorProxies[ivNextIndex - 1];
String lifeCycle = w.getMethodGenericString();
EJBException ex = ExceptionUtil.EJBException(lifeCycle
+ " is not allowed to throw an application exception", rtex);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "lifeCycleExceptionHandler throwing EJBException", ex);
}
throw ex;
} else {
// Not an application exception, so let the mapping
// strategy handle this system runtime exception.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "lifeCycleExceptionHandler is rethrowing RuntimeException "
+ "from lifecycle callback method: " + t,
t);
}
throw rtex;
}
} else if (t instanceof Error) {
// Let the mapping strategy handle this unchecked exception.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "lifeCycleExceptionHandler is rethrowing Error from "
+ "lifecycle callback method: " + t,
t);
}
throw (Error) t;
} else {
// Must be a checked exception, which should never happen since
// InterceptorMetaDataFactory throws EJBConfigurationException
// and does a Tr.error using message key of INVALID_LIFECYCLE_SIGNATURE_CNTR0231E
// if interceptor method throws clause is not empty. But if
// it does happen, wrap the exception in a special EJBException
// that does not include EJB container in the exception stack.
InterceptorProxy w = ivInterceptorProxies[ivNextIndex - 1]; // d367572.7
String lifeCycle = w.getMethodGenericString(); // d367572.7
EJBException ex = ExceptionUtil.EJBException(lifeCycle
+ " is not allowed to throw a checked exception", t);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) // d367572.7
{
Tr.debug(tc, "lifeCycleExceptionHandler throwing EJBException", ex);
}
throw ex;
}
}
|
java
|
private void throwUndeclaredExceptionCause(Throwable undeclaredException) throws Exception {
Throwable cause = undeclaredException.getCause();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "proceed unwrappering " + undeclaredException.getClass().getSimpleName() + " : " + cause, cause);
// CDI interceptors tend to result in a UndeclaredThrowableException wrapped in an InvocationTargetException
if (cause instanceof UndeclaredThrowableException) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "proceed unwrappering " + cause.getClass().getSimpleName() + " : " + cause, cause.getCause());
cause = cause.getCause();
}
if (cause instanceof RuntimeException) {
// Let the mapping strategy handle this unchecked exception.
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
// Let the mapping strategy handle this unchecked exception.
throw (Error) cause;
} else {
// Probably an application exception occurred, so just throw it. The mapping
// strategy will handle if it turns out not to be an application exception.
throw (Exception) cause;
}
}
|
java
|
protected void setCredentialProvider(ServiceReference<CredentialProvider> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Resetting unauthenticatedSubject as new CredentialProvider has been set");
}
synchronized (unauthenticatedSubjectLock) {
unauthenticatedSubject = null;
}
}
|
java
|
@Override
@FFDCIgnore(Exception.class)
public Subject getUnauthenticatedSubject() {
if (unauthenticatedSubject == null) {
CredentialsService cs = credentialsServiceRef.getService();
String unauthenticatedUserid = cs.getUnauthenticatedUserid();
try {
Subject subject = new Subject();
Hashtable<String, Object> hashtable = new Hashtable<String, Object>();
hashtable.put(AttributeNameConstants.WSCREDENTIAL_SECURITYNAME, unauthenticatedUserid);
hashtable.put(AttributeNameConstants.WSCREDENTIAL_UNIQUEID,
AccessIdUtil.createAccessId(AccessIdUtil.TYPE_USER, getUserRegistryRealm(), unauthenticatedUserid));
subject.getPublicCredentials().add(hashtable);
SecurityService securityService = securityServiceRef.getService();
AuthenticationService authenticationService = securityService.getAuthenticationService();
Subject tempUnauthenticatedSubject = authenticationService.authenticate(JaasLoginConfigConstants.SYSTEM_UNAUTHENTICATED, subject);
tempUnauthenticatedSubject.setReadOnly();
synchronized (unauthenticatedSubjectLock) {
if (unauthenticatedSubject == null) {
unauthenticatedSubject = tempUnauthenticatedSubject;
}
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Internal error creating UNAUTHENTICATED subject.", e);
}
}
}
return unauthenticatedSubject;
}
|
java
|
public void setClientAlias(String alias) throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "setClientAlias", new Object[] { alias });
if (!ks.containsAlias(alias)) {
String keyFileName = config.getProperty(Constants.SSLPROP_KEY_STORE);
String tokenLibraryFile = config.getProperty(Constants.SSLPROP_TOKEN_LIBRARY);
String location = keyFileName != null ? keyFileName : tokenLibraryFile;
String message = TraceNLSHelper.getInstance().getFormattedMessage("ssl.client.alias.not.found.CWPKI0023E", new Object[] { alias, location },
"Client alias " + alias + " not found in keystore.");
Tr.error(tc, "ssl.client.alias.not.found.CWPKI0023E", new Object[] { alias, location });
throw new IllegalArgumentException(message);
}
this.clientAlias = alias;
if (customKM != null && customKM instanceof KeyManagerExtendedInfo)
((KeyManagerExtendedInfo) customKM).setKeyStoreClientAlias(alias);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "setClientAlias");
}
|
java
|
public String chooseClientAlias(String keyType, Principal[] issuers) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "chooseClientAlias", new Object[] { keyType, issuers });
Map<String, Object> connectionInfo = JSSEHelper.getInstance().getOutboundConnectionInfo();
// if SSL client auth is disabled do not return a client alias
if (connectionInfo != null && Constants.ENDPOINT_IIOP.equals(connectionInfo.get(Constants.CONNECTION_INFO_ENDPOINT_NAME))
&& !SSLConfigManager.getInstance().isClientAuthenticationEnabled()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "chooseClientAlias: null");
return null;
} else if (clientAlias != null && !clientAlias.equals("")) {
String[] list = km.getClientAliases(keyType, issuers);
if (list != null) {
boolean found = false;
for (int i = 0; i < list.length && !found; i++) {
if (clientAlias.equalsIgnoreCase(list[i]))
found = true;
}
if (found) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "chooseClientAlias", new Object[] { clientAlias });
// JCERACFKS and JCECCARACFKS support mixed case, if we see that type,
// do not lowercase the alias
if (ks.getType() != null
&& (ks.getType().equals(Constants.KEYSTORE_TYPE_JCERACFKS) || ks.getType().equals(Constants.KEYSTORE_TYPE_JCECCARACFKS) || ks.getType().equals(Constants.KEYSTORE_TYPE_JCEHYBRIDRACFKS))) {
return clientAlias;
}
return clientAlias.toLowerCase();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "chooseClientAlias (default)", new Object[] { clientAlias });
// error case, alias not found in the list.
return clientAlias;
} else {
String[] keyArray = new String[] { keyType };
String alias = km.chooseClientAlias(keyArray, issuers, null);
// JCERACFKS and JCECCARACFKS support mixed case, if we see that type, do
// not lowercase the alias
if (ks.getType() != null
&& (!ks.getType().equals(Constants.KEYSTORE_TYPE_JCERACFKS) && !ks.getType().equals(Constants.KEYSTORE_TYPE_JCECCARACFKS) && !ks.getType().equals(Constants.KEYSTORE_TYPE_JCEHYBRIDRACFKS))) {
if (alias != null) {
alias = alias.toLowerCase();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "chooseClientAlias (from JSSE)", new Object[] { alias });
return alias;
}
}
|
java
|
@Override
public String chooseEngineServerAlias(String keyType, Principal[] issuers, SSLEngine engine) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "chooseEngineServerAlias", new Object[] { keyType, issuers, engine });
String rc = null;
if (null != customKM && customKM instanceof X509ExtendedKeyManager) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "chooseEngineServerAlias, using customKM -> " + customKM.getClass().getName());
rc = ((X509ExtendedKeyManager) customKM).chooseEngineServerAlias(keyType, issuers, engine);
} else {
rc = chooseServerAlias(keyType, issuers);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "chooseEngineServerAlias: " + rc);
return rc;
}
|
java
|
public X509KeyManager getX509KeyManager() {
if (customKM != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getX509KeyManager -> " + customKM.getClass().getName());
return customKM;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getX509KeyManager -> " + km.getClass().getName());
return km;
}
|
java
|
protected static void getAlpnResult(SSLEngine engine, SSLConnectionLink link) {
alpnNegotiator.tryToRemoveAlpnNegotiator(link.getAlpnNegotiator(), engine, link);
}
|
java
|
void metadataProcessingInitialize(ComponentNameSpaceConfiguration nameSpaceConfig)
{
ivContext = (InjectionProcessorContext) nameSpaceConfig.getInjectionProcessorContext();
ivNameSpaceConfig = nameSpaceConfig;
// Following must be available after ivContext and ivNameSpaceConfig are cleared
ivCheckAppConfig = nameSpaceConfig.isCheckApplicationConfiguration();
}
|
java
|
protected void mergeError(Object oldValue,
Object newValue,
boolean xml,
String elementName,
boolean property,
String key) throws InjectionConfigurationException {
JNDIEnvironmentRefType refType = getJNDIEnvironmentRefType();
String component = ivNameSpaceConfig.getDisplayName();
String module = ivNameSpaceConfig.getModuleName();
String application = ivNameSpaceConfig.getApplicationName();
String jndiName = getJndiName();
if (xml) {
Tr.error(tc, "CONFLICTING_XML_VALUES_CWNEN0052E",
component,
module,
application,
elementName,
refType.getXMLElementName(),
refType.getNameXMLElementName(),
jndiName,
oldValue,
newValue);
} else {
Tr.error(tc, "CONFLICTING_ANNOTATION_VALUES_CWNEN0054E",
component,
module,
application,
elementName,
'@' + refType.getAnnotationShortName(),
refType.getNameAnnotationElementName(),
jndiName,
oldValue,
newValue);
}
String exMsg;
if (xml) {
exMsg = "The " + component +
" component in the " + module +
" module of the " + application +
" application has conflicting configuration data in the XML" +
" deployment descriptor. Conflicting " + elementName +
" element values exist for multiple " + refType.getXMLElementName() +
" elements with the same " + refType.getNameXMLElementName() +
" element value : " + jndiName +
". The conflicting " + elementName +
" element values are " + oldValue +
" and " + newValue + ".";
} else {
exMsg = "The " + component +
" component in the " + module +
" module of the " + application +
" application has conflicting configuration data" +
" in source code annotations. Conflicting " + elementName +
" attribute values exist for multiple @" + refType.getAnnotationShortName() +
" annotations with the same " + refType.getNameAnnotationElementName() +
" attribute value : " + jndiName +
". The conflicting " + elementName +
" attribute values are " + oldValue +
" and " + newValue + ".";
}
throw new InjectionConfigurationException(exMsg);
}
|
java
|
protected Boolean mergeAnnotationBoolean(Boolean oldValue,
boolean oldValueXML,
boolean newValue,
String elementName,
boolean defaultValue) throws InjectionConfigurationException {
if (newValue == defaultValue || oldValueXML) {
return oldValue;
}
if (isComplete()) {
mergeError(oldValue, newValue, false, elementName, false, elementName);
return oldValue;
}
// Merge errors cannot occur for boolean attributes because there are
// only two possible values: the default value, for which there is no way
// to detect if it was explicitly specified, and the other value. So, if
// any of the annotations specify the non-default value, we use it.
return newValue;
}
|
java
|
protected Integer mergeAnnotationInteger(Integer oldValue,
boolean oldValueXML,
int newValue,
String elementName,
int defaultValue,
Map<Integer, String> valueNames) throws InjectionConfigurationException {
if (newValue == defaultValue) {
return oldValue;
}
if (oldValueXML) {
return oldValue;
}
if (oldValue == null ? isComplete() : !oldValue.equals(newValue)) {
Object oldValueName = valueNames == null ? oldValue : valueNames.get(oldValue);
Object newValueName = valueNames == null ? newValue : valueNames.get(newValue);
mergeError(oldValueName, newValueName, false, elementName, false, elementName);
return oldValue;
}
return newValue;
}
|
java
|
protected <T> T mergeAnnotationValue(T oldValue,
boolean oldValueXML,
T newValue,
String elementName,
T defaultValue) throws InjectionConfigurationException {
if (newValue.equals(defaultValue) || oldValueXML) { // d663356
return oldValue;
}
if (oldValue == null ? isComplete() : !newValue.equals(oldValue)) {
mergeError(oldValue, newValue, false, elementName, false, elementName);
return oldValue;
}
return newValue;
}
|
java
|
protected <T> T mergeXMLValue(T oldValue,
T newValue,
String elementName,
String key,
Map<T, String> valueNames) throws InjectionConfigurationException {
if (newValue == null) {
return oldValue;
}
if (oldValue != null && !newValue.equals(oldValue)) {
Object oldValueName = valueNames == null ? oldValue : valueNames.get(oldValue);
Object newValueName = valueNames == null ? newValue : valueNames.get(newValue);
mergeError(oldValueName, newValueName, true, elementName, false, key);
return oldValue;
}
return newValue;
}
|
java
|
protected Map<String, String> mergeXMLProperties(Map<String, String> oldProperties,
Set<String> oldXMLProperties,
List<Property> properties) throws InjectionConfigurationException {
if (!properties.isEmpty()) {
if (oldProperties == null) {
oldProperties = new HashMap<String, String>();
}
for (Property property : properties) {
String name = property.getName();
String newValue = property.getValue();
Object oldValue = oldProperties.put(name, newValue);
if (oldValue != null && !newValue.equals(oldValue)) {
mergeError(oldValue, newValue, true, name + " property", true, name);
continue;
}
oldXMLProperties.add(name);
}
}
return oldProperties;
}
|
java
|
protected static <K, V> void addOrRemoveProperty(Map<K, V> props, K key, V value)
{
if (value == null) {
// Generic properties have already been added to the map. Remove them
// so they aren't confused with the builtin properties.
props.remove(key);
} else {
props.put(key, value);
}
}
|
java
|
public Reference createDefinitionReference(String bindingName, String type, Map<String, Object> properties) throws InjectionException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled()) {
Map<String, Object> traceProps = properties;
if (traceProps.containsKey("password")) {
traceProps = new HashMap<String, Object>(properties);
traceProps.put("password", "********");
}
Tr.entry(tc, "createDefinitionReference: bindingName=" + bindingName + ", type=" + type, traceProps);
}
Reference ref;
try {
InternalInjectionEngine injectionEngine = (InternalInjectionEngine) InjectionEngineAccessor.getInstance();
ref = injectionEngine.createDefinitionReference(ivNameSpaceConfig, ivInjectionScope, getJndiName(), bindingName, type, properties);
} catch (Exception ex) {
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "createDefinitionReference", ex);
throw new InjectionException(ex);
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "createDefinitionReference", ref);
return ref;
}
|
java
|
public void setObjects(Object injectionObject, Reference bindingObject)
throws InjectionException
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "setObjects", injectionObject, bindingObjectToString(bindingObject));
ivInjectedObject = injectionObject; // d392996.3
if (bindingObject != null)
{
ivBindingObject = bindingObject;
ivObjectFactoryClassName = bindingObject.getFactoryClassName(); // F48603.4
if (ivObjectFactoryClassName == null) // F54050
{
throw new IllegalArgumentException("expected non-null getFactoryClassName");
}
}
else
{
ivBindingObject = injectionObject;
}
}
|
java
|
public void setReferenceObject(Reference bindingObject,
Class<? extends ObjectFactory> objectFactory)
throws InjectionException
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "setReferenceObject", bindingObjectToString(bindingObject), objectFactory);
ivInjectedObject = null;
ivBindingObject = bindingObject;
ivObjectFactoryClass = objectFactory; // F48603.4
ivObjectFactoryClassName = objectFactory.getName(); // F54050
}
|
java
|
protected Object getInjectionObjectInstance(Object targetObject,
InjectionTargetContext targetContext)
throws Exception
{
ObjectFactory objectFactory = ivObjectFactory; // volatile-read
InjectionObjectFactory injObjFactory = ivInjectionObjectFactory;
if (objectFactory == null)
{
try
{
InternalInjectionEngine ie = InjectionEngineAccessor.getInternalInstance();
objectFactory = ie.getObjectFactory(ivObjectFactoryClassName, ivObjectFactoryClass); // F54050
if (objectFactory instanceof InjectionObjectFactory) // F49213.1
{
injObjFactory = (InjectionObjectFactory) objectFactory;
ivInjectionObjectFactory = injObjFactory;
}
ivObjectFactory = objectFactory; // volatile-write
} catch (Throwable ex)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getInjectionObjectInstance", ex);
Tr.error(tc, "OBJECT_FACTORY_CLASS_FAILED_TO_LOAD_CWNEN0024E", ivObjectFactoryClassName);
throw new InjectionException(ex.toString(), ex);
}
}
if (injObjFactory != null) // F49213.1
{
return injObjFactory.getInjectionObjectInstance((Reference) getBindingObject(),
targetObject, targetContext);
}
return objectFactory.getObjectInstance(getBindingObject(), null, null, null);
}
|
java
|
public final void setJndiName(String jndiName)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() && jndiName.length() != 0)
Tr.debug(tc, "setJndiName: " + jndiName);
// Starting with Java EE 6, reference names may now start with java: and
// then global, app, module, or comp. 'env' is optional, but recommended.
// The set jndiName will always be the 'short' name, to make it consistent
// to prior releases. "java:comp/" without the optional 'env' subcontext
// will be treated specially and will be the full name. d662985.2
ivJndiName = InjectionScope.normalize(jndiName); // d726563
}
|
java
|
public void setInjectionClassType(Class<?> injectionClassType) throws InjectionException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setInjectionClassType: " + injectionClassType);
// if the injection class type hasn't been set yet ( null from XML or
// Object from annotations, the default) then set it.
if (ivInjectionClassType == null ||
ivInjectionClassType == Object.class)
{
ivInjectionClassType = injectionClassType;
}
// If the specified class is a sublcass of the current setting, then
// replace it, otherwise insure it is compatible
else
{
if (ivInjectionClassType.isAssignableFrom(injectionClassType))
{
ivInjectionClassType = injectionClassType;
}
else
{
if (!injectionClassType.isAssignableFrom(ivInjectionClassType))
{
// TODO : Currently this warning will be present for most
// primitives... need to improve this method to
// properly handle primitives, and throw an exception here!
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "WARNING: Class " + injectionClassType +
" is not assignable from " + ivInjectionClassType);
}
}
}
}
|
java
|
public void setInjectionClassTypeName(String name) // F743-32443
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setInjectionClassType: " + name);
if (ivInjectionClassTypeName != null)
{
throw new IllegalStateException("duplicate reference data for " + getJndiName());
}
ivInjectionClassTypeName = name;
}
|
java
|
public static boolean isClassesCompatible(Class<?> memberClass,
Class<?> injectClass)
{
// If the class of the field or method is the injection
// type or a parent of it, then the injection may occur. d433391
if (memberClass.isAssignableFrom(injectClass))
return true;
// TODO : Remove this hack when EJB injection is working properly
// Currently for EJB injection from XML, the 'member' class is
// is always set to 'Object'. d433391
if (injectClass.isAssignableFrom(memberClass))
return true;
// Otherwise, check to see if either is a primitive, and if so,
// verify that the types are compatible.
// TODO : this needs to handle where the primitive types are different
// but may still be compatible... or one is an Object that
// may be autoboxed to a primitive ..like Integer -> short
return getPrimitiveClass(memberClass) == getPrimitiveClass(injectClass);
}
|
java
|
public static Class<?> mostSpecificClass(Class<?> classOne,
Class<?> classTwo)
{
if (classOne.isAssignableFrom(classTwo)) {
return classTwo; // d479669
}
else if (classTwo.isAssignableFrom(classOne)) {
return classOne; // d479669
}
return null;
}
|
java
|
public static String toStringSecure(Annotation ann) {
Class<?> annType = ann.annotationType();
StringBuilder sb = new StringBuilder();
sb.append('@').append(annType.getName()).append('(');
boolean any = false;
for (Method m : annType.getMethods()) {
Object defaultValue = m.getDefaultValue();
if (defaultValue != null) {
String name = m.getName();
Object value;
try {
value = m.invoke(ann);
if (name.equals("password") && !defaultValue.equals(value)) {
value = "********";
} else if (value instanceof Object[]) {
value = Arrays.toString((Object[]) value);
} else {
value = String.valueOf(value);
}
} catch (Throwable t) {
value = "<" + t + ">";
}
if (any) {
sb.append(", ");
} else {
any = true;
}
sb.append(name).append('=').append(value);
}
}
return sb.append(')').toString();
}
|
java
|
@Override
@FFDCIgnore(Exception.class) //manually logged
protected int overQualLastAccessTimeUpdate(BackedSession sess, long nowTime) {
final boolean trace = TraceComponent.isAnyTracingEnabled();
String id = sess.getId();
int updateCount;
try {
if (trace && tc.isDebugEnabled())
tcInvoke(tcSessionMetaCache, "get", id);
synchronized (sess) {
ArrayList<?> oldValue = sessionMetaCache.get(id);
if (trace && tc.isDebugEnabled())
tcReturn(tcSessionMetaCache, "get", oldValue);
SessionInfo sessionInfo = oldValue == null ? null : new SessionInfo(oldValue).clone();
long curAccessTime = sess.getCurrentAccessTime();
if (sessionInfo == null || sessionInfo.getLastAccess() != curAccessTime) {
if (trace && tc.isDebugEnabled())
Tr.debug(this, tc, "session current access time: " + curAccessTime);
updateCount = 0;
} else if (sessionInfo.getLastAccess() >= nowTime) { // avoid setting last access when the cache already has a later time
updateCount = 1; // be consistent with Statement.executeUpdate which returns 1 when the row matches but no changes are made
} else {
sessionInfo.setLastAccess(nowTime);
ArrayList<?> newValue = sessionInfo.getArrayList();
if (trace && tc.isDebugEnabled())
tcInvoke(tcSessionMetaCache, "replace", id, oldValue, newValue);
boolean replaced = sessionMetaCache.replace(id, oldValue, newValue);
if (trace && tc.isDebugEnabled())
tcReturn(tcSessionMetaCache, "replace", replaced);
if (replaced) {
sess.updateLastAccessTime(nowTime);
updateCount = 1;
} else {
updateCount = 0;
}
}
}
} catch(Exception ex) {
FFDCFilter.processException(ex, "com.ibm.ws.session.store.cache.CacheHashMap.overQualLastAccessTimeUpdate", "859", this, new Object[] { sess });
Tr.error(tc, "ERROR_CACHE_ACCESS", ex);
throw new RuntimeException(Tr.formatMessage(tc, "INTERNAL_SERVER_ERROR"));
}
return updateCount;
}
|
java
|
@Trivial
public static String typeToString(MediaType type, List<String> ignoreParams) {
if (type == null) {
throw new IllegalArgumentException("MediaType parameter is null");
}
StringBuilder sb = new StringBuilder();
sb.append(type.getType()).append('/').append(type.getSubtype());
Map<String, String> params = type.getParameters();
if (params != null) {
for (Iterator<Map.Entry<String, String>> iter = params.entrySet().iterator();
iter.hasNext();) {
Map.Entry<String, String> entry = iter.next();
if (ignoreParams != null && ignoreParams.contains(entry.getKey())) {
continue;
}
sb.append(';').append(entry.getKey()).append('=').append(entry.getValue());
}
}
return sb.toString();
}
|
java
|
private static void createHandshakeInstance() throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createHandshakeInstance");
try {
instance = Class.forName(MfpConstants.COMP_HANDSHAKE_CLASS).newInstance();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.ws.sib.mfp.CompHandshakeFactory.createHandshakeInstance", "88");
SibTr.error(tc, "UNABLE_TO_CREATE_COMPHANDSHAKE_CWSIF0051", e);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createHandshakeInstance");
}
|
java
|
synchronized void setProperties(Map<Object, Object> m) throws ChannelFactoryPropertyIgnoredException {
this.myProperties = m;
if (cf != null) {
cf.updateProperties(m);
}
}
|
java
|
synchronized void setProperty(Object key, Object value) throws ChannelFactoryPropertyIgnoredException {
if (null == key) {
throw new ChannelFactoryPropertyIgnoredException("Ignored channel factory property key of null");
}
if (myProperties == null) {
this.myProperties = new HashMap<Object, Object>();
}
this.myProperties.put(key, value);
if (cf != null) {
cf.updateProperties(myProperties);
}
}
|
java
|
synchronized void setChannelFactory(ChannelFactory factory) throws ChannelFactoryException {
if (factory != null && cf != null) {
throw new ChannelFactoryException("ChannelFactory already exists");
}
this.cf = factory;
}
|
java
|
public void dissociate() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "dissociate");
}
if (WSSecurityHelper.isServerSecurityEnabled()) {
J2CSecurityHelper.removeRunAsSubject();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "dissociate");
}
}
|
java
|
public static void validateStatusAtInstanceRestart(long jobInstanceId, Properties restartJobParameters) throws JobRestartException, JobExecutionAlreadyCompleteException {
IPersistenceManagerService iPers = ServicesManagerStaticAnchor.getServicesManager().getPersistenceManagerService();
WSJobInstance jobInstance = iPers.getJobInstance(jobInstanceId);
Helper helper = new Helper(jobInstance, restartJobParameters);
if (!StringUtils.isEmpty(jobInstance.getJobXml())) {
helper.validateRestartableFalseJobsDoNotRestart();
}
helper.validateJobInstanceFailedOrStopped();
}
|
java
|
protected void write(WriteableLogRecord logRecord)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "write", new Object[]{logRecord, this});
// Retrieve the data stored within this data item. This will either come from
// the cached in memory copy or retrieved from disk.
byte[] data = this.getData();
if (tc.isDebugEnabled()) Tr.debug(tc, "Writing '" + data.length + "' bytes " + RLSUtils.toHexString(data,RLSUtils.MAX_DISPLAY_BYTES));
if (tc.isDebugEnabled()) Tr.debug(tc, "Writing length field");
logRecord.putInt(data.length);
// If this data item is using the file backed storage method then we need
// record details of the mapped storage buffer and offset within that buffer
// where the data has been placed. If this is the first write call then the
// information would currently be cached in memory. After this call has
// executed further access will require the getData method to go to disk.
// If this is a subsequent write call then the getData method will retrieve
// the information from the current mapped byte buffer and position and
// write it to the new mapped byte buffer and position. It will then cache
// the new location details.
if (_storageMode == MultiScopeRecoveryLog.FILE_BACKED)
{
if (tc.isDebugEnabled()) Tr.debug(tc, "Updaing data location references");
_filePosition = logRecord.position();
_logRecord = logRecord;
_data = null;
}
if (tc.isDebugEnabled()) Tr.debug(tc, "Writing data field");
logRecord.put(data);
if (!_written)
{
// This is the first time since creation of this object or reset of its internal
// data (SingleData class only, setData method) that the write method has been
// called. We know that the parent recoverable unit section is accounting for
// this data items payload in its unwritten data size. Accordingly we need to
// direct it to update this value.
_rus.payloadWritten(_dataSize + HEADER_SIZE);
}
_written = true;
if (tc.isEntryEnabled()) Tr.exit(tc, "write");
}
|
java
|
protected byte[] getData()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getData", this);
byte[] data = _data;
if (data != null)
{
// There is data cached in memory. Simply use this directly.
if (tc.isDebugEnabled()) Tr.debug(tc, "Cached data located");
}
else
{
if (_storageMode == MultiScopeRecoveryLog.FILE_BACKED)
{
// There is no data cached in memory - it must be retrieved from disk.
if (tc.isDebugEnabled()) Tr.debug(tc, "No cached data located. Attempting data retreival");
// If there is no data cached in memory and we are operating in file
// backed mode then retireve the data from disk.
if (_filePosition != UNWRITTEN)
{
if (tc.isDebugEnabled()) Tr.debug(tc, "Retrieving " + _dataSize + " bytes of data @ position " + _filePosition);
_logRecord.position(_filePosition);
data = new byte[_dataSize];
_logRecord.get(data);
}
else
{
// The data should have been stored on disk but the file position was not set. Return null
// to the caller and allow them to handle this failure.
if (tc.isDebugEnabled()) Tr.debug(tc, "Unable to retrieve data as file position is not set");
}
}
else
{
// The data should have been cached in memory but was not found Return null to the caller and
// allow them to handle this failure.
if (tc.isDebugEnabled()) Tr.debug(tc, "No cached data located");
}
}
if (tc.isEntryEnabled()) Tr.exit(tc, "getData", new Object[]{new Integer(data.length),RLSUtils.toHexString(data,RLSUtils.MAX_DISPLAY_BYTES)});
return data;
}
|
java
|
private UserRegistry getActiveUserRegistry() throws WSSecurityException {
final String METHOD = "getUserRegistry";
UserRegistry activeUserRegistry = null;
try {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, METHOD + " securityServiceRef " + securityServiceRef);
}
SecurityService ss = securityServiceRef.getService();
if (ss == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, METHOD + " No SecurityService, returning null");
}
} else {
UserRegistryService urs = ss.getUserRegistryService();
if (urs == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, METHOD + " No UserRegistryService, returning null");
}
} else {
if (urs.isUserRegistryConfigured()) {
com.ibm.ws.security.registry.UserRegistry userRegistry = urs.getUserRegistry();
activeUserRegistry = urs.getExternalUserRegistry(userRegistry);
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, METHOD + " Security enabled but no registry configured");
}
}
}
}
} catch (RegistryException e) {
String msg = "getUserRegistryWrapper failed due to an internal error: " + e.getMessage();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, msg, e);
}
throw new WSSecurityException(msg, e);
}
return activeUserRegistry;
}
|
java
|
@Override
public synchronized UserTransaction getUserTransaction()
{
// d367572.1 start
if (state == PRE_CREATE)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Incorrect state: " + getStateName(state));
throw new IllegalStateException(getStateName(state));
}
// d367572.1 end
return UserTransactionWrapper.INSTANCE; // d631349
}
|
java
|
@Override
public Map<String, Object> getContextData()
{
// Calling getContextData is not allowed from setSessionContext.
if (state == PRE_CREATE || state == DESTROYED)
{
IllegalStateException ise;
ise = new IllegalStateException("SessionBean: getContextData " +
"not allowed from state = " +
getStateName(state));
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getContextData: " + ise);
throw ise;
}
return super.getContextData();
}
|
java
|
protected void canBeRemoved()
throws RemoveException
{
ContainerTx tx = container.getCurrentContainerTx();//d171654
//-------------------------------------------------------------
// If there is no current transaction then we are removing a
// TX_BEAN_MANAGED session bean outside of a transaction which
// is correct.
//-------------------------------------------------------------
if (tx == null)
{
return;
}
// Stateful beans cannot be removed in a global transaction,
// unless this is an EJB 3.0 business method designated as a
// removemethod d451675
if (tx.isTransactionGlobal() &&
tx.ivRemoveBeanO != this)
{
throw new RemoveException("Cannot remove session bean " +
"within a transaction.");
}
}
|
java
|
@Trivial
private static String toKey(String name, String filter, SearchControls cons) {
int length = name.length() + filter.length() + 100;
StringBuffer key = new StringBuffer(length);
key.append(name);
key.append("|");
key.append(filter);
key.append("|");
key.append(cons.getSearchScope());
key.append("|");
key.append(cons.getCountLimit());
key.append("|");
key.append(cons.getTimeLimit());
String[] attrIds = cons.getReturningAttributes();
if (attrIds != null) {
for (int i = 0; i < attrIds.length; i++) {
key.append("|");
key.append(attrIds[i]);
}
}
return key.toString();
}
|
java
|
@Trivial
private static String toKey(String name, String filterExpr, Object[] filterArgs, SearchControls cons) {
int length = name.length() + filterExpr.length() + filterArgs.length + 200;
StringBuffer key = new StringBuffer(length);
key.append(name);
key.append("|");
key.append(filterExpr);
String[] attrIds = cons.getReturningAttributes();
for (int i = 0; i < filterArgs.length; i++) {
key.append("|");
key.append(filterArgs[i]);
}
if (attrIds != null) {
for (int i = 0; i < attrIds.length; i++) {
key.append("|");
key.append(attrIds[i]);
}
}
return key.toString();
}
|
java
|
public NameParser getNameParser() throws WIMException {
if (iNameParser == null) {
TimedDirContext ctx = iContextManager.getDirContext();
try {
try {
iNameParser = ctx.getNameParser("");
} catch (NamingException e) {
if (!ContextManager.isConnectionException(e)) {
throw e;
}
ctx = iContextManager.reCreateDirContext(ctx, e.toString());
iNameParser = ctx.getNameParser("");
}
} catch (NamingException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)), e);
throw new WIMSystemException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
} finally {
iContextManager.releaseDirContext(ctx);
}
}
return iNameParser;
}
|
java
|
private void initializeCaches(Map<String, Object> configProps) {
final String METHODNAME = "initializeCaches(DataObject)";
/*
* initialize the cache pool names
*/
iAttrsCacheName = iReposId + "/" + iAttrsCacheName;
iSearchResultsCacheName = iReposId + "/" + iSearchResultsCacheName;
List<Map<String, Object>> cacheConfigs = Nester.nest(CACHE_CONFIG, configProps);
Map<String, Object> attrCacheConfig = null;
Map<String, Object> searchResultsCacheConfig = null;
if (!cacheConfigs.isEmpty()) {
Map<String, Object> cacheConfig = cacheConfigs.get(0);
Map<String, List<Map<String, Object>>> cacheInfo = Nester.nest(cacheConfig, ATTRIBUTES_CACHE_CONFIG, SEARCH_CACHE_CONFIG);
List<Map<String, Object>> attrList = cacheInfo.get(ATTRIBUTES_CACHE_CONFIG);
if (!attrList.isEmpty()) {
attrCacheConfig = attrList.get(0);
}
List<Map<String, Object>> searchList = cacheInfo.get(SEARCH_CACHE_CONFIG);
if (!searchList.isEmpty()) {
searchResultsCacheConfig = searchList.get(0);
}
if (attrCacheConfig != null) {
iAttrsCacheEnabled = (Boolean) attrCacheConfig.get(CONFIG_PROP_ENABLED);
if (iAttrsCacheEnabled) {
// Initialize the Attributes Cache size
iAttrsCacheSize = (Integer) attrCacheConfig.get(CONFIG_PROP_CACHE_SIZE);
iAttrsCacheTimeOut = (Long) attrCacheConfig.get(CONFIG_PROP_CACHE_TIME_OUT);
iAttrsSizeLmit = (Integer) attrCacheConfig.get(CONFIG_PROP_ATTRIBUTE_SIZE_LIMIT);
/*
* TODO:: Cache Distribution is not yet needed.
* String cacheDistPolicy = attrCacheConfig.getString(CONFIG_PROP_CACHE_DIST_POLICY);
* if (cacheDistPolicy != null) {
* iAttrsCacheDistPolicy = LdapHelper.getCacheDistPolicyInt(cacheDistPolicy);
* }
*/
}
}
if (searchResultsCacheConfig != null) {
iSearchResultsCacheEnabled = (Boolean) searchResultsCacheConfig.get(CONFIG_PROP_ENABLED);
if (iSearchResultsCacheEnabled) {
// Initialize the Search Results Cache size
iSearchResultsCacheSize = (Integer) searchResultsCacheConfig.get(CONFIG_PROP_CACHE_SIZE);
iSearchResultsCacheTimeOut = (Long) searchResultsCacheConfig.get(CONFIG_PROP_CACHE_TIME_OUT);
iSearchResultSizeLmit = (Integer) searchResultsCacheConfig.get(CONFIG_PROP_SEARCH_RESULTS_SIZE_LIMIT);
/*
* TODO:: Cache Distribution is not yet needed.
* String cacheDistPolicy = searchResultsCacheConfig.getProperties().get(ConfigConstants.CONFIG_PROP_CACHE_DIST_POLICY);
* if (cacheDistPolicy != null) {
* iSearchResultsCacheDistPolicy = LdapHelper.getCacheDistPolicyInt(cacheDistPolicy);
* }
*/
}
}
}
if (iAttrsCacheEnabled) {
createAttributesCache();
if (iAttrsCache == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Attributes Cache: " + iAttrsCacheName + " is not available because cache is not available yet.");
}
}
} else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Attributes Cache: " + iAttrsCacheName + " is disabled.");
}
}
if (iSearchResultsCacheEnabled) {
createSearchResultsCache();
if (iSearchResultsCache == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Search Results Cache: " + iSearchResultsCacheName + " is not available because cache is not available yet.");
}
}
} else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Search Results Cache: " + iSearchResultsCacheName + " is disabled.");
}
}
}
|
java
|
private void createSearchResultsCache() {
final String METHODNAME = "createSearchResultsCache";
if (iSearchResultsCacheEnabled) {
if (FactoryManager.getCacheUtil().isCacheAvailable()) {
iSearchResultsCache = FactoryManager.getCacheUtil().initialize("SearchResultsCache", iSearchResultsCacheSize, iSearchResultsCacheSize, iSearchResultsCacheTimeOut);
if (iSearchResultsCache != null) {
if (tc.isDebugEnabled()) {
StringBuilder strBuf = new StringBuilder(METHODNAME);
strBuf.append(" \nSearch Results Cache: ").append(iSearchResultsCacheName).append(" is enabled:\n");
strBuf.append("\tCacheSize: ").append(iSearchResultsCacheSize).append("\n");
strBuf.append("\tCacheTimeOut: ").append(iSearchResultsCacheTimeOut).append("\n");
strBuf.append("\tCacheResultSizeLimit: ").append(iSearchResultSizeLmit).append("\n");
Tr.debug(tc, strBuf.toString());
}
}
}
}
}
|
java
|
private void createAttributesCache() {
final String METHODNAME = "createAttributesCache";
if (iAttrsCacheEnabled) {
if (FactoryManager.getCacheUtil().isCacheAvailable()) {
iAttrsCache = FactoryManager.getCacheUtil().initialize("AttributesCache", iAttrsCacheSize, iAttrsCacheSize, iAttrsCacheTimeOut);
if (iAttrsCache != null) {
if (tc.isDebugEnabled()) {
StringBuilder strBuf = new StringBuilder(METHODNAME);
strBuf.append(" \nAttributes Cache: ").append(iAttrsCacheName).append(" is enabled:\n");
strBuf.append("\tCacheSize: ").append(iAttrsCacheSize).append("\n");
strBuf.append("\tCacheTimeOut: ").append(iAttrsCacheTimeOut).append("\n");
strBuf.append("\tCacheSizeLimit: ").append(iAttrsSizeLmit).append("\n");
Tr.debug(tc, strBuf.toString());
}
}
}
}
}
|
java
|
public void invalidateAttributes(String DN, String extId, String uniqueName) {
final String METHODNAME = "invalidateAttributes(String, String, String)";
if (getAttributesCache() != null) {
if (DN != null) {
getAttributesCache().invalidate(toKey(DN));
}
if (extId != null) {
getAttributesCache().invalidate(extId);
}
if (uniqueName != null) {
getAttributesCache().invalidate(toKey(uniqueName));
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " " + iAttrsCacheName + " size: " + getAttributesCache().size());
}
}
}
|
java
|
public LdapEntry getEntityByIdentifier(IdentifierType id, List<String> inEntityTypes, List<String> propNames, boolean getMbrshipAttr,
boolean getMbrAttr) throws WIMException {
return getEntityByIdentifier(id.getExternalName(), id.getExternalId(), id.getUniqueName(),
inEntityTypes, propNames, getMbrshipAttr, getMbrAttr);
}
|
java
|
public LdapEntry getEntityByIdentifier(String dn, String extId, String uniqueName, List<String> inEntityTypes,
List<String> propNames, boolean getMbrshipAttr, boolean getMbrAttr) throws WIMException {
String[] attrIds = iLdapConfigMgr.getAttributeNames(inEntityTypes, propNames, getMbrshipAttr, getMbrAttr);
Attributes attrs = null;
if (dn == null && !iLdapConfigMgr.needTranslateRDN()) {
dn = iLdapConfigMgr.switchToLdapNode(uniqueName);
}
// Changed the order of the if-else ladder. Please check against tWAS code for the original order
if (dn != null) {
attrs = checkAttributesCache(dn, attrIds);
} else if (extId != null) {
if (iLdapConfigMgr.isAnyExtIdDN()) {
dn = LdapHelper.getValidDN(extId);
if (dn != null) {
attrs = checkAttributesCache(dn, attrIds);
} else if (uniqueName != null) {
attrs = getAttributesByUniqueName(uniqueName, attrIds, inEntityTypes);
dn = LdapHelper.getDNFromAttributes(attrs);
} else {
String msg = Tr.formatMessage(tc, WIMMessageKey.ENTITY_NOT_FOUND, WIMMessageHelper.generateMsgParms(null));
throw new EntityNotFoundException(WIMMessageKey.ENTITY_NOT_FOUND, msg);
}
} else {
attrs = getAttributesByUniqueName(extId, attrIds, inEntityTypes);
dn = LdapHelper.getDNFromAttributes(attrs);
}
} else if (uniqueName != null) {
attrs = getAttributesByUniqueName(uniqueName, attrIds, inEntityTypes);
dn = LdapHelper.getDNFromAttributes(attrs);
} else {
String msg = Tr.formatMessage(tc, WIMMessageKey.ENTITY_NOT_FOUND, WIMMessageHelper.generateMsgParms(null));
throw new EntityNotFoundException(WIMMessageKey.ENTITY_NOT_FOUND, msg);
}
String entityType = iLdapConfigMgr.getEntityType(attrs, uniqueName, dn, extId, inEntityTypes);
uniqueName = getUniqueName(dn, entityType, attrs);
if (extId == null) {
extId = iLdapConfigMgr.getExtIdFromAttributes(dn, entityType, attrs);
}
LdapEntry ldapEntry = new LdapEntry(dn, extId, uniqueName, entityType, attrs);
return ldapEntry;
}
|
java
|
private String getUniqueName(String dn, String entityType, Attributes attrs) throws WIMException {
final String METHODNAME = "getUniqueName";
String uniqueName = null;
dn = iLdapConfigMgr.switchToNode(dn);
if (iLdapConfigMgr.needTranslateRDN() && iLdapConfigMgr.needTranslateRDN(entityType)) {
try {
if (entityType != null) {
LdapEntity ldapEntity = iLdapConfigMgr.getLdapEntity(entityType);
if (ldapEntity != null) {
String[] rdnName = LdapHelper.getRDNAttributes(dn);
String[][] rdnWIMProps = ldapEntity.getWIMRDNProperties();
String[][] rdnWIMAttrs = ldapEntity.getWIMRDNAttributes();
String[][] rdnAttrs = ldapEntity.getRDNAttributes();
Attribute[] rdnAttributes = new Attribute[rdnWIMProps.length];
String[] rdnAttrValues = new String[rdnWIMProps.length];
for (int i = 0; i < rdnAttrs.length; i++) {
String[] rdnAttr = rdnAttrs[i];
boolean isRDN = true;
for (int j = 0; j < rdnAttr.length; j++) {
if (!rdnAttr[j].equalsIgnoreCase(rdnName[j])) {
isRDN = false;
}
}
if (isRDN) {
String[] rdnWIMProp = rdnWIMProps[i];
String[] rdnWIMAttr = rdnWIMAttrs[i];
boolean retrieveRDNs = false;
if (attrs == null) {
retrieveRDNs = true;
} else {
for (int k = 0; k < rdnWIMAttr.length; k++) {
if (attrs.get(rdnWIMAttr[k]) == null) {
retrieveRDNs = true;
break;
}
}
}
if (retrieveRDNs) {
attrs = getAttributes(dn, rdnWIMAttr);
}
for (int k = 0; k < rdnWIMAttr.length; k++) {
rdnAttributes[k] = attrs.get(rdnWIMAttr[k]);
if (rdnAttributes[k] != null) {
rdnAttrValues[k] = (String) rdnAttributes[k].get();
}
}
uniqueName = LdapHelper.replaceRDN(dn, rdnWIMProp, rdnAttrValues);
}
}
}
}
} catch (NamingException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)));
throw new WIMSystemException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
}
}
if (uniqueName == null) {
uniqueName = dn;
} else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Translated uniqueName: " + uniqueName);
}
}
return uniqueName;
}
|
java
|
@FFDCIgnore({ NamingException.class, NameNotFoundException.class })
private Attributes getAttributes(String name, String[] attrIds) throws WIMException {
Attributes attributes = null;
if (iLdapConfigMgr.getUseEncodingInSearchExpression() != null)
name = LdapHelper.encodeAttribute(name, iLdapConfigMgr.getUseEncodingInSearchExpression());
if (iAttrRangeStep > 0) {
attributes = getRangeAttributes(name, attrIds);
} else {
TimedDirContext ctx = iContextManager.getDirContext();
try {
try {
if (attrIds.length > 0) {
attributes = ctx.getAttributes(new LdapName(name), attrIds);
} else {
attributes = new BasicAttributes();
}
} catch (NamingException e) {
if (!ContextManager.isConnectionException(e)) {
throw e;
}
ctx = iContextManager.reCreateDirContext(ctx, e.toString());
if (attrIds.length > 0) {
attributes = ctx.getAttributes(new LdapName(name), attrIds);
} else {
attributes = new BasicAttributes();
}
}
} catch (NameNotFoundException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.LDAP_ENTRY_NOT_FOUND, WIMMessageHelper.generateMsgParms(name, e.toString(true)));
throw new EntityNotFoundException(WIMMessageKey.LDAP_ENTRY_NOT_FOUND, msg, e);
} catch (NamingException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)));
throw new WIMSystemException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
} finally {
iContextManager.releaseDirContext(ctx);
}
}
return attributes;
}
|
java
|
public Attributes checkAttributesCache(String name, String[] attrIds) throws WIMException {
final String METHODNAME = "checkAttributesCache";
Attributes attributes = null;
// If attribute cache is available, look up cache first
if (getAttributesCache() != null) {
String key = toKey(name);
Object cached = getAttributesCache().get(key);
// Cache entry found
if (cached != null && (cached instanceof Attributes)) {
List<String> missAttrIdList = new ArrayList<String>(attrIds.length);
Attributes cachedAttrs = (Attributes) cached;
attributes = new BasicAttributes(true);
for (int i = 0; i < attrIds.length; i++) {
Attribute attr = LdapHelper.getIngoreCaseAttribute(cachedAttrs, attrIds[i]);
if (attr != null) {
attributes.put(attr);
} else {
missAttrIdList.add(attrIds[i]);
}
}
// If no missed attributes, nothing need to do.
// Otherwise, retrieve missed attributes and add back to cache
if (missAttrIdList.size() > 0) {
String[] missAttrIds = missAttrIdList.toArray(new String[0]);
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Miss cache: " + key + " " + WIMTraceHelper.printObjectArray(missAttrIds));
}
Attributes missAttrs = getAttributes(name, missAttrIds);
// Add missed attributes to attributes.
addAttributes(missAttrs, attributes);
// Add missed attributes to cache.
updateAttributesCache(key, missAttrs, cachedAttrs, missAttrIds);
} else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Hit cache: " + key);
}
}
}
// No cache entry, call LDAP to retrieve all request attributes.
else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Miss cache: " + key);
}
attributes = getAttributes(name, attrIds);
// Add attributes to cache.
updateAttributesCache(key, attributes, null, attrIds);
}
} else {
// Attribute cache is not available, directly call LDAP server
attributes = getAttributes(name, attrIds);
}
return attributes;
}
|
java
|
private void updateAttributesCache(String uniqueNameKey, String dn, Attributes newAttrs, String[] attrIds) {
final String METHODNAME = "updateAttributesCache(key,dn,newAttrs)";
/*
* Add uniqueName to DN mapping to cache
*/
getAttributesCache().put(uniqueNameKey, dn, 1, iAttrsCacheTimeOut, 0, null);
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Update " + iAttrsCacheName + "(size: "
+ getAttributesCache().size() + ")\n" + uniqueNameKey + ": " + dn);
}
/*
* Add the DN to Attributes mapping to the cache.
*/
String dnKey = toKey(dn);
Object cached = getAttributesCache().get(dnKey);
Attributes cachedAttrs = null;
if (cached != null && cached instanceof Attributes) {
cachedAttrs = (Attributes) cached;
}
updateAttributesCache(dnKey, newAttrs, cachedAttrs, attrIds);
}
|
java
|
private void updateAttributesCache(String key, Attributes missAttrs, Attributes cachedAttrs, String[] missAttrIds) {
final String METHODNAME = "updateAttributesCache(key,missAttrs,cachedAttrs,missAttrIds)";
if (missAttrIds != null) {
boolean newattr = false; // differentiate between a new entry and an entry we'll update so we change the cache correctly and maintain the creation TTL.
if (missAttrIds.length > 0) {
if (cachedAttrs != null) {
cachedAttrs = (Attributes) cachedAttrs.clone();
} else {
cachedAttrs = new BasicAttributes(true);
newattr = true;
}
for (int i = 0; i < missAttrIds.length; i++) {
boolean findAttr = false;
for (NamingEnumeration<?> neu = missAttrs.getAll(); neu.hasMoreElements();) {
Attribute attr = (Attribute) neu.nextElement();
if (attr.getID().equalsIgnoreCase(missAttrIds[i])) {
findAttr = true;
// If the size of the attributes is larger than the
// limit, do not cache it.
if (!(iAttrsSizeLmit > 0 && attr.size() > iAttrsSizeLmit)) {
cachedAttrs.put(attr);
}
break;
} else {
int pos = attr.getID().indexOf(";");
if (pos > 0 && missAttrIds[i].equalsIgnoreCase(attr.getID().substring(0, pos))) {
findAttr = true;
// If the size of the attributes is larger than
// the limit, do not cache it.
if (!(iAttrsSizeLmit > 0 && attr.size() > iAttrsSizeLmit)) {
cachedAttrs.put(attr);
}
break;
}
}
}
if (!findAttr) {
Attribute nullAttr = new BasicAttribute(missAttrIds[i], null);
cachedAttrs.put(nullAttr);
}
}
if (newattr) { // only set the the TTL if we're putting in a new entry
getAttributesCache().put(key, cachedAttrs, 1, iAttrsCacheTimeOut, 0, null);
} else {
getAttributesCache().put(key, cachedAttrs);
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Update " + iAttrsCacheName + "(size: " + getAttributesCache().size() + " newEntry: " + newattr + ")\n" + key
+ ": " + cachedAttrs);
}
}
} else {
updateAttributesCache(key, missAttrs, cachedAttrs);
}
}
|
java
|
private void updateAttributesCache(String key, Attributes missAttrs, Attributes cachedAttrs) {
final String METHODNAME = "updateAttributeCache(key,missAttrs,cachedAttrs)";
if (missAttrs.size() > 0) {
boolean newAttr = false; // differentiate between a new entry and an entry we'll update so we change the cache correctly and maintain the creation TTL.
if (cachedAttrs != null) {
cachedAttrs = (Attributes) cachedAttrs.clone();
} else {
cachedAttrs = new BasicAttributes(true);
newAttr = true;
}
//Set extIdAttrs = iLdapConfigMgr.getExtIds();
for (NamingEnumeration<?> neu = missAttrs.getAll(); neu.hasMoreElements();) {
Attribute attr = (Attribute) neu.nextElement();
// If the size of the attributes is larger than the limit, don not cache it.
if (!(iAttrsSizeLmit > 0 && attr.size() > iAttrsSizeLmit)) {
cachedAttrs.put(attr);
}
}
if (newAttr) {
getAttributesCache().put(key, cachedAttrs, 1, iAttrsCacheTimeOut, 0, null);
} else {
getAttributesCache().put(key, cachedAttrs);
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Update " + iAttrsCacheName + "(size: " + getAttributesCache().size() + " newEntry: " + newAttr + ")\n" + key + ": " + cachedAttrs);
}
}
}
|
java
|
private NamingEnumeration<SearchResult> checkSearchCache(String name, String filterExpr, Object[] filterArgs, SearchControls cons) throws WIMException {
final String METHODNAME = "checkSearchCache";
NamingEnumeration<SearchResult> neu = null;
if (getSearchResultsCache() != null) {
String key = null;
if (filterArgs == null) {
key = toKey(name, filterExpr, cons);
} else {
key = toKey(name, filterExpr, filterArgs, cons);
}
CachedNamingEnumeration cached = (CachedNamingEnumeration) getSearchResultsCache().get(key);
if (cached == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Miss cache: " + key);
}
neu = search(name, filterExpr, filterArgs, cons, null);
String[] reqAttrIds = cons.getReturningAttributes();
neu = updateSearchCache(name, key, neu, reqAttrIds);
} else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " Hit cache: " + key);
}
neu = (CachedNamingEnumeration) cached.clone();
}
} else {
neu = search(name, filterExpr, filterArgs, cons, null);
}
return neu;
}
|
java
|
@FFDCIgnore(NamingException.class)
private NamingEnumeration<SearchResult> updateSearchCache(String searchBase, String key, NamingEnumeration<SearchResult> neu,
String[] reqAttrIds) throws WIMSystemException {
final String METHODNAME = "updateSearchCache";
CachedNamingEnumeration clone1 = new CachedNamingEnumeration();
CachedNamingEnumeration clone2 = new CachedNamingEnumeration();
int count = cloneSearchResults(neu, clone1, clone2);
// Size limit 0 means no limit.
if (iSearchResultSizeLmit == 0 || count < iSearchResultSizeLmit) {
getSearchResultsCache().put(key, clone2, 1, iSearchResultsCacheTimeOut, 0, null);
if (tc.isDebugEnabled())
Tr.debug(tc, METHODNAME + " Update " + iSearchResultsCacheName + "(size: " + getSearchResultsCache().size() + ")\n" + key);
// To reduce JNDI calls during get(), cache the entry into attribute cache
if (getAttributesCache() != null) {
try {
count = 0;
while (clone2.hasMore()) {
SearchResult result = clone2.nextElement();
String dnKey = LdapHelper.prepareDN(result.getName(), searchBase);
Object cached = getAttributesCache().get(dnKey);
Attributes cachedAttrs = null;
if (cached != null && cached instanceof Attributes) {
cachedAttrs = (Attributes) cached;
}
updateAttributesCache(dnKey, result.getAttributes(), cachedAttrs, reqAttrIds);
if (++count > 20) {
// cache only first 20 results from the search.
// caching all entries may thrash the attributeCache
if (tc.isDebugEnabled())
Tr.debug(tc, METHODNAME + " attribute cache updated with " + (count - 1) + " entries. skipping rest.");
break;
}
}
} catch (NamingException e) {
/* Ignore. */
}
}
}
return clone1;
}
|
java
|
public Map<String, LdapEntry> getDynamicGroups(String bases[], List<String> propNames, boolean getMbrshipAttr) throws WIMException {
Map<String, LdapEntry> dynaGrps = new HashMap<String, LdapEntry>();
String[] attrIds = iLdapConfigMgr.getAttributeNames(iLdapConfigMgr.getGroupTypes(), propNames, getMbrshipAttr, false);
String[] dynaMbrAttrNames = iLdapConfigMgr.getDynamicMemberAttributes();
String[] temp = attrIds;
attrIds = new String[temp.length + dynaMbrAttrNames.length];
System.arraycopy(temp, 0, attrIds, 0, temp.length);
System.arraycopy(dynaMbrAttrNames, 0, attrIds, temp.length, dynaMbrAttrNames.length);
String dynaGrpFitler = iLdapConfigMgr.getDynamicGroupFilter();
for (int i = 0, n = bases.length; i < n; i++) {
String base = bases[i];
for (NamingEnumeration<SearchResult> urls = search(base, dynaGrpFitler, SearchControls.SUBTREE_SCOPE, attrIds); urls.hasMoreElements();) {
javax.naming.directory.SearchResult thisEntry = urls.nextElement();
if (thisEntry == null) {
continue;
}
String entryName = thisEntry.getName();
if (entryName == null || entryName.trim().length() == 0) {
continue;
}
String dn = LdapHelper.prepareDN(entryName, base);
javax.naming.directory.Attributes attrs = thisEntry.getAttributes();
String extId = iLdapConfigMgr.getExtIdFromAttributes(dn, SchemaConstants.DO_GROUP, attrs);
String uniqueName = getUniqueName(dn, SchemaConstants.DO_GROUP, attrs);
LdapEntry ldapEntry = new LdapEntry(dn, extId, uniqueName, SchemaConstants.DO_GROUP, attrs);
dynaGrps.put(ldapEntry.getDN(), ldapEntry);
}
}
return dynaGrps;
}
|
java
|
public boolean isMemberInURLQuery(LdapURL[] urls, String dn) throws WIMException {
boolean result = false;
String[] attrIds = {};
String rdn = LdapHelper.getRDN(dn);
if (urls != null) {
for (int i = 0; i < urls.length; i++) {
LdapURL ldapURL = urls[i];
if (ldapURL.parsedOK()) {
String searchBase = ldapURL.get_dn();
// If dn is not under base, no need to do search
if (LdapHelper.isUnderBases(dn, searchBase)) {
int searchScope = ldapURL.get_searchScope();
String searchFilter = ldapURL.get_filter();
if (searchScope == SearchControls.SUBTREE_SCOPE) {
if (searchFilter == null) {
result = true;
break;
} else {
NamingEnumeration<SearchResult> nenu = search(dn, searchFilter, SearchControls.SUBTREE_SCOPE, attrIds);
if (nenu.hasMoreElements()) {
result = true;
break;
}
}
} else {
if (searchFilter == null) {
searchFilter = rdn;
} else {
searchFilter = "(&(" + searchFilter + ")(" + rdn + "))";
}
NamingEnumeration<SearchResult> nenu = search(searchBase, searchFilter, searchScope, attrIds);
if (nenu.hasMoreElements()) {
SearchResult thisEntry = nenu.nextElement();
if (thisEntry == null) {
continue;
}
String returnedDN = LdapHelper.prepareDN(thisEntry.getName(), searchBase);
if (dn.equalsIgnoreCase(returnedDN)) {
result = true;
break;
}
}
}
}
}
}
}
return result;
}
|
java
|
public SearchResult searchByOperationalAttribute(String dn, String filter, List<String> inEntityTypes, List<String> propNames, String oprAttribute) throws WIMException {
String inEntityType = null;
List<String> supportedProps = propNames;
if (inEntityTypes != null && inEntityTypes.size() > 0) {
inEntityType = inEntityTypes.get(0);
supportedProps = iLdapConfigMgr.getSupportedProperties(inEntityType, propNames);
}
String[] attrIds = iLdapConfigMgr.getAttributeNames(inEntityTypes, supportedProps, false, false);
attrIds = Arrays.copyOf(attrIds, attrIds.length + 1);
attrIds[attrIds.length - 1] = oprAttribute;
NamingEnumeration<SearchResult> neu = null;
neu = search(dn, filter, SearchControls.OBJECT_SCOPE, attrIds, iCountLimit, iTimeLimit);
if (neu != null) {
try {
if (neu.hasMore()) {
return neu.next();
}
} catch (NamingException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)));
throw new WIMSystemException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
}
}
return null;
}
|
java
|
private String getBinaryAttributes() {
// Add binary settings for all octet string attributes.
StringBuffer binaryAttrNamesBuffer = new StringBuffer();
// Check the ldap data type of the extId attribute.
Map<String, LdapAttribute> attrMap = iLdapConfigMgr.getAttributes();
for (String attrName : attrMap.keySet()) {
LdapAttribute attr = attrMap.get(attrName);
if (LdapConstants.LDAP_ATTR_SYNTAX_OCTETSTRING.equalsIgnoreCase(attr.getSyntax())) {
binaryAttrNamesBuffer.append(attr.getName()).append(" ");
}
}
return binaryAttrNamesBuffer.toString().trim();
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.