code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
@FFDCIgnore(Exception.class)
public DataSource getDataSource() throws Exception {
if (tc.isEntryEnabled())
Tr.entry(tc, "getDataSource");
// Retrieve the data source factory from the CustomLogProperties. This Factory should be set in the JTMConfigurationProvider
// by the jdbc component using DeclarativeServices. TxRecoveryAgentImpl gets the factory from the ConfigurationProvider and
// then sets it into CustomLogProperties.
ResourceFactory dataSourceFactory = _customLogProperties.resourceFactory();
if (dataSourceFactory != null) {
if (tc.isDebugEnabled())
Tr.debug(tc, "Using DataSourceFactory " + dataSourceFactory);
} else {
if (tc.isEntryEnabled())
Tr.exit(tc, "getDataSource", "Null ResourceFactory InternalLogException");
throw new InternalLogException("Failed to locate DataSource, null Resourcefactory", null);
}
try {
nonTranDataSource = (DataSource) dataSourceFactory.createResource(null);
} catch (Exception e) {
//e.printStackTrace();
if (tc.isEntryEnabled())
Tr.exit(tc, "getDataSource", "Caught exception " + e + "throw InternalLogException");
throw new InternalLogException("Failed to locate DataSource, caught exception ", null);
}
/*
* TEMPORARY This is waiting on fixes to DeclarativeServices which impact the jdbc component. At present it is
* possible that the DataSource will have been set but that its associated jdbc driver service will still be initialising
*/
// boolean refSet = false;
// while (!refSet)
// {
// if (tc.isDebugEnabled())
// Tr.debug(tc, "getDataSource after sleep");
// try {
//
// nonTranDataSource = (DataSource) dataSourceFactory.createResource(null);
// if (tc.isDebugEnabled())
// Tr.debug(tc, "Non Tran dataSource is " + nonTranDataSource);
// Connection conn = nonTranDataSource.getConnection();
// if (tc.isDebugEnabled())
// Tr.debug(tc, "Established connection " + conn);
//
// DatabaseMetaData mdata = conn.getMetaData();
//
// String dbName = mdata.getDatabaseProductName();
// if (tc.isDebugEnabled())
// Tr.debug(tc, "Database name " + dbName);
//
// String dbVersion = mdata.getDatabaseProductVersion();
// if (tc.isDebugEnabled())
// Tr.debug(tc, "Database version " + dbVersion);
// refSet = true;
// } catch (Exception e) {
// // We will catch an exception if the DataSource is not yet fully formed
// if (tc.isDebugEnabled())
// Tr.debug(tc, "Caught exception: " + e);
// }
//
// if (!refSet)
// Thread.sleep(200);
// }
// eof TEMPORARY
if (tc.isEntryEnabled())
Tr.exit(tc, "getDataSource", nonTranDataSource);
return nonTranDataSource;
}
|
java
|
private void writeObject(ObjectOutputStream out) throws IOException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "writeObject", out);
throw new NotSerializableException("TemporaryTopic");
}
|
java
|
public static void addCompleteJarEntryUrls(List<ContainerInfo> containers, Entry jarEntry, Collection<String> resolved) throws UnableToAdaptException {
String entryIdentity = createEntryIdentity(jarEntry);
if (!entryIdentity.isEmpty() && !resolved.contains(entryIdentity)) {
resolved.add(entryIdentity);
processMFClasspath(jarEntry, containers, resolved);
}
}
|
java
|
private static Entry findClassPathEntry(Entry jarEntry, URI pathUri) throws URISyntaxException, UnableToAdaptException {
URI relativeJarUri = new URI("/").relativize(new URI(jarEntry.getPath()));
URI targetUri = null;
targetUri = relativeJarUri.resolve(pathUri);
if (targetUri.toString().startsWith("..")) {
Entry rootEntry = jarEntry.getRoot().adapt(Entry.class);
if (rootEntry == null || rootEntry.getPath().isEmpty()) { //already at the outermost
return null;
}
return findClassPathEntry(rootEntry, new URI("..").relativize(targetUri)); // <----
} else {
return jarEntry.getRoot().getEntry(targetUri.toString());
}
}
|
java
|
protected Object[] purge() {
Object[] data = new Object[getCurrentNumElements()];
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "LocalPool is purging " + data.length + " items. firstEntry: " + firstEntry + " lastEntry: " + lastEntry + " poolSize: " + poolSize);
}
if (0 < data.length) {
int out = 0;
if (lastEntry >= firstEntry) {
for (int i = firstEntry; i <= lastEntry; i++) {
data[out] = free[i];
free[i] = null;
out++;
}
} else {
for (int i = firstEntry; i < poolSize; i++) {
data[out] = free[i];
free[i] = null;
out++;
}
for (int i = 0; i <= lastEntry; i++) {
data[out] = free[i];
free[i] = null;
out++;
}
}
lastEntry = -1;
firstEntry = -1;
}
return data;
}
|
java
|
@Override
public final boolean skipCreatingBda(CDIArchive archive) {
//only skip this if it is a leaf archive
boolean skip = isImplicitBeanArchivesScanningDisabled(archive);
skip = skip && (archive.getBeansXml() == null);
skip = skip && (!(archive.getType() == ArchiveType.WEB_MODULE));
return skip;
}
|
java
|
public synchronized void finalReap() {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "finalReap : Remote Async Results = " + ivAllRemoteAsyncResults.size());
// Re-write the finalReap to use the LinkedHashSet, iterating thru the list removing
// all the entries no matter if they have timed out or not. Cancel alarm if set. d623593
if (ivFuture != null) {
ivIsCanceled = true;
ivFuture.cancel(false);
ivFuture = null;
}
for (Iterator<RemoteAsyncResultImpl> iterator = ivAllRemoteAsyncResults.iterator(); iterator.hasNext();) {
RemoteAsyncResultImpl asyncResult = iterator.next();
releaseResources(asyncResult); // d690014.3
iterator.remove();
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "finalReap : Remote Async Results = " + ivAllRemoteAsyncResults.size());
}
|
java
|
public synchronized void add(RemoteAsyncResultImpl asyncResult) {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
ivAllRemoteAsyncResults.add(asyncResult);
if (asyncResult.ivPmiBean != null) { // d690014.3
asyncResult.ivPmiBean.asyncFutureObjectIncrement();
}
int size = ivAllRemoteAsyncResults.size();
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "add " + asyncResult + "; size=" + size);
// If this is the only entry in the list, setup the alarm. d623593
if (size == 1) {
ivFuture = ivScheduledExecutor.schedule(this, ivAlarmIntervalMillis, TimeUnit.MILLISECONDS);
} else if (size >= ivNearMaxResultsThreshold) {
// d690014.1 - Remove the oldest entry if we have exceeded the maximum
// number of results. Otherwise, issue a warning since we are near
// the maximum.
boolean warn = false;
if (size > ivMaxUnclaimedResults) {
if (!ivWarnedExceededMax) {
warn = ivWarnedExceededMax = true;
}
Iterator<RemoteAsyncResultImpl> iterator = ivAllRemoteAsyncResults.iterator();
RemoteAsyncResultImpl oldest = iterator.next();
releaseResources(oldest); // d690014.3
iterator.remove();
} else {
if (!ivWarnedNearMax) {
warn = ivWarnedNearMax = true;
}
}
if (warn) {
Tr.warning(tc, "MAXIMUM_UNCLAIMED_ASYNC_RESULTS_CNTR0328W",
size, ivMaxUnclaimedResults);
}
}
}
|
java
|
public synchronized void remove(RemoteAsyncResultImpl asyncResult) {
ivAllRemoteAsyncResults.remove(asyncResult);
releaseResources(asyncResult); // d690014.3
// If no server-side Future objects and an alarm is set then cancel the alarm. d623593
if (ivAllRemoteAsyncResults.isEmpty() && ivFuture != null) {
ivFuture.cancel(false);
ivFuture = null;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "remove " + asyncResult + "; size=" + ivAllRemoteAsyncResults.size());
}
|
java
|
public String format(long timestamp) {
// If the format is unknown, use the default formatter.
if (invalidFormat) {
return formatter.format(timestamp);
}
try {
long delta = timestamp - refTimestamp;
// If we need to reformat
if (delta >= pdiff || delta < ndiff) {
StringBuffer refTime = new StringBuffer();
refTimestamp = timestamp;
formatter.format(timestamp, refTime, position);
refMilli = Long.parseLong(refTime.substring(position.getBeginIndex(), position.getEndIndex()));
refBeginning = refTime.substring(0, position.getBeginIndex());
refEnding = refTime.substring(position.getEndIndex());
pdiff = 1000 - refMilli;
ndiff = -refMilli;
return refTime.toString();
} else {
StringBuffer sb = new StringBuffer();
long newMilli = delta + refMilli;
if (newMilli >= 100)
sb.append(refBeginning).append(newMilli).append(refEnding);
else if (newMilli >= 10)
sb.append(refBeginning).append('0').append(newMilli).append(refEnding);
else
sb.append(refBeginning).append("00").append(newMilli).append(refEnding);
return sb.toString();
}
} catch (Exception e) {
// Throw FFDC in case anything goes wrong
// Still generate the date via the SimpleDateFormat
invalidFormat = true;
return formatter.format(timestamp);
}
}
|
java
|
private void setName(String newName)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setName", newName);
this._name = newName;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "setName");
}
|
java
|
@Override
public boolean isSendAllowed()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "isSendAllowed");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "isSendAllowed", new Boolean(_isSendAllowed));
return _isSendAllowed;
}
|
java
|
public void setSendAllowed(boolean newIsSendAllowedValue)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setSendAllowed", new Boolean(newIsSendAllowedValue));
this._isSendAllowed = newIsSendAllowedValue;
updatePutRegistration(_isSendAllowed);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "setSendAllowed");
}
|
java
|
public void setAlterationTime(long newAlterationTime)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setAlterationTime", new Long(newAlterationTime));
this._alterationTime = newAlterationTime;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "setAlterationTime");
}
|
java
|
public static void rcvDeleteDurableSub(CommsByteBuffer request, Conversation conversation,
int requestNumber, boolean allocatedFromBufferPool,
boolean partOfExchange)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "rcvDeleteDurableSub",
new Object[]
{
request,
conversation,
""+requestNumber,
""+allocatedFromBufferPool
});
ConversationState convState = (ConversationState) conversation.getAttachment();
short connectionObjectID = request.getShort(); // BIT16 ConnectionObjectId
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "ConnectionObjectId:", connectionObjectID);
/**************************************************************/
/* Subscription Name */
/**************************************************************/
String subscriptionName = request.getString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Subscription Name:", subscriptionName);
/**************************************************************/
/* Subscription Home */
/**************************************************************/
String subscriptionHome = request.getString();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Subscription Home:", subscriptionHome);
SICoreConnection connection =
((CATConnection) convState.getObject(connectionObjectID)).getSICoreConnection();
try
{
connection.deleteDurableSubscription(subscriptionName, subscriptionHome);
try
{
conversation.send(poolManager.allocate(),
JFapChannelConstants.SEG_DELETE_DURABLE_SUB_R,
requestNumber,
JFapChannelConstants.PRIORITY_MEDIUM,
true,
ThrottlingPolicy.BLOCK_THREAD,
null);
}
catch (SIException e)
{
FFDCFilter.processException(e,
CLASS_NAME + ".rcvDeleteDurableSub",
CommsConstants.STATICCATSUBSCRIPTION_DELETE_01);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2025", e);
}
}
catch (SINotAuthorizedException e)
{
// No FFDC Code Needed
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
StaticCATHelper.sendExceptionToClient(e,
null,
conversation, requestNumber);
}
catch (SIException e)
{
//No FFDC code needed
//Only FFDC if we haven't received a meTerminated event.
if(!convState.hasMETerminated())
{
com.ibm.ws.ffdc.FFDCFilter.processException(e,
CLASS_NAME + ".rcvDeleteDurableSub",
CommsConstants.STATICCATSUBSCRIPTION_DELETE_02);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
StaticCATHelper.sendExceptionToClient(e,
CommsConstants.STATICCATSUBSCRIPTION_DELETE_02,
conversation, requestNumber);
}
request.release(allocatedFromBufferPool);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "rcvDeleteDurableSub");
}
|
java
|
public static void main(String[] args) {
Generator schemaGen = new Generator();
System.exit(schemaGen.createSchema(args));
}
|
java
|
private void generate(List<MetaTypeInformationSpecification> metatype) {
XMLOutputFactory factory = XMLOutputFactory.newInstance();
try {
PrintWriter writer = new PrintWriter(generatorOptions.getOutputFile(), generatorOptions.getEncoding());
XMLStreamWriter xmlWriter = null;
if (generatorOptions.getCompactOutput()) {
xmlWriter = new CompactOutputXMLStreamWriter(factory.createXMLStreamWriter(writer));
} else {
xmlWriter = new IndentingXMLStreamWriter(factory.createXMLStreamWriter(writer), writer);
}
SchemaWriter schemaWriter = new SchemaWriter(xmlWriter);
schemaWriter.setIgnoredPids(generatorOptions.getIgnoredPids());
schemaWriter.setGenerateDocumentation(true);
schemaWriter.setEncoding(generatorOptions.getEncoding());
schemaWriter.setLocale(generatorOptions.getLocale());
schemaWriter.setSchemaVersion(generatorOptions.getSchemaVersion());
schemaWriter.setOutputVersion(generatorOptions.getOutputVersion());
for (MetaTypeInformationSpecification item : metatype) {
schemaWriter.add(item);
}
schemaWriter.generate(true);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
|
java
|
void setField(int accessor, Object value) {
try {
jmfPart.setValue(accessor, value);
} catch (JMFException e) {
FFDCFilter.processException(e, "setField", "87", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "setField failed: " + e);
}
}
|
java
|
void setIntField(int accessor, int value) {
try {
jmfPart.setInt(accessor, value);
} catch (JMFException e) {
FFDCFilter.processException(e, "setIntField", "109", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "setIntField failed: " + e);
}
}
|
java
|
void setChoiceField(int accessor, int variant) {
try {
jmfPart.setInt(accessor, variant);
} catch (JMFException e) {
FFDCFilter.processException(e, "setChoiceField", "173", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "setChoiceField failed: " + e);
}
}
|
java
|
int getChoiceField(int accessor) {
int result = 0;
try {
if (jmfPart.isPresent(accessor))
result = jmfPart.getInt(accessor);
} catch (JMFException e) {
FFDCFilter.processException(e, "getChoiceField", "185", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "getChoiceField failed: " + e);
}
return result;
}
|
java
|
void setPart(int accessor, JMFSchema schema) {
try {
jmfPart.setValue(accessor, jmfPart.newNativePart(schema));
} catch (JMFException e) {
FFDCFilter.processException(e, "setDynamicField", "196", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "setDynamicField failed: " + e);
}
}
|
java
|
JsMsgPart getPart(int accessor, JMFSchema schema) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getPart", new Object[]{accessor, schema});
JsMsgPart result = null;
try {
if (jmfPart.isPresent(accessor))
result = new JsMsgPart(jmfPart.getNativePart(accessor, schema));
} catch (JMFException e) {
FFDCFilter.processException(e, "getPart", "208", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "getPart failed: " + e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getPart", result);
return result;
}
|
java
|
int estimateFieldValueSize(int accessor) {
int size = 0;
try {
if (jmfPart.isPresent(accessor)) {
size = jmfPart.estimateUnassembledValueSize(accessor);
}
}
catch (JMFException e) {
FFDCFilter.processException(e, "estimateFieldValueSize", "221", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "estimateFieldValueSize failed: " + e);
}
return size;
}
|
java
|
public boolean isNotEMPTYlist(int accessor) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isNotEMPTYlist", accessor);
// The answer is true, unless an EMPTY is found.
boolean isNotAnEMPTY = true;
// The field can't be an EMPTY singleton unless the part is a JMFMessageData
// as it is impossible for Encapsulations to hold an EMPTY.
// Note the JMF call is the reverse - i.e. isEMPTY rather than isNot
if (jmfPart instanceof JMFMessage) {
isNotAnEMPTY = !((JMFMessage)jmfPart).isEMPTYlist(accessor);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isNotEMPTYlist", isNotAnEMPTY);
return isNotAnEMPTY;
}
|
java
|
public static final String construct(Object object, ExternalContext ctx)
{
byte[] bytes = getAsByteArray(object, ctx);
if( enableCompression(ctx) )
{
bytes = compress(bytes);
}
if(isSecure(ctx))
{
bytes = encrypt(bytes, ctx);
}
bytes = encode(bytes);
try
{
return new String(bytes, ZIP_CHARSET);
}
catch (UnsupportedEncodingException e)
{
throw new FacesException(e);
}
}
|
java
|
public static final byte[] getAsByteArray(Object object, ExternalContext ctx)
{
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
// get the Factory that was instantiated @ startup
SerialFactory serialFactory = (SerialFactory) ctx.getApplicationMap().get(SERIAL_FACTORY);
if(serialFactory == null)
{
throw new NullPointerException("serialFactory");
}
try
{
ObjectOutputStream writer = serialFactory.getObjectOutputStream(outputStream);
writer.writeObject(object);
byte[] bytes = outputStream.toByteArray();
writer.close();
outputStream.close();
writer = null;
outputStream = null;
return bytes;
}
catch (IOException e)
{
throw new FacesException(e);
}
}
|
java
|
public static final Object reconstruct(String string, ExternalContext ctx)
{
byte[] bytes;
try
{
if(log.isLoggable(Level.FINE))
{
log.fine("Processing state : " + string);
}
bytes = string.getBytes(ZIP_CHARSET);
bytes = decode(bytes);
if(isSecure(ctx))
{
bytes = decrypt(bytes, ctx);
}
if( enableCompression(ctx) )
{
bytes = decompress(bytes);
}
return getAsObject(bytes, ctx);
}
catch (Throwable e)
{
if (log.isLoggable(Level.FINE))
{
log.log(Level.FINE, "View State cannot be reconstructed", e);
}
return null;
}
}
|
java
|
public static final Object getAsObject(byte[] bytes, ExternalContext ctx)
{
ByteArrayInputStream input = null;
try
{
input = new ByteArrayInputStream(bytes);
// get the Factory that was instantiated @ startup
SerialFactory serialFactory = (SerialFactory) ctx.getApplicationMap().get(SERIAL_FACTORY);
if(serialFactory == null)
{
throw new NullPointerException("serialFactory");
}
ObjectInputStream s = null;
Exception pendingException = null;
try
{
s = serialFactory.getObjectInputStream(input);
Object object = null;
if (System.getSecurityManager() != null)
{
final ObjectInputStream ois = s;
object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>()
{
//Put IOException and ClassNotFoundException as "checked" exceptions,
//so AccessController wrap them in a PrivilegedActionException
public Object run() throws PrivilegedActionException,
IOException, ClassNotFoundException
{
return ois.readObject();
}
});
// Since s has the same instance as ois,
// we don't need to close it here, rather
// close it on the finally block related to s
// and avoid duplicate close exceptions
// finally
// {
// ois.close();
// }
}
else
{
object = s.readObject();
}
return object;
}
catch (Exception e)
{
pendingException = e;
throw new FacesException(e);
}
finally
{
if (s != null)
{
try
{
s.close();
}
catch (IOException e)
{
// If a previous exception is thrown
// ignore this, but if not, wrap it in a
// FacesException and throw it. In this way
// we preserve the original semantic of this
// method, but we handle correctly the case
// when we close a stream. Obviously, the
// information about this exception is lost,
// but note that the interesting information
// is always on pendingException, since we
// only do a readObject() on the outer try block.
if (pendingException == null)
{
throw new FacesException(e);
}
}
finally
{
s = null;
}
}
}
}
finally
{
if (input != null)
{
try
{
input.close();
}
catch (IOException e)
{
//ignore it, because ByteArrayInputStream.close has
//no effect, but it is better to call close and preserve
//semantic from previous code.
}
finally
{
input = null;
}
}
}
}
|
java
|
public static void main (String[] args) throws UnsupportedEncodingException
{
byte[] bytes = encode(args[0].getBytes(ZIP_CHARSET));
System.out.println(new String(bytes, ZIP_CHARSET));
}
|
java
|
public static void initSecret(ServletContext ctx)
{
if(ctx == null)
{
throw new NullPointerException("ServletContext ctx");
}
if (log.isLoggable(Level.FINE))
{
log.fine("Storing SecretKey @ " + INIT_SECRET_KEY_CACHE);
}
// Create and store SecretKey on application scope
String cache = ctx.getInitParameter(INIT_SECRET_KEY_CACHE);
if(cache == null)
{
cache = ctx.getInitParameter(INIT_SECRET_KEY_CACHE.toLowerCase());
}
if (!"false".equals(cache))
{
String algorithm = findAlgorithm(ctx);
// you want to create this as few times as possible
ctx.setAttribute(INIT_SECRET_KEY_CACHE, new SecretKeySpec(
findSecret(ctx, algorithm), algorithm));
}
if (log.isLoggable(Level.FINE))
{
log.fine("Storing SecretKey @ " + INIT_MAC_SECRET_KEY_CACHE);
}
String macCache = ctx.getInitParameter(INIT_MAC_SECRET_KEY_CACHE);
if(macCache == null)
{
macCache = ctx.getInitParameter(INIT_MAC_SECRET_KEY_CACHE.toLowerCase());
}
if (!"false".equals(macCache))
{
String macAlgorithm = findMacAlgorithm(ctx);
// init mac secret and algorithm
ctx.setAttribute(INIT_MAC_SECRET_KEY_CACHE, new SecretKeySpec(
findMacSecret(ctx, macAlgorithm), macAlgorithm));
}
}
|
java
|
private Map<String, String> getEnvironment() {
return AccessController.doPrivileged(new PrivilegedAction<Map<String, String>>() {
@Override
public Map<String, String> run() {
return System.getenv();
}
});
}
|
java
|
public String getDefaultParentForEntityInRealm(String entType, String realmName) throws WIMException {
String defaultParent = getDefaultParent(entType);
if (realmName != null) {
validateRealmName(realmName);
String parent = null;
RealmConfig realmConfig = getRealmConfig(realmName);
Map defaultParentsMap = realmConfig.getDefaultParentMapping();
if (defaultParentsMap != null) {
parent = (String) defaultParentsMap.get(entType);
if (parent != null) {
defaultParent = parent;
}
}
if (parent == null && !isUniqueNameInRealm(defaultParent, realmName)) {
defaultParent = null;
}
}
return defaultParent;
}
|
java
|
public String getDefaultParent(String entityTypeName) {
SupportedEntityConfig entityConfig = entityTypeMap.get(entityTypeName);
if (entityConfig != null) {
return entityConfig.getDefaultParent();
}
return null;
}
|
java
|
private <T> boolean processMethod(AnnotatedMethod<T> method, Class<?> clazz, Asynchronous classLevelAsync) {
FTEnablementConfig config = FaultToleranceCDIComponent.getEnablementConfig();
Method javaMethod = method.getJavaMember();
if (javaMethod.isBridge()) {
// Skip all validation for bridge methods
// Bridge methods are created when a class overrides a method but provides more specific return or parameter types
// (usually when implementing a generic interface)
// In these cases, the bridge method matches the signature of the overridden method after type erasure and delegates directly to the overriding method
// In some cases, the signature of the overriding method is valid for some microprofile annotation, but the signature of the bridge method is not
// However, the user's code is valid, and weld seems to make sure that any interceptors get called with the real method in the InvocationContext.
return false;
}
if (classLevelAsync != null) {
AsynchronousConfig asynchronous = annotationConfigFactory.createAsynchronousConfig(javaMethod, clazz, classLevelAsync);
asynchronous.validate();
}
boolean needsIntercepting = false;
Set<Annotation> annotations = method.getAnnotations();
for (Annotation annotation : annotations) {
if (config.isFaultTolerance(annotation)) {
if (config.isAnnotationEnabled(annotation, clazz, method.getJavaMember())) {
needsIntercepting = true;
if (annotation.annotationType() == Asynchronous.class) {
AsynchronousConfig asynchronous = annotationConfigFactory.createAsynchronousConfig(javaMethod, clazz, (Asynchronous) annotation);
asynchronous.validate();
} else if (annotation.annotationType() == Fallback.class) {
FallbackConfig fallback = new FallbackConfig(javaMethod, clazz, (Fallback) annotation);
fallback.validate();
} else if (annotation.annotationType() == Retry.class) {
RetryConfig retry = new RetryConfig(javaMethod, clazz, (Retry) annotation);
retry.validate();
} else if (annotation.annotationType() == Timeout.class) {
TimeoutConfig timeout = new TimeoutConfig(javaMethod, clazz, (Timeout) annotation);
timeout.validate();
} else if (annotation.annotationType() == CircuitBreaker.class) {
CircuitBreakerConfig circuitBreaker = new CircuitBreakerConfig(javaMethod, clazz, (CircuitBreaker) annotation);
circuitBreaker.validate();
} else if (annotation.annotationType() == Bulkhead.class) {
BulkheadConfig bulkhead = new BulkheadConfig(javaMethod, clazz, (Bulkhead) annotation);
bulkhead.validate();
}
} else {
if (isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Annotation {0} on {1} was disabled and will be ignored", annotation.annotationType().getSimpleName(),
clazz.getCanonicalName() + "." + method.getJavaMember().getName());
}
}
}
}
return needsIntercepting;
}
|
java
|
public static final void setServerName(String name)
{
if (tc.isDebugEnabled())
Tr.debug(tc, "setServerName", name);
// Store the server name.
serverName = name;
}
|
java
|
public static final boolean isRecoverable()
{
if (tc.isEntryEnabled())
Tr.entry(tc, "isRecoverable");
// This JTS is recoverable if there is a server name.
// boolean result = (serverName != null);
// JTA2 - we are recoverable if we have a working log...
// We can have a serverName but no working log either because
// a) the log config or store is invalid
// b) the log config indicates no logging.
//
boolean result = false;
if (_failureScopeController != null)
{
result = (_failureScopeController.getTransactionLog() != null);
}
if (tc.isEntryEnabled())
Tr.exit(tc, "isRecoverable", Boolean.valueOf(result));
return result;
}
|
java
|
public static final void setCurrentEpoch(int number)
{
if (tc.isDebugEnabled())
Tr.debug(tc, "setCurrentEpoch", number);
currentEpoch = number;
}
|
java
|
public static final void setApplId(byte[] name)
{
if (tc.isDebugEnabled())
Tr.debug(tc, "setApplId", name);
// Store the applId.
applId = name;
}
|
java
|
protected ConversionStatus convertCompatible(String rawString, Class<?> type) {
ConversionStatus status = new ConversionStatus();
for (PriorityConverter con : converters.getAll()) {
Type key = con.getType();
if (key instanceof Class) {
Class<?> clazz = (Class<?>) key;
if (type.isAssignableFrom(clazz)) {
Object converted = convert(rawString, key);
status.setConverted(converted);
break;
}
} else if (key instanceof TypeVariable) {
TypeVariable<?> typeVariable = (TypeVariable<?>) key;
status = convertGenericClazz(rawString, type, typeVariable);
if (status.isConverterFound()) {
break;
}
}
}
return status;
}
|
java
|
public <T> T[] convertArray(String rawString, Class<T> arrayType) {
String[] elements = split(rawString);
T[] array = convertArray(elements, arrayType);
return array;
}
|
java
|
public static Class toClass(String type, ClassLoader loader)
throws ClassNotFoundException {
if(com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable(Level.FINER)){
logger.logp(Level.FINER, CLASS_NAME, "toClass(String, ClassLoader)"," type= ["+type+"] loader= ["+loader+"]");
}
Class c = null;
int i0 = type.indexOf('[');
int dims = 0;
if (i0 > 0) {
// This is an array. Count the dimensions
for (int i = 0; i < type.length(); i++) {
if (type.charAt(i) == '[')
dims++;
}
type = type.substring(0, i0);
}else if (i0==0) {
//PM12828 start
//check for a type like this "[Lcom.ibm.sample.TagsAttr;" This means it is an array type.
//a two dimensional array might look like [[Lcom.ibm.sample.TagsAttr;
int bracketL = type.indexOf("[L");
if (bracketL>-1 && type.endsWith(";")) {
type = type.substring(bracketL+2,(type.length() - 1));
dims+=(bracketL+1);
}
}
//PM12828 end
if ("boolean".equals(type))
c = boolean.class;
else if ("char".equals(type))
c = char.class;
else if ("byte".equals(type))
c = byte.class;
else if ("short".equals(type))
c = short.class;
else if ("int".equals(type))
c = int.class;
else if ("long".equals(type))
c = long.class;
else if ("float".equals(type))
c = float.class;
else if ("double".equals(type))
c = double.class;
else if ("void".equals(type)) {
return Void.class;
}
else if (type.indexOf('[') < 0)
c = loader.loadClass(type);
if (dims == 0)
return c;
if (dims == 1)
return java.lang.reflect.Array.newInstance(c, 1).getClass();
// Array of more than i dimension
return java.lang.reflect.Array.newInstance(c, new int[dims]).getClass();
}
|
java
|
@Override
public Facelet getFacelet(URL url) throws IOException, FaceletException, FacesException, ELException
{
return _faceletCache.getFacelet(url);
}
|
java
|
private String _removeFirst(String string, String toRemove)
{
// do exactly what String.replaceFirst(toRemove, "") internally does,
// except treating the search as literal text and not as regex
return Pattern.compile(toRemove, Pattern.LITERAL).matcher(string).replaceFirst("");
}
|
java
|
@Override
protected void initialize(boolean reactivate) throws RemoteException, InvocationTargetException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled()) {
Tr.entry(tc, "initialize");
}
BeanMetaData bmd = home.beanMetaData;
ivCallbackKind = bmd.ivCallbackKind;
state = PRE_CREATE; // d159152
CallbackContextHelper contextHelper = new CallbackContextHelper(this); // d630940
try {
// Disallow setRollbackOnly until create is done.
allowRollbackOnly = false;
// Set the BeanId for this MDB. Just like we do for SLSB,
// we use the BeanId for the home bean so that the same ID
// is used for all MDB instances. Note the ivStatelessId is
// for the home bean, which is implemented as a SLSB.
if (home != null) {
setId(home.ivStatelessId); // d140003.12
}
// Note that the local transaction surrounds injection methods and
// PostConstruct lifecycle callbacks.
contextHelper.begin(CallbackContextHelper.Tx.CompatLTC,
CallbackContextHelper.Contexts.CallbackBean); // d630940
InterceptorMetaData imd = bmd.ivInterceptorMetaData;
createInterceptorsAndInstance(contextHelper);
// Now set the MessageDrivenContext and/or do the dependency injection.
// Note that dependency injection must occur while in PRE_CREATE state.
injectInstance(ivManagedObject, ivEjbInstance, this);
//---------------------------------------------------------
// Now that the MessageDrivenContext is set and/or dependencies
// injection has occured, change state to CREATING state to allow
// additional methods to be called by the ejbCreate or
// PostConstruct interceptor methods (e.g. getEJBObject).
//---------------------------------------------------------
setState(CREATING); //d399469.2
// Determine of life cycle callback to make if any.
if (ivCallbackKind == CallbackKind.MessageDrivenBean) {
Method m = bmd.ivEjbCreateMethod; //d453778
if (m != null) //d453778
{
// This is a 2.x MDB that has a ejbCreate method in it.
try {
if (isTraceOn && // d527372
TEBeanLifeCycleInfo.isTraceEnabled()) {
TEBeanLifeCycleInfo.traceEJBCallEntry("ejbCreate");
}
m.invoke(ivEjbInstance, new Object[] {});
} catch (InvocationTargetException itex) {
//FFDCFilter.processException(itex, CLASS_NAME + ".MessageDrivenBeanO", "96", this);
// All exceptions returned through a reflect method call
// are wrapped... making it difficult to debug a problem
// since InovcationTargetException does not print the root
// exception. Unwrap the 'target' exception so that the
// client will see it as the cause of the
// CreateFailureException. d534353.1
Throwable targetEx = itex.getCause();
if (targetEx == null)
targetEx = itex;
// MDB 2.x is allowed to throw application exceptions as well as
// javax.ejb.CreateException. Continue to wrap with a CreateFailureException
// to ensure no behavior change with prior releases.
if (isTraceOn && tc.isDebugEnabled()) {
Tr.debug(tc, "MDB ejbCreate failure", targetEx);
}
throw new CreateFailureException(targetEx);
} catch (Throwable ex) {
//FFDCFilter.processException(ex, CLASS_NAME + ".MessageDrivenBeanO", "96", this);
// MDB 2.x is allowed to throw application exceptions as well as
// javax.ejb.CreateException. Continue to wrap with a CreateFailureException
// to ensure no behavior change with prior releases.
if (isTraceOn && tc.isDebugEnabled()) {
Tr.debug(tc, "MDB ejbCreate failure", ex);
}
throw new CreateFailureException(ex);
} finally {
if (isTraceOn && // d527372
TEBeanLifeCycleInfo.isTraceEnabled()) {
TEBeanLifeCycleInfo.traceEJBCallExit("ejbCreate");
}
}
}
} else if (ivCallbackKind == CallbackKind.InvocationContext) {
// This is a MDB 3 that may have one or more PostConstruct interceptors
// methods. Invoke PostContruct interceptors if there is atleast 1
// PostConstruct interceptor.
try {
if (imd != null) // d402681
{
InterceptorProxy[] proxies = imd.ivPostConstructInterceptors;
if (proxies != null) {
if (isTraceOn && // d527372
TEBeanLifeCycleInfo.isTraceEnabled()) {
TEBeanLifeCycleInfo.traceEJBCallEntry("PostConstruct");
}
InvocationContextImpl<?> inv = getInvocationContext();
inv.doLifeCycle(proxies, bmd._moduleMetaData); //d450431, F743-14982
}
}
} catch (Throwable t) {
//FFDCFilter.processException(t, CLASS_NAME + ".MessageDrivenBeanO", "281", this);
// PostConstruct interceptors are allowed to throw system runtime exceptions,
// but NOT application exceptions. Therefore, wrap the caught Throwable
// in a javax.ejb.EJBException so that it gets handled as an unchecked
// exception.
if (isTraceOn && tc.isDebugEnabled()) {
Tr.debug(tc, "MDB PostConstruct failure", t);
}
throw ExceptionUtil.EJBException("MDB PostConstruct failure", t);
} finally {
if (isTraceOn && // d527372
TEBeanLifeCycleInfo.isTraceEnabled() &&
imd != null &&
imd.ivPostConstructInterceptors != null) {
TEBeanLifeCycleInfo.traceEJBCallExit("PostConstruct");
}
}
} // d367572.1 end
//---------------------------------------------------------
// Now that create has completed, allow setRollbackOnly to
// be called on the SessionContext and change state to the
// POOLED state to indicate the MDB is in the method-ready
// pool state and message listener methods are now allowed to be
// invoked on this MDB.
//---------------------------------------------------------
allowRollbackOnly = true;
setState(POOLED);
} finally // d399469
{
contextHelper.complete(true);
}
if (isTraceOn && tc.isEntryEnabled()) {
Tr.exit(tc, "initialize");
}
}
|
java
|
@Override
public void discard() {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled()) {
Tr.entry(tc, "discard");
}
discarded = true;
if (state == DESTROYED) {
return;
}
setState(DESTROYED);
destroyHandleList();
// Release any JCDI creational contexts that may exist. F743-29174
this.releaseManagedObjectContext();
if (pmiBean != null) {
pmiBean.discardCount(); // F743-27070
pmiBean.beanDestroyed();
}
if (isTraceOn && tc.isEntryEnabled()) {
Tr.exit(tc, "discard");
}
}
|
java
|
@Override
public final void remove() throws RemoteException, RemoveException {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "remove");
throw new InvalidBeanOStateException(StateStrs[state], "NONE" +
": Msg Bean remove not allowed");
}
|
java
|
@Override
public int getIsolationLevel() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getIsolationLevel : " + currentIsolationLevel);
return currentIsolationLevel;
}
|
java
|
@Override
public synchronized UserTransaction getUserTransaction() {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "getUserTransaction");
// Calling getUserTransaction is not allowed from setMessageDrivenContext
// per the EJB Specification. d159152
if ((state == PRE_CREATE)) {
IllegalStateException ise;
ise = new IllegalStateException("MessageDrivenBean: getUserTransaction " +
"not allowed from state = " +
getStateName(state));
if (isTraceOn && tc.isDebugEnabled())
Tr.exit(tc, "getUserTransaction", ise);
throw ise;
}
UserTransaction userTransactionWrapper = UserTransactionWrapper.INSTANCE; // d631349
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "getUserTransaction", userTransactionWrapper);
return userTransactionWrapper;
}
|
java
|
@Override
public EJBHome getEJBHome() //d116376
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getEJBHome");
Tr.error(tc, "METHOD_NOT_ALLOWED_CNTR0047E", "MessageDrivenBeanO.getEJBHome()");
throw new IllegalStateException("Method Not Allowed Exception: See Message-drive Bean Component Contract section of the applicable EJB Specification.");
}
|
java
|
@Override
public EJBLocalHome getEJBLocalHome() //d116376
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getEJBLocalHome");
Tr.error(tc, "METHOD_NOT_ALLOWED_CNTR0047E",
"MessageDrivenBeanO.getEJBLocalHome()");
throw new IllegalStateException("Method Not Allowed Exception: See Message-drive Bean Component Contract section of the applicable EJB Specification.");
}
|
java
|
synchronized void updateRegistration(BundleContext ctx) {
if (registration == null) {
registration = ctx.registerService(KeystoreConfig.class, this, properties);
} else {
registration.setProperties(properties);
}
}
|
java
|
private String taskHelp(SecurityUtilityTask task) {
StringBuffer taskUsage = new StringBuffer(NL);
taskUsage.append(task.getTaskHelp());
taskUsage.append(NL);
return taskUsage.toString();
}
|
java
|
private Object getComponentProperty(_PropertyDescriptorHolder propertyDescriptor)
{
Method readMethod = propertyDescriptor.getReadMethod();
if (readMethod == null)
{
throw new IllegalArgumentException("Component property " + propertyDescriptor.getName()
+ " is not readable");
}
try
{
return readMethod.invoke(_component, EMPTY_ARGS);
}
catch (Exception e)
{
FacesContext facesContext = _component.getFacesContext();
throw new FacesException("Could not get property " + propertyDescriptor.getName() + " of component "
+ _component.getClientId(facesContext), e);
}
}
|
java
|
private void setComponentProperty(_PropertyDescriptorHolder propertyDescriptor, Object value)
{
Method writeMethod = propertyDescriptor.getWriteMethod();
if (writeMethod == null)
{
throw new IllegalArgumentException("Component property " + propertyDescriptor.getName()
+ " is not writable");
}
try
{
writeMethod.invoke(_component, new Object[]{value});
}
catch (Exception e)
{
FacesContext facesContext = _component.getFacesContext();
throw new FacesException("Could not set property " + propertyDescriptor.getName() +
" of component " + _component.getClientId(facesContext) + " to value : " + value + " with type : " +
(value == null ? "null" : value.getClass().getName()), e);
}
}
|
java
|
public EndpointInfo build(EndpointInfoBuilderContext ctx, String serviceImplBeanClassName, EndpointType endpointType) throws UnableToAdaptException {
EndpointInfo endpointInfo = new EndpointInfo(serviceImplBeanClassName, endpointType);
endpointInfo.setBeanName((String) ctx.getContextEnv(JaxWsConstants.ENV_ATTRIBUTE_ENDPOINT_BEAN_NAME));
endpointInfo.setServletName((String) ctx.getContextEnv(JaxWsConstants.ENV_ATTRIBUTE_ENDPOINT_SERVLET_NAME));
invokeConfigurators(ctx, ConfigMethod.PREPARE, endpointInfo);
invokeConfigurators(ctx, ConfigMethod.CONFIG, endpointInfo);
validate(ctx, endpointInfo);
ctx.clearContextEnv();
return endpointInfo;
}
|
java
|
public void addSubscriber(Handler handler) {
String handlerId = CollectorManagerUtils.getHandlerId(handler);
//temporary exception for audit Source //must change later
if (source.getSourceName().trim().equals("audit") && subscribers.isEmpty()) {
//First subscriber, assign a buffer.
bufferMgr = new BufferManagerImpl(BUFFER_SIZE, sourceId, false);
//Inform the source that a buffer is now available
//and it can start sending events to this buffer.
source.setBufferManager(this.bufferMgr);
}
subscribers.add(handlerId);
/*
* Inform the handler that this source/buffer/conduit is now available:
* Synchronous Handler - Add handler as synchronous handler to the Buffer/Conduit's sync handler set
* Asynchronous Handler - Add handler as asynchronous handler into the Buffer/Conduit
*
*/
if (handler instanceof SynchronousHandler) {
bufferMgr.addSyncHandler((SynchronousHandler) handler);
} else {
bufferMgr.addHandler(handlerId);
}
}
|
java
|
public boolean removeSubscriber(Handler handler) {
String handlerId = CollectorManagerUtils.getHandlerId(handler);
subscribers.remove(handlerId);
/*
* Inform the handler that this source/buffer will no longer be available:
* Synchronous Handler: Remove the synchronous handler from the Buffer/Conduit's sync handler set
* Asynchronous Handler: Remove the asynchronous handler from the the Buffer/Conduit
*/
if (handler instanceof SynchronousHandler) {
bufferMgr.removeSyncHandler((SynchronousHandler) handler);
} else {
bufferMgr.removeHandler(handlerId);
}
if (subscribers.isEmpty()) {
/*
* Can not set bufferMgr to null (in here or in the source )if this SrcMgr belongs
* to LogSource or TraceSource
*/
if (!sourceId.contains(CollectorConstants.MESSAGES_SOURCE) && !sourceId.contains(CollectorConstants.TRACE_SOURCE)) {
/*
* Last subscriber, unassign the buffer
* Inform the source that buffer will no longer be available
* and it should stop sending events to this buffer.
*/
source.unsetBufferManager(bufferMgr);
bufferMgr = null;
}
return true;
}
return false;
}
|
java
|
public void handleFfdc() {
if (!bFfdcAlready) {
com.ibm.ws.ffdc.FFDCFilter.processException(this, "com.ibm.websphere.security.jwt.JwtTokenException", "155", this);
bFfdcAlready = true;
}
}
|
java
|
private List<String> toListOfStrings(String headerName, List<Object> values) {
if (values == null) {
return null;
}
List<String> stringValues = new ArrayList<>(values.size());
HeaderDelegate<Object> hd = HttpUtils.getHeaderDelegate(values.get(0));
for (Object value : values) {
String actualValue = hd == null ? value.toString() : hd.toString(value);
stringValues.add(actualValue);
}
return stringValues;
}
|
java
|
public <T> T doReadEntity(Class<T> cls, Type t, Annotation[] anns) throws ProcessingException, IllegalStateException {
return doReadEntity(cls, t, anns, false);
}
|
java
|
public static String read(Container container, String ddPath) {
if (container == null || ddPath == null) {
return "";
}
Entry entry = container.getEntry(ddPath);
if (entry == null) {
throw new IllegalStateException(ddPath);
}
InputStream input;
try {
input = entry.adapt(InputStream.class);
} catch (UnableToAdaptException e) {
throw new IllegalStateException(e);
}
try {
SAXParserFactory parserFactory = SAXParserFactory.newInstance();
SAXParser parser = parserFactory.newSAXParser();
XMLReader xmlReader = parser.getXMLReader();
xmlReader.setEntityResolver(new EntityResolver() {
@Override
public InputSource resolveEntity(String arg0, String arg1) throws SAXException, IOException {
return new InputSource(new ByteArrayInputStream(new byte[0]));
}
});
Source saxSource = new SAXSource(xmlReader, new InputSource(input));
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
StringWriter writer = new StringWriter();
Result result = new StreamResult(writer);
transformer.transform(saxSource, result);
return writer.toString();
} catch (ParserConfigurationException e) {
throw new IllegalStateException(e);
} catch (SAXException e) {
throw new IllegalStateException(e);
} catch (TransformerConfigurationException e) {
throw new IllegalStateException(e);
} catch (TransformerException e) {
throw new IllegalStateException(e);
} finally {
try {
input.close();
} catch (IOException e) {
}
}
}
|
java
|
public void audit(String key, Object... params) {
Tr.audit(tc, key, params);
}
|
java
|
public String formatMessage(String key, Object... params) {
return Tr.formatMessage(tc, key, params);
}
|
java
|
public void info(String key, Object... params) {
Tr.info(tc, key, params);
}
|
java
|
@Override
final public Object getConnection(final Subject requestSubject,
final ConnectionRequestInfo requestInfo) throws ResourceException {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "getConnection", new Object[] {
subjectToString(requestSubject), requestInfo });
}
// Ensure that the credentials for this request match those passed to
// the constructor (as we don't support reauthentication)
final JmsJcaUserDetails requestUserDetails = _managedConnectionFactory
.getUserDetails(requestSubject, requestInfo);
if (_userDetails != null) {
if (!(_userDetails.equals(requestUserDetails))) {
throw new ResourceException(NLS.getFormattedMessage(
("AUTHENTICATION_ERROR_CWSJR1103"), new Object[] {
"JmsJcaManagedConnection.getConnection",
_userDetails.getUserName(),
(requestUserDetails == null) ? null
: requestUserDetails.getUserName() },
null));
}
} else {
if (!(_subject.equals(requestSubject))) {
throw new ResourceException(
NLS
.getFormattedMessage(
("AUTHENTICATION_ERROR_CWSJR1117"),
new Object[] { "JmsJcaManagedConnection.getConnection" },
null));
}
}
JmsJcaSessionImpl session = null;
if (requestInfo == null || requestInfo instanceof JmsJcaConnectionRequestInfo) {
session = new JmsJcaSessionImpl(this, (JmsJcaConnectionRequestInfo) requestInfo);
_sessions.add(session);
} else {
throw new ResourceAdapterInternalException(NLS.getFormattedMessage(
("EXCEPTION_RECEIVED_CWSJR1101"), new Object[] {
"getConnection",
JmsJcaConnectionRequestInfo.class.getName(),
requestInfo.getClass().getName() }, null));
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "getConnection", session);
}
return session;
}
|
java
|
@Override
final public void destroy() throws ResourceException {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "destroy");
}
// Invalidate all of the sessions
for (final Iterator iterator = _sessions.iterator(); iterator.hasNext();) {
final Object object = iterator.next();
if (object instanceof JmsJcaSessionImpl) {
final JmsJcaSessionImpl session = (JmsJcaSessionImpl) object;
session.invalidate();
}
}
// Empty the set
_sessions.clear();
try {
// Deregister the connection listener
_coreConnection.removeConnectionListener(_connectionListener);
// Close the core connection
// when destroy calls close connections then connection cannot be reset for future usage so force close by passing boolean true. - PM39926
_coreConnection.close(true);
} catch (final SIConnectionLostException exception) {
// No FFDC code needed
// d352473
// We are remote to the ME and the ME connection has been lost
// we shall surpress this exception as we want the destroy to complete
} catch (final SIConnectionDroppedException exception) {
// No FFDC code needed
// d352473
// We are remote to the ME and the ME connection has been dropped
// we shall surpress this exception as we want the destroy to complete
} catch (final SIException exception) {
FFDCFilter.processException(exception, CLASS_NAME + "destroy",
"1:408:1.91", this);
throw new ResourceException(NLS.getFormattedMessage(
"EXCEPTION_RECEIVED_CWSJR1110", new Object[] { exception,
"createManagedConnection" }, null), exception);
} catch (final SIErrorException exception) {
FFDCFilter.processException(exception, CLASS_NAME + "destroy",
"1:416:1.91", this);
throw new ResourceException(NLS.getFormattedMessage(
"EXCEPTION_RECEIVED_CWSJR1110", new Object[] { exception,
"createManagedConnection" }, null), exception);
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "destroy");
}
}
|
java
|
@Override
final public void cleanup() throws ResourceException {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "cleanup");
}
// Invalidate all of the sessions
for (final Iterator iterator = _sessions.iterator(); iterator.hasNext();) {
final Object object = iterator.next();
if (object instanceof JmsJcaSessionImpl) {
((JmsJcaSessionImpl) object).invalidate();
}
}
_sessions.clear();
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "cleanup");
}
}
|
java
|
@Override
final public void associateConnection(Object object)
throws ResourceException {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "associateConnection", object);
}
if (object instanceof JmsJcaSessionImpl) {
final JmsJcaSessionImpl session = (JmsJcaSessionImpl) object;
session.associate(this);
_sessions.add(session);
} else {
throw new ResourceAdapterInternalException(NLS.getFormattedMessage(
("INVALID_SESSION_CWSJR1104"), new Object[] {
"associateConnection",
JmsJcaSessionImpl.class.getName(),
(object == null ? "null" : object.getClass()
.getName()) }, null));
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "associateConnection");
}
}
|
java
|
final void disassociateSession(final JmsJcaSessionImpl session) {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "disassociateSession", session);
}
_sessions.remove(session);
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "disassociateSession");
}
}
|
java
|
@Override
final public void addConnectionEventListener(
final ConnectionEventListener listener) {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "addConnectionEventListener", listener);
}
synchronized (_connectionListeners) {
_connectionListeners.add(listener);
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "addConnectionEventListener");
}
}
|
java
|
@Override
final public ManagedConnectionMetaData getMetaData()
throws ResourceException {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "getMetaData");
}
if (_metaData == null) {
_metaData = new JmsJcaManagedConnectionMetaData();
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "getMetaData", _metaData);
}
return _metaData;
}
|
java
|
@Override
final public void dissociateConnections() throws ResourceException {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(TRACE, "dissociateConnections");
}
// Dissociate sessions
for (final Iterator iterator = _sessions.iterator(); iterator.hasNext();) {
final Object object = iterator.next();
if (object instanceof JmsJcaSessionImpl) {
((JmsJcaSessionImpl) object).dissociate();
iterator.remove();
}
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "dissociateConnections");
}
}
|
java
|
final void localTransactionStarted() {
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, "localTransactionStarted");
}
final ConnectionEvent event = new ConnectionEvent(this,
ConnectionEvent.LOCAL_TRANSACTION_STARTED);
// Copy list to protect against concurrent modification by listener
final List<ConnectionEventListener> copy;
synchronized (_connectionListeners) {
copy = new ArrayList<ConnectionEventListener>(_connectionListeners);
}
for (final Iterator iterator = copy.iterator(); iterator.hasNext();) {
final Object object = iterator.next();
if (object instanceof ConnectionEventListener) {
((ConnectionEventListener) object)
.localTransactionStarted(event);
}
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, "localTransactionStarted");
}
}
|
java
|
Key getSigningKey(JwtConsumerConfig config, JwtContext jwtContext, Map properties) throws KeyException {
Key signingKey = null;
if (config == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "JWT consumer config object is null");
}
return null;
}
signingKey = getSigningKeyBasedOnSignatureAlgorithm(config, jwtContext, properties);
if (signingKey == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "A signing key could not be found");
}
}
return signingKey;
}
|
java
|
Key getSharedSecretKey(JwtConsumerConfig config) throws KeyException {
if (config == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "JWT consumer config object is null");
}
return null;
}
String sharedKey = config.getSharedKey();
return createKeyFromSharedKey(sharedKey);
}
|
java
|
Key getPublicKey(String trustedAlias, String trustStoreRef, String signatureAlgorithm)
throws KeyStoreServiceException, KeyException {
Key signingKey = getPublicKeyFromKeystore(trustedAlias, trustStoreRef, signatureAlgorithm);
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Trusted alias: " + trustedAlias + ", Truststore: " + trustStoreRef);
Tr.debug(tc, "RSAPublicKey: " + (signingKey instanceof RSAPublicKey));
}
if (signingKey != null && !(signingKey instanceof RSAPublicKey)) {
signingKey = null;
}
return signingKey;
}
|
java
|
void validateSignatureAlgorithmWithKey(JwtConsumerConfig config, Key key) throws InvalidClaimException {
String signatureAlgorithm = config.getSignatureAlgorithm();
if (key == null && signatureAlgorithm != null && !signatureAlgorithm.equalsIgnoreCase("none")) {
String msg = Tr.formatMessage(tc, "JWT_MISSING_KEY", new Object[] { signatureAlgorithm });
throw new InvalidClaimException(msg);
}
}
|
java
|
boolean validateIssuer(String consumerConfigId, String issuers, String tokenIssuer) throws InvalidClaimException {
boolean isIssuer = false;
if (issuers == null || issuers.isEmpty()) {
String msg = Tr.formatMessage(tc, "JWT_TRUSTED_ISSUERS_NULL",
new Object[] { tokenIssuer, consumerConfigId });
throw new InvalidClaimException(msg);
}
StringTokenizer st = new StringTokenizer(issuers, ",");
while (st.hasMoreTokens()) {
String iss = st.nextToken().trim();
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Trusted issuer: " + iss);
}
if (Constants.ALL_ISSUERS.equals(iss) || (tokenIssuer != null && tokenIssuer.equals(iss))) {
isIssuer = true;
break;
}
}
if (!isIssuer) {
String msg = Tr.formatMessage(tc, "JWT_ISSUER_NOT_TRUSTED",
new Object[] { tokenIssuer, consumerConfigId, issuers });
throw new InvalidClaimException(msg);
}
return isIssuer;
}
|
java
|
boolean validateAudience(List<String> allowedAudiences, List<String> audiences) {
boolean valid = false;
if (allowedAudiences != null && allowedAudiences.contains(Constants.ALL_AUDIENCES)) {
return true;
}
if (allowedAudiences != null && audiences != null) {
for (String audience : audiences) {
for (String allowedAud : allowedAudiences) {
if (allowedAud.equals(audience)) {
valid = true;
break;
}
}
}
} else if (allowedAudiences == null && (audiences == null || audiences.isEmpty())) {
valid = true;
}
return valid;
}
|
java
|
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "readExternal");
try {
// read magic
short magic = in.readShort();
short majorVersion = in.readShort();
short minorVersion = in.readShort();
if (!(magic == EXTERNAL_MAGIC)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc,
"Magic Number absent, trying default Java deserialization");
throw new IOException("Bean ID externalized stream format error");
} else if (!(majorVersion == MAJOR_VERSION) ||
!(minorVersion == MINOR_VERSION)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc,
"BeanID Version mismatch", new Object[] { new Short(majorVersion),
new Short(minorVersion) });
throw new IOException("BeanID version mismatch");
}
// read the interface type (HOME or REMOTE)
byte ifType = in.readByte();
if (ifType == IF_HOME) {
_isHome = true;
} else {
_isHome = false;
}
//89554
// read the bean name
byte[] j2eeNameBytes = readExternalJ2EEName(in);
// read the serialized primary key
pkey = readExternalPKey(in, j2eeNameBytes);
// TAKE CARE! We don't have a container reference so can't
// restore transient fields.
// This is ok as long
// as rest of container restores BeanIds using the deserialise
// method. Since readExternal
// is a new addition
// this can be no different to the behaviour that would have been
// observed when using
// the default serialization.
} finally {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "readExternal");
}
}
|
java
|
private Serializable readExternalPKey(ObjectInput in, byte[] j2eeNameBytes)
throws java.io.IOException, ClassNotFoundException {
int pkeyLength = in.readInt();
byte[] pkeyBytes = new byte[pkeyLength];
//d164415 start
int bytesRead = 0;
for (int offset = 0; offset < pkeyLength; offset += bytesRead)
{
bytesRead = in.read(pkeyBytes, offset, pkeyLength - offset);
if (bytesRead == -1)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "readExternalKey encountered end of stream");
throw new IOException("end of input stream while reading primary key");
}
}
//d164415 end
//
// What we are trying to do here is to get the j2eename of the
// bean in question. The reason we want to do this, we have get
// the ClassLoader of the bean before we attempt to deserialize
// the primary key. The container ClassLoader is no longer aware
// of the bean classes.
// This path may be traversed on a call to keyToObject. In that
// situation, the thread's context ClassLoader is of no use. So we
// have to use some static methods to access the container and get
// the specific ClassLoader for the bean
//
final EJSContainer container = EJSContainer.getDefaultContainer();
J2EEName j2eename = container.getJ2EENameFactory().create(j2eeNameBytes);
ByteArrayInputStream bais = new ByteArrayInputStream(pkeyBytes);
//
// Use a ObjectInputStream, it can then use the bean's ClassLoader
// to resolve the primary key class.
//
ClassLoader loader = EJSContainer.getClassLoader(j2eename);
ObjectInputStream pkeyStream =
container.getEJBRuntime().createObjectInputStream(bais, loader); // RTC71814
Serializable key = (Serializable) pkeyStream.readObject();
return key;
}
|
java
|
public void writeExternal(ObjectOutput out) throws IOException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "writeExternal");
try {
// write magic
out.writeShort(EXTERNAL_MAGIC);
out.writeShort(MAJOR_VERSION);
out.writeShort(MINOR_VERSION);
// write the interface type (HOME or REMOTE)
if (_isHome) {
out.writeByte(IF_HOME);
} else {
out.writeByte(IF_REMOTE);
}
//89554
// write the Java EE name
writeExternalJ2EEName(out);
// write the external primary key
writeExternalPKey(out);
out.flush();
} finally {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "writeExternal");
}
}
|
java
|
private void writeExternalPKey(ObjectOutput out)
throws java.io.IOException {
// write the serialized primary key - can't mix eternaized stream
// and writeObject so convert to bytes...
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream pkeyStream = new ObjectOutputStream(baos);
pkeyStream.writeObject(pkey);
pkeyStream.flush();
pkeyStream.close();
byte[] pkeyBytes = baos.toByteArray();
out.writeInt(pkeyBytes.length);
out.write(pkeyBytes);
}
|
java
|
public static UIComponent getCompositeComponentParent(UIComponent component)
{
if (component == null)
{
return null;
}
UIComponent parent = component;
do
{
parent = parent.getParent();
if (parent != null && UIComponent.isCompositeComponent(parent))
{
return parent;
}
} while (parent != null);
return null;
}
|
java
|
protected StateHelper getStateHelper(boolean create)
{
if (_stateHelper != null)
{
return _stateHelper;
}
if (create)
{
_stateHelper = new _DeltaStateHelper(this);
}
return _stateHelper;
}
|
java
|
private static Boolean _getHonorCurrentComponentAttributes(FacesContext facesContext)
{
// performance note: we cache value in facesContext.attributes because
// 1) methods pushComponentToEL, popComponentFromEl, getCurrentComponent a getCurrentCompositeComponent
// can use that value
// 2) getExternalContext().getInitParameter has undetermined performance. In typical JSF app, there
// are one or two wrappers around external context; servletContext.getInitParameter has also unknown
// implementation and performance
Map<Object, Object> attributes = facesContext.getAttributes();
Boolean paramValue = (Boolean) attributes.get(HONOR_CURRENT_COMPONENT_ATTRIBUTES_PARAM_NAME);
if (paramValue == null)
{
String param
= facesContext.getExternalContext().getInitParameter(HONOR_CURRENT_COMPONENT_ATTRIBUTES_PARAM_NAME);
paramValue = Boolean.valueOf((param != null && Boolean.valueOf(param).booleanValue()));
attributes.put(HONOR_CURRENT_COMPONENT_ATTRIBUTES_PARAM_NAME, paramValue);
}
return paramValue;
}
|
java
|
@Override
public void processPartial(PhaseId phaseId)
{
assertNotReleased();
UIViewRoot viewRoot = _facesContext.getViewRoot();
if (phaseId == PhaseId.APPLY_REQUEST_VALUES
|| phaseId == PhaseId.PROCESS_VALIDATIONS
|| phaseId == PhaseId.UPDATE_MODEL_VALUES)
{
processPartialExecute(viewRoot, phaseId);
}
else if (phaseId == PhaseId.RENDER_RESPONSE)
{
processPartialRendering(viewRoot, phaseId);
}
}
|
java
|
public static Locale localeForString(String localeString) {
if (localeString == null || localeString.isEmpty()) {
return null;
}
Locale locale;
String[] localeParts = localeString.split("_");
switch (localeParts.length) {
case 1:
locale = new Locale(localeParts[0]);
break;
case 2:
locale = new Locale(localeParts[0], localeParts[1]);
break;
default:
// Use default for 3 and above, merge the parts back and put them all in the varient
StringBuilder varient = new StringBuilder(localeParts[2]);
for (int i = 3; i < localeParts.length; i++) {
varient.append("_");
varient.append(localeParts[i]);
}
locale = new Locale(localeParts[0], localeParts[1], varient.toString());
break;
}
return locale;
}
|
java
|
public Iterable<ServerInstanceLogRecordList> getLogLists(RepositoryPointer after, LogQueryBean query) throws LogRepositoryException {
logger.entering(thisClass, "getLogLists", new Object[]{after, query});
RemoteAllResults lists = readLogLists(query, after);
ArrayList<ServerInstanceLogRecordList> result = new ArrayList<ServerInstanceLogRecordList>();
if (lists != null) {
boolean firstInstance = true;
for (RemoteInstanceDetails indicator: lists.getLogLists()) {
result.add(getLogListForServerInstance(indicator, firstInstance ? after : null));
firstInstance = false;
}
}
logger.exiting(thisClass, "getLogLists", result);
return result;
}
|
java
|
private void validatePossibleEndpoint(String possibleEndpoint) throws IllegalArgumentException {
if (!possibleEndpoint.contains(":")) {
throw new IllegalArgumentException(RESTClientMessagesUtil.getMessage(RESTClientMessagesUtil.INVALID_ENDPOINT, possibleEndpoint));
}
String[] components = possibleEndpoint.split(":");
if (components.length != 2) {
throw new IllegalArgumentException(RESTClientMessagesUtil.getMessage(RESTClientMessagesUtil.INVALID_ENDPOINT, possibleEndpoint));
}
try {
Integer.valueOf(components[1]);
} catch (NumberFormatException e) {
throw new IllegalArgumentException(RESTClientMessagesUtil.getMessage(RESTClientMessagesUtil.INVALID_ENDPOINT, possibleEndpoint));
}
}
|
java
|
private Set<String> validatePathAndRetrievePathParams(ValidationHelper helper, Context context, String pathStr) {
String pathToCheck = pathStr;
Set<String> pathParameters = new HashSet<String>();
while (pathToCheck.contains("{")) {
if (!pathToCheck.contains("}")) {
final String message = Tr.formatMessage(tc, "pathItemInvalidFormat", pathStr);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation(), message));
return pathParameters;
}
int firstIndex = pathToCheck.indexOf("{");
int lastIndex = pathToCheck.indexOf("}");
if (firstIndex > lastIndex) {
final String message = Tr.formatMessage(tc, "pathItemInvalidFormat", pathStr);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation(), message));
return pathParameters;
}
String parameter = pathToCheck.substring(firstIndex + 1, lastIndex);
if (parameter.isEmpty() || parameter.contains("{") || parameter.contains("/")) {
final String message = Tr.formatMessage(tc, "pathItemInvalidFormat", pathStr);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation(), message));
return pathParameters;
}
pathParameters.add(parameter);
pathToCheck = pathToCheck.substring(lastIndex + 1);
}
if (pathToCheck.contains("}")) {
final String message = Tr.formatMessage(tc, "pathItemInvalidFormat", pathStr);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation(), message));
return pathParameters;
}
return pathParameters;
}
|
java
|
public CompositeEnumeration<T> add(Enumeration<T> enumeration) {
// optimise out empty enumerations up front
if (enumeration.hasMoreElements())
enumerations.add(enumeration);
return this;
}
|
java
|
public synchronized void incrementUseCount()
throws SIConnectionUnavailableException, SIConnectionDroppedException, SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "incrementUseCount");
// Check if this ordering conext instance is "dead". If it is, then this order context has been closed and
// we need to obtain a new proxy id for it.
if (dead) {
setOrderingContextProxyId();
dead = false;
}
useCount++;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Use count is now: " + useCount);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementUseCount");
}
|
java
|
public synchronized void decrementUseCount()
throws SIConnectionDroppedException, SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "decrementUseCount");
useCount--;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Use count is now: " + useCount);
// Now check the use count. If it is 0, we should close the order contex so that the server
// side code can release the resources held by it.
if (useCount == 0)
{
close();
dead = true;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "decrementUseCount");
}
|
java
|
public void close()
throws SIConnectionDroppedException, SIErrorException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "close");
queue = null;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Returning order context to the order context pool");
final ConnectionProxy cp = getConnectionProxy();
cp.addOrderContext(getProxyID());
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "close");
}
|
java
|
public void associateWithQueue(Queue queueToAssociate)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "associateWithQueue", queueToAssociate);
this.queue = queueToAssociate;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "associateWithQueue");
}
|
java
|
private String getMessage(String key, Object... args) {
String message = messages.getString(key);
return (args.length == 0) ? message : MessageFormat.format(message, args);
}
|
java
|
private final JsMessage restoreJsMessage(byte[] buffer, Object store) throws MessageRestoreFailedException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "restoreJsMessage" , buffer);
JsMessage newMsg = null;
String className;
int offset = 0;
/* The buffer contains: */
/* the message class name */
/* the list of JMF schema ids needed to decode the message */
/* the message itself */
// Trace the first 256 bytes just in case we get passed rubbish
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Start of buffer: ", SibTr.formatBytes(buffer, 0, 256));
// Extract the classname from the buffer
int temp = ArrayUtil.readInt(buffer, offset); // the length of the class name
offset += ArrayUtil.INT_SIZE;
try {
className = getClassName(buffer, offset, temp); // the class name itself
}
catch (RuntimeException e) {
FFDCFilter.processException(e, "com.ibm.ws.sib.mfp.impl.JsMessageFactoryImpl.restoreJsMessage", "573", this,
new Object[]{ MfpConstants.DM_BUFFER, buffer, 0, buffer.length});
// This is a disaster - presumably the buffer is garbage - so we have to throw the exception on
throw new MessageRestoreFailedException(e);
}
offset += temp;
// Extract the message schema ids from the buffer, & ensure the schemas are available.
offset = ensureSchemasAvailable(buffer, offset, store);
try {
/* Create a new JMO from the remaining buffer */
JsMsgObject newJmo = new JsMsgObject(JsHdrAccess.schema, JsPayloadAccess.schema, buffer, offset, buffer.length-offset);
/* Get the class for the appropriate specialization */
Class msgClass = Class.forName(className);
/* Now create the new JsMessage and set the JMO */
newMsg = (JsMessage)msgClass.newInstance();
((JsMessageImpl)newMsg).setJmo(newJmo);
/* Set the approxLength as we know it */
((JsMessageImpl)newMsg).setApproximateLength(newJmo.getOriginalLength());
}
catch (ClassNotFoundException e1) {
FFDCFilter.processException(e1, "com.ibm.ws.sib.mfp.impl.JsMessageFactoryImpl.restore", "534");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Exception " + e1.toString() + " finding class " + className);
throw new MessageRestoreFailedException(e1);
}
catch (MessageDecodeFailedException e2) {
/* No need to FFDC this as JsMsgObject will already have done so */
// No FFDC code needed
throw new MessageRestoreFailedException(e2);
}
catch (Exception e3) {
/* Any other exceptions from instantiation should never happen */
FFDCFilter.processException(e3, "com.ibm.ws.sib.mfp.impl.JsMessageFactoryImpl.restore", "545");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Exception " + e3.toString() + " instantiating class " + className);
throw new MessageRestoreFailedException(e3);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "restoreJsMessage");
return newMsg;
}
|
java
|
private final static int ensureSchemasAvailable(byte[] buffer, int offset, Object store) throws MessageRestoreFailedException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "ensureSchemasAvailable", new Object[] {offset, store});
// If we have a message store we need to ensure all the schemas we'll
// need to decode the message are restored from the store.
int temp = ArrayUtil.readInt(buffer, offset); // the number of encoding Ids
offset += ArrayUtil.INT_SIZE;
long[] decodeIds = new long[temp];
for (int i = 0; i < temp; i++) {
decodeIds[i] = ArrayUtil.readLong(buffer, offset); // each encoding schema id
offset += ArrayUtil.LONG_SIZE;
}
if (store != null && decodeIds.length > 0) {
if (!(store instanceof MessageStore)) throw new IllegalArgumentException("store is not a MessageStore instance");
SchemaStore.loadSchemas((MessageStore)store, decodeIds);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "ensureSchemasAvailable", offset);
return offset;
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.