code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
@Override
public void introspect(PrintWriter writer) {
RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
introspectUptime(runtime, writer);
introspectVendorVersion(runtime, writer);
introspectInputArguments(runtime, writer);
Map<String, String> props = introspectSystemProperties(runtime, writer);
//introspectPaths(runtime, writer);
introspectDirsFromSystemProperties(runtime, writer, "java.ext.dirs", props);
introspectDirsFromSystemProperties(runtime, writer, "java.endorsed.dirs", props);
}
|
java
|
public ArrayList getProperties(){
ArrayList properties = new ArrayList();
if (configEntry.properties != null){
Iterator it = configEntry.properties.values().iterator();
while (it.hasNext()){
Property property = new Property((com.ibm.ws.cache.config.Property)it.next());
properties.add(property);
}
}
return properties;
}
|
java
|
public CacheId[] getCacheIds(){
CacheId[] cacheIds = new CacheId[configEntry.cacheIds.length];
for ( int i=0; i<configEntry.cacheIds.length; i++ ){
cacheIds[i] = new CacheId(configEntry.cacheIds[i]);
}
return cacheIds;
}
|
java
|
public DependencyId[] getDependencyIds(){
DependencyId[] depIds = new DependencyId[configEntry.dependencyIds.length];
for ( int i=0; i<configEntry.dependencyIds.length; i++ ){
depIds[i] = new DependencyId(configEntry.dependencyIds[i]);
}
return depIds;
}
|
java
|
public Invalidation[] getInvalidations(){
Invalidation[] invalidations = new Invalidation[configEntry.invalidations.length];
for ( int i=0; i<configEntry.invalidations.length; i++ ){
invalidations[i] = new Invalidation(configEntry.invalidations[i]);
}
return invalidations;
}
|
java
|
private void closeSocketChannel(SocketChannel sc) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
try {
Tr.event(this, tc, "Closing connection, local: " + sc.socket().getLocalSocketAddress() + " remote: " + sc.socket().getRemoteSocketAddress());
} catch (Throwable t) {
// protect against JDK PK42970 throwing illegal arg
}
}
try {
sc.close();
} catch (IOException ioe) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "IOException caught while closing connection " + ioe);
}
}
}
|
java
|
public static Class<?>[] toTypeArray(String[] s) throws ClassNotFoundException {
if (s == null)
return null;
Class<?>[] c = new Class[s.length];
for (int i = 0; i < s.length; i++) {
c[i] = forName(s[i]);
}
return c;
}
|
java
|
public static String[] toTypeNameArray(Class<?>[] c) {
if (c == null)
return null;
String[] s = new String[c.length];
for (int i = 0; i < c.length; i++) {
s[i] = c[i].getName();
}
return s;
}
|
java
|
public boolean add(Object o) {
synchronized (pool) {
if (index < pool.length) {
pool[index++] = o;
// if (DEBUG && tc.isDebugEnabled() )
// Tr.debug(tc,"added to pool " + name + " at " + index);
return true;
}
}
// if (DEBUG && tc.isDebugEnabled() )
// Tr.debug(tc,"pool " + name + " is full");
return false;
}
|
java
|
protected synchronized Dispatchable getThreadContext()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getThreadContext");
// Start D202625
// Save the position of the data
int currentPos = data.position();
int currentLimit = data.limit();
Dispatchable dis = null;
try
{
dis = listener.getThreadContext(conversation, data, segmentType);
}
catch (Throwable t)
{
FFDCFilter.processException(t, "com.ibm.ws.sib.jfapchannel.impl.rldispatcher.ConversationReceiveListenerDataReceivedInvocation.getThreadContext",
JFapChannelConstants.CRLDATARECEIVEDINVOKE_GETTHREADCONTEXT_01,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "exception thrown by getThreadContext");
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.exception(this, tc, t);
// User has thrown an exception from getThreadContext method. Probably
// the best way to deal with this is to invalidate their connection.
// That'll learn 'em.
connection.invalidate(true, t, "exception thrown from getThreadContext - "+t.getMessage()); // D224570
// Throw this bad boy to indicate to the dispatcher that something has gone wrong and
// that it should abort processing this segment.
throw new SIErrorException(TraceNLS.getFormattedMessage(JFapChannelConstants.MSG_BUNDLE, "CRLDRI_INTERNAL_SICJ0065", null, "CRLDRI_INTERNAL_SICJ0065")); // D226223
}
// Make sure we re-position the data
data.position(currentPos);
data.limit(currentLimit);
// End D202625
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getThreadContext",dis);
return dis;
}
|
java
|
public void setLogDataDirectory(String logDataDirectory) {
LogState state = ivLog.setDataDirectory(logDataDirectory);
if (state != null) {
updateLogConfiguration(state);
state.copyTo(ivLog);
}
}
|
java
|
private void updateTraceConfiguration(TraceState state) {
if (DIRECTORY_TYPE.equals(state.ivStorageType)) {
LogRepositoryComponent.setTraceDirectoryDestination(state.ivDataDirectory, state.ivPurgeBySizeEnabled, state.ivPurgeByTimeEnabled,
state.ivFileSwitchEnabled, state.ivBufferingEnabled, state.ivPurgeMaxSize * ONE_MEG , state.ivPurgeMinTime * MILLIS_IN_HOURS,
state.ivFileSwitchTime, state.ivOutOfSpaceAction);
} else if (MEMORYBUFFER_TYPE.equals(state.ivStorageType)) {
LogRepositoryComponent.setTraceMemoryDestination(state.ivDataDirectory, state.ivMemoryBufferSize * ONE_MEG);
} else {
throw new IllegalArgumentException("Unknown value for trace storage type: " + state.ivStorageType);
}
}
|
java
|
public void setTraceMemory(String dataDirectory, long memoryBufferSize) {
TraceState state = (TraceState)ivTrace.clone();
state.ivStorageType = MEMORYBUFFER_TYPE;
state.ivDataDirectory = dataDirectory;
state.ivMemoryBufferSize = memoryBufferSize;
updateTraceConfiguration(state);
state.copyTo(ivTrace);
}
|
java
|
private static HttpServletRequest getWrappedServletRequestObject(HttpServletRequest sr) {
if (sr instanceof HttpServletRequestWrapper) {
HttpServletRequestWrapper w = (HttpServletRequestWrapper) sr;
// make sure we drill all the way down to an
// SRTServletRequest...there
// may be multiple proxied objects
sr = (HttpServletRequest) w.getRequest();
while (sr instanceof HttpServletRequestWrapper)
sr = (HttpServletRequest) ((HttpServletRequestWrapper) sr).getRequest();
}
return sr;
}
|
java
|
public static FileSharedServerLeaseLog getFileSharedServerLeaseLog(String logDirStem, String localRecoveryIdentity, String recoveryGroup) {
if (tc.isEntryEnabled())
Tr.entry(tc, "FileSharedServerLeaseLog", new Object[] { logDirStem, localRecoveryIdentity, recoveryGroup });
if (_serverInstallLeaseLogDir == null)
setLeaseLog(logDirStem, localRecoveryIdentity, recoveryGroup);
if (tc.isEntryEnabled())
Tr.exit(tc, "FileSharedServerLeaseLog", _fileLeaseLog);
return _fileLeaseLog;
}
|
java
|
public static int parseRMICCompatible(String options) // PM46698
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "parseRMICCompatible: " + options);
int flags;
if (options == null)
{
flags = RMIC_COMPATIBLE_DEFAULT;
}
else if (options.equals("none"))
{
flags = 0;
}
else if (options.isEmpty() || options.equals("all"))
{
flags = -1;
}
else
{
flags = 0;
for (String option : options.split(","))
{
if (option.equals("values"))
{
flags |= RMIC_COMPATIBLE_VALUES;
}
else if (option.equals("exceptions")) // PM94096
{
flags |= RMIC_COMPATIBLE_EXCEPTIONS;
}
else
{
throw new IllegalArgumentException("unknown RMIC compatibility option: " + option);
}
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "parseRMICCompatible: " + Integer.toHexString(flags));
return flags;
}
|
java
|
public static void registerJIT_StubClassPlugin(ClassLoader classloader)
{
boolean isRegistered = JIT_StubPluginImpl.register(classloader);
if (!isRegistered)
{
throw new IllegalArgumentException("Specified ClassLoader does not support JIT_StubClassPlugin : " + classloader);
}
}
|
java
|
synchronized void setStageTopics(String stageName, String[] topics) {
for (String t : topics) {
if (t.equals("*")) {
wildcardStageTopics.put("", stageName);
} else if (t.endsWith("/*")) {
wildcardStageTopics.put(t.substring(0, t.length() - 1), stageName);
} else {
discreteStageTopics.put(t, stageName);
}
}
// Clear the cache since it's no longer up to date
clearTopicDataCache();
}
|
java
|
TopicData getTopicData(Topic topic, String topicName) {
TopicData topicData = null;
if (topic != null) {
topicData = topic.getTopicData();
}
if (topicData == null) {
topicData = topicDataCache.get(topicName);
if (topic != null && topicData != null) {
topic.setTopicDataReference(topicData.getReference());
}
}
if (topicData == null) {
synchronized (this) {
topicData = buildTopicData(topicName);
if (topic != null) {
topic.setTopicDataReference(topicData.getReference());
}
}
}
return topicData;
}
|
java
|
public boolean accessDenied(InetAddress remoteAddr) {
String hostname = null; //F184719
// check the inclusion lists first to see if the client matches
if (includeAccess.getActive() || includeAccessNames.getActive()) {
boolean closeSocket = true;
if (includeAccess.getActive()) {
if (remoteAddr instanceof Inet6Address) {
if (includeAccess.findInList6(remoteAddr.getAddress())) {
closeSocket = false;
}
} else {
if (includeAccess.findInList(remoteAddr.getAddress())) {
closeSocket = false;
}
}
}
if (closeSocket && includeAccessNames.getActive()) {
// look at hostnames to check inclusion
hostname = remoteAddr.getHostName();
if (caseInsensitiveHostnames && (hostname != null)) {
hostname = hostname.toLowerCase();
}
if (includeAccessNames.findInList(hostname)) {
closeSocket = false;
}
}
if (closeSocket) {
// close the excluded socket connection
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
Tr.event(tc, "Address and host name not in include list, address: " + remoteAddr.getHostAddress() + " host name: " + remoteAddr.getHostName());
return true;
}
}
if (excludeAccess.getActive() || excludeAccessNames.getActive()) {
boolean closeSocket = false;
if (excludeAccess.getActive()) {
if (remoteAddr instanceof Inet6Address) {
if (excludeAccess.findInList6(remoteAddr.getAddress())) {
// close the excluded socket connection
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
Tr.event(tc, "Address (IPv6) in exclude list, address: " + remoteAddr.getHostAddress());
return true;
}
} else {
if (excludeAccess.findInList(remoteAddr.getAddress())) {
// close the excluded socket connection
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
Tr.event(tc, "Address in exclude list, address: " + remoteAddr.getHostAddress());
return true;
}
}
}
if (closeSocket == false && excludeAccessNames.getActive()) {
// look at hostnames to check exclusion
hostname = remoteAddr.getHostName();
if (caseInsensitiveHostnames && (hostname != null)) {
hostname = hostname.toLowerCase();
}
if (excludeAccessNames.findInList(hostname)) {
// close the excluded socket connection
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
Tr.event(tc, "Host name in exclude list, host name: " + remoteAddr.getHostName());
return true;
}
}
} // end if(there are excludes to check)
return false;
}
|
java
|
final protected void eventPrecommitAdd(MessageItem msg, final TransactionCommon transaction) throws SIDiscriminatorSyntaxException, SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "eventPrecommitAdd", new Object[] { msg, transaction });
if (!(_destination.isToBeDeleted()))
{
if (msg.isTransacted() && (!(msg.isToBeStoredAtSendTime())))
{
// LockR the destination to prevent reallocation from occurring on the chosen localisation
LockManager reallocationLock = _destination.getReallocationLockManager();
reallocationLock.lock();
try
{
// If we fixed the ME it'll be in the routing address in the message
SIBUuid8 fixedME = null;
JsDestinationAddress routingAddr = msg.getMessage().getRoutingDestination();
if (routingAddr != null)
fixedME = routingAddr.getME();
// If the sender prefers any local ME over others then we'll give it a go
SIBUuid8 preferredME = null;
if (msg.preferLocal())
{
if (_destination.hasLocal())
preferredME = _messageProcessor.getMessagingEngineUuid();
}
// 176658.3.5
OutputHandler handler = _destination.choosePtoPOutputHandler(fixedME,
preferredME,
!msg.isFromRemoteME(),
msg.isForcePut(),
null);
if (handler == null)
{
// We can't find a suitable localisation.
// Although a queue must have at least one localisation this is
// possible if the sender restricted the potential localisations
// using a fixed ME or a scoping alias (to an out-of-date set of
// localisation)
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, "No suitable OutputHandler found for " + _destination.getName() + " (" + fixedME + ")");
}
//Put the message to the exception destination.
handleUndeliverableMessage(_destination
, null // null LinkHandler
, msg
, SIRCConstants.SIRC0026_NO_LOCALISATIONS_FOUND_ERROR
, new String[] { _destination.getName() }
, transaction);
}
else
{
//Indicate in the message if this was a guess
msg.setStreamIsGuess(handler.isWLMGuess());
// put the message to the output handler
handler.put(msg, transaction, null, true);
}
} finally
{
// unlock the reallocation lock
reallocationLock.unlock();
}
}
}
else
{
//The destination has been deleted. Put the message to the exception destination#
ExceptionDestinationHandlerImpl exceptionDestinationHandlerImpl =
(ExceptionDestinationHandlerImpl) _messageProcessor.createExceptionDestinationHandler(null);
//Set indicator to send the message to the exception destination immediately,
//rather than registering it for pre-prepare of the transaction, as this is
//pre-prepare of the transaction!
msg.setStoreAtSendTime(true);
String destName = _destination.getName();
if (_destination.isLink())
destName = ((LinkHandler) _destination).getBusName();
final UndeliverableReturnCode rc =
exceptionDestinationHandlerImpl.handleUndeliverableMessage(msg
, transaction
, SIRCConstants.SIRC0032_DESTINATION_DELETED_ERROR
, new String[] { destName,
_messageProcessor.getMessagingEngineName() });
if (rc != UndeliverableReturnCode.OK)
{
if (rc == UndeliverableReturnCode.DISCARD)
{
//The message is to be discarded. Do nothing and it will disappear.
}
else
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "eventPrecommitAdd", "WsRuntimeException");
//We cannot put the message to the exception destination. All we can
//do in this case is rollback the users transaction. This is done by
//throwing an exception that is caught by the transaction manager.
throw new WsRuntimeException(
nls.getFormattedMessage(
"DESTINATION_DELETED_ERROR_CWSIP0247",
new Object[] { _destination.getName(),
rc },
null));
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "eventPrecommitAdd");
}
|
java
|
@Override
public void sendAckMessage(SIBUuid8 sourceMEUuid,
SIBUuid12 destUuid,
SIBUuid8 busUuid,
long ackPrefix,
int priority,
Reliability reliability,
SIBUuid12 stream,
boolean consolidate) throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "sendAckMessage", new Long(ackPrefix));
ControlAck ackMsg = createControlAckMessage();
// As we are using the Guaranteed Header - set all the attributes as
// well as the ones we want.
SIMPUtils.setGuaranteedDeliveryProperties(ackMsg,
_messageProcessor.getMessagingEngineUuid(),
sourceMEUuid,
stream,
null,
destUuid,
ProtocolType.UNICASTOUTPUT,
GDConfig.PROTOCOL_VERSION);
ackMsg.setPriority(priority);
ackMsg.setReliability(reliability);
ackMsg.setAckPrefix(ackPrefix);
// Send Ack messages at the priority of the original message +1
sendToME(ackMsg, sourceMEUuid, busUuid, priority + 1);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "sendAckMessage");
}
|
java
|
@Override
public void sendNackMessage(SIBUuid8 sourceMEUuid,
SIBUuid12 destUuid,
SIBUuid8 busUuid,
long startTick,
long endTick,
int priority,
Reliability reliability,
SIBUuid12 stream)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"sendNackMessage",
new Object[] { new Long(startTick), new Long(endTick) });
ControlNack nackMsg = createControlNackMessage();
// As we are using the Guaranteed Header - set all the attributes as
// well as the ones we want.
SIMPUtils.setGuaranteedDeliveryProperties(nackMsg,
_messageProcessor.getMessagingEngineUuid(),
sourceMEUuid,
stream,
null,
destUuid,
ProtocolType.UNICASTOUTPUT,
GDConfig.PROTOCOL_VERSION);
nackMsg.setPriority(priority);
nackMsg.setReliability(reliability);
nackMsg.setStartTick(startTick);
nackMsg.setEndTick(endTick);
// Send Nack messages at original message priority +2
sendToME(nackMsg, sourceMEUuid, busUuid, priority + 2);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "sendNackMessage ");
}
|
java
|
private ControlNack createControlNackMessage()
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "createControlNackMessage");
ControlNack nackMsg = null;
// Create new NackMessage
try
{
nackMsg = _cmf.createNewControlNack();
} catch (MessageCreateFailedException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.PtoPInputHandler.createControlNackMessage",
"1:1604:1.323",
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.exception(tc, e);
SibTr.exit(tc, "createControlNackMessage", e);
}
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.impl.PtoPInputHandler",
"1:1616:1.323",
e });
throw new SIResourceException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.impl.PtoPInputHandler",
"1:1624:1.323",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createControlNackMessage");
return nackMsg;
}
|
java
|
protected ControlRequestFlush createControlRequestFlush() throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "createControlRequestFlush");
ControlRequestFlush rflushMsg = null;
// Create new message
try
{
rflushMsg = _cmf.createNewControlRequestFlush();
} catch (MessageCreateFailedException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.PtoPInputHandler.createControlRequestFlush",
"1:1717:1.323",
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.exception(tc, e);
SibTr.exit(tc, "createControlRequestFlush", e);
}
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.impl.PtoPInputHandler",
"1:1729:1.323",
e });
throw new SIResourceException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.impl.PtoPInputHandler",
"1:1737:1.323",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createControlRequestFlush", rflushMsg);
return rflushMsg;
}
|
java
|
private int checkCanExceptionMessage(DestinationHandler destinationHandler)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"checkCanExceptionMessage",
new Object[] { destinationHandler });
// Destination exception destination handler
ExceptionDestinationHandlerImpl exceptionDestinationHandler = null;
// Instantiate an ExceptionDestinationHandlerImpl for the destination
exceptionDestinationHandler = new ExceptionDestinationHandlerImpl(destinationHandler);
int returnValue = exceptionDestinationHandler.checkCanExceptionMessage();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "checkCanExceptionMessage", Integer.valueOf(returnValue));
return returnValue;
}
|
java
|
private int checkTargetAbleToAcceptOrExceptionMessage(JsDestinationAddress targetDestinationAddr)
throws SITemporaryDestinationNotFoundException, SIResourceException, SINotPossibleInCurrentConfigurationException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "checkTargetAbleToAcceptOrExceptionMessage", targetDestinationAddr);
int blockingReason = DestinationHandler.OUTPUT_HANDLER_NOT_FOUND;
// If the original routingDestination address in the message was blank we simply return
// 'not found'.
if (targetDestinationAddr != null)
{
// Lookup the routing (target) destination. This may throw a SIMPNotPossibleInCurrentConfigurationException.
DestinationHandler targetDestination =
_messageProcessor.getDestinationManager().getDestination(targetDestinationAddr, false);
SIBUuid8 targetDestinationMEUuid = targetDestinationAddr.getME();
// Can the routing destination accept a message
blockingReason = targetDestination.checkCanAcceptMessage(targetDestinationMEUuid, null);
// If the target is full (or put-disabled, etc) then we want to go on & see if we can
// put to the exception destination of the target destination
if (blockingReason != DestinationHandler.OUTPUT_HANDLER_FOUND)
{
int linkBlockingReason = checkCanExceptionMessage(targetDestination);
// If we can exception the message then reset the blockingReason return code
if (linkBlockingReason == DestinationHandler.OUTPUT_HANDLER_FOUND)
blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "checkTargetAbleToAcceptOrExceptionMessage", Integer.valueOf(blockingReason));
return blockingReason;
}
|
java
|
private int checkLinkAbleToExceptionMessage()
throws SIException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "checkLinkAbleToExceptionMessage");
int blockingReason = DestinationHandler.OUTPUT_HANDLER_NOT_FOUND;
blockingReason = checkCanExceptionMessage(_destination);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "checkLinkAbleToExceptionMessage", Integer.valueOf(blockingReason));
return blockingReason;
}
|
java
|
@Override
public int checkStillBlocked()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "checkStillBlocked");
// For safety, we assume that the destination is blocked (def 244425 and 464463)
int blockingReason = DestinationHandler.OUTPUT_HANDLER_NOT_FOUND;
if (!_isLink)
{
// For non-links we want to process ackExpecteds as normal
blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
}
else
{
// If this is a link then we are potentially interested in a number of destinations: the destination
// currently blocking the link, its exception destination, the link's exception destination and maybe
// the system exception destination. For example, if no link exception destination is defined and a
// message could not be delivered on either the target destination or the target's exception destination,
// then the entire link will be blocked until that message can be delivered or has been deleted at the
// source end.
//
// If a link does have an exception destination defined then there are situations where that exception
// destination itself may be unable to accept messages and will therefore lead to the link being blocked.
// If the condition that led to the blocking of the link no longer applies and if no other blocking
// condition has arisen then we can start sending NACKs to the source as there will be space for what
// might be returned. If it still cannot accept messages then we are still not able to send NACKs.
// If the link was blocked because the routing destination or the configured exception destinations
// were full, then check that they now have room
boolean checkedTarget = false;
try
{
// Do a general message acceptance test on the link blocking destination and any associated
// exception destination if the link is still marked as blocked.
blockingReason =
checkTargetAbleToAcceptOrExceptionMessage(_linkBlockingDestination);
// We've checked the target and have a return code
checkedTarget = true;
} catch (SIMPNotPossibleInCurrentConfigurationException e)
{
// No FFDC code needed
// There's a problem with the configuration of the target destination - so set checkedTarget to
// true, retain the OUTPUT_HANDLER_NOT_FOUND return code and continue processing. If we find that
// the link exception destination is also unable to accept the message then we want to report
// the target blocking reason rather than the link blocking reason, which may be different.
checkedTarget = true;
// Log the exception
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.exception(tc, e);
} catch (SIException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.PtoPInputHandler.checkStillBlocked",
"1:3720:1.323",
this);
}
// If still blocked, then are we able to exploit the link exception destination
try
{
if (blockingReason != DestinationHandler.OUTPUT_HANDLER_FOUND)
{
int linkBlockingReason = checkLinkAbleToExceptionMessage();
// If we can exception the message then reset the blockingReason return code
if (linkBlockingReason == DestinationHandler.OUTPUT_HANDLER_FOUND)
blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
// If we didn't get a reason code from checking the target or its exception destination
// then use the link's.
else if (!checkedTarget)
blockingReason = linkBlockingReason;
}
} catch (SIException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.PtoPInputHandler.checkStillBlocked",
"1:3745:1.323",
this);
}
// If the link is no longer blocked, clear out the blocking destination
if (blockingReason == DestinationHandler.OUTPUT_HANDLER_FOUND)
_linkBlockingDestination = null;
} // eof processing specific to link
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "checkStillBlocked", new Integer(blockingReason));
return blockingReason;
}
|
java
|
void balancedPush(
int state,
GBSNode node)
{
push(state, node);
if (node.balance() != 0)
_bpidx = _cidx;
}
|
java
|
void processSubFringe(
GBSNode p)
{
/* Depth of a balanced T-zero tree for */
/* this tree's K factor */
int t0_depth = _tree.tZeroDepth();
/* Determine top-most node we must visit in the tree walk */
int ntop = 0; /* This is the index within the */
/* NodeStack that represents the top */
/* of the sub-tree. We start by */
/* assuming we have to walk the whole */
/* tree. */
int xChild = 0; /* Assume current node has no children */
if (p.hasChild())
xChild = 1; /* Allow for terminal child */
if (index() > t0_depth) /* Have at least a whole t0 sub-tree */
ntop = index() - (t0_depth - xChild);
innerProcessSubTree(p, NodeStack.VISIT_RIGHT, ntop);
}
|
java
|
private void innerProcessSubTree(
GBSNode p,
int initialState,
int topIndex)
{
boolean done = false;
_topIndex = topIndex;
_endp = p;
_endIndex = _idx;
GBSNode q; /* Used for tree walking */
int s = initialState;
while ( !done )
{
switch(s)
{
case NodeStack.VISIT_LEFT:
s = NodeStack.PROCESS_CURRENT;
q = p.leftChild();
while (q != null)
{
push(s, p);
p = q;
q = p.leftChild();
}
break;
case NodeStack.PROCESS_CURRENT:
s = NodeStack.VISIT_RIGHT;
done = processNode(p);
_endp = p; /* Last node processed */
_endIndex = _idx; /* Index to parent of last node processed*/
break;
case NodeStack.VISIT_RIGHT:
s = NodeStack.DONE_VISITS;
q = p.rightChild();
if (q != null)
{
push(s, p);
s = NodeStack.VISIT_LEFT;
p = p.rightChild();
}
break;
case NodeStack.DONE_VISITS:
if (_idx == topIndex) /* Have finally hit end of sub-tree */
done = true;
else
{
s = _state[_cidx];
p = _node[_cidx];
pop();
}
break;
default:
throw new RuntimeException("Help!, s = " + s + ".");
// break;
} /* switch(s) */
} /* while ( !done ) */
}
|
java
|
public String stateName(
int state)
{
String name = "Unknown state = " + state;
switch(state)
{
case NodeStack.VISIT_LEFT:
name = "VISIT_LEFT";
break;
case NodeStack.PROCESS_CURRENT:
name = "PROCESS_CURRENT";
break;
case NodeStack.VISIT_RIGHT:
name = "VISIT_RIGHT";
break;
case NodeStack.DONE_VISITS:
name = "DONE_VISITS";
break;
}
return name;
}
|
java
|
public final static void logException(TraceComponent compTc, Throwable t, EJBMethodMetaData m, BeanO bean) {
//d408351 - only log recursive exceptions if they have not been logged before
if (hasBeenLogged(t)) {
return;
}
BeanId beanId = null;
if (bean != null) {
beanId = bean.getId();
}
if (m == null) {
if (beanId == null) {
Tr.error(compTc, "NON_APPLICATION_EXCEPTION_CNTR0018E", t);
} else {
Tr.error(compTc, "NON_APPLICATION_EXCEPTION_ON_BEAN_CNTR0021E", new Object[] { t, beanId });
}
} else {
String methodName = m.getMethodName();
if (beanId == null) {
Tr.error(compTc, "NON_APPLICATION_EXCEPTION_METHOD_CNTR0019E", new Object[] { t, methodName });
} else {
Tr.error(compTc, "NON_APPLICATION_EXCEPTION_METHOD_ON_BEAN_CNTR0020E", new Object[] { t, methodName, beanId });
}
}
}
|
java
|
static public Throwable findRootCause(Throwable throwable) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "findRootCause: " + throwable);
}
Throwable root = throwable;
Throwable next = root;
while (next != null) {
root = next;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "finding cause of: " + root.getClass().getName());
}
if (root instanceof java.rmi.RemoteException) {
next = ((java.rmi.RemoteException) root).detail;
} else if (root instanceof WsNestedException) // d162976
{
next = ((WsNestedException) root).getCause(); // d162976
} else if (root instanceof TransactionRolledbackLocalException) //d180095 begin
{
next = ((TransactionRolledbackLocalException) root).getCause();
} else if (root instanceof AccessLocalException) {
next = ((AccessLocalException) root).getCause();
} else if (root instanceof NoSuchObjectLocalException) {
next = ((NoSuchObjectLocalException) root).getCause();
} else if (root instanceof TransactionRequiredLocalException) {
next = ((TransactionRequiredLocalException) root).getCause();
}
// else if (root instanceof InvalidActivityLocalException)
// {
// root = ((InvalidActivityLocalException) root).getCause();
// }
// else if (root instanceof ActivityRequiredLocalException)
// {
// root = ((ActivityRequiredLocalException) root).getCause();
// }
// else if (root instanceof ActivityCompletedLocalException)
// {
// next = ((ActivityCompletedLocalException) root).getCause(); //d180095 end
// }
else if (root instanceof NamingException) {
next = ((NamingException) root).getRootCause();
} else if (root instanceof InvocationTargetException) {
next = ((InvocationTargetException) root).getTargetException();
} else if (root instanceof org.omg.CORBA.portable.UnknownException) {
next = ((org.omg.CORBA.portable.UnknownException) root).originalEx;
} else if (root instanceof InjectionException) // d436080
{
next = root.getCause();
} else {
next = null;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "findRootCause returning: " + root);
return root;
}
|
java
|
public static Exception Exception(Throwable cause) {
return (cause instanceof Exception) ? (Exception) cause : new Exception("See nested Throwable", cause);
}
|
java
|
protected ClientBehaviorAttachedObjectTargetImpl createAttachedObjectTarget(FaceletContext ctx)
{
ClientBehaviorAttachedObjectTargetImpl target = new ClientBehaviorAttachedObjectTargetImpl();
if (_event != null)
{
target.setEvent(_event.getValueExpression(ctx, String.class));
}
if (_name != null)
{
target.setName(_name.getValueExpression(ctx, String.class));
}
if (_default != null)
{
target.setDefault(_default.getBoolean(ctx));
}
if (_targets != null)
{
target.setTargets(_targets.getValueExpression(ctx, String.class));
}
return target;
}
|
java
|
private void registerEndpointMBean(String name, EndPointInfoImpl ep) {
endpointMBeans.put(name, registerMBeanAsService(name, ep));
}
|
java
|
private EndPointInfoImpl updateEndpointMBean(String name, String host, int port) {
EndPointInfoImpl existingEP = endpoints.get(name);
existingEP.updateHost(host);
existingEP.updatePort(port);
return existingEP;
}
|
java
|
private void destroyEndpointMBeans() {
for (Map.Entry<String, ServiceRegistration<DynamicMBean>> mbean : endpointMBeans.entrySet()) {
String mbeanName = mbean.getKey();
endpointMBeans.remove(mbeanName);
mbean.getValue().unregister();
}
}
|
java
|
public static void destroyEndpoints() {
EndPointMgrImpl _this = (EndPointMgrImpl) getRef();
synchronized (_this.endpoints) {
_this.destroyEndpointMBeans();
_this.endpoints.clear();
}
}
|
java
|
private void unregisterMBeanInService(String name) {
ServiceRegistration<DynamicMBean> existingMBean = endpointMBeans.remove(name);
if (existingMBean != null) {
existingMBean.unregister();
}
}
|
java
|
@Override
public void removeEndPoint(String name) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Deleting endpoint: " + name);
}
synchronized (this.endpoints) {
if (this.endpoints.remove(name) != null) {
unregisterMBeanInService(name);
}
}
}
|
java
|
private static String[] getTokensArray(String tokenComposite)
throws ParseException
{
if (tokenComposite == null || "".equals(tokenComposite))
{
return null;
}
return parseNameTokens(tokenComposite);
}
|
java
|
static public String[] parseNameTokens(String stringValue)
{
if (stringValue == null)
{
return null;
}
ArrayList<String> list = new ArrayList<String>(5);
int length = stringValue.length();
boolean inSpace = true;
int start = 0;
for (int i = 0; i < length; i++)
{
char ch = stringValue.charAt(i);
// We're in whitespace; if we've just departed
// a run of non-whitespace, append a string.
// Now, why do we use the supposedly deprecated "Character.isSpace()"
// function instead of "isWhitespace"? We're following XML rules
// here for the meaning of whitespace, which specifically
// EXCLUDES general Unicode spaces.
if (Character.isWhitespace(ch))
{
if (!inSpace)
{
list.add(stringValue.substring(start, i));
inSpace = true;
}
}
// We're out of whitespace; if we've just departed
// a run of whitespace, start keeping track of this string
else
{
if (inSpace)
{
start = i;
inSpace = false;
}
}
}
if (!inSpace)
{
list.add(stringValue.substring(start));
}
if (list.isEmpty())
{
return null;
}
return list.toArray(new String[list.size()]);
}
|
java
|
public static FlowType getKey(int ordinal) {
if (ordinal >= 0 && ordinal < _values.length) {
return _values[ordinal];
}
return null;
}
|
java
|
public boolean containsChannel(String channelName) {
boolean found = false;
for (int i = 0; i < channels.length; i++) {
if (channels[i].getName().equals(channelName)) {
found = true;
break;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "containsChannel: " + channelName + "=" + found);
}
return found;
}
|
java
|
private static boolean needsEncoding(String s, boolean relax, boolean[] unreserved) {
int len = s.length();
for (int i = 0; i < len; ++i) {
char c = s.charAt(i);
if (c == '%' && relax) {
continue;
}
if (c > unreserved.length) {
return true;
}
if (unreserved[c] == false) {
return true;
}
}
return false;
}
|
java
|
public Object getWLMEndPointData()
{
if (mode != PropertiesType.WLM_EP)
{
throw new SIErrorException(
nls.getFormattedMessage("INVALID_METHOD_FOR_OBJECT_TYPE_SICO0006", null, "INVALID_METHOD_FOR_OBJECT_TYPE_SICO0006") // D270373
);
}
return wlmEndPointData;
}
|
java
|
public static String getContextRootNotFoundMessage() {
// this does not return a default string, since the caller may (and does in our case) choose to build a runtime
// dependent string.
HttpDispatcher f = instance.get().get();
if (f != null)
return f.appOrContextRootNotFound;
return null;
}
|
java
|
public boolean isTrusted(String hostAddr, String headerName) {
if (!wcTrusted) {
return false;
}
if (HttpHeaderKeys.isSensitivePrivateHeader(headerName)) {
// if this is a sensitive private header, check trustedSensitiveHeaderOrigin values
return isTrustedForSensitiveHeaders(hostAddr);
}
if (!usePrivateHeaders) {
// trustedHeaderOrigin list is explicitly set to "none"
return isTrustedForSensitiveHeaders(hostAddr);
}
if (restrictPrivateHeaderOrigin == null) {
// trustedHeaderOrigin list is set to "*"
return true;
} else {
// check trustedHeaderOrigin for given host IP
boolean trustedOrigin = restrictPrivateHeaderOrigin.contains(hostAddr.toLowerCase());
if (!trustedOrigin) {
// if hostAddr is not in trustedHeaderOrigin, allow trustedSensitiveHeaderOrigin to override trust
trustedOrigin = isTrustedForSensitiveHeaders(hostAddr);
}
return trustedOrigin;
}
}
|
java
|
public boolean isTrustedForSensitiveHeaders(String hostAddr) {
if (!useSensitivePrivateHeaders) {
// trustedSensitiveHeaderOrigin list is either unset (defaults to "none") or explicitly set to "none"
return false;
}
if (restrictSensitiveHeaderOrigin == null) {
// trustedSensitiveHeaderOrigin is set to "*"
return true;
} else {
// check trustedSensitiveHeaderOrigin list for given host IP
return restrictSensitiveHeaderOrigin.contains(hostAddr.toLowerCase());
}
}
|
java
|
public static ExecutorService getExecutorService() {
HttpDispatcher f = instance.get().get();
if (f == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "HttpDispatcher instance not found");
}
return null;
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "HttpDispatcher instance: " + f.toString());
}
return f.executorService;
}
}
|
java
|
public static CHFWBundle getCHFWBundle() {
HttpDispatcher f = instance.get().get();
if (f != null)
return f.chfw;
return null;
}
|
java
|
public static WsByteBufferPoolManager getBufferManager() {
final CHFWBundle chfw = getCHFWBundle();
if (null == chfw) {
return ChannelFrameworkFactory.getBufferManager();
}
return chfw.getBufferManager();
}
|
java
|
public static ChannelFramework getFramework() {
final CHFWBundle chfw = getCHFWBundle();
if (null == chfw) {
return ChannelFrameworkFactory.getChannelFramework();
}
return chfw.getFramework();
}
|
java
|
@Reference(name = "workClassifier", policy = ReferencePolicy.DYNAMIC, cardinality = ReferenceCardinality.OPTIONAL)
protected void setWorkClassifier(WorkClassifier service) {
workClassifier = service;
}
|
java
|
public static WorkClassifier getWorkClassifier() {
HttpDispatcher f = instance.get().get();
if (f != null)
return f.workClassifier;
return null;
}
|
java
|
private static ObjectName createObjectName(String type, String name, Hashtable<String, String> props) {
props.put(KEY_TYPE, type);
props.put(KEY_NAME, name);
try {
return new ObjectName(DOMAIN_NAME, props);
} catch (MalformedObjectNameException e) {
throw new IllegalArgumentException(e);
}
}
|
java
|
public static ObjectName createApplicationObjectName(String name, String serverName) {
Hashtable<String, String> props = new Hashtable<String, String>();
props.put(TYPE_SERVER, serverName);
return createObjectName(TYPE_APPLICATION, name, props);
}
|
java
|
public static ObjectName createEJBModuleObjectName(String uri, String appName, String serverName) {
return createModuleObjectName(ModuleType.EJBModule, uri, appName, serverName);
}
|
java
|
public static ObjectName createWebModuleObjectName(String moduleURI, String appName, String serverName) {
return createModuleObjectName(ModuleType.WebModule, moduleURI, appName, serverName);
}
|
java
|
public static ObjectName createJavaMailObjectName(String serverName, String mailSessionID, int resourceCounter) {
Hashtable<String, String> props = new Hashtable<String, String>();
props.put(TYPE_SERVER, serverName);
props.put(MAIL_SESSION_ID, mailSessionID);
props.put(RESOURCE_ID, TYPE_JAVA_MAIL_RESOURCE + "-" + resourceCounter);
ObjectName objectName;
try {
objectName = createObjectName(TYPE_JAVA_MAIL_RESOURCE, NAME_JAVA_MAIL_RESOURCE, props);
} catch (IllegalArgumentException e) {
// mailSessionID contains illegal characters
props.remove(MAIL_SESSION_ID);
objectName = createObjectName(TYPE_JAVA_MAIL_RESOURCE, NAME_JAVA_MAIL_RESOURCE, props);
}
return objectName;
}
|
java
|
public static ObjectName createResourceObjectName(String serverName, String resourceType, String keyName) {
ObjectName objectName;
Hashtable<String, String> props = new Hashtable<String, String>();
props.put(TYPE_SERVER, serverName);
objectName = createObjectName(resourceType, keyName, props);
return objectName;
}
|
java
|
@Override
public boolean libraryExists(String libraryName)
{
FacesContext facesContext = FacesContext.getCurrentInstance();
String localePrefix = getLocalePrefixForLocateResource(facesContext);
final List<String> contracts = facesContext.getResourceLibraryContracts();
String pathToLib = null;
Boolean libraryFound = null;
if (libraryName != null && !ResourceValidationUtils.isValidLibraryName(
libraryName, isAllowSlashesLibraryName()))
{
return false;
}
if (localePrefix != null)
{
//Check with locale
pathToLib = localePrefix + '/' + libraryName;
libraryFound = getResourceLoaderCache().libraryExists(pathToLib);
if (libraryFound != null)
{
return libraryFound.booleanValue();
}
}
libraryFound = getResourceLoaderCache().libraryExists(libraryName);
if (libraryFound != null)
{
return libraryFound.booleanValue();
}
if (localePrefix != null)
{
if (!contracts.isEmpty())
{
for (String contract : contracts)
{
for (ContractResourceLoader loader : getResourceHandlerSupport()
.getContractResourceLoaders())
{
if (loader.libraryExists(pathToLib, contract))
{
getResourceLoaderCache().confirmLibraryExists(pathToLib);
return true;
}
}
}
}
for (ResourceLoader loader : getResourceHandlerSupport()
.getResourceLoaders())
{
if (loader.libraryExists(pathToLib))
{
getResourceLoaderCache().confirmLibraryExists(pathToLib);
return true;
}
}
}
//Check without locale
if (!contracts.isEmpty())
{
for (String contract : contracts)
{
for (ContractResourceLoader loader : getResourceHandlerSupport()
.getContractResourceLoaders())
{
if (loader.libraryExists(libraryName, contract))
{
getResourceLoaderCache().confirmLibraryExists(libraryName);
return true;
}
}
}
}
for (ResourceLoader loader : getResourceHandlerSupport()
.getResourceLoaders())
{
if (loader.libraryExists(libraryName))
{
getResourceLoaderCache().confirmLibraryExists(libraryName);
return true;
}
}
if (localePrefix != null)
{
//Check with locale
getResourceLoaderCache().confirmLibraryNotExists(pathToLib);
}
else
{
getResourceLoaderCache().confirmLibraryNotExists(libraryName);
}
return false;
}
|
java
|
public Object setValue(Token object) {
Object result = value;
value = object;
return result;
}
|
java
|
@Override
protected MatchResponse getMatchResponse(SecurityConstraint securityConstraint, String resourceName, String method) {
CollectionMatch collectionMatch = getCollectionMatch(securityConstraint.getWebResourceCollections(), resourceName, method);
if (CollectionMatch.RESPONSE_NO_MATCH.equals(collectionMatch)) {
return MatchResponse.NO_MATCH_RESPONSE;
}
if (com.ibm.ws.webcontainer.osgi.WebContainer.getServletContainerSpecLevel() >= 31) {
if (collectionMatch.isExactMatch() && securityConstraint.isAccessUncovered() && securityConstraint.isFromHttpConstraint()) {
return new MatchResponse(securityConstraint.getRoles(), securityConstraint.isSSLRequired(),
securityConstraint.isAccessPrecluded(), CollectionMatch.RESPONSE_PERMIT);
}
}
return new MatchResponse(securityConstraint.getRoles(), securityConstraint.isSSLRequired(),
securityConstraint.isAccessPrecluded(), collectionMatch);
}
|
java
|
public void purge() {
synchronized(this){
// Clear all references to VirtualHost objects
for (DynamicVirtualHost host : hostMap.values()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Purge host : " + host.hashCode() + ", this : " +this);
}
host.getHostConfiguration().setConfiguration(null);
}
hostMap.clear();
}
//do not clear the transport map.
//DS looks after the transport map via set/unset/updateVirtualHost
//transportMap.clear();
}
|
java
|
private void setSsoTokenCredential(Subject subject, String principalAccessId)
throws CredentialException {
try {
TokenManager tokenManager = tokenManagerRef.getService();
SingleSignonToken ssoToken = null;
Set<Token> tokens = subject.getPrivateCredentials(Token.class);
if (tokens.isEmpty() == false) {
Token ssoLtpaToken = tokens.iterator().next();
subject.getPrivateCredentials().remove(ssoLtpaToken);
ssoToken = tokenManager.createSSOToken(ssoLtpaToken);
} else {
Map<String, Object> tokenData = new HashMap<String, Object>();
tokenData.put("unique_id", principalAccessId);
ssoToken = tokenManager.createSSOToken(tokenData);
}
subject.getPrivateCredentials().add(ssoToken);
} catch (TokenCreationFailedException e) {
throw new CredentialException(e.getLocalizedMessage());
}
}
|
java
|
public ManagedObject get(Token token)
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled()) {
trace.entry(this,
cclass,
"get",
token);
trace.exit(this,
cclass,
"get returns null");
}
return null;
// TODO If the memory object store has been restarted after a restart of the ObjectManager,
// TODO we may have reused an ObjectSequenceNumber, in which case rathet than findingin null
// TODO getManagedObject will find a newly created MAnagedObject instead of null.
// TODO Need some kind of ObjectManagerCycle number in the Token!
// TODO Alternatively we know that any Token trying to find the currentToken after restart
// TODO of the ObjectMAnager must have been restored from previous run so it must return
// TODO null and leave the get method the to throw an exception.
// TODO Alternatively we could occasionally save a safe staer sequencenumber, perhaps on e
// TODO checkpoint when the ObjectStopre is serialized anyway.
}
|
java
|
public synchronized void flush()
throws ObjectManagerException
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled()) {
trace.entry(this,
cclass,
"flush");
trace.exit(this,
cclass,
"flush");
}
}
|
java
|
static void buildEjbWebServiceEndpointInfos(EndpointInfoBuilder endpointInfoBuilder, EndpointInfoBuilderContext ctx, JaxWsServerMetaData jaxWsServerMetaData,
List<EJBEndpoint> ejbEndpoints, JaxWsModuleInfo jaxWsModuleInfo) throws UnableToAdaptException {
Set<String> presentedServices = jaxWsModuleInfo.getEndpointImplBeanClassNames();
for (EJBEndpoint ejbEndpoint : ejbEndpoints) {
if (!ejbEndpoint.isWebService()) {
continue;
}
if (presentedServices.contains(ejbEndpoint.getClassName())) {
continue;
}
String ejbName = ejbEndpoint.getJ2EEName().getComponent();
ctx.addContextEnv(JaxWsConstants.ENV_ATTRIBUTE_ENDPOINT_BEAN_NAME, ejbName);
EndpointInfo endpointInfo = endpointInfoBuilder.build(ctx, ejbEndpoint.getClassName(), EndpointType.EJB);
if (endpointInfo != null) {
jaxWsModuleInfo.addEndpointInfo(ejbEndpoint.getName(), endpointInfo);
jaxWsServerMetaData.putEndpointNameAndJ2EENameEntry(ejbName, ejbEndpoint.getJ2EEName());
}
}
}
|
java
|
public static Jose4jRsaJWK getInstance(int size, String alg, String use, String type) {
String kid = RandomUtils.getRandomAlphaNumeric(KID_LENGTH);
KeyPairGenerator keyGenerator = null;
try {
keyGenerator = KeyPairGenerator.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
// This should not happen, since we hardcoded as "RSA"
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Caught unexpected exception: " + e.getLocalizedMessage(), e);
}
return null;
}
keyGenerator.initialize(size);
KeyPair keypair = keyGenerator.generateKeyPair();
RSAPublicKey pubKey = (RSAPublicKey) keypair.getPublic();
RSAPrivateKey priKey = (RSAPrivateKey) keypair.getPrivate();
Jose4jRsaJWK jwk = new Jose4jRsaJWK(pubKey);
jwk.setPrivateKey(priKey);
jwk.setAlgorithm(alg);
jwk.setKeyId(kid);
jwk.setUse((use == null) ? JwkConstants.sig : use);
return jwk;
}
|
java
|
public static Jose4jRsaJWK getInstance(String alg, String use, PublicKey publicKey, PrivateKey privateKey, String kid) {
//String kid = RandomUtils.getRandomAlphaNumeric(KID_LENGTH);
RSAPublicKey pubKey = (RSAPublicKey) publicKey;
RSAPrivateKey priKey = (RSAPrivateKey) privateKey;
Jose4jRsaJWK jwk = new Jose4jRsaJWK(pubKey);
jwk.setPrivateKey(priKey);
jwk.setAlgorithm(alg);
jwk.setKeyId(kid);
jwk.setUse(use == null ? JwkConstants.sig : use);
return jwk;
}
|
java
|
private List<Object> reprocessFormParams(Method method, List<Object> origParams, Message m) {
Form form = null;
boolean hasFormParamAnnotations = false;
Object[] newValues = new Object[origParams.size()];
java.lang.reflect.Parameter[] methodParams = method.getParameters();
for (int i = 0; i < methodParams.length; i++) {
if (Form.class.equals(methodParams[i].getType())) {
form = (Form) origParams.get(i);
}
if (methodParams[i].getAnnotation(FormParam.class) != null) {
hasFormParamAnnotations = true;
} else {
newValues[i] = origParams.get(i);
}
}
if (!hasFormParamAnnotations || form == null) {
return origParams;
}
for (int i = 0; i < newValues.length; i++) {
if (newValues[i] == null) {
String formFieldName = methodParams[i].getAnnotation(FormParam.class).value();
List<String> values = form.asMap().get(formFieldName);
newValues[i] = InjectionUtils.createParameterObject(values,
methodParams[i].getType(),
methodParams[i].getParameterizedType(),
methodParams[i].getAnnotations(),
(String) origParams.get(i),
false,
ParameterType.FORM,
m);
if (LOG.isLoggable(Level.FINEST)) {
LOG.log(Level.FINEST, "replacing @FormParam value of {0} with {1}",
new Object[]{origParams.get(i), newValues[i]});
}
}
}
return Arrays.asList(newValues);
}
|
java
|
private Collection<LibertyVersion> filterVersions(Collection<LibertyVersion> minimumVersions, String version) {
LibertyVersion versionToMatch = LibertyVersion.valueOf(version);
if (versionToMatch == null) {
return minimumVersions;
}
Collection<LibertyVersion> filteredVersions = new HashSet<LibertyVersion>();
for (LibertyVersion versionToTest : minimumVersions) {
if (versionToTest.matchesToMicros(versionToMatch)) {
filteredVersions.add(versionToTest);
}
}
return filteredVersions;
}
|
java
|
Map<Object, Object> createOrRestoreMap(FacesContext context, String prefix,
boolean create)
{
ExternalContext external = context.getExternalContext();
Map<String, Object> sessionMap = external.getSessionMap();
Map<Object, Object> map = (Map<Object, Object>) sessionMap.get(prefix);
if (map == null && create)
{
map = new ConcurrentHashMap<Object, Object>();
sessionMap.put(prefix, map);
}
return map;
}
|
java
|
public static TSSConfig getTSSConfig(Map<String, Object> props, Map<OptionsKey, List<TransportAddress>> addrMap, Bundle bundle) throws Exception {
TSSConfig tssConfig = new TSSConfig();
List<Map<String, Object>> tssConfigs = Nester.nest(CSIV2_CONFIGURATION, props);
if (!tssConfigs.isEmpty()) {
Map<String, Object> properties = tssConfigs.get(0);
// tssConfig.setInherit((Boolean) properties.get(INHERIT));
List<Map<String, Object>> mechList = Nester.nest(COMPOUND_SEC_MECH_TYPE_LIST, properties);
//TODO liberty get the ssl transport info from the corbabean?
// List<Map<String, Object>> transportMechGroups = mechInfo.get(SSL_OPTIONS);
// if (!transportMechGroups.isEmpty()) {
// Map<String, Object> transportMechGroup = transportMechGroups.get(0);
// String type = (String) transportMechGroup.get(CONFIG_REFERENCE_TYPE);
// if (SSL_TRANSPORT_MECH.equals(type)) {
// tssConfig.setTransport_mech(extractSSL(transportMechGroup));
// } else if (SECIOP_TRANSPORT_MECH.equals(type)) {
// throw new IllegalStateException("SECIOP processing not implemented");
// } else {
// throw new IllegalStateException("Unrecognized transport mech type: " + type);
// }
// } else {
// tssConfig.setTransport_mech(new TSSNULLTransportConfig());
// }
// List<Map<String, Object>> secmechlists = mechInfo.get(COMPOUND_SEC_MECH_TYPE_LIST);
// if (!secmechlists.isEmpty()) {
// Map<String, Object> secMechList = secmechlists.get(0);
TSSCompoundSecMechListConfig mechListConfig = tssConfig.getMechListConfig();
mechListConfig.setStateful((Boolean) properties.get(STATEFUL));
// List<Map<String, Object>> mechList = Nester.nest(COMPOUND_SECH_MECH_LIST, secMechList);
for (Map<String, Object> mech : mechList) {
TSSCompoundSecMechConfig cMech = extractCompoundSecMech(mech, addrMap, bundle);
// cMech.setTransport_mech(tssConfig.getTransport_mech());
mechListConfig.add(cMech);
}
// }
}
return tssConfig;
}
|
java
|
public ZipFileData addFirst(ZipFileData newFirstData) {
String newFirstPath = newFirstData.path;
Cell dupCell = cells.get(newFirstPath);
if ( dupCell != null ) {
throw new IllegalArgumentException("Path [ " + newFirstPath + " ] is already stored");
}
Cell oldFirstCell = anchor.next;
Cell newFirstCell = new Cell(newFirstData);
cells.put(newFirstPath, newFirstCell);
newFirstCell.putBetween(anchor, oldFirstCell);
return oldFirstCell.data;
}
|
java
|
public ZipFileData addLast(ZipFileData newLastData) {
String newLastPath = newLastData.path;
Cell dupCell = cells.get(newLastPath);
if ( dupCell != null ) {
throw new IllegalArgumentException("Path [ " + newLastPath + " ] is already stored");
}
Cell oldLastCell = anchor.prev;
Cell newLastCell = new Cell(newLastData);
cells.put(newLastPath, newLastCell);
newLastCell.putBetween(oldLastCell, anchor);
return oldLastCell.data;
}
|
java
|
public ZipFileData addLast(ZipFileData newLastData, int maximumSize) {
String newLastPath = newLastData.path;
Cell dupCell = cells.get(newLastPath);
if ( dupCell != null ) {
throw new IllegalArgumentException("Path [ " + newLastPath + " ] is already stored");
}
int size = size();
if ( (maximumSize == -1) || (size < maximumSize) ) {
@SuppressWarnings("unused")
ZipFileData oldLastData = addLast(newLastData);
return null;
}
Cell oldFirstCell = anchor.next;
ZipFileData oldFirstData = oldFirstCell.data;
String oldFirstPath = oldFirstData.path;
if ( oldFirstCell != cells.remove(oldFirstPath) ) {
throw new IllegalStateException("Bad cell alignment on path [ " + oldFirstPath + " ]");
}
oldFirstCell.data = newLastData;
cells.put(newLastPath, oldFirstCell);
if ( size != 1 ) {
oldFirstCell.excise();
oldFirstCell.putBetween(anchor.prev, anchor);
}
return oldFirstData;
}
|
java
|
public void refresh(ApplicationMonitorConfig config) {
_config.set(config);
UpdateTrigger trigger = config.getUpdateTrigger();
if (trigger != UpdateTrigger.DISABLED) {
// Start all existing listeners
for (ApplicationListeners listeners : _appListeners.values()) {
listeners.startListeners(config.getPollingRate(), config.getUpdateTrigger() == UpdateTrigger.MBEAN);
}
} else {
// Stop all existing listeners
for (ApplicationListeners listeners : _appListeners.values()) {
listeners.stopListeners(false);
}
}
}
|
java
|
@FFDCIgnore(value = UnableToAdaptException.class)
public void addApplication(ApplicationInstallInfo installInfo) {
// ...and now create the new... start by asking the handler what needs monitoring
final Collection<Notification> notificationsToMonitor;
final boolean listenForRootStructuralChanges;
ApplicationMonitoringInformation ami = installInfo.getApplicationMonitoringInformation();
if (ami != null) {
notificationsToMonitor = ami.getNotificationsToMonitor();
listenForRootStructuralChanges = ami.isListeningForRootStructuralChanges();
} else {
notificationsToMonitor = null;
listenForRootStructuralChanges = true;
}
try {
// Now create the listeners for these notifications
ApplicationListeners listeners = new ApplicationListeners(installInfo.getUpdateHandler(), _executorService);
/*
* Go through all of the notifications to monitor and create a listener for it. Note we also always create a different type of listener for root so if the app is
* deleted we
* know about it. Optionally (based on the handler) this might also monitor for files being added or removed from the root to trigger an update, i.e. if a WAR gets
* added to
* the root of an EAR.
*/
if (notificationsToMonitor != null) {
for (Notification notificationToMonitor : notificationsToMonitor) {
ApplicationListener listener = new ApplicationListener(notificationToMonitor, listeners, installInfo);
listeners.addListener(listener);
}
// If the handler did request monitoring then we still need a non-recursive handler to check root
listeners.addListener(new RootApplicationListener(installInfo.getContainer(), listenForRootStructuralChanges, listeners));
} else {
/*
* If the handler didn't give us any information about what to monitor then monitor the whole application, note we use another type of listener again here that will
* monitor for root deletions or updates to any part of the application
*/
listeners.addListener(new CompleteApplicationListener(installInfo.getContainer(), listeners));
}
ApplicationListeners old = _appListeners.put(installInfo.getPid(), listeners);
if (old != null) {
old.stopListeners(true);
}
// If we're actively scanning, start the new listener
ApplicationMonitorConfig config = _config.get();
if (config.getUpdateTrigger() != UpdateTrigger.DISABLED) {
listeners.startListeners(config.getPollingRate(), config.getUpdateTrigger() == UpdateTrigger.MBEAN);
}
} catch (UnableToAdaptException e) {
// Ignore, we just won't monitor this application but do put out a warning message
AppMessageHelper.get(installInfo.getHandler()).warning("APPLICATION_MONITORING_FAIL", installInfo.getName());
}
}
|
java
|
public void removeApplication(String pid) {
// remove the application listener from the set we know about and stop it
ApplicationListeners listeners = _appListeners.remove(pid);
//check that the app is known, this can be run after the app is already removed.
if (listeners != null) {
listeners.stopListeners(true);
}
}
|
java
|
public static void traceEJBCallEntry(String methodDesc)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
StringBuffer sbuf = new StringBuffer();
sbuf
.append(BeanLifeCycle_EJBCallEntry_Type_Str).append(DataDelimiter)
.append(BeanLifeCycle_EJBCallEntry_Type).append(DataDelimiter)
.append(methodDesc);
Tr.debug(tc, sbuf.toString());
}
}
|
java
|
public static void traceEJBCallExit(String methodDesc)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
StringBuffer sbuf = new StringBuffer();
sbuf
.append(BeanLifeCycle_EJBCallExit_Type_Str).append(DataDelimiter)
.append(BeanLifeCycle_EJBCallExit_Type).append(DataDelimiter)
.append(methodDesc);
Tr.debug(tc, sbuf.toString());
}
}
|
java
|
public static void traceBeanState(int oldState, String oldString, int newState, String newString) // d167264
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
StringBuffer sbuf = new StringBuffer();
sbuf
.append(BeanLifeCycle_State_Type_Str).append(DataDelimiter)
.append(BeanLifeCycle_State_Type).append(DataDelimiter)
.append(oldState).append(DataDelimiter) // d167264
.append(oldString).append(DataDelimiter) // d167264
.append(newState).append(DataDelimiter) // d167264
.append(newString).append(DataDelimiter) // d167264
;
Tr.debug(tc, sbuf.toString());
}
}
|
java
|
protected synchronized void add(Object id, int bufferType, int cause, int source, boolean fromDepIdTemplateInvalidation, boolean fireEvent,
boolean isAlias) {
final String methodName = "add(Object)";
if (id == null) {
return;
}
if (bufferType == EXPLICIT_BUFFER) {
byte info = 0;
if (cause != 0 && source != 0) {
info = (byte) cause;
if (source == CachePerf.REMOTE) {
info = (byte) (info | STATUS_REMOTE);
}
if (fromDepIdTemplateInvalidation) {
info = (byte) (info | STATUS_FROM_DEPID_TEMPLATE);
}
if (isAlias) {
info = (byte) (info | STATUS_ALIAS);
}
if (fireEvent) {
info = (byte) (info | STATUS_FIRE_EVENT);
}
}
this.explicitBuffer.put(id, new Byte(info));
this.scanBuffer.remove(id);
} else if (bufferType == SCAN_BUFFER) {
if (!this.explicitBuffer.containsKey(id)) {
this.scanBuffer.add(id);
}
} else if (bufferType == GC_BUFFER) {
this.garbageCollectorBuffer.add(id);
}
traceDebug(methodName, "cacheName=" + this.cod.cacheName + " id=" + id + " bufferType=" + bufferType + " ExplicitBuffer="
+ this.explicitBuffer.size() + " ScanBuffer=" + this.scanBuffer.size() + " GCBuffer=" + this.garbageCollectorBuffer.size()
+ " cause=" + cause + " source=" + source + " fireEvent=" + fireEvent);
if (isFull() || bufferType == GC_BUFFER) { // 3821 NK end
invokeBackgroundInvalidation(!SCAN);
}
}
|
java
|
protected synchronized void add(ValueSet idSet, int bufferType, int cause, int source, boolean fromDepIdTemplateInvalidation, boolean fireEvent,
boolean checkFull) {
final String methodName = "add(ValueSet)";
if (idSet == null || idSet.isEmpty()) {
return;
}
int size = idSet.size();
if (bufferType == EXPLICIT_BUFFER) {
byte info = 0;
if (cause != 0 && source != 0) {
info = (byte) cause;
if (source == CachePerf.REMOTE) {
info = (byte) (info | STATUS_REMOTE);
}
if (fromDepIdTemplateInvalidation) {
info = (byte) (info | STATUS_FROM_DEPID_TEMPLATE);
}
if (fireEvent) {
info = (byte) (info | STATUS_FIRE_EVENT);
}
}
Iterator it = idSet.iterator();
while (it.hasNext()) {
Object entryId = it.next();
this.explicitBuffer.put(entryId, new Byte(info));
}
if (!this.scanBuffer.isEmpty()) {
filter(this.scanBuffer, idSet);
}
} else if (bufferType == SCAN_BUFFER) {
if (!explicitBuffer.isEmpty()) {
filter(idSet, this.explicitBuffer);
}
this.scanBuffer.addAll(idSet);
} else if (bufferType == GC_BUFFER) {
this.garbageCollectorBuffer.addAll(idSet);
}
// if (size > 50) {
traceDebug(methodName, "cacheName=" + this.cod.cacheName + " idSet=" + size + " idSetFilter=" + idSet.size() + " bufferType=" + bufferType
+ " explicitBuffer=" + this.explicitBuffer.size() + " scanBuffer=" + this.scanBuffer.size() + " GCBuffer="
+ this.garbageCollectorBuffer.size());
// }
if ((checkFull && isFull()) || bufferType == GC_BUFFER) { // 3821 NK end
invokeBackgroundInvalidation(!SCAN);
}
}
|
java
|
protected synchronized Object get(int bufferType) {
// final String methodName = "get(boolean)";
Object id = null;
if (bufferType == this.EXPLICIT_BUFFER) {
if (!this.explicitBuffer.isEmpty()) {
Set s = this.explicitBuffer.keySet();
Iterator it = s.iterator();
ExplicitIdData idData = new ExplicitIdData();
while (it.hasNext()) {
idData.id = it.next();
idData.info = ((Byte) this.explicitBuffer.get(idData.id)).byteValue();
if ((idData.info & HTODInvalidationBuffer.STATUS_ALIAS) == 0) {
id = idData;
break;
}
}
}
} else if (bufferType == this.SCAN_BUFFER) {
if (!this.scanBuffer.isEmpty()) {
id = this.scanBuffer.getOne();
}
} else if (bufferType == this.GC_BUFFER) {
if (!this.garbageCollectorBuffer.isEmpty()) {
// Always get the first one from the list
id = this.garbageCollectorBuffer.get(0);
}
}
// if (id != null) {
// traceDebug(methodName, "cacheName=" + this.cod.cacheName + " id=" + id + " bufferType=" + bufferType);
// }
return id;
}
|
java
|
protected synchronized void remove(Object id, int bufferType, boolean returnToPool) {
// final String methodName = "remove(Object,bufferType)";
if (id == null) {
return;
}
if (bufferType == this.EXPLICIT_BUFFER) {
this.explicitBuffer.remove(id);
} else if (bufferType == this.SCAN_BUFFER) {
this.scanBuffer.remove(id);
} else if (bufferType == this.GC_BUFFER) {
if (id instanceof EvictionTableEntry) {
EvictionTableEntry evt1 = (EvictionTableEntry) id;
int i;
for (i = 0; i < garbageCollectorBuffer.size(); i++) {
EvictionTableEntry evt = (EvictionTableEntry) garbageCollectorBuffer.get(i);
if (evt == evt1)
break;
}
if (i < garbageCollectorBuffer.size())
this.garbageCollectorBuffer.remove(i);
if (returnToPool) {
cod.htod.evictionEntryPool.add(id);
}
}
}
// traceDebug(methodName, "cacheName=" + this.cod.cacheName + " id=" + id + " bufferType=" + bufferType);
}
|
java
|
protected synchronized void remove(Object id) {
// final String methodName = "remove(Object)";
if (id == null) {
return;
}
this.explicitBuffer.remove(id);
this.scanBuffer.remove(id);
// this.garbageCollectorBuffer.remove(id);
// if (id instanceof HTODDynacache.EvictionTableEntry)
// cod.htod.evictionEntryPool.add(id);
// traceDebug(methodName, "id=" + id);
}
|
java
|
protected synchronized ValueSet getAndRemoveFromExplicitBuffer() {
final String methodName = "getAndRemoveFromExplicitBuffer()";
ValueSet valueSet = null;
if (this.explicitBuffer.size() == 0) {
valueSet = new ValueSet(1);
} else {
valueSet = new ValueSet(this.explicitBuffer.size());
Iterator it = this.explicitBuffer.keySet().iterator();
while (it.hasNext()) {
Object current = it.next();
byte info = ((Byte) this.explicitBuffer.get(current)).byteValue();
if ((info & HTODInvalidationBuffer.STATUS_ALIAS) == 0) {
valueSet.add(current);
}
}
this.explicitBuffer.clear();
}
traceDebug(methodName, "cacheName=" + this.cod.cacheName + " bufferSize=" + valueSet.size());
return valueSet;
}
|
java
|
protected synchronized boolean findAndRemoveFromGCBuffer(long expirationTime, int hashcode, int size) {
EvictionTableEntry evt = null;
int i;
for (i = 0; i < garbageCollectorBuffer.size(); i++) {
evt = (EvictionTableEntry) garbageCollectorBuffer.get(i);
if (evt.expirationTime == expirationTime && evt.hashcode == hashcode && evt.size == size) {
break;
}
}
if (i < garbageCollectorBuffer.size()) {
this.garbageCollectorBuffer.remove(i);
if (evt != null) {
cod.htod.evictionEntryPool.add(evt);
}
return true;
}
return false;
}
|
java
|
protected synchronized void clear(int bufferType) {
final String methodName = "clear()";
if (bufferType == HTODInvalidationBuffer.EXPLICIT_BUFFER) {
this.explicitBuffer.clear();
} else if (bufferType == HTODInvalidationBuffer.SCAN_BUFFER) {
this.scanBuffer.clear();
} else if (bufferType == HTODInvalidationBuffer.GC_BUFFER) {
// todo: return GC to pool?
for (int i = 0; i < garbageCollectorBuffer.size(); i++) {
EvictionTableEntry evt = (EvictionTableEntry) garbageCollectorBuffer.get(i);
cod.htod.evictionEntryPool.add(evt);
}
this.garbageCollectorBuffer.clear();
}
traceDebug(methodName, "cacheName=" + this.cod.cacheName + " bufferType=" + bufferType);
}
|
java
|
protected synchronized void invokeBackgroundInvalidation(boolean scan) {
final String methodName = "invokeBackgroundInvalidation()";
if (!stopping) {
synchronized (cod.diskCleanupThread.dcMonitor) {
if (cod.diskCleanupThread.currentThread != null) {
this.cod.invokeDiskCleanup(scan);
} else {
if (scan == SCAN) {
traceDebug(methodName, "cacheName=" + this.cod.cacheName + " set cleanupDiskPending to true");
this.cleanupDiskPending = true;
}
}
}
}
}
|
java
|
protected synchronized boolean contains(Object id) {
boolean found = false;
if (this.explicitBuffer.containsKey(id) || this.scanBuffer.contains(id)) {
found = true;
}
return found;
}
|
java
|
@Trivial
public synchronized boolean isFull() {
// final String methodName = "isFull()";
boolean isFull = false;
int size = this.explicitBuffer.size() + this.scanBuffer.size() + this.garbageCollectorBuffer.size();
if (size > this.maxInvalidationBufferSize || (System.currentTimeMillis() - this.lastRemoveTime) >= this.maxInvalidationBufferLife) {
isFull = true;
setlastRemoveTime();
}
// if (isFull) {
// traceDebug(methodName, "cacheName=" + this.cod.cacheName + " isFull=" + isFull + " explicitBuffer=" +
// explicitBuffer.size() + " scanBuffer=" + this.scanBuffer.size());
// }
return isFull;
}
|
java
|
protected synchronized void filter(ValueSet filterValueSet) {
boolean explicitBufferEmpty = this.explicitBuffer.isEmpty();
boolean scanBufferEmpty = this.scanBuffer.isEmpty();
if (filterValueSet != null && !filterValueSet.isEmpty() && (!explicitBufferEmpty || !scanBufferEmpty)) {
Iterator it = filterValueSet.iterator();
while (it.hasNext()) {
Object o = it.next();
if (!explicitBufferEmpty && this.explicitBuffer.containsKey(o)) {
it.remove();
} else if (!scanBufferEmpty && this.scanBuffer.contains(o)) {
it.remove();
}
}
}
}
|
java
|
@Trivial
protected synchronized int size(int bufferType) {
if (bufferType == EXPLICIT_BUFFER) {
return this.explicitBuffer.size();
} else if (bufferType == SCAN_BUFFER) {
return this.scanBuffer.size();
} else if (bufferType == GC_BUFFER) {
return this.garbageCollectorBuffer.size();
}
return 0;
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.