code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
private SSLSocketFactory getSocketFactory(String id) throws IOException {
// first use?
SSLSocketFactory socketFactory = socketFactoryMap.get(id);
if (socketFactory == null) {
// the SSLConfig is optional, so if it's not there, use the default SSLSocketFactory.
if (id == null) {
socketFactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
} else {
// ask the SSLConfig bean to create a factory for us.
try {
socketFactory = sslConfig.createSSLFactory(id);
} catch (Exception e) {
Tr.error(tc, "Unable to create client SSL socket factory", e);
throw (IOException) new IOException("Unable to create client SSL socket factory: " + e.getMessage()).initCause(e);
}
}
socketFactoryMap.put(id, socketFactory);
}
return socketFactory;
} | java |
private SSLServerSocketFactory getServerSocketFactory(String id) throws IOException {
// first use?
SSLServerSocketFactory serverSocketFactory = serverSocketFactoryMap.get(id);
if (serverSocketFactory == null) {
// the SSLConfig is optional, so if it's not there, use the default SSLSocketFactory.
if (id == null) {
serverSocketFactory = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
} else {
try {
serverSocketFactory = sslConfig.createSSLServerFactory(id);
} catch (Exception e) {
Tr.error(tc, "Unable to create server SSL socket factory", e);
throw (IOException) new IOException("Unable to create server SSL socket factory: " + e.getMessage()).initCause(e);
}
serverSocketFactoryMap.put(id, serverSocketFactory);
}
// There's a bit of a timing problem with server-side ORBs. Part of the ORB shutdown is to
// establish a self-connection to shutdown the acceptor threads. This requires a client
// SSL socket factory. Unfortunately, if this is occurring during server shutdown, the
// FileKeystoreManager will get a NullPointerException because some name queries fail because
// things are getting shutdown. Therefore, if we need the server factory, assume we'll also
// need the client factory to shutdown, and request it now.
getSocketFactory(id);
}
return serverSocketFactory;
} | java |
private void configureServerSocket(SSLServerSocket serverSocket, SSLServerSocketFactory serverSocketFactory, String sslConfigName, OptionsKey options) throws IOException {
try {
String[] cipherSuites = sslConfig.getCipherSuites(sslConfigName, serverSocketFactory.getSupportedCipherSuites());
serverSocket.setEnabledCipherSuites(cipherSuites);
// set the SSL protocol on the server socket
String protocol = sslConfig.getSSLProtocol(sslConfigName);
if (protocol != null)
serverSocket.setEnabledProtocols(new String[] {protocol});
boolean clientAuthRequired = ((options.requires & EstablishTrustInClient.value) == EstablishTrustInClient.value);
boolean clientAuthSupported = ((options.supports & EstablishTrustInClient.value) == EstablishTrustInClient.value);
if (clientAuthRequired) {
serverSocket.setNeedClientAuth(true);
} else if (clientAuthSupported) {
serverSocket.setWantClientAuth(true);
} else {
serverSocket.setNeedClientAuth(false); //could set want with the same effect
}
serverSocket.setSoTimeout(60 * 1000);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.debug(tc, "Created SSL server socket on port " + serverSocket.getLocalPort());
Tr.debug(tc, " client authentication " + (clientAuthSupported ? "SUPPORTED" : "UNSUPPORTED"));
Tr.debug(tc, " client authentication " + (clientAuthRequired ? "REQUIRED" : "OPTIONAL"));
Tr.debug(tc, " cipher suites:");
for (int i = 0; i < cipherSuites.length; i++) {
Tr.debug(tc, " " + cipherSuites[i]);
}
}
} catch (SSLException e) {
throw new IOException("Could not configure server socket", e);
}
} | java |
private Collection<String> getRolesForSpecialSubject(String resourceName, String specialSubject) {
int found = 0;
Collection<String> roles = null;
FeatureAuthorizationTableService featureAuthzTableSvc = featureAuthzTableServiceRef.getService();
String featureAuthzRoleHeaderValue = null;
if (featureAuthzTableSvc != null) {
featureAuthzRoleHeaderValue = featureAuthzTableSvc.getFeatureAuthzRoleHeaderValue();
}
if (featureAuthzRoleHeaderValue != null &&
!featureAuthzRoleHeaderValue.equals(MGMT_AUTHZ_ROLES)) {
roles = featureAuthzTableSvc.getRolesForSpecialSubject(resourceName, specialSubject);
} else {
Iterator<AuthorizationTableService> itr = authorizationTables.getServices();
while (itr.hasNext()) {
AuthorizationTableService authzTableSvc = itr.next();
Collection<String> rolesFound = authzTableSvc.getRolesForSpecialSubject(resourceName, specialSubject);
if (rolesFound != null) {
roles = rolesFound;
found++;
}
}
// We must find one, and only one, Collection of roles
if (found > 1) {
Tr.error(tc, "AUTHZ_MULTIPLE_RESOURCES_WITH_SAME_NAME", resourceName);
roles = null;
}
}
return roles;
} | java |
private boolean isSubjectAuthorized(String resourceName,
Collection<String> requiredRoles, Subject subject) {
AccessDecisionService accessDecisionService = accessDecisionServiceRef.getService();
// check user access first
boolean isGranted = false;
WSCredential wsCred = getWSCredentialFromSubject(subject);
String accessId = getAccessId(wsCred);
// if (useRoleAsGroupName && !isAuthzInfoAvailableForApp(resourceName) && !resourceName.equalsIgnoreCase(ADMIN_RESOURCE_NAME)) {
if (useRoleAsGroupName && !isAuthzInfoAvailableForApp(resourceName)) {
isGranted = useRoleAsGroupNameForAccessDecision(resourceName, requiredRoles, subject, accessDecisionService, wsCred);
} else {
isGranted = useAppBndForAccessDecision(resourceName, requiredRoles, subject, accessDecisionService, wsCred, accessId);
}
return isGranted;
} | java |
private WSCredential getWSCredentialFromSubject(Subject subject) {
if (subject != null) {
java.util.Collection<Object> publicCreds = subject.getPublicCredentials();
if (publicCreds != null && publicCreds.size() > 0) {
java.util.Iterator<Object> publicCredIterator = publicCreds.iterator();
while (publicCredIterator.hasNext()) {
Object cred = publicCredIterator.next();
if (cred instanceof WSCredential) {
return (WSCredential) cred;
}
}
}
}
return null;
} | java |
private String getAccessId(WSCredential cred) {
String accessId = null;
try {
accessId = cred.getAccessId();
} catch (CredentialExpiredException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Caught exception getting the access id: " + e);
}
} catch (CredentialDestroyedException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Caught exception getting the access id: " + e);
}
}
// TODO if ignoreCase is Collection, then lower case the accessid
return accessId;
} | java |
@SuppressWarnings("unchecked")
private String[] getGroupIds(WSCredential cred) {
Collection<String> ids = null;
if (cred != null) {
try {
ids = cred.getGroupIds();
} catch (CredentialExpiredException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Caught exception getting the group access ids: " + e);
}
} catch (CredentialDestroyedException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Caught exception getting the group access ids: " + e);
}
}
if (ids != null) {
return ids.toArray(new String[ids.size()]);
}
}
return null;
// TODO if ignoreCase is Collection, then lower case the groupids
} | java |
protected boolean isAllAuthenticatedGranted(String resourceName,
Collection<String> requiredRoles,
Subject subject) {
Collection<String> roles = getRolesForSpecialSubject(resourceName, AuthorizationTableService.ALL_AUTHENTICATED_USERS);
AccessDecisionService accessDecisionService = accessDecisionServiceRef.getService();
return accessDecisionService.isGranted(resourceName, requiredRoles,
roles, subject);
} | java |
private boolean isSubjectValid(Subject subject) {
final WSCredential wsCred = getWSCredentialFromSubject(subject);
if (wsCred == null) {
return false;
} else {
// TODO revisit this when EJBs are supported add additional
// checks would be required
return !wsCred.isUnauthenticated() && !wsCred.isBasicAuth();
}
} | java |
private String getRealmName(WSCredential cred) {
String realmName = null;
if (cred != null) {
try {
realmName = cred.getRealmName();
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Caught exception getting the realm name: " + e);
}
}
}
return realmName;
} | java |
final void init() throws DiagnosticModuleRegistrationFailureException {
if (initialized) {
return;
}
initialized = true;
Method[] methods = getClass().getMethods();
for (Method method : methods) {
String name = method.getName().toLowerCase();
if (name.startsWith(FFDC_DUMP_PREFIX)) {
Class<?>[] params = method.getParameterTypes();
if (params.length == FFDC_DUMP_PARAMS.length) {
// Possible candidate method, so check the types
boolean allOK = true;
for (int i = 0; (i < params.length) && (allOK); i++) {
allOK = (params[i] == FFDC_DUMP_PARAMS[i]);
}
if (allOK) {
_directives.add(method.getName());
if (name.startsWith(FFDC_DUMP_DEFAULT_PREFIX))
_dumpDefaultMethods.add(method);
else
_dumpMethods.add(method);
} else if (makeNoise()) {
throw new DiagnosticModuleRegistrationFailureException("Error: " + method + " starts with " + FFDC_DUMP_DEFAULT_PREFIX
+ " but does not conform to the signature. Method skipped!");
}
} else if (makeNoise()) {
throw new DiagnosticModuleRegistrationFailureException("Error: " + method + " starts with " + FFDC_DUMP_DEFAULT_PREFIX
+ " but does not conform to the signature. Method skipped!");
}
}
}
} | java |
public final boolean dumpComponentData(String[] input_directives, Throwable ex, IncidentStream ffdcis, Object callerThis, Object[] catcherObjects, String sourceId,
String[] callStack) {
startProcessing();
try {
ffdcis.writeLine("==> Performing default dump from " + getClass().getName() + " ", new Date());
for (Method m : _dumpDefaultMethods) {
invokeDiagnosticMethod(m, ex, ffdcis, callerThis, catcherObjects, sourceId);
if (!continueProcessing())
break;
}
if (input_directives != null && input_directives.length > 0) {
ffdcis.writeLine("==> Performing custom/other dump from " + getClass().getName() + " ", new Date());
getDataForDirectives(input_directives, ex, ffdcis, callerThis, catcherObjects, sourceId);
}
ffdcis.writeLine("==> Dump complete for " + getClass().getName() + " ", new Date());
} catch (Throwable th) {
ffdcis.writeLine("==> Dump did not complete for " + getClass().getName() + " ", new Date());
}
return finishProcessing();
} | java |
public final void getDataForDirectives(String[] directives, Throwable ex, IncidentStream ffdcis, Object callerThis, Object[] catcherObjects, String sourceId) {
if (directives == null || directives.length <= 0 || !continueProcessing())
return;
for (String s : directives) {
String sName = s.toLowerCase();
for (Method m : _dumpMethods) {
String mName = m.getName().toLowerCase();
if (mName.equals(sName)) {
invokeDiagnosticMethod(m, ex, ffdcis, callerThis, catcherObjects, sourceId);
break;
}
}
if (!continueProcessing())
break;
}
} | java |
private final void invokeDiagnosticMethod(Method m, Throwable ex, IncidentStream ffdcis, Object callerThis, Object[] catcherObjects, String sourceId) {
try {
m.invoke(this, new Object[] { ex, ffdcis, callerThis, catcherObjects, sourceId });
ffdcis.writeLine("+ Data for directive [" + m.getName().substring(FFDC_DUMP_PREFIX.length()) + "] obtained.", "");
} catch (Throwable t) {
ffdcis.writeLine("Error while processing directive [" + m.getName().substring(FFDC_DUMP_PREFIX.length()) + "] !!!", t);
}
} | java |
public final boolean validate() {
if (makeNoise()) {
System.out.println("This method is NOT intended to be called from the runtime");
System.out.println("but is provided as part of unit test for diagnostic modules");
ListIterator<Method> im;
try {
init();
System.out.println("default directives on the diagnostic module : ");
im = _dumpDefaultMethods.listIterator();
while (im.hasNext()) {
System.out.println("\t" + im.next());
}
System.out.println("ffdc methods on the diagnostic module : ");
im = _dumpMethods.listIterator();
while (im.hasNext()) {
System.out.println("\t" + im.next());
}
} catch (DiagnosticModuleRegistrationFailureException dmfailed) {
System.out.println("Diagnostic Module failed to register: " + dmfailed);
dmfailed.printStackTrace();
return false;
} catch (Throwable th) {
System.out.println("Some unknown failure occured: " + th);
th.printStackTrace();
return false;
}
}
return true;
} | java |
private boolean continueProcessing() {
Boolean currentValue = _continueProcessing.get();
if (currentValue != null)
return currentValue.booleanValue();
return true;
} | java |
public static int[] parseSpecStr(String in) {
if (in == null) {
return new int[0];
}
in = in.replaceAll(" ", "");
in = in.trim();
if (in.length() == 0) {
return new int[0];
}
String[] tokens = in.split(",");
int[] toReturn = new int[tokens.length];
for (int i = 0; i < tokens.length; i++) {
tokens[i] = tokens[i].trim();
try {
toReturn[i] = Integer.parseInt(tokens[i]);
} catch (NumberFormatException e) {
if (tokens[i].equals("*") && i == 0) {
toReturn[i] = PmiConstants.ALL_DATA;
}
// invalid configuration specification, set to undefined (no op)
else {
toReturn[i] = PmiConstants.LEVEL_UNDEFINED;
}
}
}
return toReturn;
} | java |
public static SelectionCriteriaFactory getInstance() {
if (_instance == null) {
synchronized (SIDestinationAddressFactory.class) {
try {
Class cls = Class
.forName(MESSAGE_SELECTOR_FACTORY_CLASS);
_instance = (SelectionCriteriaFactory) cls.newInstance();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.wsspi.sib.core.SelectionCriteriaFactory.createFactoryInstance", "100");
SibTr.error(tc,"UNABLE_TO_CREATE_FACTORY_CWSIB0001",e);
}
}
}
/* Otherwise, return the singleton */
return _instance;
} | java |
private void setValue(Object newValue) {
try {
if (this.type == null)
value = newValue;
else if (this.type.equals("java.lang.String"))
value = newValue;
else if (this.type.equals("java.lang.Boolean"))
value = Boolean.valueOf((String) newValue);
else if (this.type.equals("java.lang.Integer"))
value = new Integer(((String) newValue));
else if (this.type.equals("java.lang.Double"))
value = new Double(((String) newValue));
else if (this.type.equals("java.lang.Byte"))
value = new Byte(((String) newValue));
else if (this.type.equals("java.lang.Short"))
value = new Short(((String) newValue));
else if (this.type.equals("java.lang.Long"))
value = new Long(((String) newValue));
else if (this.type.equals("java.lang.Float"))
value = new Float(((String) newValue));
else if (this.type.equals("java.lang.Character"))
value = Character.valueOf(((String) newValue).charAt(0));
else
value = newValue;
} catch (NumberFormatException nfe) {
Tr.warning(tc, "INCOMPATIBLE_PROPERTY_TYPE_J2CA0207", new Object[] { name, type, newValue });
}
} | java |
public void addSelectionCriteria(SelectionCriteria selCriteria)
throws SIDiscriminatorSyntaxException, SISelectorSyntaxException, SIResourceException
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "addSelectionCriteria",
new Object[] { selCriteria });
// We should really check discriminator access at this stage
// However since these checks require access to the connection which
// does not belong on this object , I have decided to avoid the checks
// at this stage as they will be done at message delivery time
// Also, it is the case that in all current usage the discriminators will
// be the same for all selectionCriteria
boolean duplicateCriteria = _consumerDispatcher.getConsumerDispatcherState().addSelectionCriteria(selCriteria);
if( !duplicateCriteria )
{
// Add the new criteria to the matchspace
try
{
_messageProcessor
.getMessageProcessorMatching()
.addConsumerDispatcherMatchTarget(
_consumerDispatcher,
_consumerDispatcher.getDestination().getUuid(),
selCriteria );
}
catch (SIDiscriminatorSyntaxException e)
{
// No FFDC code needed
// Remove the selection criteria as it was added to the list
_consumerDispatcher.getConsumerDispatcherState().removeSelectionCriteria(selCriteria);
if (tc.isEntryEnabled())
SibTr.exit(tc, "addSelectionCriteria", e);
throw e;
}
catch (SISelectorSyntaxException e)
{
// No FFDC code needed
// Remove the selection criteria as it was added to the list
_consumerDispatcher.getConsumerDispatcherState().removeSelectionCriteria(selCriteria);
if (tc.isEntryEnabled())
SibTr.exit(tc, "addSelectionCriteria", e);
throw e;
}
// Persist change made to consumerDispatcherState
Transaction tran = _messageProcessor.getTXManager().createAutoCommitTransaction();
if( !_consumerDispatcher.getReferenceStream().isUpdating() )
{
try
{
_consumerDispatcher.getReferenceStream().requestUpdate(tran);
}
catch (MessageStoreException e)
{
// MessageStoreException shouldn't occur so FFDC.
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.MPSubscriptionImpl.addSelectionCriteria",
"1:153:1.6",
this);
// Remove the selection criteria as it was added to the list
_consumerDispatcher.getConsumerDispatcherState().removeSelectionCriteria(selCriteria);
SibTr.exception(tc, e);
if (tc.isEntryEnabled()) SibTr.exit(tc, "addSelectionCriteria", "SIResourceException");
throw new SIResourceException(e);
}
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "addSelectionCriteria");
} | java |
public SelectionCriteria[] getSelectionCriteria()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getSelectionCriteria");
SelectionCriteria[] list = _consumerDispatcher.getConsumerDispatcherState().getSelectionCriteriaList();
if (tc.isEntryEnabled())
SibTr.exit(tc, "getSelectionCriteria", list);
return list;
} | java |
public void setUserProperties(Map userData) throws SIResourceException
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "setUserProperties",
new Object[] { userData });
_consumerDispatcher.getConsumerDispatcherState().setUserData(userData);
Transaction tran = _messageProcessor.getTXManager().createAutoCommitTransaction();
if( !_consumerDispatcher.getReferenceStream().isUpdating() )
{
try
{
_consumerDispatcher.getReferenceStream().requestUpdate(tran);
}
catch (MessageStoreException e)
{
// MessageStoreException shouldn't occur so FFDC.
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.MPSubscriptionImpl.setUserProperties",
"1:269:1.6",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled()) SibTr.exit(tc, "setUserProperties", "SIResourceException");
throw new SIResourceException(e);
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "setUserProperties");
} | java |
public Map getUserProperties()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getUserProperties");
Map map = _consumerDispatcher.getConsumerDispatcherState().getUserData();
if (tc.isEntryEnabled())
SibTr.exit(tc, "getUserProperties", map);
return map;
} | java |
public String getSubscriberId()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getSubscriberId");
String subscriberId = _consumerDispatcher.getConsumerDispatcherState().getSubscriberID();
if (tc.isEntryEnabled())
SibTr.exit(tc, "getSubscriberId", subscriberId);
return subscriberId;
} | java |
public String getWPMTopicSpaceName()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getWPMTopicSpaceName");
String tsName = _consumerDispatcher.getConsumerDispatcherState().getTopicSpaceName();
if (tc.isEntryEnabled())
SibTr.exit(tc, "getWPMTopicSpaceName", tsName);
return tsName;
} | java |
public String getMEName()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getMEName");
String meName = _messageProcessor.getMessagingEngineName();
if (tc.isEntryEnabled())
SibTr.exit(tc, "getMEName", meName);
return meName;
} | java |
@Override
public int getLocalId() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "getLocalId");
int localId = 0;
final TransactionImpl tran = ((TranManagerSet) TransactionManagerFactory.getTransactionManager()).getTransactionImpl();
if (tran != null) {
localId = (int) tran.getLocalTID();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "getLocalId", localId);
return localId;
} | java |
public static void beforeCompletion(TransactionImpl tran, int syncLevel) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "beforeCompletion", new Object[] { tran, syncLevel });
if (syncLevel >= 0) {
final ArrayList syncs = _syncLevels.get(syncLevel);
if (syncs != null) {
final int localID = (int) tran.getLocalTID();
final byte[] globalID = tran.getTID();
final int numSyncs = syncs.size();
for (int s = 0; s < numSyncs; s++) {
((SynchronizationCallback) syncs.get(s)).beforeCompletion(localID, globalID);
// exception here means rollback
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "beforeCompletion");
} | java |
public static void afterCompletion(TransactionImpl tran, int status, int syncLevel) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "afterCompletion", new Object[] { tran, status, syncLevel });
if (syncLevel >= 0) {
final ArrayList syncs = _syncLevels.get(syncLevel);
if (syncs != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "syncs.length=" + syncs.size());
final int localID = (int) tran.getLocalTID();
final byte[] globalID = tran.getTID();
// d281425 - status maybe committed, unknown or rolledback
final boolean committed = !(status == Status.STATUS_ROLLEDBACK); // @281425C
final int numSyncs = syncs.size();
for (int s = 0; s < numSyncs; s++) {
try {
((SynchronizationCallback) syncs.get(s)).afterCompletion(localID, globalID, committed);
} catch (Throwable t) {
// No FFDC needed
Tr.error(tc, "WTRN0074_SYNCHRONIZATION_EXCEPTION", new Object[] { "afterCompletion", syncs.get(s), t });
// absorb and allow other afterCompletions to run.
}
}
} else if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "syncs is null");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "afterCompletion");
} | java |
public static boolean callbacksRegistered() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "callbacksRegistered");
if (_syncLevel < 0) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "callbacksRegistered", Boolean.FALSE);
return false;
}
final int maxLevels = _syncLevels.size();
for (int level = 0; level < maxLevels; level++) {
final ArrayList syncs = _syncLevels.get(_syncLevel);
if (syncs != null && !syncs.isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "callbacksRegistered", Boolean.TRUE);
return true;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "callbacksRegistered", Boolean.FALSE);
return false;
} | java |
private static void garbageCollectUnusedLevels() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "garbageCollectUnusedLevels");
final int numLevels = _syncLevels.size();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Levels: " + numLevels);
// No need to do anything if we only have one level
if (numLevels < 2) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "garbageCollectUnusedLevels", "Doing nothing");
return;
}
final int[] counts = new int[numLevels];
// Check through all transactions to see which levels are still in use
final TransactionImpl[] txns = LocalTIDTable.getAllTransactions();
// Record the levels with transactions referring to them
// Record the levels with transactions referring to them
for (int i = txns.length; --i >= 0;) {
// TransactionImpl has a dependency on CORBA which we definitely don't want
// Skip this step to avoid a classcastexception
// TODO can we work around the dependency?
int level = 0;
// final int level = ((com.ibm.ws.tx.jta.TransactionImpl) txns[i]).getExtJTASyncLevel();
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Not generating any counts for garbageCollectUnusedLevels()");
}
if (level >= 0 && level < numLevels) {
counts[level]++;
}
}
// Now null out the levels with no references
for (int i = counts.length; --i >= 0;) {
// We never want to null out the current level
if (i != _syncLevel) {
if (counts[i] == 0) {
_syncLevels.set(i, null);
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "garbageCollectUnusedLevels", _syncLevels.size());
} | java |
private static void setLevel(ArrayList level) {
_syncLevel = nextLevel();
if (_syncLevel == _syncLevels.size()) {
_syncLevels.add(level);
} else {
_syncLevels.set(_syncLevel, level);
}
} | java |
private void validateParameters(String filePath, String password, int validity, String subjectDN, int keySize, String sigAlg) {
if (!validateFilePath(filePath)) {
throw new IllegalArgumentException("filePath must be a valid filePath within the file system.");
}
if (password == null || password.length() < MINIMUM_PASSWORD_LENGTH) {
throw new IllegalArgumentException("The password must be at least " +
MINIMUM_PASSWORD_LENGTH +
" characters in length.");
}
if (validity < MINIMUM_VALIDITY) {
throw new IllegalArgumentException("The validity period must be at least " +
MINIMUM_VALIDITY + " days.");
}
List<String> validSigAlg = VALID_SIG_ALG;
if (!validSigAlg.contains(sigAlg)) {
throw new IllegalArgumentException("The signagure algorithm values include " + VALID_SIG_ALG);
}
String type = getKeyFromSigAlg(sigAlg);
if (type.equals(KEYALG_RSA_TYPE)) {
List<Integer> validKeySizes = VALID_RSA_KEYSIZE;
if (!validKeySizes.contains(keySize)) {
throw new IllegalArgumentException("The key sizes for an RSA key include " + VALID_RSA_KEYSIZE);
}
} else {
List<Integer> validKeySizes = VALID_EC_KEYSIZE;
if (!validKeySizes.contains(keySize)) {
throw new IllegalArgumentException("The key sizes for an EC key include " + VALID_EC_KEYSIZE);
}
}
validateSubjectDN(subjectDN);
} | java |
private boolean validateFilePath(String filePath) {
if (filePath == null || filePath.isEmpty()) {
throw new IllegalArgumentException("filePath must be a valid filePath within the file system.");
}
// Check if the filename exists as a File -- use an absolute file to ensure we have
// a parent: even if that parent is ${user.dir} ...
File loc = new File(filePath).getAbsoluteFile();
return (loc.exists() || loc.getParentFile().exists());
} | java |
public <K2 extends K, E2 extends E> BlockingList<K2, E2> make() {
@SuppressWarnings("unchecked")
BlockingListMaker<K2, E2> stricterThis = (BlockingListMaker<K2, E2>) this;
return stricterThis.internalCreateBlockingList();
} | java |
public BlockingListMaker<K, E> log(Logger logger) {
this.logger = logger == null ? NULL_LOGGER : logger;
return this;
} | java |
public BlockingListMaker<K, E> waitFor(long time, TimeUnit unit) {
this.nanoTimeout = time == 0 ? 1 : NANOSECONDS.convert(time, unit);
return this;
} | java |
public String getSystemMessageId() {
//based on com.ibm.ws.sib.mfp.impl.JsHdrsImpl
if (uuid != null) {
StringBuilder buff = new StringBuilder(uuid.toString());
buff.append(MfpConstants.MESSAGE_HANDLE_SEPARATOR);
buff.append(value);
return new String(buff);
}
else {
return null;
}
} | java |
private void processExistingWSDL(String wsdlLocation, Member newMember) throws InjectionException {
// if the wsdlLocation for this service reference is specified in the DD, log a debug statement and continue
if (wsrInfo.getWsdlLocation() != null && !"".equals(wsrInfo.getWsdlLocation())) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "For the " + wsrInfo.getJndiName() + " service reference, " + "the " + wsrInfo.getWsdlLocation()
+ " WSDL file is specified in the " + "deployment descriptor. Annotation metadata referencing a WSDL file for "
+ "this service reference will be ignored.");
}
} else { // else we want to set the value to whatever is in the annotation
if (tc.isDebugEnabled()) {
Tr.debug(tc, "For the " + wsrInfo.getJndiName() + " service reference, " + "setting the wsdlLocation: " + wsdlLocation);
}
wsrInfo.setWsdlLocation(wsdlLocation);
}
} | java |
public int compare (Object o1, Object o2) {
String re1 = ((ConnectionStatus)o1).getRemoteEngineName();
String re2 = ((ConnectionStatus)o2).getRemoteEngineName();
return re1.compareTo(re2);
} | java |
public synchronized void put(byte item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "put", Byte.valueOf(item));
checkValid();
getCurrentByteBuffer(1).put(item);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "put");
} | java |
public synchronized void putShort(short item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putShort", Short.valueOf(item));
checkValid();
getCurrentByteBuffer(2).putShort(item);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putShort");
} | java |
public synchronized void putInt(int item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putInt", Integer.valueOf(item));
checkValid();
getCurrentByteBuffer(4).putInt(item);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putInt");
} | java |
public synchronized void putLong(long item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putLong", Long.valueOf(item));
checkValid();
getCurrentByteBuffer(4).putLong(item);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putLong");
} | java |
public synchronized void setReadOnly()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setReadOnly");
// And actually mark the real buffers as read-only too
for (int x = 0; x < dataList.size(); x++)
{
WsByteBuffer buff = dataList.get(x);
buff.setReadOnly(true);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setReadOnly");
} | java |
public synchronized long prepareForTransmission()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "prepareForTransmission");
checkValid();
valid = false;
// Get the last buffer and flip it. Then we can simply return the list of buffers
if (dataList.size() > 0)
{
WsByteBuffer buff = dataList.get(dataList.size() - 1);
buff.flip();
}
long sendAmount = 0;
for (int x = 0; x < dataList.size(); x++)
{
WsByteBuffer buff = dataList.get(x);
sendAmount += buff.remaining();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "prepareForTransmission", Long.valueOf(sendAmount));
return sendAmount;
} | java |
public synchronized WsByteBuffer[] getBuffersForTransmission()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getBufferForTransmission");
// Ensure the buffer has been prepared
checkNotValid();
WsByteBuffer[] bufferArray = new WsByteBuffer[dataList.size()];
for (int x = 0; x < dataList.size(); x++)
{
bufferArray[x] = dataList.get(x);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getBufferForTransmission", dataList);
return bufferArray;
} | java |
protected WsByteBuffer getCurrentByteBuffer(int sizeNeeded)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getCurrentByteBuffer", Integer.valueOf(sizeNeeded));
WsByteBuffer byteBuffer = null;
// First have a look in the dataList for a buffer.
if (dataList.size() == 0)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Creating first buffer");
// This is the first piece of data to be written into the buffer. As such, we simply
// allocate a new buffer and return that
dataList = new ArrayList<WsByteBuffer>();
byteBuffer = createNewWsByteBuffer(sizeNeeded);
dataList.add(byteBuffer);
}
else
{
// Otherwise get the last byte buffer in the list
byteBuffer = dataList.get(dataList.size() - 1);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Last buffer: ", byteBuffer);
// Now check and see if there is enough room in there for data that needs to be written.
// If there is enough room, great - we return that buffer. Otherwise we need to complete
// the current buffer and start a new one.
if (byteBuffer.remaining() < sizeNeeded)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "No room in buffer, creating a new one");
// First flip the finished one
byteBuffer.flip();
// Now create a new one and add it onto the list
byteBuffer = createNewWsByteBuffer(sizeNeeded);
dataList.add(byteBuffer);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getCurrentByteBuffer", byteBuffer);
return byteBuffer;
} | java |
private WsByteBuffer createNewWsByteBuffer(int sizeNeeded)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "createNewWsByteBuffer", Integer.valueOf(sizeNeeded));
if (sizeNeeded < DEFAULT_BUFFER_SIZE)
{
sizeNeeded = DEFAULT_BUFFER_SIZE;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Allocating a buffer of size: " + sizeNeeded);
WsByteBuffer buffer = poolMan.allocate(sizeNeeded);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "createNewWsByteBuffer", buffer);
return buffer;
} | java |
public synchronized String getDumpReceivedBytes(int bytesToDump)
{
String dump = null;
if (receivedBuffer != null)
{
dump = getDumpBytes(receivedBuffer, bytesToDump, false);
}
return dump;
} | java |
private static String getDumpBytes(WsByteBuffer buffer, int bytesToDump, boolean rewind)
{
// Save the current position
int pos = buffer.position();
if (rewind)
{
buffer.rewind();
}
byte[] data = null;
int start;
int count = bytesToDump;
if (count > buffer.remaining() || count == ENTIRE_BUFFER) count = buffer.remaining();
if (buffer.hasArray())
{
data = buffer.array();
start = buffer.arrayOffset() + buffer.position();
}
else
{
data = new byte[count];
buffer.get(data);
start = 0;
}
String strData = "Dumping "+count+" bytes of buffer data:\r\n";
if (count > 0) strData += SibTr.formatBytes(data, start, count);
// Return the position to where it should be
if (rewind) buffer.position(pos);
return strData;
} | java |
private int getIntKeyForString(ArrayList<String> uniqueStrings, Object value) {
String stringValue = String.valueOf(value);
int retval = uniqueStrings.indexOf(stringValue);
if (retval < 0) {
retval = uniqueStrings.size();
uniqueStrings.add(stringValue);
}
return retval;
} | java |
public static void writeObjectInstanceOutput(final RESTResponse response, final ObjectInstanceWrapper value, final JSONConverter converter) {
response.setContentType(APIConstants.MEDIA_TYPE_APPLICATION_JSON);
OutputStream outStream = null;
try {
outStream = response.getOutputStream();
//Converter the value
converter.writeObjectInstance(outStream, value);
//Return converter
JSONConverter.returnConverter(converter);
outStream.flush();
} catch (Exception e) {
throw ErrorHelper.createRESTHandlerJsonException(e, converter, APIConstants.STATUS_INTERNAL_SERVER_ERROR);
} finally {
FileUtils.tryToClose(outStream);
}
} | java |
public static StatsGroup createStatsGroup(String groupName, String statsTemplate, StatsGroup parentGroup, ObjectName mBean, StatisticActions actionLsnr)
throws StatsFactoryException {
if (tc.isEntryEnabled())
Tr.entry(tc, new StringBuffer("createStatsGroup:name=").append(groupName).append(";parent group=").
append(parentGroup.getName()).append(";template=").append(statsTemplate).append(";mBean=").append((mBean == null) ? null : mBean.toString()).toString());
checkPMIService(groupName);
StatsGroup group;
try {
group = StatsGroupImpl.createGroup(groupName, parentGroup, statsTemplate, mBean, false, actionLsnr);
} catch (StatsFactoryException e) {
if (tc.isDebugEnabled())
Tr.debug(tc, "Exception:", e);
if (tc.isEntryEnabled())
Tr.exit(tc, "createStatsGroup");
throw e;
}
if (tc.isEntryEnabled())
Tr.exit(tc, "createStatsGroup");
return group;
} | java |
public static void removeStatsInstance(StatsInstance instance)
throws StatsFactoryException {
if (tc.isEntryEnabled())
Tr.entry(tc, new StringBuffer("removeStatsInstance:name=").append(instance.getName()).toString());
StatsFactoryUtil.unRegisterStats((PmiModule) instance, instance.getMBean());
if (tc.isEntryEnabled())
Tr.exit(tc, "removeStatsInstance");
} | java |
public static void removeStatsGroup(StatsGroup group)
throws StatsFactoryException {
if (tc.isEntryEnabled())
Tr.entry(tc, new StringBuffer("removeStatsGroup:name=").append(group.getName()).toString());
StatsFactoryUtil.unRegisterStats((PmiModule) group, group.getMBean());
if (tc.isEntryEnabled())
Tr.exit(tc, "removeStatsGroup");
} | java |
@Override
protected Validator createValidator() throws JspException
{
if (null == _minimum && null == _maximum)
{
throw new JspException("a minimum and / or a maximum have to be specified");
}
ELContext elContext = FacesContext.getCurrentInstance().getELContext();
if (null != _minimum)
{
_min = getValue(_minimum.getValue(elContext));
}
if (null != _maximum)
{
_max = getValue(_maximum.getValue(elContext));
}
if (null != _minimum && null != _maximum)
{
if (!isMinLTMax())
{
throw new JspException("maximum limit must be greater than the minimum limit");
}
}
return super.createValidator();
} | java |
private String incrementAlias(KeyStore jKeyStore, String alias) throws KeyStoreException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "incrementAlias: " + alias);
int num = 0;
String base;
int index = alias.lastIndexOf('_');
if (-1 == index) {
// no underscore found
base = alias + '_';
} else if (index == (alias.length() - 1)) {
// alias ends with underscore
base = alias;
} else {
// alias ends with _X where X might be a number...
try {
++index; // jump past the underscore
num = Integer.parseInt(alias.substring(index));
base = alias.substring(0, index);
} catch (NumberFormatException nfe) {
// not a number
base = alias + '_';
}
}
String newAlias = base + Integer.toString(++num);
while (jKeyStore.containsAlias(newAlias)) {
newAlias = base + Integer.toString(++num);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "incrementAlias: " + newAlias);
return newAlias;
} | java |
public String getUserName(boolean notAlternateUser)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getUserName",
new Object[]{new Boolean(notAlternateUser)});
String userName = null;
if(!notAlternateUser // this catches the case where we want the
// user associated with the subject
&& isAlternateUserBased())
{
userName = alternateUser;
}
else if(isSubjectBased())
{
if(authorisationUtils != null)
{
userName = authorisationUtils.getUserName(subject);
}
}
else if(isUserIdBased())
{
userName = userId;
}
else if(isMsgBased())
{
userName = msg.getSecurityUserid();
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "getUserName", userName);
return userName;
} | java |
public boolean isSIBServerSubject()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "isSIBServerSubject");
boolean ispriv = false;
// If the context is userid or alternate user based then it cannot be the
// privileged SIBServerSubject, so we only need to check the Subject and
// msg based contexts.
if(isSubjectBased())
{
if(authorisationUtils != null)
{
ispriv = authorisationUtils.isSIBServerSubject(subject);
}
}
else if(isMsgBased())
{
if(authorisationUtils != null)
{
ispriv = authorisationUtils.sentBySIBServer(msg);
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "isSIBServerSubject", new Boolean(ispriv));
return ispriv;
} | java |
@Override
public void complete(VirtualConnection vc, TCPWriteRequestContext wsc) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "complete() called: vc=" + vc);
}
HttpInboundServiceContextImpl mySC = (HttpInboundServiceContextImpl) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPISC);
if (null != wsc) {
wsc.setBuffers(null);
}
// access logging if the finishResponse API was used
if (mySC.isMessageSent()) {
mySC.logFinalResponse(mySC.getNumBytesWritten());
HttpInvalidMessageException inv = mySC.checkResponseValidity();
if (null != inv) {
// response was invalid in some way... error scenario
mySC.setPersistent(false);
if (null != mySC.getAppWriteCallback()) {
mySC.getAppWriteCallback().error(vc, inv);
}
return;
}
}
// if a callback exists above, pass along the complete. But if the
// app channel didn't give us a callback (it doesn't care) then we
// can't pass anything along and we stop further work here
if (null != mySC.getAppWriteCallback()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Calling write complete callback of app channel.");
}
if (mySC.getResponseImpl().isTemporaryStatusCode()) {
// allow other responses to follow a temporary one
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Temp response sent, resetting send flags");
}
mySC.resetWrite();
}
mySC.getAppWriteCallback().complete(vc);
} else {
// this is dangerous since we're not notifying the channel above
// of the complete work, but they don't care since they didn't
// give us a callback to use... hopefully they will continue this
// connection properly.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "No available app channel callback");
}
}
} | java |
@Override
public void error(VirtualConnection vc, TCPWriteRequestContext wsc, IOException ioe) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "error called: vc=" + vc + " ioe=" + ioe);
}
HttpInboundServiceContextImpl mySC = (HttpInboundServiceContextImpl) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPISC);
if (mySC.getHttpConfig().getDebugLog().isEnabled(DebugLog.Level.WARN)) {
mySC.getHttpConfig().getDebugLog().log(DebugLog.Level.WARN, HttpMessages.MSG_WRITE_FAIL, mySC);
}
mySC.logLegacyMessage();
// pass on the error if possible, else just close the connection
mySC.setPersistent(false);
if (null != mySC.getAppWriteCallback()) {
mySC.getAppWriteCallback().error(vc, ioe);
} else {
mySC.getLink().getDeviceLink().close(vc, ioe);
}
} | java |
@Deactivate
protected void deactivate(int reason) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Deactivating " + this, "reason=" + reason);
}
// purge cached data from config
this.cachedEncoding = null;
this.cachedLocale = null;
this.localeMap.clear();
this.converterMap.clear();
this.supportedEncodingsCache.clear();
this.localesCache.clear();
} | java |
private List<List<String>> processAcceptLanguage(String acceptLanguage) {
StringTokenizer languageTokenizer = new StringTokenizer(acceptLanguage, ",");
TreeMap<Double, List<String>> map = new TreeMap<Double, List<String>>(Collections.reverseOrder());
List<String> list;
while (languageTokenizer.hasMoreTokens()) {
String language = languageTokenizer.nextToken().trim();
if (language.length() == 0) {
continue;
}
int semicolonIndex = language.indexOf(';');
Double qValue = Double.valueOf(1);
if (semicolonIndex > -1) {
int qIndex = language.indexOf("q=");
String qValueStr = language.substring(qIndex + 2);
try {
qValue = Double.valueOf(qValueStr.trim());
} catch (NumberFormatException nfe) {
FFDCFilter.processException(nfe,
"EncodingUtils.processAcceptLanguage", "215");
}
language = language.substring(0, semicolonIndex);
}
if (language.length() > 0) {
if ((qValue.doubleValue() > 0) && (language.charAt(0) != '*')) {
list = map.get(qValue);
if (null == list) {
list = new ArrayList<String>(1);
}
list.add(language);
map.put(qValue, list);
}
}
}
List<List<String>> rc = null;
if (!map.isEmpty()) {
rc = new ArrayList<List<String>>(map.values());
}
return rc;
} | java |
private List<Locale> extractLocales(List<List<String>> allLangs) {
List<Locale> rc = new ArrayList<Locale>();
for (List<String> langList : allLangs) {
for (String language : langList) {
String country = "";
String variant = "";
int countryIndex = language.indexOf('-');
if (countryIndex > -1) {
int variantIndex = language.indexOf('-', (countryIndex + 1));
if (variantIndex > -1) {
variant = language.substring(variantIndex + 1).trim();
country = language.substring(countryIndex, variantIndex).trim();
} else {
country = language.substring(countryIndex + 1).trim();
}
language = language.substring(0, countryIndex).trim();
}
rc.add(new Locale(language, country, variant));
}
}
return rc;
} | java |
public Token getMetaDataToken()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getMetaDataToken");
SibTr.exit(this, tc, "getMetaDataToken", "return=" + _metaDataToken);
}
return _metaDataToken;
} | java |
public void updateMetaDataOnly(Transaction tran, Persistable persistable) throws PersistenceException, ObjectManagerException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "updateMetaDataOnly", new Object[] { "Tran=" + tran, "Persistable=" + persistable });
// Defect 585163
// Get the meta data object to work with. This may involve
// pulling it off disk if it has fallen out of memory.
PersistableMetaData metaData = getMetaData();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "MetaData=" + metaData);
tran.lock(metaData);
// Update the MetaData with the cached values
metaData.setLockID(persistable.getLockID());
metaData.setRedeliveredCount(persistable.getRedeliveredCount());
tran.replace(metaData);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "updateMetaDataOnly", "MetaData=" + metaData);
} | java |
@Override
public java.util.List<DataSlice> getData() throws PersistentDataEncodingException, SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getData");
java.util.List<DataSlice> retval = null;
synchronized (this)
{
if (_link != null)
{
retval = _link.getMemberData();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getData", "return=" + retval);
return retval;
} | java |
@Override
public void setWasSpillingAtAddition(boolean wasSpillingAtAddition)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setWasSpillingAtAddition", Boolean.valueOf(wasSpillingAtAddition));
_wasSpillingAtAddition = wasSpillingAtAddition;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setWasSpillingAtAddition");
} | java |
public void setWriter(Object sysLogHolder, Object sysErrHolder) {
this.sysOutHolder = (SystemLogHolder) sysLogHolder;
this.sysErrHolder = (SystemLogHolder) sysErrHolder;
} | java |
public static SecurityMetadata getSecurityMetadata() {
SecurityMetadata secMetadata = null;
ModuleMetaData mmd = ComponentMetaDataAccessorImpl.getComponentMetaDataAccessor().getComponentMetaData().getModuleMetaData();
if (mmd instanceof WebModuleMetaData) {
secMetadata = (SecurityMetadata) ((WebModuleMetaData) mmd).getSecurityMetaData();
} else {
// ejb environment, check threadlocal.
WebModuleMetaData wmmd = getWebModuleMetaData();
if (wmmd != null) {
secMetadata = (SecurityMetadata) wmmd.getSecurityMetaData();
}
}
return secMetadata;
} | java |
public CompoundName getFirstInChain()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getFirstInChain");
CompoundName firstInChain = collector.getFirst();
if (tc.isEntryEnabled())
SibTr.exit(tc, "getFirstInChain", firstInChain);
return firstInChain;
} | java |
public void validate(String destName, String busName) throws SINotPossibleInCurrentConfigurationException
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "validate", new Object[] { destName, busName });
if (collector.contains(destName, busName))
{
// Throw out exception detailing loop
// Add the destination name which has triggered the exception to the end
// of the list, making the problem obvious.
String chainText = toStringPlus(destName, busName);
CompoundName firstInChain = getFirstInChain();
String nlsMessage = nls.getFormattedMessage(
"ALIAS_CIRCULAR_DEPENDENCY_ERROR_CWSIP0621",
new Object[] { firstInChain, chainText, busName },
null);
SINotPossibleInCurrentConfigurationException e
= new SINotPossibleInCurrentConfigurationException(nlsMessage);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "validate", nlsMessage);
throw e;
}
collector.add(destName, busName);
if (tc.isEntryEnabled())
SibTr.exit(tc, "validate");
} | java |
public String toStringPlus(String destName, String busName)
{
StringBuffer sb = new StringBuffer(toString());
// Add the destination name which has triggered the exception to the end
// of the list, making the problem obvious.
String compoundName = new CompoundName(destName, busName).toString();
sb.append(" -> ");
sb.append(compoundName);
return sb.toString();
} | java |
private void initialize(final File logDirectory, final String aaplName) {
if (logDirectory == null) {
captureEnabled = false;
return;
}
AccessController.doPrivileged(new PrivilegedAction<Void>() {
@Override
public Void run() {
// Create a new or reuse an existing base capture directory
String captureDirStr = "JPATransform" + "/" + ((aaplName != null) ? aaplName : "unknownapp");
captureRootDir = new File(logDirectory, captureDirStr);
captureEnabled = captureRootDir.mkdirs() || captureRootDir.isDirectory();
if (!captureEnabled) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Cannot create server instance capture directory, so enhanced entity bytecode will not be captured.");
}
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Capturing enhanced bytecode for JPA entities to " + captureRootDir.getAbsolutePath());
}
}
return null;
}
});
} | java |
private static boolean resourceExist(ExternalContext externalContext, String path)
{
if ("/".equals(path))
{
// The root context exists always
return true;
}
Object ctx = externalContext.getContext();
if (ctx instanceof ServletContext)
{
ServletContext servletContext = (ServletContext) ctx;
InputStream stream = servletContext.getResourceAsStream(path);
if (stream != null)
{
try
{
stream.close();
}
catch (IOException e)
{
// Ignore here, since we donnot wanted to read from this
// resource anyway
}
return true;
}
}
return false;
} | java |
public synchronized void addSlice(CommsByteBuffer bufferContainingSlice, boolean last)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "addSlice", new Object[]{bufferContainingSlice, last});
slices.add(bufferContainingSlice.getDataSlice());
// If this is the last slice, calculate the message length
if (last)
{
for (DataSlice slice : slices)
{
messageLength += slice.getLength();
}
complete = true;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Message now consists of " + slices.size() + " slices");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "addSlice");
} | java |
public void updateArrivalTime(long messageArrivalTime)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "updateMessageArrivalTime", messageArrivalTime);
this.arrivalTime = messageArrivalTime;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "updateMessageArrivalTime");
} | java |
public void stop(int requestNumber, SendListener sendListener)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "stop", requestNumber);
logicallyStarted = false;
super.stop(requestNumber, sendListener);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "stop");
} | java |
public void close(int requestNumber)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "close", requestNumber);
// Deregister any error callback created for this connection.
if (asynchReader != null)
{
try
{
mainConsumer.getConsumerSession().getConnection().removeConnectionListener(asynchReader);
}
catch (SIException e)
{
//No FFDC code needed
//Only FFDC if we haven't received a meTerminated event.
if(!((ConversationState)getConversation().getAttachment()).hasMETerminated())
{
FFDCFilter.processException(e, CLASS_NAME + ".close",
CommsConstants.CATSESSSYNCHCONSUMER_CLOSE_01, this);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.exception(this, tc, e);
}
if (asynchReader.isCurrentlyDoingReceiveWithWait()) asynchReader.sendNoMessageToClient();
}
super.close(requestNumber);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "close");
} | java |
public void setAsynchConsumerCallback(int requestNumber,
int maxActiveMessages,
long messageLockExpiry,
int batchsize,
OrderingContext orderContext)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setAsynchConsumerCallback",
new Object[]
{
requestNumber,
maxActiveMessages,
messageLockExpiry,
batchsize,
orderContext
});
mainConsumer.setAsynchConsumerCallback(requestNumber,
maxActiveMessages,
messageLockExpiry,
batchsize,
orderContext);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setAsynchConsumerCallback");
} | java |
@Override
public void postConstruct(Object instance, Object creationMetaData) throws InjectionProviderException
{
// TODO the servlet spec is not clear about searching in superclass??
Class clazz = instance.getClass();
Method[] methods = getDeclaredMethods(clazz);
if (methods == null)
{
methods = clazz.getDeclaredMethods();
Map<Class,Method[]> declaredMethodBeansMap = getDeclaredMethodBeansMap();
synchronized(declaredMethodBeansMap)
{
declaredMethodBeansMap.put(clazz, methods);
}
}
Method postConstruct = null;
for (int i = 0; i < methods.length; i++)
{
Method method = methods[i];
if (method.isAnnotationPresent(PostConstruct.class))
{
// a method that does not take any arguments
// the method must not be static
// must not throw any checked expections
// the return value must be void
// the method may be public, protected, package private or private
if ((postConstruct != null)
|| (method.getParameterTypes().length != 0)
|| (Modifier.isStatic(method.getModifiers()))
|| (method.getExceptionTypes().length > 0)
|| (!method.getReturnType().getName().equals("void")))
{
throw new IllegalArgumentException("Invalid PostConstruct annotation");
}
postConstruct = method;
}
}
try
{
invokeAnnotatedMethod(postConstruct, instance);
}
catch (IllegalAccessException ex)
{
throw new InjectionProviderException(ex);
}
catch (InvocationTargetException ex)
{
throw new InjectionProviderException(ex);
}
} | java |
private WebSphereCDIDeployment createWebSphereCDIDeployment(Application application,
Set<ExtensionArchive> extensionArchives) throws CDIException {
WebSphereCDIDeployment webSphereCDIDeployment = new WebSphereCDIDeploymentImpl(application, cdiRuntime);
DiscoveredBdas discoveredBdas = new DiscoveredBdas(webSphereCDIDeployment);
if (application.hasModules()) {
Collection<CDIArchive> libraryArchives = application.getLibraryArchives();
Collection<CDIArchive> moduleArchives = application.getModuleArchives();
ClassLoader applicationClassLoader = application.getClassLoader();
webSphereCDIDeployment.setClassLoader(applicationClassLoader);
processLibraries(webSphereCDIDeployment,
discoveredBdas,
libraryArchives);
processModules(webSphereCDIDeployment,
discoveredBdas,
moduleArchives);
//discoveredBdas has the full map, let's go through them all to make sure the wire is complete
discoveredBdas.makeCrossBoundaryWiring();
//and finally the runtime extensions
addRuntimeExtensions(webSphereCDIDeployment,
discoveredBdas);
}
return webSphereCDIDeployment;
} | java |
private void addRuntimeExtensions(WebSphereCDIDeployment webSphereCDIDeployment,
DiscoveredBdas discoveredBdas) throws CDIException {
//add the normal runtime extension using the bundle classloader to load the bda classes
Set<WebSphereBeanDeploymentArchive> extensions = createExtensionBDAs(webSphereCDIDeployment);
//add the runtime extensions containers
webSphereCDIDeployment.addBeanDeploymentArchives(extensions);
//add the runtime extensions containers
for (WebSphereBeanDeploymentArchive bda : webSphereCDIDeployment.getApplicationBDAs()) {
for (WebSphereBeanDeploymentArchive extBDA : extensions) {
if (bda != extBDA) {
bda.addBeanDeploymentArchive(extBDA);
if (extBDA.extensionCanSeeApplicationBDAs() && !discoveredBdas.isExcluded(bda)) {
extBDA.addBeanDeploymentArchive(bda);
}
}
}
}
} | java |
private Set<WebSphereBeanDeploymentArchive> createExtensionBDAs(WebSphereCDIDeployment applicationContext) throws CDIException {
Set<WebSphereBeanDeploymentArchive> extensionBdas = new HashSet<WebSphereBeanDeploymentArchive>();
Set<ExtensionArchive> extensions = getExtensionArchives();
if (extensions != null) {
for (ExtensionArchive extArchive : extensions) {
WebSphereBeanDeploymentArchive moduleCDIContext = BDAFactory.createBDA(applicationContext,
extArchive,
cdiRuntime);
extensionBdas.add(moduleCDIContext);
}
}
return extensionBdas;
} | java |
private void processModules(WebSphereCDIDeployment applicationContext,
DiscoveredBdas discoveredBdas,
Collection<CDIArchive> moduleArchives) throws CDIException {
List<WebSphereBeanDeploymentArchive> moduleBDAs = new ArrayList<WebSphereBeanDeploymentArchive>();
for (CDIArchive archive : moduleArchives) {
if (cdiRuntime.isClientProcess()) {
// when on a client process, we only process client modules and ignore the others
if (ArchiveType.CLIENT_MODULE != archive.getType()) {
continue;
}
} else {
// when on a server process, we do not process client modules, just the others
if (ArchiveType.CLIENT_MODULE == archive.getType()) {
continue;
}
}
//if the app is not an EAR then there should be only one module and we can just use it's classloader
if (applicationContext.getClassLoader() == null) {
applicationContext.setClassLoader(archive.getClassLoader());
}
String archiveID = archive.getJ2EEName().toString();
// we need to work our whether to create a bda or not
if (cdiRuntime.skipCreatingBda(archive)) {
continue;
}
WebSphereBeanDeploymentArchive moduleBda = BDAFactory.createBDA(applicationContext,
archiveID,
archive,
cdiRuntime);
discoveredBdas.addDiscoveredBda(archive.getType(), moduleBda);
moduleBDAs.add(moduleBda);
}
// Having processed all the modules, we now process their libraries
// We do it in this order in case one of the modules references another of the same type as a library
for (WebSphereBeanDeploymentArchive bda : moduleBDAs) {
processModuleLibraries(bda, discoveredBdas);
}
} | java |
private synchronized Set<ExtensionArchive> getExtensionArchives() throws CDIException {
if (runtimeExtensionSet == null) {
runtimeExtensionSet = new HashSet<ExtensionArchive>();
// get hold of the container for extension bundle
//add create the bean deployment archive from the container
Iterator<ServiceAndServiceReferencePair<WebSphereCDIExtension>> extensions = cdiRuntime.getExtensionServices();
while (extensions.hasNext()) {
ServiceAndServiceReferencePair<WebSphereCDIExtension> extension = extensions.next();
ServiceReference<WebSphereCDIExtension> sr = extension.getServiceReference();
Bundle bundle = null;
if (sr == null) {
continue;
}
bundle = sr.getBundle();
String extra_classes_blob = (String) sr.getProperty(EXTENSION_API_CLASSES);
Set<String> extra_classes = new HashSet<String>();
//parse the list
if (extra_classes_blob != null) {
String[] classes = extra_classes_blob.split(EXTENSION_API_CLASSES_SEPARATOR);
if ((classes != null) && (classes.length > 0)) {
Collections.addAll(extra_classes, classes);
}
}
String extraAnnotationsBlob = (String) sr.getProperty(EXTENSION_BEAN_DEFINING_ANNOTATIONS);
Set<String> extraAnnotations = new HashSet<String>();
if (extraAnnotationsBlob != null) {
String[] annotations = extraAnnotationsBlob.split(EXTENSION_API_CLASSES_SEPARATOR);
if ((annotations != null) && (annotations.length > 0)) {
Collections.addAll(extraAnnotations, annotations);
}
}
String applicationBDAsVisibleStr = (String) sr.getProperty(EXTENSION_APP_BDAS_VISIBLE);
boolean applicationBDAsVisible = Boolean.parseBoolean(applicationBDAsVisibleStr);
String extClassesOnlyStr = (String) sr.getProperty(EXTENSION_CLASSES_ONLY_MODE);
boolean extClassesOnly = Boolean.parseBoolean(extClassesOnlyStr);
ExtensionArchive extensionArchive = cdiRuntime.getExtensionArchiveForBundle(bundle, extra_classes, extraAnnotations,
applicationBDAsVisible,
extClassesOnly);
runtimeExtensionSet.add(extensionArchive);
}
if (CDIUtils.isDevelopementMode()) {
//add the probeExcension
runtimeExtensionSet.add(new ProbeExtensionArchive(cdiRuntime, null));
}
}
return runtimeExtensionSet;
} | java |
public int compareEntitysWithRespectToProperties(Entity entity1, Entity entity2) {
List<SortKeyType> sortKeys = sortControl.getSortKeys();
int temp = 0;
for (int i = 0; i < sortKeys.size() && temp == 0; i++) {
SortKeyType sortKey = (SortKeyType) sortKeys.get(i);
String propName = sortKey.getPropertyName();
boolean ascendingSorting = sortKey.isAscendingOrder();
Object propValue1 = getPropertyValue(entity1, propName, ascendingSorting);
Object propValue2 = getPropertyValue(entity2, propName, ascendingSorting);
temp = compareProperties(propValue1, propValue2);
if (!ascendingSorting) {
temp = 0 - temp;
}
}
return temp;
} | java |
public List<Entity> sortEntities(List<Entity> entities) {
if (entities != null && entities.size() > 0) {
Entity[] ents = (Entity[]) entities.toArray(new Entity[entities.size()]);
WIMSortCompare<Entity> wimSortComparator = new WIMSortCompare<Entity>(sortControl);
Arrays.sort(ents, wimSortComparator);
entities.clear();
for (int i = 0; i < ents.length; i++) {
entities.add(ents[i]);
}
}
return entities;
} | java |
@Override
public void encodeBegin(FacesContext context) throws IOException
{
_initialDescendantComponentState = null;
if (_isValidChilds && !hasErrorMessages(context))
{
// Clear the data model so that when rendering code calls
// getDataModel a fresh model is fetched from the backing
// bean via the value-binding.
_dataModelMap.clear();
// When the data model is cleared it is also necessary to
// clear the saved row state, as there is an implicit 1:1
// relation between objects in the _rowStates and the
// corresponding DataModel element.
if (!isRowStatePreserved())
{
_rowStates.clear();
}
}
super.encodeBegin(context);
} | java |
private void processColumnFacets(FacesContext context, int processAction)
{
for (int i = 0, childCount = getChildCount(); i < childCount; i++)
{
UIComponent child = getChildren().get(i);
if (child instanceof UIColumn)
{
if (! _ComponentUtils.isRendered(context, child))
{
// Column is not visible
continue;
}
if (child.getFacetCount() > 0)
{
for (UIComponent facet : child.getFacets().values())
{
process(context, facet, processAction);
}
}
}
}
} | java |
private void processColumnChildren(FacesContext context, int processAction)
{
int first = getFirst();
int rows = getRows();
int last;
if (rows == 0)
{
last = getRowCount();
}
else
{
last = first + rows;
}
for (int rowIndex = first; last == -1 || rowIndex < last; rowIndex++)
{
setRowIndex(rowIndex);
// scrolled past the last row
if (!isRowAvailable())
{
break;
}
for (int i = 0, childCount = getChildCount(); i < childCount; i++)
{
UIComponent child = getChildren().get(i);
if (child instanceof UIColumn)
{
if (! _ComponentUtils.isRendered(context, child))
{
// Column is not visible
continue;
}
for (int j = 0, columnChildCount = child.getChildCount(); j < columnChildCount; j++)
{
UIComponent columnChild = child.getChildren().get(j);
process(context, columnChild, processAction);
}
}
}
}
} | java |
public void setRows(int rows)
{
if (rows < 0)
{
throw new IllegalArgumentException("rows: " + rows);
}
getStateHelper().put(PropertyKeys.rows, rows );
} | java |
@JSFProperty(literalOnly=true, faceletsOnly=true)
public boolean isRowStatePreserved()
{
Boolean b = (Boolean) getStateHelper().get(PropertyKeys.rowStatePreserved);
return b == null ? false : b.booleanValue();
} | java |
@Override
public List<String> getManagedObjects() {
ArrayList<String> managedObjects = new ArrayList<String>();
if (this.application != null) {
managedObjects.addAll(application.getManagedObjects());
}
if (this.factory != null) {
managedObjects.addAll(factory.getManagedObjects());
}
if (this.lifecycle != null) {
managedObjects.addAll(lifecycle.getManagedObjects());
}
return managedObjects;
} | java |
public long getLastModified() {
if(matchedEntry != null){
return matchedEntry.getLastModified();
} else if (matchedZipFile != null){
return matchedZipFile.getLastModified();
} else if (matchedFile != null){
return matchedFile.lastModified();
} else {
return 0;
}
} | java |
public void expiryAlarm(AORequestedTick requestedTick)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "expiryAlarm", requestedTick);
boolean transitionOccured = false;
ArrayList<AORequestedTick> satisfiedTicks = null;
try
{
this.lock();
try
{
// it is possible that this event occurs after this object is closed.
// it is safe to ignore it since we must have already transitioned the requestedTick to its final state
if (closed)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "expiryAlarm");
return;
}
transitionOccured = cancelRequestInternal(requestedTick, true);
// If we expired the request and have more then process those
// requests now
if (transitionOccured && !listOfRequests.isEmpty())
satisfiedTicks = processQueuedMsgs(null);
}
finally
{
this.unlock();
}
}
catch(SINotPossibleInCurrentConfigurationException e)
{
// No FFDC code needed
notifyException(e);
}
if (transitionOccured)
{ // parent needs to be informed
parent.expiredRequest(requestedTick.tick);
}
if (satisfiedTicks != null)
{
// inform parent about satisfied ticks - outside lock
int length = satisfiedTicks.size();
for (int i = 0; i < length; i++)
{
AORequestedTick aotick = (AORequestedTick) satisfiedTicks.get(i);
long tick = aotick.tick;
SIMPMessage m = aotick.getMessage();
parent.satisfiedRequest(tick, m);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "expiryAlarm");
} | java |
public void alarm(Object thandle)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "alarm", thandle);
boolean doClose = false;
// We're probably about to close this consumer, which needs us to remove it from the AOStream's
// consciousness first (so that it doesn't allow it to be used while we're closing it - as that's
// done outside of the lock). To do this we need to take the AOStream's (parent's) lock first and
// remove it from the parent's list prior to releasing the lock.
synchronized(parent)
{
this.lock();
try
{
if (idleHandler != null)
{ // so we are still idle
if (!listOfRequests.isEmpty())
{ // we have an outstanding request. idleHandler should be null, and therefore != thandle
// Since this should never occur, log this error
SIErrorException e =
new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint",
"1:1121:1.43.2.26" },
null));
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint.alarm",
"1:1126:1.43.2.26",
this);
SibTr.exception(tc, e);
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.JSRemoteConsumerPoint",
"1:1132:1.43.2.26" });
}
else
{
// Remove this consumer so that it is no longer handed out for new requests (they'll
// have to create a new consumer to use)
parent.removeConsumerKey(selectionCriteriasAsString, this);
doClose = true;
}
}
}
finally
{
this.unlock();
}
} // synchronised(parent)
if (doClose)
{
close(); //Never call close() from within synchronized (this)!!
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "alarm");
} | java |
public void cleanup() {
cleanupLock.lock();
try {
// Clean up the write interface.
if (null != writeInterface) {
this.writeInterface.close();
this.writeInterface = null;
}
// Clean up the read interface.
if (null != readInterface) {
this.readInterface.close();
this.readInterface = null;
}
// Clean up the SSL engine.
if (null != getSSLEngine()) {
//If the channel has already processed the stop signal, it is too late to try and send the write handshake
if (this.sslChannel.getstop0Called() == true) {
this.connected = false;
}
SSLUtils.shutDownSSLEngine(this, isInbound, this.connected);
this.sslEngine = null;
}
// mark that we have disconnected
this.connected = false;
} finally {
cleanupLock.unlock();
}
} | java |