code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
synchronized void deactivate() {
paused = false;
if (activeTask != null) {
activeTask.cancel();
activeTask = null;
}
this.threadPool = null;
} | java |
synchronized void resume() {
paused = false;
if (activeTask == null) {
activeTask = new IntervalTask(this);
timer.schedule(activeTask, interval, interval);
}
} | java |
ThroughputDistribution getThroughputDistribution(int activeThreads, boolean create) {
if (activeThreads < coreThreads)
activeThreads = coreThreads;
Integer threads = Integer.valueOf(activeThreads);
ThroughputDistribution throughput = threadStats.get(threads);
if ((throughput == null) && create) {
throughput = new ThroughputDistribution();
throughput.setLastUpdate(controllerCycle);
threadStats.put(threads, throughput);
}
return throughput;
} | java |
boolean manageIdlePool(ThreadPoolExecutor threadPool, long intervalCompleted) {
// Manage the intervalCompleted count
if (intervalCompleted == 0 && threadPool.getActiveCount() == 0) {
consecutiveIdleCount++;
} else {
consecutiveIdleCount = 0;
}
if (consecutiveIdleCount >= IDLE_INTERVALS_BEFORE_PAUSE) {
pause();
lastAction = LastAction.PAUSE;
return true;
}
return false;
} | java |
boolean handleOutliers(ThroughputDistribution distribution, double throughput) {
if (throughput < 0.0) {
resetStatistics(false);
return true;
} else if (throughput == 0.0) {
return false;
}
double zScore = distribution.getZScore(throughput);
boolean currentIsOutlier = zScore <= -3.0 || zScore >= 3.0;
// 8/10/2012: Reset the data for this thread count when we hit an outlier
// 1/20/2018: refine the distribution reset criteria
if (currentIsOutlier) {
/*
* Decide whether to reset the distribution, which throws away the historical
* ewma for the poolSize and replaces it with the new throughput.
* We will use 3 criteria, any of which is sufficient to reset the distribution:
*
* 1) How much do we trust the historical data?
* If the historical ewma is the result of many observations with similar throughput,
* the standard deviation will be a small fraction of the ewma. If stddev/ewma is
* greater than 10%, then the historical data is not really strong, let's reset.
*
* 2) How much different is the new tput from the ewma?
* If the new throughput is very very different from the ewma, that suggests the workload
* may have changed significantly, in which case the historical data would no longer be
* valid. If the throughput change is greater than 50% of ewma, let's reset.
*
* 3) Is the throughput simply unstable?
* If every new datapoint at this poolSize is more than 3 standard deviations off the
* historical ewma, then we may as well follow the bouncing ball, rather than averaging
* points which do not seem to want to cluster around a mean. If we get N outliers in a
* row at this poolSize, let's reset.
*/
double ewma = distribution.getMovingAverage();
double stddev = distribution.getStddev();
if ((stddev / ewma) > resetDistroStdDevEwmaRatio
|| (Math.abs(throughput - ewma) / ewma) > resetDistroNewTputEwmaRatio
|| distribution.incrementAndGetConsecutiveOutliers() >= resetDistroConsecutiveOutliers) {
if (tc.isEventEnabled()) {
Tr.event(tc, "reset distribution", (" distribution: " + distribution + ", new throughput: " + throughput));
}
distribution.reset(throughput, controllerCycle);
distributionReset = true;
} else if (tc.isEventEnabled()) {
Tr.event(tc, "outlier detected", (" distribution: " + distribution + ", new throughput: " + throughput));
}
} else {
distribution.resetConsecutiveOutliers();
}
// Check for repeated outliers
// 1/20/2018: increment only after resetting a distribution, not a single outlier event
if (lastAction != LastAction.NONE) {
if (distributionReset) {
consecutiveOutlierAfterAdjustment++;
} else {
consecutiveOutlierAfterAdjustment = 0;
}
}
// If we repeatedly hit an outlier after changing the pool size
// we should reset the statistics
if (consecutiveOutlierAfterAdjustment >= MAX_OUTLIER_AFTER_CHANGE_BEFORE_RESET) {
resetThreadPool();
return true;
}
return false;
} | java |
int adjustPoolSize(int poolSize, int poolAdjustment) {
if (threadPool == null)
return poolSize; // arguably should return 0, but "least change" is safer... This happens during shutdown.
int newPoolSize = poolSize + poolAdjustment;
lastAction = LastAction.NONE;
if (poolAdjustment != 0) {
// don't shrink below coreThreads
if (poolAdjustment < 0 && newPoolSize >= coreThreads) {
lastAction = LastAction.SHRINK;
setPoolSize(newPoolSize);
} else if (poolAdjustment > 0 && newPoolSize <= maxThreads) {
lastAction = LastAction.GROW;
setPoolSize(newPoolSize);
} else {
newPoolSize = poolSize;
}
}
return newPoolSize;
} | java |
private String poolTputRatioData(double poolTputRatio, double poolRatio, double tputRatio,
double smallerPoolTput, double largerPoolTput, int smallerPoolSize, int largerPoolSize) {
StringBuilder sb = new StringBuilder();
sb.append("\n ");
sb.append(String.format(" poolTputRatio: %.3f", Double.valueOf(poolTputRatio)));
sb.append(String.format(" poolRatio: %.3f", Double.valueOf(poolRatio)));
sb.append(String.format(" tputRatio: %.3f", Double.valueOf(tputRatio)));
sb.append("\n ");
sb.append(String.format(" smallerPoolSize: %d", Integer.valueOf(smallerPoolSize)));
sb.append(String.format(" largerPoolSize: %d", Integer.valueOf(largerPoolSize)));
sb.append(String.format(" smallerPoolTput: %.3f", Double.valueOf(smallerPoolTput)));
sb.append(String.format(" largerPoolTput: %.3f", Double.valueOf(largerPoolTput)));
return sb.toString();
} | java |
private boolean resolveHang(long tasksCompleted, boolean queueEmpty, int poolSize) {
boolean actionTaken = false;
if (tasksCompleted == 0 && !queueEmpty) {
/**
* When a hang is detected the controller enters hang resolution mode.
* The controller will run on a shorter-than-usual cycle for hangResolutionCycles
* from the last hang detection, to resolve hang situations more quickly.
*/
if (hangResolutionCountdown == 0) {
// cancel regular controller schedule
activeTask.cancel();
// restart with shortened interval for quicker hang resolution
activeTask = new IntervalTask(this);
timer.schedule(activeTask, hangInterval, hangInterval);
}
hangResolutionCountdown = hangResolutionCycles;
controllerCyclesWithoutHang = 0;
// if this is the first time we detected a given deadlock, record how many threads there are
// and print a message
if (poolSizeWhenHangDetected < 0) {
poolSizeWhenHangDetected = poolSize;
if (tc.isEventEnabled()) {
Tr.event(tc, "Executor hang detected at poolSize=" + poolSizeWhenHangDetected, threadPool);
}
} else if (tc.isEventEnabled()) {
Tr.event(tc, "Executor hang continued at poolSize=" + poolSize, threadPool);
}
setPoolIncrementDecrement(poolSize);
if (poolSize + poolIncrement <= maxThreads && poolSize < MAX_THREADS_TO_BREAK_HANG) {
targetPoolSize = adjustPoolSize(poolSize, poolIncrement);
// update the poolSize set to resolve the hang, plus a buffer amount
int targetSize = poolSize + (compareRange * poolIncrement);
if (hangBufferPoolSize < targetSize) {
hangBufferPoolSize = targetSize;
}
actionTaken = true;
} else {
// there's a hang, but we can't add any more threads... emit a warning the first time this
// happens for a given hang, but otherwise just bail
if (hangMaxThreadsMessageEmitted == false && hangIntervalCounter > 0) {
if (tc.isWarningEnabled()) {
Tr.warning(tc, "unbreakableExecutorHang", poolSizeWhenHangDetected, poolSize);
}
hangMaxThreadsMessageEmitted = true;
}
}
hangIntervalCounter++;
} else {
// no hang exists, so reset the appropriate variables that track hangs
poolSizeWhenHangDetected = -1;
hangIntervalCounter = 0;
hangMaxThreadsMessageEmitted = false;
// manage hang resolution mode
if (hangResolutionCountdown > 0) {
hangResolutionCountdown--;
if (hangResolutionCountdown <= 0) {
// move out of hang resolution cycle time
activeTask.cancel();
// restart using regular cycle time
activeTask = new IntervalTask(this);
timer.schedule(activeTask, interval, interval);
}
}
/**
* if controller is running below hangResolutionPoolSize marker without hanging,
* we can reduce that marker ... the workload must have changed, so prior hang
* information is no longer valid. We will reduce it gradually, to maintain a
* conservative stance toward avoiding hangs.
*/
if (hangBufferPoolSize > coreThreads) {
if (hangBufferPoolSize > poolSize) {
controllerCyclesWithoutHang++;
if (controllerCyclesWithoutHang > noHangCyclesThreshold) {
setPoolIncrementDecrement(poolSize);
hangBufferPoolSize -= poolDecrement;
controllerCyclesWithoutHang = 0;
}
}
}
}
return actionTaken;
} | java |
private boolean pruneData(ThroughputDistribution priorStats, double forecast) {
boolean prune = false;
// if forecast tput is much greater or much smaller than priorStats, we suspect
// priorStats is no longer relevant, so prune it
double tputRatio = forecast / priorStats.getMovingAverage();
if (tputRatio > tputRatioPruneLevel || tputRatio < (1 / tputRatioPruneLevel)) {
prune = true;
} else {
// age & reliability (represented by standard deviation) check
int age = controllerCycle - priorStats.getLastUpdate();
double variability = (priorStats.getStddev() / priorStats.getMovingAverage());
if (age * variability > dataAgePruneLevel)
prune = true;
}
return prune;
} | java |
private Integer getSmallestValidPoolSize(Integer poolSize, Double forecast) {
Integer smallestPoolSize = threadStats.firstKey();
Integer nextPoolSize = threadStats.higherKey(smallestPoolSize);
Integer pruneSize = -1;
boolean validSmallData = false;
while (!validSmallData && nextPoolSize != null) {
ThroughputDistribution smallestPoolSizeStats = getThroughputDistribution(smallestPoolSize, false);;
// prune data that is too old or outside believable range
if (pruneData(smallestPoolSizeStats, forecast)) {
pruneSize = smallestPoolSize;
smallestPoolSize = nextPoolSize;
nextPoolSize = threadStats.higherKey(smallestPoolSize);
if (pruneSize > hangBufferPoolSize && pruneSize > coreThreads) {
threadStats.remove(pruneSize);
}
} else {
validSmallData = true;
}
}
return smallestPoolSize;
} | java |
private Integer getLargestValidPoolSize(Integer poolSize, Double forecast) {
Integer largestPoolSize = -1;
// find largest poolSize with valid data
boolean validLargeData = false;
while (!validLargeData) {
largestPoolSize = threadStats.lastKey();
ThroughputDistribution largestPoolSizeStats = getThroughputDistribution(largestPoolSize, false);;
// prune any data that is too old or outside believable range
if (pruneData(largestPoolSizeStats, forecast)) {
threadStats.remove(largestPoolSize);
} else {
validLargeData = true;
}
}
return largestPoolSize;
} | java |
private boolean leanTowardShrinking(Integer smallerPoolSize, int largerPoolSize,
double smallerPoolTput, double largerPoolTput) {
boolean shouldShrink = false;
double poolRatio = largerPoolSize / smallerPoolSize;
double tputRatio = largerPoolTput / smallerPoolTput;
double poolTputRatio = poolRatio / tputRatio;
// compare the poolSize ratio and tput ratio between current and largest poolSizes
// if tput no better at larger poolSize, or not much better, lean toward shrinking
if (tputRatio < 1.0) {
// much larger poolSize has smaller tput - lean strongly (75%) toward shrinking
shouldShrink = (flipCoin() && flipCoin()) ? false : true;
} else if (poolTputRatio > poolTputRatioHigh) {
// poolSize ratio is much larger than tput ratio - lean strongly (75%) toward shrinking
shouldShrink = (flipCoin() && flipCoin()) ? false : true;
} else if (poolTputRatio > poolTputRatioLow) {
// poolSize ratio is slightly larger than tput ratio - lean weakly (50%) toward shrinking
shouldShrink = (flipCoin()) ? false : true;
}
// Format an event level trace point with the key tput ratio data
if (tc.isEventEnabled() && shouldShrink)
Tr.event(tc, "Tput ratio shrinkScore adjustment, larger poolSizes",
poolTputRatioData(poolTputRatio, poolRatio, tputRatio, smallerPoolTput,
largerPoolTput, smallerPoolSize, largerPoolSize));
return shouldShrink;
} | java |
protected void setConfigurationProvider(ConfigurationProvider p) {
if (tc.isEntryEnabled())
Tr.entry(tc, "setConfigurationProvider", p);
try {
ConfigurationProviderManager.setConfigurationProvider(p);
// in an osgi environment we may get unconfigured and then reconfigured as bundles are
// started/stopped. If we were previously unconfigured, then we would have shutdown and
// our state will be 'stopped' (rather than inactive). If so, then re-start now.
// The alternative would perhaps be to modify the checkTMState method to re-start for this state?
if (_state == TMService.TMStates.STOPPED) {
start();
}
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.util.impl.TxTMHelper.setConfigurationProvider", "37", this);
}
if (tc.isEntryEnabled())
Tr.exit(tc, "setConfigurationProvider");
} | java |
protected void setXaResourceFactory(ServiceReference<ResourceFactory> ref) {
if (tc.isEntryEnabled())
Tr.entry(tc, "setXaResourceFactory, ref " + ref);
_xaResourceFactoryReady = true;
if (ableToStartRecoveryNow()) {
// Can start recovery now
try {
startRecovery();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.util.impl.TxTMHelper.setXaResourceFactory", "148", this);
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "setXaResourceFactory");
} | java |
public void setRecoveryLogFactory(RecoveryLogFactory fac) {
if (tc.isEntryEnabled())
Tr.entry(tc, "setRecoveryLogFactory, factory: " + fac, this);
_recoveryLogFactory = fac;
_recoveryLogFactoryReady = true;
if (ableToStartRecoveryNow()) {
// Can start recovery now
try {
startRecovery();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.util.impl.TxTMHelper.setRecoveryLogFactory", "206", this);
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "setRecoveryLogFactory");
} | java |
public void setRecoveryLogService(ServiceReference<RecLogServiceImpl> ref) {
if (tc.isEntryEnabled())
Tr.entry(tc, "setRecoveryLogService", ref);
_recoveryLogServiceReady = true;
if (ableToStartRecoveryNow()) {
// Can start recovery now
try {
startRecovery();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.util.impl.TxTMHelper.setRecoveryLogService", "148", this);
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "setRecoveryLogService");
} | java |
public void shutdown(ConfigurationProvider cp) throws Exception {
final int shutdownDelay;
if (cp != null) {
shutdownDelay = cp.getDefaultMaximumShutdownDelay();
} else {
shutdownDelay = 0;
}
shutdown(false, shutdownDelay);
} | java |
protected void retrieveBundleContext() {
BundleContext bc = TxBundleTools.getBundleContext();
if (tc.isDebugEnabled())
Tr.debug(tc, "retrieveBundleContext, bc " + bc);
_bc = bc;
} | java |
protected void enqueue (final AbstractInvocation invocation) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "enqueue", invocation);
barrier.pass(); // Block until allowed to pass
// We need to ensure that the thread processing this queue does not change the "running" state before we decide whether a new
// thread needs to be started or not so synchronize on "this"
synchronized (this) {
final boolean isEmpty = isEmpty(); // Remember whether queue is currently empty or not
// Add the invocation to the queue
synchronized (barrier) {
queue.add(invocation);
queueSize += invocation.getSize();
// Check to see if the queue limits have been exceeded and the queue should now be locked
if (queueSize >= maxQueueSize || (maxQueueMsgs > 0 && queue.size() >= maxQueueMsgs)) {
barrier.lock();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Locked the barrier: bytes="+queueSize+" ("+maxQueueSize+") msgs="+queue.size()+" ("+maxQueueMsgs+")");
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Leaving barrier unlocked: bytes="+queueSize+" ("+maxQueueSize+") msgs="+queue.size()+" ("+maxQueueMsgs+")");
}
}
// If queue was previously empty we need to either prompt the existing processing thread or start a new thread to
// process the new invocation request
if (isEmpty) {
if (running) { // A processing thread already exists for this queue so wake it up
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Notifying existing thread");
notify();
} else { // We need to start a new processing thread
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Starting a new thread");
boolean interrupted = true;
while (interrupted) {
try {
threadPool.execute(this);
interrupted = false;
} catch (InterruptedException e) {
// No FFDC code needed
}
}
}
}
} // synchronized (this)
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "enqueue");
} | java |
private AbstractInvocation dequeue() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dequeue");
AbstractInvocation invocation;
synchronized (barrier) {
invocation = queue.remove(0);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dequeue", invocation);
return invocation;
} | java |
private void unlockBarrier(final int size, final Conversation.ConversationType conversationType)
{
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "unlockBarrier", new Object[]{Integer.valueOf(size), conversationType});
synchronized(barrier)
{
queueSize -= size;
// If queue size is now below the maximum size for both data in bytes and number of msgs unlock the barrier (if not already unlocked)
if(queueSize < maxQueueSize && (maxQueueMsgs == 0 || (maxQueueMsgs > 0 && queue.size() < maxQueueMsgs)))
{
if(barrier.unlock())
{
if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Unlocked the barrier: bytes="+queueSize+" ("+maxQueueSize+") msgs="+queue.size()+" ("+maxQueueMsgs+")");
}
else
{
if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Barrier already unlocked: bytes="+queueSize+" ("+maxQueueSize+") msgs="+queue.size()+" ("+maxQueueMsgs+")");
}
}
else
{
if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Leaving barrier locked: bytes="+queueSize+" ("+maxQueueSize+") msgs="+queue.size()+" ("+maxQueueMsgs+")");
}
}
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "unlockBarrier");
} | java |
protected boolean isEmpty () {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isEmpty");
boolean rc;
synchronized (barrier) {
rc = queue.isEmpty();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isEmpty", rc);
return rc;
} | java |
protected int getDepth() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getDepth");
int depth;
synchronized (barrier) {
depth = queue.size();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getDepth", depth);
return depth;
} | java |
protected boolean doesQueueContainConversation (final Conversation conversation) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "doesQueueContainConversation", conversation);
boolean rc = false;
synchronized (barrier) {
for (int i = 0; i < queue.size(); i++) {
final AbstractInvocation invocation = queue.get(i);
if (invocation.getConversation().equals(conversation)) {
rc = true;
break;
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "doesQueueContainConversation", rc);
return rc;
} | java |
public void sweep() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "Sweep : Stateful Beans = " + ivStatefulBeanList.size());
for (Enumeration<TimeoutElement> e = ivStatefulBeanList.elements(); e.hasMoreElements();) {
TimeoutElement elt = e.nextElement();
// If the bean has timed out, regardless of whether it has been
// passivated, or is still in the cache ('active'), go ahead and try
// to delete it. d112258
if (elt.isTimedOut()) // F61004.5
{
deleteBean(elt.beanId);
}
}
// Sweep failover cache if SFSB failover is enabled.
if (ivSfFailoverCache != null) //LIDB2018-1
{
ivSfFailoverCache.sweep(); //LIDB2018-1
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "Sweep : Stateful Beans = " + ivStatefulBeanList.size());
} | java |
public void finalSweep(StatefulPassivator passivator) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "finalSweep : Stateful Beans = " + ivStatefulBeanList.size());
for (Enumeration<TimeoutElement> e = ivStatefulBeanList.elements(); e.hasMoreElements();) {
TimeoutElement elt = e.nextElement();
if (elt.passivated) {
try {
// If the bean hasn't already been removed (possibly by the
// regular sweep(), then go ahead and remove the file. d129562
if (remove(elt.beanId)) {
passivator.remove(elt.beanId, false); //LIDB2018-1
}
} catch (RemoteException ex) {
FFDCFilter.processException(ex, CLASS_NAME + ".finalSweep",
"298", this);
Tr.warning(tc, "REMOVE_FROM_PASSIVATION_STORE_FAILED_CNTR0016W", new Object[] { elt.beanId, ex }); //p111002.3
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "finalSweep : Stateful Beans = " + ivStatefulBeanList.size());
} | java |
public boolean beanDoesNotExistOrHasTimedOut(TimeoutElement elt, BeanId beanId) {
if (elt == null) {
// Not in the reaper list, but it might be in local
// failover cache if not in reaper list. So check it if
// there is a local SfFailoverCache object (e.g. when SFSB
// failover is enabled to use failover cache).
if (ivSfFailoverCache != null) {
// Not in reaper list, but SFSB failover enabled.
// Have local SfFailoverCache determine if bean does not exist
// or has timed out.
return ivSfFailoverCache.beanDoesNotExistOrHasTimedOut(beanId);
}
// Return true since bean not found in reaper list
// and SFSB failover is not enabled so not in failover
// cache list.
return true;
}
// SFSB found in reaper list, so return whether it
// has timed out or not.
return elt.isTimedOut(); // F61004.5
} | java |
public void add(StatefulBeanO beanO) {
BeanId id = beanO.beanId;
TimeoutElement elt = beanO.ivTimeoutElement;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "add " + beanO.beanId + ", " + elt.timeout);
// LIDB2775-23.4 Begins
Object obj = ivStatefulBeanList.put(id, elt);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, (obj != null) ? "Stateful bean information replaced" : "Stateful bean information added");
// LIDB2775-23.4 Ends
synchronized (this) {
if (numObjects == 0 && !ivIsCanceled) // F743-33394
{
startAlarm();
}
numObjects++;
numAdds++;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "add");
} | java |
public boolean remove(BeanId id) // d129562
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "remove (" + id + ")");
TimeoutElement elt = null;
elt = ivStatefulBeanList.remove(id);
synchronized (this) {
if (elt != null) {
numObjects--;
numRemoves++;
if (numObjects == 0) { // F743-33394
stopAlarm();
}
} else {
numNullRemoves++;
}
}
boolean result = elt != null;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "remove (" + result + ")");
return result; // d129562
} | java |
public synchronized Iterator<BeanId> getPassivatedStatefulBeanIds(J2EEName homeName) {
ArrayList<BeanId> beanList = new ArrayList<BeanId>();
for (Enumeration<TimeoutElement> e = ivStatefulBeanList.elements(); e.hasMoreElements();) {
TimeoutElement elt = e.nextElement();
if (homeName.equals(elt.beanId.getJ2EEName())
&& (elt.passivated))
beanList.add(elt.beanId);
}
return (beanList.iterator());
} | java |
public long getBeanTimeoutTime(BeanId beanId) {
TimeoutElement elt = ivStatefulBeanList.get(beanId);
long timeoutTime = 0;
if (elt != null) {
if (elt.timeout != 0) {
timeoutTime = elt.lastAccessTime + elt.timeout;
if (timeoutTime < 0) { // F743-6605.1
timeoutTime = Long.MAX_VALUE; // F743-6605.1
}
}
}
return timeoutTime;
} | java |
public void dump() {
if (dumped) {
return;
}
try {
Tr.dump(tc, "-- StatefulBeanReaper Dump -- ", this);
synchronized (this) {
Tr.dump(tc, "Number of objects: " + this.numObjects);
Tr.dump(tc, "Number of adds: " + this.numAdds);
Tr.dump(tc, "Number of removes: " + this.numRemoves);
Tr.dump(tc, "Number of null removes: " + this.numNullRemoves);
Tr.dump(tc, "Number of deletes: " + this.numDeletes);
}
} finally {
dumped = true;
}
} | java |
public synchronized void cancel() // d583637
{
ivIsCanceled = true;
stopAlarm();
// F743-33394 - Wait for the sweep to finish.
while (ivIsRunning) {
try {
wait();
} catch (InterruptedException ex) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "interrupted", ex);
Thread.currentThread().interrupt();
}
}
ivActivator = null;
} | java |
private String getServerId() {
UUID fullServerId = null;
WsLocationAdmin locationService = this.wsLocationAdmin;
if (locationService != null) {
fullServerId = locationService.getServerId();
}
if (fullServerId == null) {
fullServerId = UUID.randomUUID(); // shouldn't get here, but be careful just in case
}
return fullServerId.toString().toLowerCase(); // clone IDs need to be in lower case for consistency with tWAS
} | java |
private void initialize() {
if(this.initialized) {
return;
}
if (LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.INFO)) {
if (this.sessionStoreService==null) {
LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, "initialize", "SessionMgrComponentImpl.noPersistence");
} else {
String modeName = "sessionPersistenceMode";
Object modeValue = this.mergedConfiguration.get(modeName);
LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, "initialize", "SessionMgrComponentImpl.persistenceMode", new Object[] { modeValue });
}
}
SessionProperties.setPropertiesInSMC(this.serverLevelSessionManagerConfig, this.mergedConfiguration);
String cloneId = SessionManagerConfig.getCloneId();
if (cloneId == null) {
if (this.sessionStoreService==null && SessionManagerConfig.isTurnOffCloneId()) {
/*-
* In tWAS, WsSessionAffinityManager sets the CloneID to -1 when two conditions are both met:
* A) Running in a standalone server (com.ibm.ws.runtime.service.WLM#getMemberUID()==null)
* B) The HttpSessionCloneId custom property is not explicitly set
*
* In addition, tWAS will set the CloneID to "" (the empty String) if a third condition is also met:
* C) The NoAdditionalSessionInfo custom property is set to "true"
*
* In lWAS, there's no notion of a "standalone" server, because potentially any lWAS server
* could require a CloneID for session affinity. As a result, our logic for using an
* empty Clone ID on lWAS needs to be different than our logic on tWAS.
*
* Since most customers who specify a session store will be interested in session affinity,
* we'll assume that these customers are always interested in a non-empty Clone ID.
*
* We'll also assume that customers who do not specify a session store who also explicitly
* set the noAdditionalInfo property to "true" would prefer an empty Clone ID.
*
* All customers can always explicitly set the cloneId property to override these assumptions.
*/
cloneId = "";
} else {
String serverId = getServerId(); // never returns null
if (TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "initialize", "serverId=" + serverId);
}
SessionManagerConfig.setServerId(serverId);
cloneId = EncodeCloneID.encodeString(serverId); // never returns null
}
SessionManagerConfig.setCloneId(cloneId);
}
this.initialized=true;
} | java |
public boolean startInactivityTimer (Transaction t, InactivityTimer iat)
{
if (t != null)
return ((EmbeddableTransactionImpl) t).startInactivityTimer(iat);
return false;
} | java |
public void registerSynchronization(UOWCoordinator coord,
Synchronization sync)
throws RollbackException, IllegalStateException, SystemException
{
registerSynchronization(coord, sync, EmbeddableWebSphereTransactionManager.SYNC_TIER_NORMAL);
} | java |
void setDestName(String destName) throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setDestName", destName);
if ((null == destName) || ("".equals(destName))) {
// d238447 FFDC review. More likely to be an external rather than internal error,
// so no FFDC.
throw (JMSException) JmsErrorUtils.newThrowable(
InvalidDestinationException.class,
"INVALID_VALUE_CWSIA0281",
new Object[] { "destName", destName },
tc
);
}
// Store the property
updateProperty(DEST_NAME, destName);
// Clear the cached destinationAddresses, as they may now be incorrect
clearCachedProducerDestinationAddress();
clearCachedConsumerDestinationAddress();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setDestName");
} | java |
void setDestDiscrim(String destDiscrim) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setDestDiscrim", destDiscrim);
updateProperty(DEST_DISCRIM, destDiscrim);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setDestDiscrim");
} | java |
protected Reliability getReplyReliability() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getReplyReliability");
Reliability result = null;
if (replyReliabilityByte != -1) {
result = Reliability.getReliability(replyReliabilityByte);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getReplyReliability", result);
return result;
} | java |
protected void setReplyReliability(Reliability replyReliability) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setReplyReliability", replyReliability);
this.replyReliabilityByte = replyReliability.toByte();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setReplyReliability");
} | java |
protected boolean isProducerTypeCheck() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "isProducerTypeCheck");
boolean checking = true;
// We can carry out checking if there is no FRP, or the FRP has 0 size.
StringArrayWrapper frp = (StringArrayWrapper) properties.get(FORWARD_ROUTING_PATH);
if (frp != null) {
List totalPath = frp.getMsgForwardRoutingPath();
if ((totalPath != null) && (totalPath.size() > 0))
checking = false;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "isProducerTypeCheck", checking);
return checking;
} | java |
protected String getProducerDestName() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getProducerDestName");
String pDestName = null;
// Get the forward routing path.
StringArrayWrapper frp = (StringArrayWrapper) properties.get(FORWARD_ROUTING_PATH);
if (frp == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "No forward routing path to examine");
// If the frp is null then we have the simple case of returning the
// 'big' destination.
pDestName = getDestName();
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "There is a forward routing path to examine.");
// There is an FRP to examine, and we want to return the name of the
// first destination in the FRP.
SIDestinationAddress producerAddr = frp.getProducerSIDestAddress();
if (producerAddr != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "Using first element of FRP as producer dest name");
pDestName = producerAddr.getDestinationName();
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "FRP is empty - use original dest name");
pDestName = getDestName();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getProducerDestName", pDestName);
return pDestName;
} | java |
protected String getConsumerDestName() throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getConsumerDestName");
String cDestName = getDestName();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getConsumerDestName", cDestName);
return cDestName;
} | java |
Map<String, Object> getCopyOfProperties() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getCopyOfProperties");
Map<String, Object> temp = null;
// Make sure no-one changes the properties underneath us.
synchronized (properties) {
temp = new HashMap<String, Object>(properties);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getCopyOfProperties", temp);
return temp;
} | java |
protected List getConvertedFRP() {
List theList = null;
StringArrayWrapper saw = (StringArrayWrapper) properties.get(FORWARD_ROUTING_PATH);
if (saw != null) {
// This list is the forward routing path for the message.
theList = saw.getMsgForwardRoutingPath();
}
return theList;
} | java |
protected List getConvertedRRP() {
List theList = null;
StringArrayWrapper saw = (StringArrayWrapper) properties.get(REVERSE_ROUTING_PATH);
if (saw != null)
theList = saw.getCorePath();
return theList;
} | java |
protected SIDestinationAddress getProducerSIDestinationAddress() throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getProducerSIDestinationAddress");
if (producerDestinationAddress == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "No cached value");
StringArrayWrapper frp = (StringArrayWrapper) properties.get(FORWARD_ROUTING_PATH);
if (frp != null) {
// There is an actual forward routing path to investigate.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "Obtain from the frp data.");
producerDestinationAddress = frp.getProducerSIDestAddress();
}
if (producerDestinationAddress == null) {
// Set up the producer address from the big destination info.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "Either FRP was empty, or no FRP at all - create from big dest info.");
// Establish whether this producer should be scoped to a local queue point only.
boolean localOnly = isLocalOnly();
// This variable should be initialised already since it is set up in the static
// init for the class, which must have been run by the time we get to access it.
producerDestinationAddress = JmsMessageImpl.destAddressFactory.createSIDestinationAddress(getProducerDestName(), localOnly, getBusName());
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getProducerSIDestinationAddress", producerDestinationAddress);
return producerDestinationAddress;
} | java |
protected boolean isLocalOnly() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "isLocalOnly");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "isLocalOnly", false);
return false;
} | java |
static JmsDestinationImpl checkNativeInstance(Destination destination) throws InvalidDestinationException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "checkNativeInstance", destination);
JmsDestinationImpl castDest = null;
// if the supplied destination is set to null, throw a jms
// InvalidDestinationException.
if (destination == null) {
throw (InvalidDestinationException) JmsErrorUtils.newThrowable(InvalidDestinationException.class
, "INVALID_VALUE_CWSIA0281"
, new Object[] { "Destination", null }
, tc
);
}
// Attempt to convert a non-native destination into a native one.
if (!(destination instanceof JmsDestinationImpl)) {
// Use the variable to pass the failed conversion exception if one occurs.
Exception rootCause = null;
//106556: if (destination instanceof java.lang.reflect.Proxy) is commented to generically support all types of Proxies.
//We get a WovenProxy here when Apache Aries framework is used to deploy .eba files in liberty.
//This WovenProxy is new type itself and it is not extending java.lang.reflect.Proxy.
// 412946 workaround - the Spring framework passes in dynamic proxy objects
// that wrap a real JmsDestinationImpl object if the application is using
// Aspects to implement its transactional behaviour in an OSGi environment.
// To work around this we have to take the unpleasant option of recreating
// one of our objects using the toString of the object we have been given.
// We should never normally rely on the format of a toString, but it seems to
// be the only way to resolve the problem in this case.
String destToString = destination.toString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Dynamic proxy has been provided instead of a destination: " + destToString);
try {
if (destination instanceof Queue) {
castDest = (JmsDestinationImpl) JmsFactoryFactory.getInstance().createQueue(destToString);
}
else if (destination instanceof Topic) {
castDest = (JmsDestinationImpl) JmsFactoryFactory.getInstance().createTopic(destToString);
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "A destination must be either a queue or a topic");
}
} catch (JMSException jmse) {
// No FFDC Code Needed
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Failed to convert the dynamic proxy to a JmsDestinationImpl object;");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.exception(tc, jmse);
rootCause = jmse;
}
// If the supplied destination isn't a Jetstream destination, throw a jms
// InvalidDestinationException.
if (castDest == null) {
throw (InvalidDestinationException) JmsErrorUtils.newThrowable(InvalidDestinationException.class
, "FOREIGN_IMPLEMENTATION_CWSIA0046"
, new Object[] { destination }
, rootCause
, null
, JmsDestinationImpl.class
, tc
);
}
}
else {
castDest = (JmsDestinationImpl) destination;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "checkNativeInstance", castDest);
return castDest;
} | java |
static void checkBlockedStatus(JmsDestinationImpl dest) throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "checkBlockedStatus", dest);
// get the status of the destinations blocked attribute
Integer code = dest.getBlockedDestinationCode();
// check for specific known PSB reason for blockage
if (code == null) {
// default case of null value - don't want to throw exception
}
else if (code.equals(JmsInternalConstants.PSB_REPLY_DATA_MISSING)) {
// throw specific PSB blocked JMSException
throw (JMSException) JmsErrorUtils.newThrowable(JMSException.class
, "DESTINATION_BLOCKED_PSBREPLY_CWSIA0284"
, new Object[] { dest.toString() }
, tc
);
}
else {
// throw generic blocked JMSException
throw (JMSException) JmsErrorUtils.newThrowable(JMSException.class
, "DESTINATION_BLOCKED_CWSIA0283"
, new Object[] { code }
, tc
);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "checkBlockedStatus");
} | java |
static JmsDestinationImpl getJMSReplyToInternal(JsJmsMessage _msg, List<SIDestinationAddress> rrp, SICoreConnection _siConn) throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getJMSReplyToInternal", new Object[] { _msg, rrp, _siConn });
JmsDestinationImpl tempReplyTo = null;
// Case a) - check for JMS specific data in compressed byte form.
byte[] replyURIBytes = _msg.getJmsReplyTo();
if (replyURIBytes != null) {
tempReplyTo = (JmsDestinationImpl) JmsInternalsFactory.getMessageDestEncodingUtils().getDestinationFromMsgRepresentation(replyURIBytes);
}
if (tempReplyTo == null) {
// Cases b) & c) both depend on there being a reverse routing path, otherwise
// there is no replyTo.
// lookup the name of the dest in the reverse routing path
SIDestinationAddress sida = null;
if (rrp.size() > 0) {
// The last element of the RRP becomes the reply to destination
int lastDestInRRP = rrp.size() - 1;
sida = rrp.get(lastDestInRRP);
// Case b) - if we have a live connection, we can use that to query the dest type
if (_siConn != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Determine reply dest type using SICoreConnection");
try {
// get the destination configuration & type
DestinationConfiguration destConfig = _siConn.getDestinationConfiguration(sida);
DestinationType destType = destConfig.getDestinationType();
if (destType == DestinationType.TOPICSPACE) {
tempReplyTo = new JmsTopicImpl();
}
else {
tempReplyTo = new JmsQueueImpl();
}
} catch (SIException sice) {
// No FFDC code needed
// d246604 Trace exceptions, but don't throw on. Fall back to
// case c) below.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
SibTr.debug(tc, "failed to look up dest type because of " + sice);
SibTr.debug(tc, "detail ", sice);
}
}
}
// Case c) - Guess based on the discriminator
if (tempReplyTo == null) {
// 239238 - make a stab at determining whether it's a queue or topic
// reply destination based on the reply disciminator.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Guess reply dest type using reply discriminator");
String replyDiscrim = _msg.getReplyDiscriminator();
if ((replyDiscrim == null) || ("".equals(replyDiscrim))) {
tempReplyTo = new JmsQueueImpl();
}
else {
tempReplyTo = new JmsTopicImpl();
}
}
}
}
// Now fill in the fields that were hidden in the reply header.
if (tempReplyTo != null) {
populateReplyToFromHeader(tempReplyTo, _msg, rrp);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getJMSReplyToInternal", tempReplyTo);
return tempReplyTo;
} | java |
String fullEncode() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "fullEncode");
String encoded = null;
// If we have a cached version of the string, use it.
if (cachedEncodedString != null) {
encoded = cachedEncodedString;
}
// Otherwise, encode it
else {
// Get a copy of the properties which make up this Destination. We need a
// copy since we remove the jms name before iterating over the other
// properties, and encoding them.
Map<String, Object> destProps = getCopyOfProperties();
// Pass off to a common helper method (between full and partial encodings).
encoded = encodeMap(destProps);
// Now store this string in the cache in case we need it later.
cachedEncodedString = encoded;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "fullEncode", encoded);
return encoded;
} | java |
String partialEncode() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "partialEncode()");
String encoded = null;
// If we have a cached version of the string, use it.
if (cachedPartialEncodedString != null) {
encoded = cachedPartialEncodedString;
}
else {
// Get a copy of the properties which make up this Destination. We need a
// copy since we remove the jms name before iterating over the other
// properties, and encoding them.
Map<String, Object> destProps = getCopyOfProperties();
// Remove the props that are stored in the reply header.
// NB. The deliveryMode is used in the creation of the reply header,
// but must still be carried.
destProps.remove(JmsInternalConstants.DEST_NAME);
destProps.remove(JmsInternalConstants.DEST_DISCRIM);
destProps.remove(JmsInternalConstants.PRIORITY);
destProps.remove(JmsInternalConstants.TIME_TO_LIVE);
destProps.remove(JmsInternalConstants.FORWARD_ROUTING_PATH);
destProps.remove(JmsInternalConstants.REVERSE_ROUTING_PATH);
// Pass off to a common helper method (between full and partial encodings).
encoded = encodeMap(destProps);
// Now store this string in the cache in case we need it later.
cachedPartialEncodedString = encoded;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "partialEncode", encoded);
return encoded;
} | java |
void configureDestinationFromRoutingPath(List fwdPath) throws JMSException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "configureDestinationFromRoutingPath", fwdPath);
// Clear the cache of the encoding string since we are changing properties.
clearCachedEncodings();
// Clear the producerDestinationAddress, as changing the FRP would make it out-of-date
clearCachedProducerDestinationAddress();
// Store the property if it has entries...
if ((fwdPath != null) && (fwdPath.size() > 0)) {
// There is at least one element in this path.
// The last element in the list is used to configure the 'big' destination.
int lastEltIndex = fwdPath.size() - 1;
// The last element of the reverse routing path becomes the destination, and
// anything left over goes into the forward path of the destination.
SIDestinationAddress lastElt = (SIDestinationAddress) fwdPath.get(lastEltIndex);
// Fill in the destination name information early so that it is there when
// the forward routing path is set.
String destName = lastElt.getDestinationName();
setDestName(destName);
// Set up the bus name to point at the bus of the last element as
// well.
//not setting the bus name for Liberty .. as in other config paths the bus name was not set.
// this is leading the same destination with different properties.
//String destBusName = lastElt.getBusName();
//setBusName(destBusName);
// If there is more than one element then we store the rest of the path
// in the wrapper object.
if (fwdPath.size() > 1) {
properties.put(FORWARD_ROUTING_PATH, new StringArrayWrapper(fwdPath));
}
// Otherwise, i.e. if there is only one element, we stash away the destination
// as we need to use it as the producerDestinationAddress.
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "caching producerDestinationAddress: " + lastElt);
producerDestinationAddress = lastElt;
}
}
// ...otherwise, remove it
else {
properties.remove(FORWARD_ROUTING_PATH);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "configureDestinationFromRoutingPath");
} | java |
private void clearCachedEncodings() {
cachedEncodedString = null;
cachedPartialEncodedString = null;
for (int i = 0; i < cachedEncoding.length; i++)
cachedEncoding[i] = null;
} | java |
public void initialiseNonPersistent(MessageProcessor messageProcessor,
SIMPTransactionManager txManager)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "initialiseNonPersistent", messageProcessor);
//Release 1 has no Link Bundle IDs for this Neighbour
// Cache the reference to the message processor
_messageProcessor = messageProcessor;
// Create the ObjectPool that will be used to store the
// subscriptionMessages. Creating with an intial length of
// 2, but this could be made a settable parameter for performance
_subscriptionMessagePool = new ObjectPool("SubscriptionMessages", NUM_MESSAGES);
// Create a new object to contain all the Neighbours
_neighbours = new Neighbours(this, _messageProcessor.getMessagingEngineBus());
// Create a new LockManager instance
_lockManager = new LockManager();
// Assign the transaction manager
_transactionManager = txManager;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "initialiseNonPersistent");
} | java |
public void initalised() throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "initalised");
try
{
_lockManager.lockExclusive();
// Flag that we are in a started state.
_started = true;
// If the Neighbour Listener hasn't been created, create it
if (_proxyListener == null)
createProxyListener();
// Indicate that reconciling is complete
_reconciling = false;
_neighbours.resetBusSubscriptionList();
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "initalised");
} | java |
public void stop()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "stop");
try
{
_lockManager.lockExclusive();
// Flag that we are in a started state.
_started = false;
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "stop");
} | java |
public void removeUnusedNeighbours()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeUnusedNeighbours");
final Enumeration neighbourList = _neighbours.getAllRecoveredNeighbours();
LocalTransaction transaction = null;
try
{
_lockManager.lockExclusive();
transaction = _transactionManager.createLocalTransaction(true);
// Enumerate through the Neighbours.
while (neighbourList.hasMoreElements())
{
final Neighbour neighbour = (Neighbour) neighbourList.nextElement();
// If the neigbour is a foreign neighbour and still has a link
// definition associated with it then we leave it in the recovered
// state. The link start operation will make the neighbour available.
// Link deletion will remove the neighbour
if (_messageProcessor.
getDestinationManager().
getLinkDefinition(neighbour.getBusId()) == null)
{
// If the Neighbour was created at startup from the message
// store, then this Neighbour can be deleted as it hasn't
// been reinstated from Admin.
// Delete this Neighbour with the forced option
// as we don't know the state of this Neighbour.
_neighbours.removeRecoveredNeighbour(neighbour.getUUID(),
(Transaction) transaction);
}
}
transaction.commit();
}
catch (SIException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.proxyhandler.MultiMEProxyHandler.removeUnusedNeighbours",
"1:310:1.96",
this);
try
{
if (transaction!=null)
transaction.rollback();
}
catch (SIException e1)
{
// FFDC
FFDCFilter.processException(
e1,
"com.ibm.ws.sib.processor.proxyhandler.MultiMEProxyHandler.removeUnusedNeighbours",
"1:324:1.96",
this);
SibTr.exception(tc, e1);
}
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeUnusedNeighbours", "SIErrorException");
throw new SIErrorException(e);
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeUnusedNeighbours");
} | java |
public void subscribeEvent(
ConsumerDispatcherState subState,
Transaction transaction)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"subscribeEvent",
new Object[] { subState, transaction });
try
{
// Get the lock Manager lock
// multiple subscribes can happen at the same time -
// this is allowed.
_lockManager.lock();
if (!_started)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "subscribeEvent", "Returning as stopped");
return;
}
// Get the list of Buses that this subscription needs to be forwarded
// onto
final BusGroup[] buses = _neighbours.getAllBuses();
// Declaration of a message handler that can be used for
// building up the proxy subscription message to be forwarded.
SubscriptionMessageHandler messageHandler = null;
// Loop through each of the Buses deciding if this
// subscription event needs to be forwarded
if (!_reconciling)
for (int i = 0; i < buses.length; ++i)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(
tc,
"Forwarding topic " + subState.getTopic() + " to Bus " + buses[i]);
// Send the proxy always
messageHandler =
buses[i].addLocalSubscription(
subState,
messageHandler,
transaction,
true);
// If the subscription message isn't null, then add it back into
// the pool of subscription messages.
if (messageHandler != null)
{
addMessageHandler(messageHandler);
messageHandler = null;
}
}
}
finally
{
// Release the lock that was obtained
_lockManager.unlock();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "subscribeEvent");
} | java |
public void topicSpaceCreatedEvent(DestinationHandler destination) throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "topicSpaceCreatedEvent", destination);
try
{
_lockManager.lockExclusive();
_neighbours.topicSpaceCreated(destination);
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "topicSpaceCreatedEvent");
} | java |
public void topicSpaceDeletedEvent(DestinationHandler destination)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "topicSpaceDeletedEvent", destination);
try
{
_lockManager.lockExclusive();
_neighbours.topicSpaceDeleted(destination);
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "topicSpaceDeletedEvent");
} | java |
public void linkStarted(String busId, SIBUuid8 meUuid)
throws SIIncorrectCallException, SIErrorException, SIDiscriminatorSyntaxException,
SISelectorSyntaxException, SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "linkStarted", new Object[] {busId, meUuid});
// Look for existing neighbour for the link
Neighbour neighbour = getNeighbour(meUuid);
if (neighbour == null)
{
// If the neighbour doesn't exist then create it now.
LocalTransaction tran = _transactionManager.createLocalTransaction(true);
neighbour = createNeighbour(meUuid, busId, (Transaction) tran);
tran.commit();
}
// Reset the list of subscriptions
_neighbours.resetBusSubscriptionList();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "linkStarted");
} | java |
public void cleanupLinkNeighbour(String busName)
throws SIRollbackException,
SIConnectionLostException,
SIIncorrectCallException,
SIResourceException,
SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "cleanupLinkNeighbour");
Neighbour neighbour = _neighbours.getBusNeighbour(busName);
if (neighbour != null)
{
LocalTransaction tran =
_messageProcessor.getTXManager().createLocalTransaction(true);
deleteNeighbourForced(neighbour.getUUID(), busName, (Transaction) tran);
tran.commit();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "cleanupLinkNeighbour");
} | java |
public void deleteNeighbourForced(
SIBUuid8 meUUID,
String busId,
Transaction transaction)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"deleteNeighbourForced",
new Object[] { meUUID, busId, transaction } );
try
{
_lockManager.lockExclusive();
// Force remove the Neighbour
_neighbours.removeNeighbour(meUUID, busId, transaction);
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "deleteNeighbourForced");
} | java |
public void deleteAllNeighboursForced(
Transaction transaction)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"deleteAllNeighboursForced",
new Object[] { transaction } );
try
{
_lockManager.lockExclusive();
Enumeration neighbs = _neighbours.getAllNeighbours();
while (neighbs.hasMoreElements())
{
Neighbour neighbour = (Neighbour)neighbs.nextElement();
// Force remove the Neighbour
_neighbours.removeNeighbour(neighbour.getUUID(), neighbour.getBusId(), transaction);
}
neighbs = _neighbours.getAllRecoveredNeighbours();
while (neighbs.hasMoreElements())
{
Neighbour neighbour = (Neighbour)neighbs.nextElement();
// Force remove the Neighbour
_neighbours.removeNeighbour(neighbour.getUUID(), neighbour.getBusId(), transaction);
}
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "deleteAllNeighboursForced");
} | java |
public void recoverNeighbours() throws SIResourceException, MessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "recoverNeighbours");
try
{
// Lock the manager exclusively
_lockManager.lockExclusive();
// Indicate that we are now reconciling
_reconciling = true;
_neighbours.recoverNeighbours();
}
finally
{
_lockManager.unlockExclusive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "recoverNeighbours");
} | java |
Enumeration reportAllNeighbours()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "reportAllNeighbours");
// Call out to the Neighbours class to get the list of Neighbours.
final Enumeration neighbours = _neighbours.getAllNeighbours();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "reportAllNeighbours");
return neighbours;
} | java |
void addMessageHandler(SubscriptionMessageHandler messageHandler)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "addMessageHandler", messageHandler);
final boolean inserted = _subscriptionMessagePool.add(messageHandler);
// If the message wasn't inserted, then the pool was exceeded
if (!inserted)
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(
tc,
"SubscriptionObjectPool size exceeded");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addMessageHandler");
} | java |
SubscriptionMessageHandler getMessageHandler()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getMessageHandler");
SubscriptionMessageHandler messageHandler =
(SubscriptionMessageHandler) _subscriptionMessagePool.remove();
if (messageHandler == null)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(
tc,
"doProxySubscribeOp",
"Creating a new Message Handler as none available");
messageHandler = new SubscriptionMessageHandler(this);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getMessageHandler", messageHandler);
return messageHandler;
} | java |
private void createProxyListener() throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "createProxyListener");
// Create the proxy listener instance
_proxyListener = new NeighbourProxyListener(_neighbours, this);
/*
* Now we can create our asynchronous consumer to listen on
* SYSTEM.MENAME.PROXY.QUEUE Queue for receiving subscription
* updates
*/
// 169897.1 modified parameters
try
{
_proxyAsyncConsumer =
_messageProcessor
.getSystemConnection()
.createSystemConsumerSession(
_messageProcessor.getProxyHandlerDestAddr(), // destination name
null, //Destination filter
null, // SelectionCriteria - discriminator and selector
Reliability.ASSURED_PERSISTENT, // reliability
false, // enable read ahead
false,
null,
false);
// 169897.1 modified parameters
_proxyAsyncConsumer.registerAsynchConsumerCallback(
_proxyListener,
0, 0, 1,
null);
_proxyAsyncConsumer.start(false);
}
catch (SIException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.proxyhandler.MultiMEProxyHandler.createProxyListener",
"1:1271:1.96",
this);
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createProxyListener", "SIResourceException");
// The Exceptions should already be NLS'd
throw new SIResourceException(e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createProxyListener");
} | java |
public final Neighbour getNeighbour(SIBUuid8 neighbourUUID, boolean includeRecovered)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getNeighbour", new Object[] { neighbourUUID, Boolean.valueOf(includeRecovered)});
Neighbour neighbour = _neighbours.getNeighbour(neighbourUUID);
if((neighbour == null) && includeRecovered)
neighbour = _neighbours.getRecoveredNeighbour(neighbourUUID);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getNeighbour", neighbour);
return neighbour;
} | java |
public void getSharedLock(int requestId)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getSharedLock",new Object[] {this,new Integer(requestId)});
Thread currentThread = Thread.currentThread();
Integer count = null;
synchronized(this)
{
// If this thread does not have any existing shared locks and there is a thread waiting to get the exclusive
// lock or a thread (other than this thread) who already holds the exclusive lock then we will have to wait
// until the exclusive lock is eventually dropped before granting the shared lock.
if ( (!_sharedThreads.containsKey(currentThread)) &&
( (_threadRequestingExclusiveLock != null) ||
((_threadHoldingExclusiveLock != null) && (!_threadHoldingExclusiveLock.equals(currentThread)))))
{
while ((_threadHoldingExclusiveLock != null) || (_threadRequestingExclusiveLock != null))
{
if (tc.isDebugEnabled()) Tr.debug(tc, "Thread " + Integer.toHexString(currentThread.hashCode()) + " is waiting for the exclusive lock to be released");
try
{
if (tc.isDebugEnabled()) Tr.debug(tc, "Thread " + Integer.toHexString(currentThread.hashCode()) + " waiting..");
this.wait();
}
catch(java.lang.InterruptedException exc)
{
FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.Lock.getSharedLock", "180", this);
if (tc.isDebugEnabled()) Tr.debug(tc, "Thread " + Integer.toHexString(currentThread.hashCode()) + " was interrupted unexpectedly during wait. Retesting condition");
// This exception is recieved if another thread interrupts this thread by calling this threads
// Thread.interrupt method. The Lock class does not use this mechanism for breaking out of the
// wait call - it uses notifyAll to wake up all waiting threads. This exception should never
// be generated. If for some reason it is called then ignore it and start to wait again.
}
}
if (tc.isDebugEnabled()) Tr.debug(tc, "Thread " + Integer.toHexString(currentThread.hashCode()) + " is has detected that the exclusive lock has been released");
}
count = (Integer)_sharedThreads.get(currentThread);
if (count == null)
{
count = new Integer(1);
}
else
{
count = new Integer(count.intValue()+1);
}
_sharedThreads.put(currentThread,count);
}
if (tc.isDebugEnabled()) Tr.debug(tc, "Count: " + count);
if (tc.isEntryEnabled()) Tr.exit(tc, "getSharedLock");
} | java |
public void releaseSharedLock(int requestId) throws NoSharedLockException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "releaseSharedLock",new Object[]{this,new Integer(requestId)});
Thread currentThread = Thread.currentThread();
int newValue = 0;
synchronized(this)
{
Integer count = (Integer)_sharedThreads.get(currentThread);
if (count == null)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "releaseSharedLock", "NoSharedLockException");
throw new NoSharedLockException();
}
newValue = count.intValue()-1;
if (newValue > 0)
{
count = new Integer(newValue);
_sharedThreads.put(currentThread,count);
}
else
{
count = null;
_sharedThreads.remove(currentThread);
}
// If this thread no longer holds any shared locks then inform those waiting of this
// fact.
if (count == null)
{
this.notifyAll();
}
}
if (tc.isDebugEnabled())
{
int countValue = 0;
Integer count = (Integer)_sharedThreads.get(currentThread);
if (count != null) countValue = count.intValue();
Tr.debug(tc, "Count: " + count);
}
if (tc.isEntryEnabled()) Tr.exit(tc, "releaseSharedLock");
} | java |
public boolean handleHTTP2AlpnConnect(HttpInboundLink link) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2AlpnConnect entry");
}
initialHttpInboundLink = link;
Integer streamID = new Integer(0);
H2VirtualConnectionImpl h2VC = new H2VirtualConnectionImpl(initialVC);
// remove the HttpDispatcherLink from the map, so a new one will be created and used by this new H2 stream
h2VC.getStateMap().remove(HttpDispatcherLink.LINK_ID);
H2HttpInboundLinkWrap wrap = new H2HttpInboundLinkWrap(httpInboundChannel, h2VC, streamID, this);
// create the initial stream processor, add it to the link stream table, and add it to the write queue
H2StreamProcessor streamProcessor = new H2StreamProcessor(streamID, wrap, this, StreamState.OPEN);
streamTable.put(streamID, streamProcessor);
writeQ.addNewNodeToQ(streamID, Node.ROOT_STREAM_ID, Node.DEFAULT_NODE_PRIORITY, false);
this.setDeviceLink((ConnectionLink) myTSC);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2AlpnConnect, exit");
}
return true;
} | java |
public boolean handleHTTP2UpgradeRequest(Map<String, String> headers, HttpInboundLink link) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest entry");
}
//1) Send the 101 response
//2) Setup the new streams and Links
//3) Place the new stream into the existing links
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, sending 101 response");
}
link.getHTTPContext().send101SwitchingProtocol("h2c");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, sent 101 response");
}
// if the above call goes async, not sure if we will then have a race condition, need to check further.System.out.println("H2InboundLink.handleHTTP2UpgradeRequest sent out 101");
Integer streamID = new Integer(1);
H2VirtualConnectionImpl h2VC = new H2VirtualConnectionImpl(initialVC);
// remove the HttpDispatcherLink from the map, so a new one will be created and used by this new H2 stream
h2VC.getStateMap().remove(HttpDispatcherLink.LINK_ID);
H2HttpInboundLinkWrap wrap = new H2HttpInboundLinkWrap(httpInboundChannel, h2VC, streamID, this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, creating stream processor");
}
H2StreamProcessor streamProcessor = new H2StreamProcessor(streamID, wrap, this, StreamState.HALF_CLOSED_REMOTE);
incrementActiveClientStreams();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, created stream processor : " + streamProcessor);
}
// first stream on this connection will have the root as parent, exclusive isn't an option
// not sure yet if priority can be anything other than the default for setting up the first stream on a connection
writeQ.addNewNodeToQ(streamID, Node.ROOT_STREAM_ID, Node.DEFAULT_NODE_PRIORITY, false);
streamTable.put(streamID, streamProcessor);
highestClientStreamId = streamID;
// add stream 0 to the table, in case we need to write out any control frames prior to initialization completion
streamID = 0;
streamProcessor = new H2StreamProcessor(streamID, wrap, this, StreamState.OPEN);
streamTable.put(streamID, streamProcessor);
// pull the settings header out of the request;
// process it and apply it to the stream
String settings = headers.get("HTTP2-Settings");
try {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, processing upgrade header settings : " + settings);
}
getRemoteConnectionSettings().processUpgradeHeaderSettings(settings);
} catch (Http2Exception e1) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest an error occurred processing the settings during connection initialization");
}
return false;
}
initialHttpInboundLink = link;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, reinit the link : " + link);
}
link.reinit(wrap.getConnectionContext(), wrap.getVirtualConnection(), wrap);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleHTTP2UpgradeRequest, exit");
}
return true;
} | java |
protected void updateHighestStreamId(int proposedHighestStreamId) throws ProtocolException {
if ((proposedHighestStreamId & 1) == 0) { // even number, server-initialized stream
if (proposedHighestStreamId > highestLocalStreamId) {
highestLocalStreamId = proposedHighestStreamId;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "highestLocalStreamId set to stream-id: " + proposedHighestStreamId);
}
} else if (proposedHighestStreamId < highestLocalStreamId) {
throw new ProtocolException("received a new stream with a lower ID than previous; "
+ "current stream-id: " + proposedHighestStreamId + " highest stream-id: "
+ highestLocalStreamId);
}
} else {
if (proposedHighestStreamId > highestClientStreamId) {
highestClientStreamId = proposedHighestStreamId;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "highestClientStreamId set to stream-id: " + proposedHighestStreamId);
}
} else if (proposedHighestStreamId < highestClientStreamId) {
throw new ProtocolException("received a new stream with a lower ID than previous; "
+ "current stream-id: " + proposedHighestStreamId + " highest stream-id: "
+ highestClientStreamId);
}
}
} | java |
@Override
public void destroy() {
httpInboundChannel.stop(50);
initialVC = null;
frameReadProcessor = null;
h2MuxReadCallback = null;
h2MuxTCPConnectionContext = null;
h2MuxTCPReadContext = null;
h2MuxTCPWriteContext = null;
localConnectionSettings = null;
remoteConnectionSettings = null;
readContextTable = null;
writeContextTable = null;
super.destroy();
} | java |
public void incrementConnectionWindowUpdateLimit(int x) throws FlowControlException {
if (!checkIfGoAwaySendingOrClosing()) {
writeQ.incrementConnectionWindowUpdateLimit(x);
H2StreamProcessor stream;
for (Integer i : streamTable.keySet()) {
stream = streamTable.get(i);
if (stream != null) {
stream.connectionWindowSizeUpdated();
}
}
}
} | java |
public void closeStream(H2StreamProcessor p) {
// only place that should be dealing with the closed stream table,
// be called by multiple stream objects at the same time, so sync access
synchronized (streamOpenCloseSync) {
if (p.getId() != 0) {
writeQ.removeNodeFromQ(p.getId());
this.closedStreams.add(p);
if (p.getId() % 2 == 0) {
this.openPushStreams--;
} else {
decrementActiveClientStreams();
}
}
// Removes all streams that are older than STREAM_CLOSE_DELAY from the streamTable
long currentTime = System.currentTimeMillis();
while (closedStreams.peek() != null &&
currentTime - closedStreams.peek().getCloseTime() > STREAM_CLOSE_DELAY) {
streamTable.remove(closedStreams.remove().getId());
}
}
} | java |
public H2StreamProcessor getStream(int streamID) {
H2StreamProcessor streamProcessor = null;
streamProcessor = streamTable.get(streamID);
return streamProcessor;
} | java |
public void remove(BeanId beanId, boolean removeFromFailoverCache)
throws RemoteException //LIDB2018-1
{
// LIDB2018-1 begins
if (ivStatefulFailoverCache == null || !ivStatefulFailoverCache.beanExists(beanId))
{
//PK69093 - beanStore.remove will access a file, as such lets synch this call
//such that only one file can be open for remove at a time.
synchronized (ivRemoveLock)
{
// failover cache does not exist (e.g. SFSB failover is not enabled)
// or SFSB is not in failover cache. Therefore, SFSB must be in
// the passivation file for the bean. So remove it from bean store.
ivBeanStore.remove(beanId);
}
}
else
{
// SFSB is in the failover cache, so remove it from failover Cache.
if (removeFromFailoverCache)
{
ivStatefulFailoverCache.removeCacheEntry(beanId);
}
}
// LIDB2018-1 ends
} | java |
private byte[] getCompressedBytes(Object sb,
long lastAccessTime,
Object exPC) throws IOException // d367572.7
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "getCompressedBytes", sb);
// Serialize SessionBean to a byte[].
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
GZIPOutputStream gout = new GZIPOutputStream(baos);
ObjectOutputStream beanStream2 = createPassivationOutputStream(gout);
if (isTraceOn && tc.isDebugEnabled()) //d204278.2
Tr.debug(tc, "writing failover data with last access time set to: " + lastAccessTime);
// First write the last access time.
beanStream2.writeLong(lastAccessTime); //d204278.2
// Write the persistence context
beanStream2.writeObject(exPC);
// Now the SFSB data.
beanStream2.writeObject(sb);
gout.finish();
gout.close();
beanStream2.close();
byte[] bytes = baos.toByteArray();
baos.close();
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "getCompressedBytes");
return bytes;
} | java |
public Map<String, Map<String, Field>> getPassivatorFields(final BeanMetaData bmd) // d648122
{
// Volatile data race. We do not care if multiple threads do the work
// since they will all get the same result.
Map<String, Map<String, Field>> result = bmd.ivPassivatorFields;
if (result == null)
{
result = AccessController.doPrivileged(new PrivilegedAction<Map<String, Map<String, Field>>>()
{
@Override
public Map<String, Map<String, Field>> run()
{
Map<String, Map<String, Field>> allFields = new HashMap<String, Map<String, Field>>();
collectPassivatorFields(bmd.enterpriseBeanClass, allFields);
if (bmd.ivInterceptorMetaData != null)
{
for (Class<?> klass : bmd.ivInterceptorMetaData.ivInterceptorClasses)
{
collectPassivatorFields(klass, allFields);
}
}
return allFields;
}
});
bmd.ivPassivatorFields = result;
}
return result;
} | java |
public Token removeFirst(Transaction transaction)
throws ObjectManagerException
{
Iterator iterator = entrySet().iterator();
List.Entry entry = (List.Entry) iterator.next(transaction);
iterator.remove(transaction);
return entry.getValue();
} | java |
public void postProcessMatches(DestinationHandler topicSpace,
String topic,
Object[] results,
int index)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "postProcessMatches","results: "+Arrays.toString(results)+";index: "+index + ";topic"+topic);
Set subRes = (Set) results[index];
Iterator itr = subRes.iterator();
if(authorization != null)
{
// If security is enabled then we'll do the permissions check
if(authorization.isBusSecure())
{
if(topicSpace != null &&
topicSpace.isTopicAccessCheckRequired()) // Bypass security checks
{
while (itr.hasNext())
{
ControllableProxySubscription cps = (ControllableProxySubscription) itr.next();
if(cps.isForeignSecuredProxy())
{
// The proxy sub originated in a foreign bus
String userid = cps.getMESubUserId();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Foreign bus proxy in a secured env for user, " + userid + ", on topic, " + topic);
try
{
if(!authorization.
checkPermissionToSubscribe(topicSpace,
topic,
userid,
(TopicAclTraversalResults)results[MessageProcessorMatchTarget.ACL_TYPE]))
{
// Not authorized to subscribe to topic, need to remove from results
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Not authorized, remove from PSOH results");
itr.remove();
}
}
catch (Exception e)
{
// No FFDC code needed
}
}
}
}
}
}
else
{
// Its a glitch and I need to feed this back.
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "postProcessMatches");
} | java |
private static void createInstance() throws Exception {
if (tc.isEntryEnabled())
SibTr.entry(tc, "createInstance", null);
try {
Class cls = Class.forName(JsConstants.JS_ADMIN_FACTORY_CLASS);
_instance = (JsAdminFactory) cls.newInstance();
} catch (Exception e) {
com.ibm.ws.ffdc.FFDCFilter.processException(e, CLASS_NAME + ".<clinit>", JsConstants.PROBE_10);
SibTr.error(tc, "EXCP_DURING_INIT_SIEG0001", e);
// TODO: HIGH: Is this the correct error?
throw e;
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "createInstance");
} | java |
public SIBusMessage[] readSet(SIMessageHandle[] msgHandles)
throws SISessionUnavailableException, SISessionDroppedException,
SIConnectionUnavailableException, SIConnectionDroppedException,
SIResourceException, SIConnectionLostException,
SIIncorrectCallException, SIMessageNotLockedException,
SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "readSet",
new Object[]
{
msgHandles.length + " msg ids"
});
SIBusMessage[] messages = null;
try
{
closeLock.readLock().lockInterruptibly();
try
{
checkAlreadyClosed();
CommsByteBuffer request = getCommsByteBuffer();
request.putShort(getConnectionObjectID());
request.putShort(getProxyID());
request.putSIMessageHandles(msgHandles);
CommsByteBuffer reply = jfapExchange(request,
JFapChannelConstants.SEG_READ_SET,
JFapChannelConstants.PRIORITY_MEDIUM,
true);
try
{
short err = reply.getCommandCompletionCode(JFapChannelConstants.SEG_READ_SET_R);
if (err != CommsConstants.SI_NO_EXCEPTION)
{
checkFor_SISessionUnavailableException(reply, err);
checkFor_SISessionDroppedException(reply, err);
checkFor_SIConnectionUnavailableException(reply, err);
checkFor_SIConnectionDroppedException(reply, err);
checkFor_SIResourceException(reply, err);
checkFor_SIConnectionLostException(reply, err);
checkFor_SIIncorrectCallException(reply, err);
checkFor_SIMessageNotLockedException(reply, err);
checkFor_SIErrorException(reply, err);
defaultChecker(reply, err);
}
int numberOfMessages = reply.getInt();
messages = new SIBusMessage[numberOfMessages];
for (int x = 0; x < numberOfMessages; x++)
{
messages[x] = reply.getMessage(getCommsConnection());
}
}
finally
{
reply.release(false);
}
}
finally
{
closeLock.readLock().unlock();
}
}
catch (InterruptedException e)
{
// No FFDC Code needed
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "readSet");
return messages;
} | java |
public SIBusMessage[] readAndDeleteSet(SIMessageHandle[] msgHandles, SITransaction tran)
throws SISessionUnavailableException, SISessionDroppedException,
SIConnectionUnavailableException, SIConnectionDroppedException,
SIResourceException, SIConnectionLostException, SILimitExceededException,
SIIncorrectCallException, SIMessageNotLockedException,
SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "readAndDeleteSet",
new Object[]
{
msgHandles.length + " msg ids",
tran
});
SIBusMessage[] messages = null;
try
{
closeLock.readLock().lockInterruptibly();
try
{
checkAlreadyClosed();
// Now we need to synchronise on the transaction object if there is one.
if (tran != null)
{
synchronized (tran)
{
// Check transaction is in a valid state.
// Enlisted for an XA UOW and not rolledback or
// completed for a local transaction.
if (!((Transaction) tran).isValid())
{
throw new SIIncorrectCallException(
nls.getFormattedMessage("TRANSACTION_COMPLETE_SICO1066", null, null)
);
}
messages = _readAndDeleteSet(msgHandles, tran);
}
}
else
{
messages = _readAndDeleteSet(msgHandles, null);
}
}
finally
{
closeLock.readLock().unlock();
}
}
catch (InterruptedException e)
{
// No FFDC Code needed
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "readAndDeleteSet");
return messages;
} | java |
private SIBusMessage[] _readAndDeleteSet(SIMessageHandle[] msgHandles, SITransaction tran)
throws SISessionUnavailableException, SISessionDroppedException,
SIConnectionUnavailableException, SIConnectionDroppedException,
SIResourceException, SIConnectionLostException, SILimitExceededException,
SIIncorrectCallException, SIMessageNotLockedException,
SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "_readAndDeleteSet",
new Object[]
{
msgHandles.length + " msg ids",
tran
});
// 531458 Allow minimal tracing to include message ids and tran id
if (TraceComponent.isAnyTracingEnabled()) {
CommsLightTrace.traceMessageIds(tc, "ReadAndDeleteSetMsgTrace", msgHandles);
}
SIBusMessage[] messages = null;
CommsByteBuffer request = getCommsByteBuffer();
request.putShort(getConnectionObjectID());
request.putShort(getProxyID());
request.putSITransaction(tran);
request.putSIMessageHandles(msgHandles);
CommsByteBuffer reply = jfapExchange(request,
JFapChannelConstants.SEG_READ_AND_DELETE_SET,
JFapChannelConstants.PRIORITY_MEDIUM,
true);
try
{
short err = reply.getCommandCompletionCode(JFapChannelConstants.SEG_READ_AND_DELETE_SET_R);
if (err != CommsConstants.SI_NO_EXCEPTION)
{
checkFor_SISessionUnavailableException(reply, err);
checkFor_SISessionDroppedException(reply, err);
checkFor_SIConnectionUnavailableException(reply, err);
checkFor_SIConnectionDroppedException(reply, err);
checkFor_SIResourceException(reply, err);
checkFor_SIConnectionLostException(reply, err);
checkFor_SILimitExceededException(reply, err);
checkFor_SIIncorrectCallException(reply, err);
checkFor_SIMessageNotLockedException(reply, err);
checkFor_SIErrorException(reply, err);
defaultChecker(reply, err);
}
int numberOfMessages = reply.getInt();
messages = new SIBusMessage[numberOfMessages];
for (int x = 0; x < numberOfMessages; x++)
{
messages[x] = reply.getMessage(getCommsConnection());
}
}
finally
{
reply.release(false);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "_readAndDeleteSet", messages);
return messages;
} | java |
public static Object[] generateMsgParms(Object parm1, Object parm2, Object parm3, Object parm4, Object parm5,
Object parm6, Object parm7) {
Object parms[] = new Object[7];
parms[0] = parm1;
parms[1] = parm2;
parms[2] = parm3;
parms[3] = parm4;
parms[4] = parm5;
parms[5] = parm6;
parms[6] = parm7;
return parms;
} | java |
private void scan() {
if (ivScanned) {
return;
}
ivScanned = true;
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
for (Class<?> klass = ivClass; klass != null && klass != Object.class; klass = klass.getSuperclass()) {
if (isTraceOn && (tc.isDebugEnabled() || tcMetaData.isDebugEnabled()))
Tr.debug(tc.isDebugEnabled() ? tc : tcMetaData,
"scanning " + klass.getName());
ivCurrentClassName = klass.getName();
ivCurrentPrivateMethodMetaData = null;
ClassLoader classLoader = klass.getClassLoader();
if (classLoader == null) {
classLoader = getBootClassLoader(); // d742751
}
String resourceName = klass.getName().replace('.', '/') + ".class";
InputStream input = classLoader.getResourceAsStream(resourceName);
if (input == null) // d728537
{
if (isTraceOn && (tc.isDebugEnabled() || tcMetaData.isDebugEnabled()))
Tr.debug(tc.isDebugEnabled() ? tc : tcMetaData,
"failed to find " + resourceName + " from " + classLoader);
ivScanException = new FileNotFoundException(resourceName);
return;
}
try {
ClassReader classReader = new ClassReader(input);
classReader.accept(this, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
}
// If the class is malformed, ASM might throw any exception. d728537
catch (Throwable t) {
FFDCFilter.processException(t, CLASS_NAME + ".scan", "168", this,
new Object[] { resourceName, klass, classLoader });
if (isTraceOn && (tc.isDebugEnabled() || tcMetaData.isDebugEnabled()))
Tr.debug(tc.isDebugEnabled() ? tc : tcMetaData,
"scan exception", t);
ivScanException = t;
return;
} finally {
try {
input.close();
} catch (IOException ex) {
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "error closing input stream", ex);
}
}
}
} | java |
public Method getBridgeMethodTarget(Method method) {
scan();
if (ivBridgeMethodMetaData == null) {
return null;
}
BridgeMethodMetaData md = ivBridgeMethodMetaData.get(getNonPrivateMethodKey(method));
return md == null ? null : md.ivTarget;
} | java |
public boolean isInElementSet(Set<String> skipList, Class<?> excClass) throws ClassNotFoundException {
//String mName = "isInElementSet(Set<String> skipList, Class<?> excClass)";
boolean retVal = false;
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
for(String value : skipList) {
Class<?> clazz = tccl.loadClass(value);
if(clazz.isAssignableFrom(excClass)) {
retVal = true;
break;
}
}
return retVal;
} | java |
public void updated(Dictionary<?, ?> props) {
String value = (String) props.get(PROP_IDNAME);
if (null != value) {
this.idName = value.trim();
}
value = (String) props.get(PROP_USE_URLS);
if (null != value && Boolean.parseBoolean(value.trim())) {
this.urlRewritingMarker = ";" + getIDName() + "=" + getSessionVersion();
}
value = (String) props.get(PROP_USE_COOKIES);
if (null != value) {
this.enableCookies = Boolean.parseBoolean(value.trim());
}
if (this.enableCookies) {
// we're using cookies for session information
value = (String) props.get(PROP_COOKIE_SECURE);
if (null != value) {
this.cookieSecure = Boolean.parseBoolean(value.trim());
}
value = (String) props.get(PROP_COOKIE_PATH);
if (null != value) {
this.cookiePath = value.trim();
}
value = (String) props.get(PROP_COOKIE_DOMAIN);
if (null != value) {
this.cookieDomain = value.trim();
}
value = (String) props.get(PROP_COOKIE_MAXAGE);
if (null != value) {
try {
this.cookieMaxAge = Integer.parseInt(value.trim());
} catch (NumberFormatException nfe) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Ignoring incorrect max-age [" + value + "]", nfe.getMessage());
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Config: id name [" + this.idName + "]");
if (isURLRewriting()) {
Tr.event(tc, "Config: use URL rewriting [" + this.urlRewritingMarker + "]");
}
if (this.enableCookies) {
Tr.event(tc, "Config: cookie max-age [" + this.cookieMaxAge + "]");
Tr.event(tc, "Config: cookie secure [" + this.cookieSecure + "]");
Tr.event(tc, "Config: cookie domain [" + this.cookieDomain + "]");
Tr.event(tc, "Config: cookie path [" + this.cookiePath + "]");
} else {
Tr.event(tc, "Config: cookies disabled");
}
}
} | java |
@Trivial
@Override
public synchronized void run() {
clientSupport = null;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "run : cached ClientSupport reference cleared");
}
} | java |
public boolean isProtected() {
List<String> requiredRoles = null;
return !webRequest.isUnprotectedURI() &&
webRequest.getMatchResponse() != null &&
(requiredRoles = webRequest.getRequiredRoles()) != null &&
!requiredRoles.isEmpty();
} | java |
@Override
protected Object performInvocation(Exchange exchange, Object serviceObject, Method m, Object[] paramArray) throws Exception {
paramArray = insertExchange(m, paramArray, exchange);
return this.libertyJaxRsServerFactoryBean.performInvocation(exchange, serviceObject, m, paramArray);
} | java |
@FFDCIgnore(value = { SecurityException.class, IllegalAccessException.class, IllegalArgumentException.class, InvocationTargetException.class })
private void callValidationMethod(String methodName, Object[] paramValues, Object theProvider) {
if (theProvider == null) {
return;
}
Method m = cxfBeanValidationProviderMethodsMap.get(methodName);
if (m == null) {
return;
}
try {
m.invoke(theProvider, paramValues);
} catch (SecurityException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Can't access the method \"" + m.getName() + "\" due to security issue." + e.getMessage());
}
} catch (IllegalAccessException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Can't access the method \"" + m.getName() + "\"." + e.getMessage());
}
} catch (IllegalArgumentException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Illegal argument to the method \"" + m.getName() + "\"." + e.getMessage());
}
} catch (InvocationTargetException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Invocation of the method \"" + m.getName() + "\" fails" + e.getMessage());
}
/**
* throw the javax.validation.ValidationException to keep the same behavior as CXF expected
*/
Throwable validationException = e.getTargetException();
if (null != validationException && validationException instanceof RuntimeException) {
throw (RuntimeException) validationException;
}
}
} | java |