code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public synchronized void putString(String item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putString", item);
checkValid();
// A String is presented by a BIT16 denoting the length followed by encoded bytes. If the
// String is null, then a length of 1, followed by a single null byte (0x00) is written into
// the buffer.
if (item == null)
{
WsByteBuffer currentBuffer = getCurrentByteBuffer(3);
currentBuffer.putShort((short) 1);
currentBuffer.put(new byte[] { (byte) 0 });
}
else
{
try
{
byte[] stringAsBytes = item.getBytes(stringEncoding);
WsByteBuffer currentBuffer = getCurrentByteBuffer(2 + stringAsBytes.length);
currentBuffer.putShort((short) stringAsBytes.length);
currentBuffer.put(stringAsBytes);
}
catch (UnsupportedEncodingException e)
{
FFDCFilter.processException(e, CLASS_NAME + ".putString",
CommsConstants.COMMSBYTEBUFFER_PUTSTRING_01,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Unable to encode String: ", e);
SibTr.error(tc, "UNSUPPORTED_STRING_ENCODING_SICO8005", new Object[] {stringEncoding, e});
throw new SIErrorException(
TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE, "UNSUPPORTED_STRING_ENCODING_SICO8005", new Object[] {stringEncoding, e}, null)
);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putString");
} | java |
public synchronized void putSIDestinationAddress(SIDestinationAddress destAddr, short fapLevel)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putSIDestinationAddress", new Object[]{destAddr, Short.valueOf(fapLevel)});
checkValid();
String destName = null;
String busName = null;
byte[] uuid = new byte[0];
boolean localOnly = false;
if (destAddr != null)
{
destName = destAddr.getDestinationName();
busName = destAddr.getBusName();
// If the user has passed in something that we do not know how to serialize, do not even
// try and do anything with the other parts of it.
if (destAddr instanceof JsDestinationAddress)
{
JsDestinationAddress jsDestAddr = (JsDestinationAddress) destAddr;
// If the isMediation() flag has been set, ensure we propagate this as a special UUId.
// We can do this because a mediation destination only carries a name and the UUId
// field is actually redundant.
//lohith liberty change
/* if (jsDestAddr.isFromMediation())
{
uuid = new byte[1];
uuid[0] = CommsConstants.DESTADDR_ISFROMMEDIATION;
}
else*/
{
if (jsDestAddr.getME() != null) uuid = jsDestAddr.getME().toByteArray();
localOnly = jsDestAddr.isLocalOnly();
}
}
}
putShort((short) uuid.length);
if (uuid.length != 0) put(uuid);
putString(destName);
putString(busName);
//Only send localOnly field if fapLevel >= 9 so we don't break down-level servers/client.
if(fapLevel >= JFapChannelConstants.FAP_VERSION_9)
{
put(localOnly ? CommsConstants.TRUE_BYTE : CommsConstants.FALSE_BYTE);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putSIDestinationAddress");
} | java |
public synchronized void putSelectionCriteria(SelectionCriteria criteria)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putSelectionCriteria", criteria);
checkValid();
String discriminator = null;
String selector = null;
short selectorDomain = (short) SelectorDomain.SIMESSAGE.toInt();
if (criteria != null)
{
discriminator = criteria.getDiscriminator();
selector = criteria.getSelectorString();
SelectorDomain selDomain = criteria.getSelectorDomain();
if (selDomain != null)
{
selectorDomain = (short) selDomain.toInt();
}
}
putShort(selectorDomain);
putString(discriminator);
putString(selector);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putSelectionCriteria");
} | java |
public synchronized void putXid(Xid xid)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "putXid", xid);
putInt(xid.getFormatId());
putInt(xid.getGlobalTransactionId().length);
put(xid.getGlobalTransactionId());
putInt(xid.getBranchQualifier().length);
put(xid.getBranchQualifier());
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "putXid");
} | java |
public synchronized void putSITransaction(SITransaction transaction)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "putSITransaction", transaction);
Transaction commsTx = (Transaction)transaction;
int flags = -1;
if (transaction == null)
{
// No transaction - add "no transaction" flags to buffer.
putInt(0x00000000);
}
else
{
// First we must search for any optimized transactions as they hold much more information
// than the old-style ones.
OptimizedTransaction optTx = null;
// First see if the transaction is a global one. This could be both optimized or
// unoptimized but the result is buried within it
if (transaction instanceof SuspendableXAResource)
{
SIXAResource suspendableXARes = ((SuspendableXAResource) transaction).getCurrentXAResource();
if (suspendableXARes instanceof OptimizedTransaction)
{
// The current XA Resource is indeed optimized
optTx = (OptimizedTransaction) suspendableXARes;
}
}
// Otherwise the actual transaction itself may be an optimized one - this is in the case
// of an optimized local transaction.
else if (transaction instanceof OptimizedTransaction)
{
optTx = (OptimizedTransaction) transaction;
}
// If we are optimized...
if (optTx != null)
{
// Optimized transaction
flags = CommsConstants.OPTIMIZED_TX_FLAGS_TRANSACTED_BIT;
boolean local = optTx instanceof SIUncoordinatedTransaction;
boolean addXid = false;
boolean endPreviousUow = false;
if (local)
{
flags |= CommsConstants.OPTIMIZED_TX_FLAGS_LOCAL_BIT;
}
if (!optTx.isServerTransactionCreated())
{
flags |= CommsConstants.OPTIMIZED_TX_FLAGS_CREATE_BIT;
if (local && optTx.areSubordinatesAllowed())
flags |= CommsConstants.OPTIMIZED_TX_FLAGS_SUBORDINATES_ALLOWED;
optTx.setServerTransactionCreated();
addXid = !local;
}
if (addXid && (optTx.isEndRequired()))
{
flags |= CommsConstants.OPTIMIZED_TX_END_PREVIOUS_BIT;
endPreviousUow = true;
}
putInt(flags);
putInt(optTx.getCreatingConversationId());
putInt(commsTx.getTransactionId());
if (addXid)
{
if (endPreviousUow)
{
putInt(optTx.getEndFlags());
optTx.setEndNotRequired();
}
putXid(new XidProxy(optTx.getXidForCurrentUow()));
}
}
else
{
// This is an un-optimized transaction - simply append transaction ID.
putInt(commsTx.getTransactionId());
}
}
if (TraceComponent.isAnyTracingEnabled()) {
int commsId = -1;
if (commsTx != null) commsId = commsTx.getTransactionId();
CommsLightTrace.traceTransaction(tc, "PutTxnTrace", commsTx, commsId, flags);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "putSITransaction");
} | java |
public int putMessgeWithoutEncode(List<DataSlice> messageParts)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putMessgeWithoutEncode", messageParts);
int messageLength = 0;
// Now we have a list of MessagePart objects. First work out the overall length.
for (int x = 0; x < messageParts.size(); x++)
{
messageLength += messageParts.get(x).getLength();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Message is " + messageLength + "byte(s) in length");
// Write the length
putLong(messageLength);
// Now take the message parts and wrap them into byte buffers using the offset's supplied
for (int x = 0; x < messageParts.size(); x++)
{
DataSlice messPart = messageParts.get(x);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "DataSlice[" + x + "]: " +
"Array: " + Arrays.toString(messPart.getBytes()) + ", " +
"Offset: " + messPart.getOffset() + ", " +
"Length: " + messPart.getLength());
wrap(messPart.getBytes(), messPart.getOffset(), messPart.getLength());
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putMessgeWithoutEncode", messageLength);
return messageLength;
} | java |
public synchronized void putDataSlice(DataSlice slice)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putDataSlice", slice);
// First pump in the length
putInt(slice.getLength());
// Now add in the payload
wrap(slice.getBytes(), slice.getOffset(), slice.getLength());
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putDataSlice");
} | java |
public synchronized void putSIMessageHandles(SIMessageHandle[] siMsgHandles)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "putSIMessageHandles", siMsgHandles);
putInt(siMsgHandles.length);
for (int handleIndex = 0; handleIndex < siMsgHandles.length; ++handleIndex)
{
JsMessageHandle jsHandle = (JsMessageHandle)siMsgHandles[handleIndex];
putLong(jsHandle.getSystemMessageValue());
put(jsHandle.getSystemMessageSourceUuid().toByteArray());
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "message handle: "+siMsgHandles[handleIndex]);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "putSIMessageHandles");
} | java |
public synchronized void putException(Throwable throwable, String probeId, Conversation conversation)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putException",
new Object[]{throwable, probeId, conversation});
Throwable currentException = throwable;
// First we need to work out how many exceptions to send back
short numberOfExceptions = 0;
while(currentException != null)
{
currentException = currentException.getCause();
numberOfExceptions++;
}
// Now add them to the buffer
currentException = throwable;
// First put in the buffer how many exceptions are being sent back
putShort(numberOfExceptions);
// Now iterate over the rest
while (currentException != null)
{
short exceptionId = getExceptionId(currentException);
addException(currentException,
exceptionId,
probeId);
// Now get the next one in the chain
currentException = currentException.getCause();
// Ensure we null out the probe - this doesn't apply for any more exceptions
probeId = null;
}
final HandshakeProperties handshakeProperties = conversation.getHandshakeProperties();
if ((handshakeProperties != null) &&
((CATHandshakeProperties)handshakeProperties).isFapLevelKnown())
{
// Only do FAP level checking if we know the FAP level - otherwise, assume a pre-FAP
// 9 format for the exception flow. We can find ourselves in a situation where we
// don't know the FAP level if, for example, an exception is thrown during handshaking.
final int fapLevel = ((CATHandshakeProperties)handshakeProperties).getFapLevel();
if (fapLevel >= JFapChannelConstants.FAP_VERSION_9)
{
// At FAP version 9 or greater we transport the reason and inserts
// of any exception which implements the Reasonable interface, or
// inherits from SIException or SIErrorException.
int reason = Reasonable.DEFAULT_REASON;
String inserts[] = Reasonable.DEFAULT_INSERTS;
if (throwable instanceof Reasonable)
{
reason = ((Reasonable)throwable).getExceptionReason();
inserts = ((Reasonable)throwable).getExceptionInserts();
}
else if (throwable instanceof SIException)
{
reason = ((SIException)throwable).getExceptionReason();
inserts = ((SIException)throwable).getExceptionInserts();
}
else if (throwable instanceof SIErrorException)
{
reason = ((SIErrorException)throwable).getExceptionReason();
inserts = ((SIErrorException)throwable).getExceptionInserts();
}
putInt(reason);
putShort(inserts.length);
for (int i=0; i < inserts.length; ++i)
{
putString(inserts[i]);
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putException");
} | java |
public synchronized String getString()
{
checkReleased();
String returningString = null;
// Read the length in
short stringLength = receivedBuffer.getShort();
// Allocate the right amount of space for it
byte[] stringBytes = new byte[stringLength];
// And copy the data in
receivedBuffer.get(stringBytes);
// If the length is 1, and the byte is 0x00, then this is null - so do nothing
if (stringLength == 1 && stringBytes[0] == 0)
{
// String is null...
}
else
{
try
{
returningString = new String(stringBytes, stringEncoding);
}
catch (UnsupportedEncodingException e)
{
FFDCFilter.processException(e, CLASS_NAME + ".getString",
CommsConstants.COMMSBYTEBUFFER_GETSTRING_01,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, "Unable to encode String: ", e);
SibTr.exception(tc, e);
}
SibTr.error(tc, "UNSUPPORTED_STRING_ENCODING_SICO8005", new Object[] {stringEncoding, e});
throw new SIErrorException(
TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE, "UNSUPPORTED_STRING_ENCODING_SICO8005", new Object[] {stringEncoding, e}, null)
);
}
}
return returningString;
} | java |
public synchronized SIDestinationAddress getSIDestinationAddress(short fapLevel)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getSIDestinationAddress", Short.valueOf(fapLevel)); //469395
checkReleased();
boolean isFromMediation = false;
/**************************************************************/
/* Uuid */
/**************************************************************/
short uuidLength = getShort(); // BIT16 Uuid Length
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Uuid length:", ""+uuidLength);
SIBUuid8 uuid = null;
// Note: In all other cases, a length of -1 would normally indicate a null value.
// However, in this case we use a length 0 to inidicate a null value, mainly
// because the uuid can not be 0 in length, and using 0 makes the code neater.
if (uuidLength != 0)
{
if (uuidLength == 1)
{
byte addressFlags = get();
if (addressFlags == CommsConstants.DESTADDR_ISFROMMEDIATION)
{
isFromMediation = true;
}
}
else
{
byte[] uuidBytes = get(uuidLength); // BYTE[] Uuid
uuid = new SIBUuid8(uuidBytes);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Uuid:", uuid);
}
}
else
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Uuid was null");
}
/**************************************************************/
/* Destination */
/**************************************************************/
String destinationName = getString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Destination name:", destinationName);
/**************************************************************/
/* Bus name */
/**************************************************************/
String busName = getString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Bus name:", busName);
/**************************************************************/
/* Local only */
/**************************************************************/
//Only read from buffer if fap 9 or greater
//Default value if not flown is false for backwards compatibility.
boolean localOnly = false;
if(fapLevel >= JFapChannelConstants.FAP_VERSION_9)
{
final byte localOnlyByte = get();
localOnly = (localOnlyByte == CommsConstants.TRUE_BYTE);
}
if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "localOnly: ", localOnly);
// If we get a null UUID, a null name and a null bus name, return null
JsDestinationAddress destAddress = null;
if (uuid == null && destinationName == null && busName == null)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Both UUID, destination name and bus name were null");
}
else
{
//lohith liberty change
/* if (isFromMediation)
{
destAddress =
((JsDestinationAddressFactory) JsDestinationAddressFactory.getInstance()).
createJsMediationdestinationAddress(destinationName);
}
else*/
{
destAddress =
((JsDestinationAddressFactory) JsDestinationAddressFactory.getInstance()).
createJsDestinationAddress(destinationName,
localOnly,
uuid,
busName);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getSIDestinationAddress",destAddress); //469395
return destAddress;
} | java |
public synchronized SelectionCriteria getSelectionCriteria()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getSelectionCriteria"); //469395
checkReleased();
SelectorDomain selectorDomain = SelectorDomain.getSelectorDomain(getShort());
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selector domain", selectorDomain);
/**************************************************************/
/* Destination */
/**************************************************************/
String discriminator = getString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Discriminator:", discriminator);
/**************************************************************/
/* Destination */
/**************************************************************/
String selector = getString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selector:", selector);
SelectionCriteria selectionCriteria =
CommsClientServiceFacade.getSelectionCriteriaFactory().createSelectionCriteria(discriminator,
selector,
selectorDomain);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getSelectionCriteria"); //469395
return selectionCriteria;
} | java |
public synchronized Xid getXid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "getXid");
checkReleased();
int formatId = getInt();
int glidLength = getInt();
byte[] globalTransactionId = get(glidLength);
int blqfLength = getInt();
byte[] branchQualifier = get(blqfLength);
XidProxy xidProxy = new XidProxy(formatId, globalTransactionId, branchQualifier);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getXid", xidProxy);
return xidProxy;
} | java |
public synchronized SIBusMessage getMessage(CommsConnection commsConnection)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "getMessage");
checkReleased();
SIBusMessage mess = null;
// Now build a JsMessage from the returned data. Note that a message length of -1 indicates
// that no message has been returned and a null value should be returned to the caller.
// Get length of JsMessage
int messageLen = (int) getLong();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Message length", messageLen);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Remaining in buffer", receivedBuffer.remaining());
if (messageLen > -1)
{
// Build Message from byte array. If the buffer is backed by an array we should simply
// pass that into MFP rather than copying into a new byte[]
try
{
if (receivedBuffer.hasArray())
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received buffer has a backing array");
mess = JsMessageFactory.getInstance().createInboundJsMessage(receivedBuffer.array(),
receivedBuffer.position() + receivedBuffer.arrayOffset(),
messageLen,
commsConnection);
// Move the position to the end of the message so that any data after the message
// can be got
receivedBuffer.position(receivedBuffer.position() + messageLen);
}
else
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received buffer does NOT have a backing array");
byte[] messageArray = get(messageLen);
mess = JsMessageFactory.getInstance().createInboundJsMessage(messageArray,
0,
messageLen,
commsConnection);
}
}
catch (Exception e)
{
FFDCFilter.processException(e, CLASS_NAME + ".getMessage", CommsConstants.COMMSBYTEBUFFER_GETMESSAGE_01, this,
new Object[] {"messageLen="+messageLen+", position="+receivedBuffer.position()+", limit="+receivedBuffer.limit() + " " +
(receivedBuffer.hasArray()?"arrayOffset="+receivedBuffer.arrayOffset()+" array.length="+receivedBuffer.array().length:"no backing array")});
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(this, tc, "Unable to create message", e);
dump(this, tc, 100);
}
throw new SIResourceException(e);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getMessage", mess);
return mess;
} | java |
public synchronized SIMessageHandle[] getSIMessageHandles()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getSIMessageHandles");
int arrayCount = getInt(); // BIT32 ArrayCount
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "arrayCount", arrayCount);
SIMessageHandle[] msgHandles = new SIMessageHandle[arrayCount];
JsMessageHandleFactory jsMsgHandleFactory = JsMessageHandleFactory.getInstance();
// Get arrayCount SIMessageHandles
for (int msgHandleIndex = 0; msgHandleIndex < msgHandles.length; ++msgHandleIndex)
{
long msgHandleValue = getLong();
byte[] msgHandleUuid = get(8);
msgHandles[msgHandleIndex] =
jsMsgHandleFactory.createJsMessageHandle(new SIBUuid8(msgHandleUuid),
msgHandleValue);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getSIMessageHandles", msgHandles);
return msgHandles;
} | java |
public synchronized int peekInt()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "peekInt");
checkReleased();
int result = 0;
if (receivedBuffer != null)
{
int currentPosition = receivedBuffer.position();
result = receivedBuffer.getInt();
receivedBuffer.position(currentPosition);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "peekInt", result);
return result;
} | java |
public synchronized long peekLong()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "peekLong");
checkReleased();
long result = 0;
if (receivedBuffer != null)
{
int currentPosition = receivedBuffer.position();
result = receivedBuffer.getLong();
receivedBuffer.position(currentPosition);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "peekLong", result);
return result;
} | java |
public synchronized void skip(int lengthToSkip)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "skip", lengthToSkip);
checkReleased();
if (receivedBuffer != null)
{
receivedBuffer.position(receivedBuffer.position() + lengthToSkip);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "skip");
} | java |
public synchronized void rewind()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "rewind");
checkReleased();
if (receivedBuffer != null)
{
receivedBuffer.rewind();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rewind");
} | java |
public List<DataSlice> encodeFast(AbstractMessage message, CommsConnection commsConnection, Conversation conversation)
throws MessageEncodeFailedException, SIConnectionDroppedException,
IncorrectMessageTypeException, UnsupportedEncodingException, MessageCopyFailedException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "encodeFast",
new Object[]{CommsLightTrace.msgToString(message), commsConnection, CommsLightTrace.minimalToString(conversation)});
if(!message.isControlMessage())
{
// Determine capabilities negotiated at handshake time.
short clientCapabilities = ((CATHandshakeProperties) conversation.getHandshakeProperties()).getCapabilites();
boolean requiresJMF = (clientCapabilities & CommsConstants.CAPABILITIY_REQUIRES_JMF_ENCODING) != 0;
boolean requiresJMS = (clientCapabilities & CommsConstants.CAPABILITIY_REQUIRES_JMS_MESSAGES) != 0;
if (requiresJMF || requiresJMS)
{
// If the client requires that we only send it JMS messages, convert the message.
// As we can only transcribe JMS messages to a JMF encoding - if the client requires
// a JMF encoded message then also apply this conversion.
message = ((JsMessage) message).makeInboundJmsMessage();
}
if (requiresJMF)
{
// If the client requires that we only send it JMF encoded messages, perform the
// appropriate transcription. Note: this assumes the message is a JMS message.
message = ((JsMessage) message).transcribeToJmf();
}
}
List<DataSlice> messageParts = null;
try
{
messageParts = message.encodeFast(commsConnection);
}
catch (MessageEncodeFailedException e)
{
// No FFDC Code Needed
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Caught a MessageEncodeFailedException from MFP:", e);
// We interrogate the MessageEncodeFailedException to see if it hides a problem which we want to reflect back to our caller
// using a different exception
if (e.getCause() != null) {
if (e.getCause() instanceof SIConnectionDroppedException) { // Was the connection dropped under MFP?
throw new SIConnectionDroppedException(TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE, "CONVERSATION_CLOSED_SICO0065", null, null));
} else if (e.getCause() instanceof IllegalStateException) { // An IllegalStateException may indicate a dropped connection
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "The linked exception IS an IllegalStateException");
if (conversation.isClosed()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "The conversation was closed - rethrowing as SIConnectionDroppedException");
throw new SIConnectionDroppedException(TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE, "CONVERSATION_CLOSED_SICO0065", null, null));
}
}
}
throw e;
}
if (TraceComponent.isAnyTracingEnabled())
CommsLightTrace.traceMessageId(tc, "EncodeMsgTrace", message);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "encodeFast", messageParts);
return messageParts;
} | java |
public static int calculateEncodedStringLength(String s)
{
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "calculateEncodedStringLength", s);
final int length;
if(s == null)
{
length = 3;
}
else
{
try
{
final byte[] stringAsBytes = s.getBytes(stringEncoding);
length = stringAsBytes.length + 2;
}
catch (UnsupportedEncodingException e)
{
FFDCFilter.processException(e, CLASS_NAME + ".calculateEncodedStringLength", CommsConstants.COMMSBYTEBUFFER_CALC_ENC_STRLEN_01);
if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Unable to encode String: ", e);
SibTr.error(tc, "UNSUPPORTED_STRING_ENCODING_SICO8023", new Object[] {stringEncoding, e});
throw new SIErrorException(
TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE, "UNSUPPORTED_STRING_ENCODING_SICO8023", new Object[] {stringEncoding, e}, null)
);
}
}
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "calculateEncodedStringLength", Integer.valueOf(length));
return length;
} | java |
public synchronized boolean getBoolean()
{
final byte value = get();
if(value == CommsConstants.TRUE_BYTE) return true;
else if(value == CommsConstants.FALSE_BYTE) return false;
else throw new IllegalStateException("Unexpected byte: " + value);
} | java |
protected File assertDirectory(String dirName, String locName) {
File d = new File(dirName);
if (d.isFile())
throw new LocationException("Path must reference a directory", MessageFormat.format(BootstrapConstants.messages.getString("error.specifiedLocation"), locName,
d.getAbsolutePath()));
return d;
} | java |
protected void substituteSymbols(Map<String, String> initProps) {
for (Entry<String, String> entry : initProps.entrySet()) {
Object value = entry.getValue();
if (value instanceof String) {
String strValue = (String) value;
Matcher m = SYMBOL_DEF.matcher(strValue);
int i = 0;
while (m.find() && i++ < 4) {
String symbol = m.group(1);
Object expansion = initProps.get(symbol);
if (expansion != null && expansion instanceof String) {
strValue = strValue.replace(m.group(0), (String) expansion);
entry.setValue(strValue);
}
}
}
}
} | java |
public boolean checkCleanStart() {
String fwClean = get(BootstrapConstants.INITPROP_OSGI_CLEAN);
if (fwClean != null && fwClean.equals(BootstrapConstants.OSGI_CLEAN_VALUE)) {
return true;
}
String osgiClean = get(BootstrapConstants.OSGI_CLEAN);
return Boolean.valueOf(osgiClean);
} | java |
protected ReturnCode generateServerEnv(boolean generatePassword) {
double jvmLevel;
String s = null;
try {
s = AccessController.doPrivileged(new java.security.PrivilegedExceptionAction<String>() {
@Override
public String run() throws Exception {
String javaSpecVersion = System.getProperty("java.specification.version");
return javaSpecVersion;
}
});
jvmLevel = Double.parseDouble(s);
} catch (Exception ex) {
// If we get here, it is most likely because the java.specification.version property
// is not a valid double. Return bad java version
throw new LaunchException("Invalid java.specification.version, " + s, MessageFormat.format(BootstrapConstants.messages.getString("error.create.unknownJavaLevel"),
s), ex, ReturnCode.ERROR_BAD_JAVA_VERSION);
}
BufferedWriter bw = null;
File serverEnv = getConfigFile("server.env");
try {
char[] keystorePass = PasswordGenerator.generateRandom();
String serverEnvContents = FileUtils.readFile(serverEnv);
String toWrite = "";
if (generatePassword && (serverEnvContents == null || !serverEnvContents.contains("keystore_password="))) {
if (serverEnvContents != null)
toWrite += System.getProperty("line.separator");
toWrite += "keystore_password=" + new String(keystorePass);
}
if (jvmLevel >= 1.8 && (serverEnvContents == null || !serverEnvContents.contains("WLP_SKIP_MAXPERMSIZE="))) {
if (serverEnvContents != null || !toWrite.isEmpty())
toWrite += System.getProperty("line.separator");
toWrite += "WLP_SKIP_MAXPERMSIZE=true";
}
if (serverEnvContents == null)
FileUtils.createFile(serverEnv, new ByteArrayInputStream(toWrite.getBytes("UTF-8")));
else
FileUtils.appendFile(serverEnv, new ByteArrayInputStream(toWrite.getBytes("UTF-8")));
} catch (IOException ex) {
throw new LaunchException("Failed to create/update the server.env file for this server", MessageFormat.format(BootstrapConstants.messages.getString("error.create.java8serverenv"),
serverEnv.getAbsolutePath()), ex, ReturnCode.LAUNCH_EXCEPTION);
} finally {
if (bw != null) {
try {
bw.close();
} catch (IOException ex) {
}
}
}
return ReturnCode.OK;
} | java |
protected void setProbeListeners(ProbeImpl probe, Collection<ProbeListener> listeners) {
Set<ProbeListener> enabled = enabledProbes.get(probe);
if (enabled == null) {
enabled = new HashSet<ProbeListener>();
enabledProbes.put(probe, enabled);
}
enabled.addAll(listeners);
} | java |
protected Set<ProbeListener> getProbeListeners(ProbeImpl probe) {
Set<ProbeListener> listeners = enabledProbes.get(probe);
if (listeners == null) {
listeners = Collections.emptySet();
}
return listeners;
} | java |
protected void unbox(final Type type) {
switch (type.getSort()) {
case Type.BOOLEAN:
visitTypeInsn(CHECKCAST, "java/lang/Boolean");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
break;
case Type.BYTE:
visitTypeInsn(CHECKCAST, "java/lang/Byte");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);
break;
case Type.CHAR:
visitTypeInsn(CHECKCAST, "java/lang/Character");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false);
break;
case Type.DOUBLE:
visitTypeInsn(CHECKCAST, "java/lang/Double");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D", false);
break;
case Type.FLOAT:
visitTypeInsn(CHECKCAST, "java/lang/Float");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F", false);
break;
case Type.INT:
visitTypeInsn(CHECKCAST, "java/lang/Integer");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false);
break;
case Type.LONG:
visitTypeInsn(CHECKCAST, "java/lang/Long");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false);
break;
case Type.SHORT:
visitTypeInsn(CHECKCAST, "java/lang/Short");
visitMethodInsn(INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S", false);
break;
case Type.ARRAY:
case Type.OBJECT:
visitTypeInsn(CHECKCAST, type.getInternalName());
break;
default:
break;
}
} | java |
void replaceArgsWithArray(String desc) {
Type[] methodArgs = Type.getArgumentTypes(desc);
createObjectArray(methodArgs.length); // [target] args... array
for (int i = methodArgs.length - 1; i >= 0; i--) {
if (methodArgs[i].getSize() == 2) {
visitInsn(DUP_X2); // [target] args... array arg_arg array
visitLdcInsn(Integer.valueOf(i)); // [target] args... array arg_arg array idx
visitInsn(DUP2_X2); // [target] args... array array idx arg_arg array idx
visitInsn(POP2); // [target] args... array array idx arg_arg
} else {
visitInsn(DUP_X1); // [target] args... array arg array
visitInsn(SWAP); // [target] args... array array arg
visitLdcInsn(Integer.valueOf(i)); // [target] args... array array arg idx
visitInsn(SWAP); // [target] args... array array idx arg
}
box(methodArgs[i]); // [target] args... array array idx boxed
visitInsn(AASTORE); // [target] args... array
} // [target] array
} | java |
void restoreArgsFromArray(String desc) {
Type[] methodArgs = Type.getArgumentTypes(desc);
for (int i = 0; i < methodArgs.length; i++) { // [target] array
visitInsn(DUP); // [target] args... array array
visitLdcInsn(Integer.valueOf(i)); // [target] args... array array idx
visitInsn(AALOAD); // [target] args... array boxed
unbox(methodArgs[i]); // [target] args... array arg
if (methodArgs[i].getSize() == 2) {
visitInsn(DUP2_X1); // [target] args... array arg_arg
visitInsn(POP2); // [target] args... array
} else {
visitInsn(SWAP); // [target] args... array
}
}
visitInsn(POP); // [target] args...
} | java |
protected void setProbeInProgress(boolean inProgress) {
if (inProgress && !this.probeInProgress) {
this.probeInProgress = true;
if (this.probeMethodAdapter != null) {
this.mv = this.visitor;
}
} else if (!inProgress && this.probeInProgress) {
this.probeInProgress = false;
this.mv = probeMethodAdapter != null ? probeMethodAdapter : this.visitor;
}
} | java |
public void setTargetSignificance(String targetSignificance) {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
SibTr.debug(this, TRACE, "setTargetSignificance", targetSignificance);
}
_targetSignificance = targetSignificance;
} | java |
public void setTargetTransportChain(String targetTransportChain) {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
SibTr.debug(this, TRACE, "setTargetTransportChain", targetTransportChain);
}
_targetTransportChain = targetTransportChain;
} | java |
public void setUseServerSubject(Boolean useServerSubject) {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
SibTr.debug(this, TRACE, "setUseServerSubject", useServerSubject);
}
_useServerSubject = useServerSubject;
} | java |
public void setRetryInterval(String retryInterval)
{
_retryInterval = (retryInterval == null ? null : Integer.valueOf(retryInterval));
} | java |
static PortComponent getPortComponentByEJBLink(String ejbLink, Adaptable containerToAdapt) throws UnableToAdaptException {
return getHighLevelElementByServiceImplBean(ejbLink, containerToAdapt, PortComponent.class, LinkType.EJB);
} | java |
static PortComponent getPortComponentByServletLink(String servletLink, Adaptable containerToAdapt) throws UnableToAdaptException {
return getHighLevelElementByServiceImplBean(servletLink, containerToAdapt, PortComponent.class, LinkType.SERVLET);
} | java |
static WebserviceDescription getWebserviceDescriptionByEJBLink(String ejbLink, Adaptable containerToAdapt) throws UnableToAdaptException {
return getHighLevelElementByServiceImplBean(ejbLink, containerToAdapt, WebserviceDescription.class, LinkType.EJB);
} | java |
static WebserviceDescription getWebserviceDescriptionByServletLink(String servletLink, Adaptable containerToAdapt) throws UnableToAdaptException {
return getHighLevelElementByServiceImplBean(servletLink, containerToAdapt, WebserviceDescription.class, LinkType.SERVLET);
} | java |
@SuppressWarnings("unchecked")
private static <T> T getHighLevelElementByServiceImplBean(String portLink, Adaptable containerToAdapt, Class<T> clazz, LinkType linkType) throws UnableToAdaptException {
if (null == portLink) {
return null;
}
if (PortComponent.class.isAssignableFrom(clazz)
|| WebserviceDescription.class.isAssignableFrom(clazz)) {
Webservices wsXml = containerToAdapt.adapt(Webservices.class);
if (null == wsXml) {
return null;
}
for (WebserviceDescription wsDes : wsXml.getWebServiceDescriptions()) {
if (wsDes.getPortComponents().size() == 0) {
continue;
}
for (PortComponent portCmpt : wsDes.getPortComponents()) {
ServiceImplBean servImplBean = portCmpt.getServiceImplBean();
String serviceLink = LinkType.SERVLET == linkType ? servImplBean.getServletLink() : servImplBean.getEJBLink();
if (serviceLink == null) {
continue;
} else if (serviceLink.equals(portLink)) {
if (PortComponent.class.isAssignableFrom(clazz)) {
return (T) portCmpt;
} else {
return (T) wsDes;
}
}
}
}
return null;
}
return null;
} | java |
public long getCompletionTime()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getCompletionTime");
long completionTime =-1;
//only calculate if the timeout is not infinite
long timeOut = getTimeout();
if(timeOut != SIMPConstants.INFINITE_TIMEOUT)
{
completionTime = getIssueTime() + timeOut;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getCompletionTime", new Long(completionTime));
return completionTime;
} | java |
protected synchronized void deactivate(ComponentContext context) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Unregistering JNDIEntry " + serviceRegistration);
}
if (this.serviceRegistration != null) {
this.serviceRegistration.unregister();
}
} | java |
public static UserProfile getUserProfile() {
UserProfile userProfile = null;
Subject subject = getSubject();
Iterator<UserProfile> userProfilesIterator = subject.getPrivateCredentials(UserProfile.class).iterator();
if (userProfilesIterator.hasNext()) {
userProfile = userProfilesIterator.next();
}
return userProfile;
} | java |
public void dispatchAsynchException(ProxyQueue proxyQueue, Exception exception)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "dispatchAsynchException",
new Object[] { proxyQueue, exception });
// Create a runnable with the data
AsynchExceptionThread thread = new AsynchExceptionThread(proxyQueue, exception);
dispatchThread(thread);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "dispatchAsynchException");
} | java |
public void dispatchAsynchEvent(short eventId, Conversation conversation)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dispatchAsynchEvent",
new Object[] { ""+eventId, conversation });
// Create a runnable with the data
AsynchEventThread thread = new AsynchEventThread(eventId, conversation);
dispatchThread(thread);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dispatchAsynchEvent");
} | java |
public void dispatchCommsException(SICoreConnection conn,
ProxyQueueConversationGroup proxyQueueConversationGroup,
SIConnectionLostException exception)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dispatchCommsException");
// Create a runnable with the data
CommsExceptionThread thread = new CommsExceptionThread(conn, proxyQueueConversationGroup, exception);
dispatchThread(thread);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dispatchCommsException");
} | java |
public void dispatchDestinationListenerEvent(SICoreConnection conn, SIDestinationAddress destinationAddress,
DestinationAvailability destinationAvailability, DestinationListener destinationListener)
{
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dispatchDestinationListenerEvent",
new Object[]{conn, destinationAddress, destinationAvailability, destinationListener});
//Create a new DestinationListenerThread and dispatch it.
final DestinationListenerThread thread = new DestinationListenerThread(conn, destinationAddress, destinationAvailability, destinationListener);
dispatchThread(thread);
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dispatchDestinationListenerEvent");
} | java |
public void dispatchConsumerSetChangeCallbackEvent(ConsumerSetChangeCallback consumerSetChangeCallback,boolean isEmpty)
{
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dispatchConsumerSetChangeCallbackEvent",
new Object[]{consumerSetChangeCallback, isEmpty});
//Create a new ConsumerSetChangeCallbackThread and dispatch it.
final ConsumerSetChangeCallbackThread thread = new ConsumerSetChangeCallbackThread(consumerSetChangeCallback,isEmpty);
dispatchThread(thread);
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dispatchConsumerSetChangeCallbackEvent");
} | java |
public void dispatchStoppableConsumerSessionStopped(ConsumerSessionProxy consumerSessionProxy)
{
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dispatchStoppableConsumerSessionStopped", consumerSessionProxy);
//Create a new StoppableAsynchConsumerCallbackThread and dispatch it.
final StoppableAsynchConsumerCallbackThread thread = new StoppableAsynchConsumerCallbackThread(consumerSessionProxy);
dispatchThread(thread);
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dispatchStoppableConsumerSessionStopped");
} | java |
private void dispatchThread(Runnable runnable)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dispatchThread");
try
{
// Get a thread from the pool to excute it
// By only passing the thread we default to wait if the threadpool queue is full
// We should wait as some callbacks are more important then others but we have no
// way of distinguishing this.
threadPool.execute(runnable);
}
catch (InterruptedException e)
{
// No FFDC code needed
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Thread was interrupted", e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dispatchThread");
} | java |
private static void invokeCallback(SICoreConnection conn, ConsumerSession session, // d172528
Exception exception, int eventId)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "invokeCallback",
new Object[] { conn, session, exception, eventId });
if (conn != null) // f174318
{ // f174318
try
{
final AsyncCallbackSynchronizer asyncCallbackSynchronizer = ((ConnectionProxy)conn).getAsyncCallbackSynchronizer();
SICoreConnectionListener[] myListeners = conn.getConnectionListeners();
for (int x = 0; x < myListeners.length; x++)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Invoking callback on: " + myListeners[x]);
// Obtain permission from the callback synchronizer to call the application
asyncCallbackSynchronizer.enterAsyncExceptionCallback();
// start f174318
try
{
switch (eventId)
{
// This special event ID will not be received across the wire, but will
// be used internally when we get notified of a JFAP error.
case (0x0000):
myListeners[x].commsFailure(conn, (SIConnectionLostException) exception);
break;
case (CommsConstants.EVENTID_ME_QUIESCING): // f179464
myListeners[x].meQuiescing(conn);
break;
case (CommsConstants.EVENTID_ME_TERMINATED): // f179464
myListeners[x].meTerminated(conn); // f179464
break; // f179464
case (CommsConstants.EVENTID_ASYNC_EXCEPTION): // d172528 // f179464
myListeners[x].asynchronousException(session, exception); // d172528
break; // d172528
default:
// Should never happen
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Invalid event ID: " + eventId);
break;
}
}
catch (Exception e)
{
FFDCFilter.processException(e, CLASS_NAME + ".invokeCallback",
CommsConstants.CLIENTASYNCHEVENTTHREADPOOL_INVOKE_01,
new Object[] { myListeners[x], conn, session, exception, ""+eventId});
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Caught an exception from the callback", e);
} finally {
// Tell the callback synchronizer that we have completed the exception callback
asyncCallbackSynchronizer.exitAsyncExceptionCallback();
}
// end f174318
} // f174318
}
catch (SIException e)
{
// No FFDC Code needed
// We couldn't get hold of the connection listeners for some reason. Not a lot we can
// do here except debug the failure
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Unable to get connection listeners", e);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "invokeCallback");
} | java |
@Sensitive
public static String getHeader(HttpServletRequest req, String key) {
HttpServletRequest sr = getWrappedServletRequestObject(req);
return sr.getHeader(key);
} | java |
@Override
public void destroy() // PK20881
{
if (tc.isEntryEnabled())
Tr.entry(tc, "destroy");
// Dummy transactionWrappers may not be in any table and so
// will not have a resourceCallback registered to remove them.
if (_resourceCallback != null)
_resourceCallback.destroy();
_wrappers.remove(_transaction.getGlobalId());
// Do not remove connection with the TransactionImpl. This will delay garbage
// collection until the TransactionWrapper is garbage collected.
// There is a window when an incoming request can access the remoteable object
// (ie WSCoordinator or CoordinatorResource) and get access to the TransactionWrapper
// while destroy() is called by another thread as the synchronization is on the
// TransactionWrapper. When the incoming request gets control, it will find that
// _transaction is null. Rather than check for this case, we leave the connection
// to the TransactionImpl and its associated TransactionState. The code above will
// then check the transaction state and respond appropriately. These checks are
// already required as the superior may retry requests, etc.
// _transaction = null;
if (tc.isEntryEnabled())
Tr.exit(tc, "destroy");
} | java |
protected void close()
throws ObjectManagerException
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this, cclass
, "close"
);
if (flushHelper != null)
flushHelper.shutdown(); // Complete outstanding work.
if (notifyHelper != null)
notifyHelper.shutdown(); // No longer need a notify thread.
logFile = null;
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this, cclass
, "close"
);
} | java |
private void setFileSpaceLeft()
throws ObjectManagerException
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this, cclass,
"setFileSpaceLeft",
new Object[] { new Long(fileLogHeader.fileSize), new Long(fileLogHeader.startByteAddress),
new Long(filePosition) }
);
// Assume we have wrapped around the end of the file, the space left is between the current
// file position and the start of the log file.
long newFileSpaceLeft = fileLogHeader.startByteAddress - filePosition;
if (newFileSpaceLeft <= 0) // If we have not wrapped.
newFileSpaceLeft = newFileSpaceLeft + fileLogHeader.fileSize - FileLogHeader.headerLength * 2;
fileSpaceLeft = newFileSpaceLeft;
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this,
cclass,
"setFileSpaceLeft",
new Object[] { new Long(fileSpaceLeft) });
} | java |
final void flush()
throws ObjectManagerException
{
final String methodName = "flush";
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this,
cclass,
methodName);
int startPage = 0;
// The logBuffer we will wait for.
LogBuffer flushLogBuffer = null;
synchronized (logBufferLock) {
startPage = lastPageFilling;
// // Don't flush a new empty page, where we have stepped past the sector byte
// // but not put anything in it.
// if (nextFreeByteInLogBuffer % pageSize == 1) {
// int newStartPage = startPage -1;
// if (lastPageNotified == newStartPage ) {
// System.out.println("FFFFFFFFFFFFFFF Flush bypassed");
// if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
// trace.exit(this,
// cclass,
// "flush");
// return;
// }
// } // if (nextFreeByteInLogBuffer % pageSize == 1).
// Capture the logBuffer containing the page we will flush.
flushLogBuffer = logBuffer;
flushLogBuffer.pageWaiterExists[startPage] = true;
if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
trace.debug(this,
cclass,
methodName,
new Object[] { "logBuffer_flushing",
new Integer(startPage),
new Integer(firstPageFilling),
new Integer(lastPageFilling),
new Integer(flushLogBuffer.pageWritersActive.get(startPage)) });
} // synchronized (logBufferLock).
flushLogBuffer.waitForFlush(startPage);
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this,
cclass,
methodName);
} | java |
protected void reserve(long reservedDelta)
throws ObjectManagerException
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this, cclass,
"reserve",
new Object[] { new Long(reservedDelta) }
);
long unavailable = reserveLogFileSpace(reservedDelta);
if (unavailable != 0) {
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this, cclass,
"reserve",
new Object[] { "via LogFileFullException", new Long(unavailable), new Long(reservedDelta) }
);
throw new LogFileFullException(this
, reservedDelta
, reservedDelta
, reservedDelta - unavailable);
} // if (unavailable != 0).
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this,
cclass,
"reserve");
} | java |
private long reserveLogFileSpace(long reservedDelta)
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this,
cclass,
"reserveLogFileSpace",
new Object[] { new Long(reservedDelta) });
long stillToReserve = reservedDelta;
// Pick an arbitrary starting point in the array of sub totals.
int index = new java.util.Random(Thread.currentThread().hashCode()).nextInt(fileSpaceAvailable.length);
int startIndex = index;
while (stillToReserve != 0) {
synchronized (fileSpaceAvailableLock[index]) {
if (stillToReserve <= fileSpaceAvailable[index]) {
fileSpaceAvailable[index] = fileSpaceAvailable[index] - stillToReserve;
stillToReserve = 0;
} else {
stillToReserve = stillToReserve - fileSpaceAvailable[index];
fileSpaceAvailable[index] = 0;
// Move on to the next subTotal.
index++;
if (index == fileSpaceAvailable.length)
index = 0;
if (index == startIndex)
break;
} // if (stillToReserve <= fileSpaceAvailable[index]).
} // synchronized (fileSpaceAvailableLock[index]).
} // while...
// Did we get all we needed?
if (stillToReserve != 0) {
// Give back what we got.
long giveBack = reservedDelta - stillToReserve;
for (int i = 0; i < fileSpaceAvailable.length; i++) {
synchronized (fileSpaceAvailableLock[i]) {
fileSpaceAvailable[i] = fileSpaceAvailable[i] + giveBack / fileSpaceAvailable.length;
if (i == startIndex)
fileSpaceAvailable[i] = fileSpaceAvailable[i] + giveBack % fileSpaceAvailable.length;
} // synchronized (fileSpaceAvailableLock[i]).
} // for ..
} // if (stillToReserve != 0).
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this, cclass
, "reserveLogFileSpace"
, new Object[] { new Long(stillToReserve), new Integer(startIndex) });
return stillToReserve;
} | java |
private long paddingReserveLogSpace(long spaceToReserve) throws ObjectManagerException
{
if (trace.isEntryEnabled())
trace.entry(this,
cclass,
"paddingReserveLogSpace",
new Object[] { new Long(spaceToReserve) });
synchronized (paddingSpaceLock)
{
// adjust the padding space
paddingSpaceAvailable -= spaceToReserve;
// is this a reserve or unreserve
if (spaceToReserve > 0)
{
// space being reserved
// if paddingSpaceAvailable has gone negative we should do a real reserve for the
// difference. Don't let paddingSpaceAvailable go negative!
// Also cut an FFDC because this should not happen!
if (paddingSpaceAvailable < 0)
{
NegativePaddingSpaceException exception = new NegativePaddingSpaceException(this, paddingSpaceAvailable);
ObjectManager.ffdc.processException(this,
cclass,
"paddingReserveLogSpace",
exception,
"1:1088:1.52");
spaceToReserve = -paddingSpaceAvailable;
paddingSpaceAvailable = 0;
}
else
{
// success case - we don't need to reserve any more
spaceToReserve = 0;
}
}
else
{
// its an unreserve.
if (paddingSpaceAvailable > PADDING_SPACE_TARGET)
{
// space being unreserved and we have exceeded our target so need to give some back
spaceToReserve = PADDING_SPACE_TARGET - paddingSpaceAvailable;
paddingSpaceAvailable = PADDING_SPACE_TARGET;
}
else
{
// space being unreserved and we will keep it all
spaceToReserve = 0;
}
}
} // drop lock before giving back any space
if (spaceToReserve != 0)
{
// this can throw ObjectManagerException, only if spaceToReserve is positive.
// This is good, because not only should spaceToReserve never be positive,
// we must stop now because we are about to write into space that we don't have.
reserve(spaceToReserve);
}
if (trace.isEntryEnabled())
trace.exit(this, cclass
, "paddingReserveLogSpace", new Object[] { new Long(spaceToReserve) });
return spaceToReserve;
} | java |
protected final long writeNext(LogRecord logRecord
, long reservedDelta
, boolean checkSpace
, boolean flush
)
throws ObjectManagerException
{
// if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
// trace.entry(this,
// cclass,
// "writeNext",
// new Object[] {logRecord,
// new Long(reservedDelta),
// new Boolean(checkSpace),
// new Boolean (flush));
long logSequenceNumber = addLogRecord(logRecord,
reservedDelta,
false,
checkSpace,
flush);
// if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
// trace.exit(this,
// cclass,
// "writeNext",
// new Object[] {new Long(logSequenceNumber)});
return logSequenceNumber;
} | java |
protected final long markAndWriteNext(LogRecord logRecord,
long reservedDelta,
boolean checkSpace,
boolean flush)
throws ObjectManagerException
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this,
cclass,
"markAndWriteNext",
new Object[] { logRecord,
new Long(reservedDelta),
new Boolean(checkSpace),
new Boolean(flush) });
long logSequenceNumber;
synchronized (fileMarkLock) {
logSequenceNumber = addLogRecord(logRecord,
reservedDelta,
true,
checkSpace,
flush);
} // synchronized (fileMarkLock).
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this, cclass
, "markAndWriteNext"
, new Object[] { new Long(logSequenceNumber), new Long(fileMark) }
);
return logSequenceNumber;
} | java |
private int addPart(LogRecord logRecord,
byte[] fillingBuffer,
boolean completed,
int offset,
int partLength)
throws ObjectManagerException
{
final String methodName = "addPart";
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this,
cclass,
methodName,
new Object[] { logRecord,
fillingBuffer,
new Boolean(completed),
new Integer(offset),
new Integer(partLength) });
// Make the part header.
byte[] partHeader = new byte[partHeaderLength];
if (completed)
partHeader[0] = PART_Last;
else if (logRecord.atStart())
partHeader[0] = PART_First;
else
partHeader[0] = PART_Middle;
partHeader[1] = logRecord.multiPartID;
partHeader[2] = (byte) (partLength >>> 8);
partHeader[3] = (byte) (partLength >>> 0);
// Place the part header into the logBuffer.
// Calculate how much of the partHeader will fit in this page.
int remainder = pageSize - offset % pageSize;
int length = Math.min(remainder, partHeaderLength);
System.arraycopy(partHeader,
0,
fillingBuffer,
offset,
length);
offset = offset + length;
// If we are now positioned at the first byte in a page, skip over it.
if (remainder <= partHeaderLength)
offset++;
// Have we wrapped the logBuffer?
if (offset >= fillingBuffer.length) {
fillingBuffer = logBuffer.buffer;
offset = 1;
} // if (offset >= logBuffer.length).
// Did the whole part header fit in the previous page, was there any overflow?
if (length < partHeaderLength) {
// Copy the piece covering the page boundary one byte further down the logBuffer.
// We may copy the entire part header.
System.arraycopy(partHeader,
length,
fillingBuffer,
offset,
partHeaderLength - length);
offset = offset + partHeaderLength - length;
} // if (length < partHeaderLength).
// Now copy in the the part of the LogRecord.
int bytesToAdd = Math.min(pageSize - (offset % pageSize)
, partLength
);
// Fill one page at a time.
// If offset leaves us about to write on the first byte in a page then we will write
// zero bytes first time round the loop and step over the sector byte.
for (;;) {
// See if we have stepped past the end of the log buffer.
if (offset >= fillingBuffer.length) {
fillingBuffer = logBuffer.buffer;
offset = 1;
} // if (offset >= logBuffer.length).
offset = logRecord.fillBuffer(fillingBuffer
, offset
, bytesToAdd
);
partLength = partLength - bytesToAdd;
if (partLength == 0)
break;
bytesToAdd = Math.min(pageSize - 1
, partLength
);
offset++; // Step past the next sector bits.
} // for (;;).
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(this,
cclass,
methodName,
new Object[] { new Integer(offset) });
return offset;
} | java |
public void cancel() { //d583637, F73234
synchronized (ivCancelLock) { //d601399
ivIsCanceled = true;
if (ivScheduledFuture != null)
ivScheduledFuture.cancel(false);
ivCache = null;
ivElements = null;
}
} | java |
protected void renderTextAreaValue(FacesContext facesContext, UIComponent uiComponent) throws IOException
{
ResponseWriter writer = facesContext.getResponseWriter();
Object addNewLineAtStart = uiComponent.getAttributes().get(ADD_NEW_LINE_AT_START_ATTR);
if (addNewLineAtStart != null)
{
boolean addNewLineAtStartBoolean = false;
if (addNewLineAtStart instanceof String)
{
addNewLineAtStartBoolean = Boolean.valueOf((String)addNewLineAtStart);
}
else if (addNewLineAtStart instanceof Boolean)
{
addNewLineAtStartBoolean = (Boolean) addNewLineAtStart;
}
if (addNewLineAtStartBoolean)
{
writer.writeText("\n", null);
}
}
String strValue = org.apache.myfaces.shared.renderkit.RendererUtils.getStringValue(facesContext, uiComponent);
if (strValue != null)
{
writer.writeText(strValue, org.apache.myfaces.shared.renderkit.JSFAttr.VALUE_ATTR);
}
} | java |
public final void put(long priority, Object value)
{
// if (tc.isEntryEnabled())
// SibTr.entry(tc, "put", new Object[] { new Long(priority), value});
PriorityQueueNode node = new PriorityQueueNode(priority,value);
// Resize the array (double it) if we are out of space.
if (size == elements.length)
{
PriorityQueueNode[] tmp = new PriorityQueueNode[2*size];
System.arraycopy(elements,0,tmp,0,size);
elements = tmp;
}
int pos = size++;
setElement(node, pos);
moveUp(pos);
// if (tc.isEntryEnabled())
// SibTr.exit(tc, "put");
} | java |
protected void moveUp(int pos)
{
// if (tc.isEntryEnabled())
// SibTr.entry(tc, "moveUp", new Integer(pos));
PriorityQueueNode node = elements[pos];
long priority = node.priority;
while ((pos > 0) && (elements[parent(pos)].priority > priority))
{
setElement(elements[parent(pos)], pos);
pos = parent(pos);
}
setElement(node, pos);
// if (tc.isEntryEnabled())
// SibTr.exit(tc, "moveUp");
} | java |
public final Object getMin()
throws NoSuchElementException
{
PriorityQueueNode max = null;
if (size == 0)
throw new NoSuchElementException();
max = elements[0];
setElement(elements[--size], 0);
heapify(0);
return max.value;
} | java |
protected final void setElement(PriorityQueueNode node, int pos)
{
// if (tc.isEntryEnabled())
// SibTr.entry(tc, "setElement", new Object[] { node, new Integer(pos)});
elements[pos] = node;
node.pos = pos;
// if (tc.isEntryEnabled())
// SibTr.exit(tc, "setElement");
} | java |
protected void heapify(int position)
{
// if (tc.isEntryEnabled())
// SibTr.entry(tc, "heapify", new Integer(position));
// Heapify the remaining heap
int i = -1;
int l;
int r;
int smallest = position;
// Heapify routine from CMR.
// This was done without recursion.
while (smallest != i)
{
i = smallest;
l = left(i);
r = right(i);
if ((l < size) && (elements[l].priority < elements[i].priority))
smallest = l;
else smallest = i;
if ((r < size) && (elements[r].priority < elements[smallest].priority))
smallest = r;
if (smallest != i)
{
PriorityQueueNode tmp = elements[smallest];
setElement(elements[i], smallest);
setElement(tmp, i);
}
}
// if (tc.isEntryEnabled())
// SibTr.exit(tc, "heapify");
} | java |
public static void setJPAComponent(JPAComponent instance)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "setJPAComponent", instance);
jpaComponent = instance;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "setJPAComponent");
} | java |
public Tag decorate(Tag tag)
{
Tag t = null;
for (int i = 0; i < this.decorators.length; i++)
{
t = this.decorators[i].decorate(tag);
if (t != null)
{
return t;
}
}
return tag;
} | java |
protected PriorityConverterMap getConverters() {
//the map to be returned
PriorityConverterMap allConverters = new PriorityConverterMap();
//add the default converters
if (addDefaultConvertersFlag()) {
allConverters.addAll(getDefaultConverters());
}
//add the discovered converters
if (addDiscoveredConvertersFlag()) {
allConverters.addAll(DefaultConverters.getDiscoveredConverters(getClassLoader()));
}
//finally add the programatically added converters
allConverters.addAll(userConverters);
allConverters.setUnmodifiable();
return allConverters;
} | java |
JsMessagingEngine[] getMEsToCheck()
{
final String methodName = "getMEsToCheck";
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
{
SibTr.entry(this, TRACE, methodName);
}
JsMessagingEngine[] retVal = SibRaEngineComponent.getMessagingEngines (_endpointConfiguration.getBusName ());
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
{
SibTr.exit(this, TRACE, methodName, retVal);
}
return retVal;
} | java |
JsMessagingEngine[] removeStoppedMEs (JsMessagingEngine[] MEList)
{
final String methodName = "removeStoppedMEs";
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
{
SibTr.entry(this, TRACE, methodName, MEList);
}
JsMessagingEngine[] startedMEs = SibRaEngineComponent.getActiveMessagingEngines(_endpointConfiguration.getBusName());
List<JsMessagingEngine> runningMEs = Arrays.asList(startedMEs);
List<JsMessagingEngine> newList = new ArrayList<JsMessagingEngine> ();
for (int i = 0; i < MEList.length; i++)
{
JsMessagingEngine nextME = MEList [i];
if (runningMEs.contains(nextME))
{
newList.add (nextME);
}
}
JsMessagingEngine[] retVal = new JsMessagingEngine[newList.size ()];
retVal = newList.toArray (retVal);
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
{
SibTr.exit(this, TRACE, methodName, retVal);
}
return retVal;
} | java |
public void messagingEngineDestroyed(JsMessagingEngine messagingEngine)
{
final String methodName = "messagingEngineDestroyed";
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
{
SibTr.entry(this, TRACE, methodName, messagingEngine);
}
/*
* If there are no longer any local messaging engines on the required
* bus, switch to a remote messaging engine
*/
final JsMessagingEngine[] localMessagingEngines = SibRaEngineComponent
.getMessagingEngines(_endpointConfiguration.getBusName());
if (0 == localMessagingEngines.length)
{
/*
* The last local messaging engine for the required bus has been
* destroyed; we may be able to now connect remotely so kick off
* a check.
*/
SibTr.info(TRACE, "ME_DESTROYED_CWSIV0779", new Object[] {
messagingEngine.getName(),
_endpointConfiguration.getBusName() });
try
{
clearTimer ();
timerLoop ();
}
catch (final ResourceException exception)
{
FFDCFilter.processException(exception, CLASS_NAME + "."
+ methodName, FFDC_PROBE_1, this);
SibTr.error(TRACE, "MESSAGING_ENGINE_STOPPING_CWSIV0765",
new Object[] { exception, messagingEngine.getName(),
messagingEngine.getBusName() });
}
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
{
SibTr.exit(this, TRACE, methodName);
}
} | java |
public RemoteListCache getCache() {
RemoteRepositoryCache logCache = getLogResult()==null ? null : getLogResult().getCache();
RemoteRepositoryCache traceCache = getTraceResult()==null ? null : getTraceResult().getCache();
return switched ? new RemoteListCacheImpl(traceCache, logCache) : new RemoteListCacheImpl(logCache, traceCache);
} | java |
public void setCache(RemoteListCache cache) {
if (cache instanceof RemoteListCacheImpl) {
RemoteListCacheImpl cacheImpl = (RemoteListCacheImpl)cache;
if (getLogResult() != null) {
RemoteRepositoryCache logCache = switched ? cacheImpl.getTraceCache() : cacheImpl.getLogCache();
if (logCache != null) {
getLogResult().setCache(logCache);
}
}
if (getTraceResult() != null) {
RemoteRepositoryCache traceCache = switched ? cacheImpl.getLogCache() : cacheImpl.getTraceCache();
if (traceCache != null) {
getTraceResult().setCache(traceCache);
}
}
} else {
throw new IllegalArgumentException("Unknown implementation of the RemoteListCache instance");
}
} | java |
protected Iterator<RepositoryLogRecord> getNewIterator(int offset, int length) {
OnePidRecordListImpl logResult = getLogResult();
OnePidRecordListImpl traceResult = getTraceResult();
if (logResult == null && traceResult == null) {
return EMPTY_ITERATOR;
} else if (traceResult == null) {
return logResult.getNewIterator(offset, length);
} else if (logResult == null) {
return traceResult.getNewIterator(offset, length);
} else {
MergedServerInstanceLogRecordIterator result = new MergedServerInstanceLogRecordIterator(logResult, traceResult);
result.setRange(offset, length);
return result;
}
} | java |
@Override
public void processXML() throws InjectionException {
@SuppressWarnings("unchecked")
List<ServiceRef> serviceRefs = (List<ServiceRef>) ivNameSpaceConfig.getWebServiceRefs();
// no need to do any work if there are no service refs in the XML
if (serviceRefs == null || serviceRefs.isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "No service-refs in XML for module: " + ivNameSpaceConfig.getModuleName());
}
return;
}
ClassLoader moduleClassLoader = ivNameSpaceConfig.getClassLoader();
if (moduleClassLoader == null) {
throw new InjectionException("Internal Error: The classloader of module " + ivNameSpaceConfig.getModuleName() + " is null.");
}
// get all JAX-WS service refs from deployment descriptor
List<ServiceRef> jaxwsServiceRefs = InjectionHelper.normalizeJaxWsServiceRefs(serviceRefs, moduleClassLoader);
if (jaxwsServiceRefs.isEmpty()) {
return;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Found JAX-WS service refs in XML for module: " + ivNameSpaceConfig.getModuleName());
}
// build up the metadata and create WebServiceRefBinding instances that will be used by the injection engine,
// then we will be saving off this metadata in the module or component metadata slot for later use by our ServiceRefObjectFactory
List<InjectionBinding<WebServiceRef>> bindingList = WebServiceRefBindingBuilder.buildJaxWsWebServiceRefBindings(jaxwsServiceRefs, ivNameSpaceConfig);
// now add all the bindings that were created
if (bindingList != null && !bindingList.isEmpty()) {
for (InjectionBinding<WebServiceRef> binding : bindingList) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Adding binding for JAX-WS service-ref: " + binding.getJndiName());
}
addInjectionBinding(binding);
}
}
} | java |
@Override
public void resolve(InjectionBinding<WebServiceRef> binding) throws InjectionException {
// This was a JAX-WS service reference, we need to do some setup for
// our object factory, and we also need to make sure we store the
// metadata away in the appropriate location.
WebServiceRefInfo wsrInfo = ((WebServiceRefBinding) binding).getWebServiceRefInfo();
Reference ref = null;
// If the "lookup-name" attribute was specified for this service-ref, then we'll bind into the namespace
// an instance of the IndirectJndiLookup reference that will be resolved by the IndirectJndiLookupObjectFactory.
// If a JNDI lookup is performed on this "service-ref", then the IndirectJndiLookupObjectFactory will simply
// turn around and handle the extra level of indirection by looking up the referenced service-ref, which
// will in turn cause our ServiceRefObjectFactory to be invoked.
if (wsrInfo.getLookupName() != null && !wsrInfo.getLookupName().isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Build IndirectJndiLookup(" + wsrInfo.getLookupName() + ") for service-ref '" + wsrInfo.getJndiName());
}
IndirectJndiLookupReferenceFactory factory = ivNameSpaceConfig.getIndirectJndiLookupReferenceFactory();
ref = factory.createIndirectJndiLookup(binding.getJndiName(), wsrInfo.getLookupName(), Object.class.getName());
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Obtained Reference from IndirectJndiLookup object: " + ref.toString());
}
} else { // Otherwise, we'll build a reference that will be resolved by our own object factory.
ref = new Reference(WebServiceRefProcessor.class.getName(), ServiceRefObjectFactory.class.getName(), null);
// Add our serializable service-ref metadata to the Reference.
WebServiceRefInfoRefAddr wsrInfoRefAddr = new WebServiceRefInfoRefAddr(wsrInfo);
ref.add(wsrInfoRefAddr);
// If our classloader is not null, then that means we're being called under the context of an application module.
// In this case, we want to store away the module-specific metadata in the module's metadata slot.
// This has been moved to LibertyProviderImpl since in that time slot, clientMetadata will always be available
// If CDI is enabled, the injections happens before JaxwsModuleMetaDataLister.metaDataCreated()
/*
* if (ivNameSpaceConfig.getClassLoader() != null) {
* // get the client metadata. in client side, here should be the first time get the client metadata, so will create one.
* JaxWsClientMetaData clientMetaData = JaxWsMetaDataManager.getJaxWsClientMetaData(ivNameSpaceConfig.getModuleMetaData());
*
* // parsing and merge the client configuration from the ibm-ws-bnd.xml
* if (clientMetaData != null)
* {
* mergeWebServicesBndInfo(wsrInfo, clientMetaData);
* }
*
* }
*/
J2EEName j2eeName = ivNameSpaceConfig.getJ2EEName();
String componenetName = (null != j2eeName) ? j2eeName.getComponent() : null;
wsrInfo.setComponenetName(componenetName);
}
WebServiceRefInfoBuilder.configureWebServiceRefPartialInfo(wsrInfo, ivNameSpaceConfig.getClassLoader());
binding.setObjects(null, ref);
} | java |
private static void checkResponseCode(URLConnection uc) throws IOException {
if (uc instanceof HttpURLConnection) {
HttpURLConnection httpConnection = (HttpURLConnection) uc;
int rc = httpConnection.getResponseCode();
if (rc != HttpURLConnection.HTTP_OK && rc != HttpURLConnection.HTTP_MOVED_TEMP) {
throw new IOException();
}
}
} | java |
private String getCommonRootDir(String filePath, HashMap validFilePaths) {
for (Iterator it = validFilePaths.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String path = (String) ((entry).getKey());
if (filePath.startsWith(path))
return (String) entry.getValue();
}
return null;
} | java |
private ArrayList<String> getExtensionInstallDirs() throws IOException {
String extensiondir = root + "etc/extensions/";
ArrayList<String> extensionDirs = new ArrayList<String>();
for (Entry entry : container) {
if (entry.getName().startsWith(extensiondir) && entry.getName().endsWith(".properties")) {
Properties prop = new Properties();
prop.load(entry.getInputStream());
String installDir = (prop.getProperty("com.ibm.websphere.productInstall"));
if (null != installDir && !installDir.equals("")) {
extensionDirs.add(installDir);
}
}
}
return extensionDirs;
} | java |
public static void printNeededIFixes(File outputDir, List extractedFiles) {
try {
// To get the ifix information we run the productInfo validate command which as well as
// listing the state of the runtime, also displays any ifixes that need to be reapplied.
Runtime runtime = Runtime.getRuntime();
// Set up the command depending on the OS we're running on.
final String productInfo = new File(outputDir, isWindows ? "bin/productInfo.bat" : "bin/productInfo").getAbsolutePath();
final String[] runtimeCmd = { productInfo, "validate" };
Process process = runtime.exec(runtimeCmd, null, new File(outputDir, "bin"));
Thread stderrCopier = new Thread(new OutputStreamCopier(process.getErrorStream(), System.err));
stderrCopier.start();
new OutputStreamCopier(process.getInputStream(), System.out).run();
try {
stderrCopier.join();
process.waitFor();
} catch (InterruptedException e) {
// Auto FFDC
}
} catch (IOException ioe) {
System.out.println(ioe.getMessage());
}
} | java |
protected Set listMissingCoreFeatures(File outputDir) throws SelfExtractorFileException {
Set missingFeatures = new HashSet();
// If we have a Require Feature manifest header, we need to check that the runtime we're extracting into contains the
// required features. If the customer has minified their runtime to a smaller set of features, then we may
// not be able to install this extract into the runtime.
// If we don't have a list of features then this is probably because we're not an extended install, and we don't need to check anymore.
if (requiredFeatures != null && !"".equals(requiredFeatures)) {
// Break the required feature headers value into indiviual strings and load them into a set.
StringTokenizer tokenizer = new StringTokenizer(requiredFeatures, ",");
while (tokenizer.hasMoreElements()) {
String nextFeature = tokenizer.nextToken();
if (nextFeature.indexOf(";") >= 0)
nextFeature = nextFeature.substring(0, nextFeature.indexOf(";"));
missingFeatures.add(nextFeature.trim());
}
// Create fileFilter to get just the manifest files.
FilenameFilter manifestFilter = createManifestFilter();
File featuresDir = new File(outputDir + "/lib/features");
File[] manifestFiles = featuresDir.listFiles(manifestFilter);
// Iterate over each manifest in the runtime we're extracting to, until we've read all manifests or until we've found all of the
// required features.
if (manifestFiles != null) {
for (int i = 0; i < manifestFiles.length && !missingFeatures.isEmpty(); i++) {
FileInputStream fis = null;
File currentManifestFile = null;
try {
currentManifestFile = manifestFiles[i];
fis = new FileInputStream(currentManifestFile);
Manifest currentManifest = new Manifest(fis);
Attributes attrs = currentManifest.getMainAttributes();
String manifestSymbolicName = attrs.getValue("Subsystem-SymbolicName");
if (manifestSymbolicName.indexOf(";") >= 0)
manifestSymbolicName = manifestSymbolicName.substring(0, manifestSymbolicName.indexOf(";"));
// Remove the current manifest from the list of required features. We may need to remove the short name depending on what has
// been stored.
missingFeatures.remove(manifestSymbolicName.trim());
} catch (FileNotFoundException fnfe) {
throw new SelfExtractorFileException(currentManifestFile.getAbsolutePath(), fnfe);
} catch (IOException ioe) {
throw new SelfExtractorFileException(currentManifestFile.getAbsolutePath(), ioe);
} finally {
SelfExtractUtils.tryToClose(fis);
}
}
}
}
return missingFeatures;
} | java |
protected static boolean argIsOption(String arg, String option) {
return arg.equalsIgnoreCase(option) || arg.equalsIgnoreCase('-' + option);
} | java |
protected static void displayCommandLineHelp(SelfExtractor extractor) {
// This method takes a SelfExtractor in case we want to tailor the help to the current archive
// Get the name of the JAR file to display in the command syntax");
String jarName = System.getProperty("sun.java.command", "wlp-liberty-developers-core.jar");
String[] s = jarName.split(" ");
jarName = s[0];
System.out.println("\n" + SelfExtract.format("usage"));
System.out.println("\njava -jar " + jarName + " [" + SelfExtract.format("options") + "] [" + SelfExtract.format("installLocation") + "]\n");
System.out.println(SelfExtract.format("options"));
System.out.println(" --acceptLicense");
System.out.println(" " + SelfExtract.format("helpAcceptLicense"));
System.out.println(" --verbose");
System.out.println(" " + SelfExtract.format("helpVerbose"));
System.out.println(" --viewLicenseAgreement");
System.out.println(" " + SelfExtract.format("helpAgreement"));
System.out.println(" --viewLicenseInfo");
System.out.println(" " + SelfExtract.format("helpInformation"));
if (extractor.isUserSample()) {
System.out.println(" --downloadDependencies");
System.out.println(" " + SelfExtract.format("helpDownloadDependencies"));
}
} | java |
public void handleLicenseAcceptance(LicenseProvider licenseProvider, boolean acceptLicense) {
//
// Display license requirement
//
SelfExtract.wordWrappedOut(SelfExtract.format("licenseStatement", new Object[] { licenseProvider.getProgramName(), licenseProvider.getLicenseName() }));
System.out.println();
if (acceptLicense) {
// Indicate license acceptance via option
SelfExtract.wordWrappedOut(SelfExtract.format("licenseAccepted", "--acceptLicense"));
System.out.println();
} else {
// Check for license agreement: exit if not accepted.
if (!obtainLicenseAgreement(licenseProvider)) {
System.exit(0);
}
}
} | java |
private static boolean obtainLicenseAgreement(LicenseProvider licenseProvider) {
// Prompt for word-wrapped display of license agreement & information
boolean view;
SelfExtract.wordWrappedOut(SelfExtract.format("showAgreement", "--viewLicenseAgreement"));
view = SelfExtract.getResponse(SelfExtract.format("promptAgreement"), "", "xX");
if (view) {
SelfExtract.showLicenseFile(licenseProvider.getLicenseAgreement());
System.out.println();
}
SelfExtract.wordWrappedOut(SelfExtract.format("showInformation", "--viewLicenseInfo"));
view = SelfExtract.getResponse(SelfExtract.format("promptInfo"), "", "xX");
if (view) {
SelfExtract.showLicenseFile(licenseProvider.getLicenseInformation());
System.out.println();
}
System.out.println();
SelfExtract.wordWrappedOut(SelfExtract.format("licenseOptionDescription"));
System.out.println();
boolean accept = SelfExtract.getResponse(SelfExtract.format("licensePrompt", new Object[] { "[1]", "[2]" }),
"1", "2");
System.out.println();
return accept;
} | java |
public String close() {
if (instance == null) {
return null;
}
try {
container.close();
instance = null;
} catch (IOException e) {
return e.getMessage();
}
return null;
} | java |
public void clear() {
// TODO not currently used since EventImpl itself doesn't have a clear
this.parentMap = null;
if (null != this.values) {
for (int i = 0; i < this.values.length; i++) {
this.values[i] = null;
}
this.values = null;
}
} | java |
public V get(String name) {
V rc = null;
K key = getKey(name);
if (null != key) {
rc = get(key);
}
return rc;
} | java |
private K getKey(String name) {
if (null != this.keys) {
// we have locally stored values
final K[] temp = this.keys;
K key;
for (int i = 0; i < temp.length; i++) {
key = temp[i];
if (null != key && name.equals(key.toString())) {
return key;
}
}
}
// if nothing found locally and we have a parent, check that
if (null != this.parentMap) {
return this.parentMap.getKey(name);
}
return null;
} | java |
public V get(K key) {
return get(key.hashCode() / SIZE_ROW, key.hashCode() % SIZE_ROW);
} | java |
public void put(K key, V value) {
final int hash = key.hashCode();
final int row = hash / SIZE_ROW;
final int column = hash & (SIZE_ROW - 1); // DON'T use the % operator as we
// need the result to be
// non-negative (-1%16 is -1 for
// example)
validateKey(hash);
validateTable(row);
this.values[row][column] = value;
this.keys[hash] = key;
} | java |
public V remove(K key) {
final int hash = key.hashCode();
final int row = hash / SIZE_ROW;
final int column = hash & (SIZE_ROW - 1); // DON'T use the % operator as we
// need the result to be
// non-negative (-1%16 is -1 for
// example)
final V rc = get(row, column);
validateKey(hash);
validateTable(row);
this.values[row][column] = null;
this.keys[hash] = null;
return rc;
} | java |
@SuppressWarnings("unchecked")
private void validateKey(int index) {
final int size = (index + 1);
if (null == this.keys) {
// nothing has been created yet
this.keys = (K[]) new Object[size];
} else if (index >= this.keys.length) {
// this row puts us beyond the current storage
Object[] newKeys = new Object[size];
System.arraycopy(this.keys, 0, newKeys, 0, this.keys.length);
this.keys = (K[]) newKeys;
}
} | java |
@SuppressWarnings("unchecked")
private void validateTable(int targetRow) {
// TODO pooling of the arrays?
if (null == this.values) {
// nothing has been created yet
int size = (targetRow + 1);
if (SIZE_TABLE > size) {
size = SIZE_TABLE;
}
this.values = (V[][]) new Object[size][];
} else if (targetRow >= this.values.length) {
// this row puts us beyond the current storage
final int size = (targetRow + 1);
Object[][] newTable = new Object[size][];
System.arraycopy(this.values, 0, newTable, 0, this.values.length);
this.values = (V[][]) newTable;
} else if (null != this.values[targetRow]) {
// we already have this row created and are set
return;
}
// need to create the new row in the table
this.values[targetRow] = (V[]) new Object[SIZE_ROW];
for (int i = 0; i < SIZE_ROW; i++) {
this.values[targetRow][i] = (V) NO_VALUE;
}
} | java |
public String getRemoteEngineUuid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getRemoteEngineUuid");
String engineUUID = _anycastInputHandler.getLocalisationUuid().toString();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getRemoteEngineUuid", engineUUID);
return engineUUID;
} | java |