code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public static void log(Logger logger,
Level level,
String message,
Throwable throwable,
Object parameter) {
if (logger.isLoggable(level)) {
final String formattedMessage =
MessageFormat.format(localize(logger, message), parameter);
doLog(logger, level, formattedMessage, throwable);
}
}
|
java
|
private static String localize(Logger logger, String message) {
ResourceBundle bundle = logger.getResourceBundle();
try {
return bundle != null ? bundle.getString(message) : message;
} catch (MissingResourceException ex) {
//string not in the bundle
return message;
}
}
|
java
|
public synchronized int add(Object value)
throws IdTableFullException
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "add", value);
if (value == null) throw new SIErrorException(nls.getFormattedMessage("IDTABLE_INTERNAL_SICJ0050", null, "IDTABLE_INTERNAL_SICJ0050")); // D226232
int id = 0;
if (highWaterMark < table.length)
{
// Can we store the object in any free space at the end of the table?
id = highWaterMark;
if (table[id] != null) throw new SIErrorException(nls.getFormattedMessage("IDTABLE_INTERNAL_SICJ0050", null, "IDTABLE_INTERNAL_SICJ0050")); // D226232
table[id] = value;
if (lowestPossibleFree == highWaterMark) ++lowestPossibleFree;
++highWaterMark;
}
else if (table.length < maxSize)
{
// Resize the table if we can
growTable();
id = highWaterMark;
if (table[id] != null) throw new SIErrorException(nls.getFormattedMessage("IDTABLE_INTERNAL_SICJ0050", null, "IDTABLE_INTERNAL_SICJ0050")); // D226232
table[id] = value;
if (lowestPossibleFree == highWaterMark) ++lowestPossibleFree;
++highWaterMark;
}
else
{
// Scan for free slot
id = findFreeSlot();
if (id == 0) throw new IdTableFullException();
}
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "add", ""+id);
return id;
}
|
java
|
public synchronized Object remove(int id)
throws IllegalArgumentException
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "remove", ""+id);
Object returnValue = get(id);
if (returnValue != null) table[id] = null;
if (id < lowestPossibleFree) lowestPossibleFree = id;
// If the ID removed was at just below the high water mark, then
// move the high water mark down as far as we can.
if ((id+1) == highWaterMark)
{
int index = id;
while(index >= lowestPossibleFree)
{
if (table[index] == null) highWaterMark = index;
--index;
}
}
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "remove", returnValue);
return returnValue;
}
|
java
|
public synchronized Object get(int id)
throws IllegalArgumentException
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "get", ""+id);
if ((id < 1) || (id > maxSize)) throw new SIErrorException(nls.getFormattedMessage("IDTABLE_INTERNAL_SICJ0050", null, "IDTABLE_INTERNAL_SICJ0050")); // D226232
Object returnValue = null;
if (id < table.length) returnValue = table[id];
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "get", ""+returnValue);
return returnValue;
}
|
java
|
private void growTable()
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "growTable");
int newSize = Math.min(table.length+TABLE_GROWTH_INCREMENT, maxSize);
if (tc.isDebugEnabled()) SibTr.debug(this, tc, "existing size="+table.length+" new size="+newSize);
Object[] newTable = new Object[newSize+1];
System.arraycopy(table, 0, newTable, 0, table.length);
table = newTable;
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "growTable");
}
|
java
|
private int findFreeSlot()
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "findFreeSlot");
boolean foundFreeSlot = false;
int index = lowestPossibleFree;
int largestIndex = Math.min(highWaterMark, table.length-1);
while ((!foundFreeSlot) && (index <= largestIndex))
{
foundFreeSlot = (table[index] == null);
++index;
}
int freeSlot = 0;
if (foundFreeSlot)
{
freeSlot = index-1;
// If we have already scanned more than half the table then
// we might as well spend a little more time and see if we can
// move the high water mark any lower...
if ((index*2) > largestIndex)
{
boolean quit = false;
int lowest = index;
index = largestIndex;
while (!quit && (index >= lowest))
{
if (table[index] == null) highWaterMark = index;
else quit = true;
--index;
}
}
}
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "findFreeSlot", ""+freeSlot);
return freeSlot;
}
|
java
|
public void init(HttpInboundConnection conn, SessionManager sessMgr) {
this.connection = conn;
this.request = conn.getRequest();
this.sessionData = new SessionInfo(this, sessMgr);
}
|
java
|
public void clear() {
this.attributes.clear();
this.queryParameters = null;
this.inReader = null;
this.streamActive = false;
this.inStream = null;
this.encoding = null;
this.sessionData = null;
this.strippedURI = null;
this.srvContext = null;
this.srvPath = null;
this.pathInfo = null;
this.pathInfoComputed = false;
this.filters = null;
}
|
java
|
private void parseQueryFormData() throws IOException {
int size = getContentLength();
if (0 == size) {
// no body present
this.queryParameters = new HashMap<String, String[]>();
return;
} else if (-1 == size) {
// chunked encoded perhaps
size = 1024;
}
StringBuilder sb = new StringBuilder(size);
char[] data = new char[size];
BufferedReader reader = getReader();
int len = reader.read(data);
while (-1 != len) {
sb.append(data, 0, len);
len = reader.read(data);
}
this.queryParameters = parseQueryString(sb.toString());
}
|
java
|
private Map<String, String[]> parseQueryString(String data) {
Map<String, String[]> map = new Hashtable<String, String[]>();
if (null == data) {
return map;
}
String valArray[] = null;
char[] chars = data.toCharArray();
int key_start = 0;
for (int i = 0; i < chars.length; i++) {
// look for the key name delimiter
if ('=' == chars[i]) {
if (i == key_start) {
// missing the key name
throw new IllegalArgumentException("Missing key name: " + i);
}
String key = parseName(chars, key_start, i);
int value_start = ++i;
for (; i < chars.length && '&' != chars[i]; i++) {
// just keep looping looking for the end or &
}
if (i > value_start) {
// did find at least one char for the value
String value = parseName(chars, value_start, i);
if (map.containsKey(key)) {
String oldVals[] = map.get(key);
valArray = new String[oldVals.length + 1];
System.arraycopy(oldVals, 0, valArray, 0, oldVals.length);
valArray[oldVals.length] = value;
} else {
valArray = new String[] { value };
}
map.put(key, valArray);
}
key_start = i + 1;
}
}
return map;
}
|
java
|
private void mergeQueryParams(Map<String, String[]> urlParams) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "mergeQueryParams: " + urlParams);
}
for (Entry<String, String[]> entry : urlParams.entrySet()) {
String key = entry.getKey();
// prepend to postdata values if necessary
String[] post = this.queryParameters.get(key);
String[] url = entry.getValue();
if (null != post) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "map already contains key " + key);
}
String[] newVals = new String[post.length + url.length];
System.arraycopy(url, 0, newVals, 0, url.length);
System.arraycopy(post, 0, newVals, url.length, post.length);
this.queryParameters.put(key, newVals);
} else {
this.queryParameters.put(key, url);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "put key " + key + " into map.");
}
}
}
|
java
|
private String getCipherSuite() {
String suite = null;
SSLContext ssl = this.connection.getSSLContext();
if (null != ssl) {
suite = ssl.getSession().getCipherSuite();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "getCipherSuite [" + suite + "]");
}
return suite;
}
|
java
|
private X509Certificate[] getPeerCertificates() {
X509Certificate[] rc = null;
SSLContext ssl = this.connection.getSSLContext();
if (null != ssl && (ssl.getNeedClientAuth() || ssl.getWantClientAuth())) {
try {
Object[] objs = ssl.getSession().getPeerCertificates();
if (null != objs) {
rc = (X509Certificate[]) objs;
}
} catch (Throwable t) {
FFDCFilter.processException(t,
getClass().getName(), "peercerts",
new Object[] { this, ssl });
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Error getting peer certs; " + t);
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
if (null == rc) {
Tr.debug(tc, "getPeerCertificates: none");
} else {
Tr.debug(tc, "getPeerCertificates: " + rc.length);
}
}
return rc;
}
|
java
|
public void removeTarget(Object key) throws MatchingException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc,
"removeTarget",
new Object[]{key});
// Remove from the HashMap, with synch, there may be other accessors
synchronized(_targets)
{
Target targ = (Target) _targets.get(key);
if (targ == null)
throw new MatchingException();
for (int i = 0; i < targ.targets.length; i++)
_matchSpace.removeTarget(targ.expr[i], targ.targets[i]);
// Now remove the Target from the cache
_targets.remove(key);
// Remove from the Monitor state, with synch, there may be other accessors
if(targ.targets.length > 0) // Defect 417084, check targets is non-empty
{
if(targ.targets[0] instanceof MonitoredConsumer)
_consumerMonitoring.removeConsumer((MonitoredConsumer)targ.targets[0]);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "removeTarget");
}
|
java
|
public void removeConsumerPointMatchTarget(DispatchableKey consumerPointData)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeConsumerPointMatchTarget", consumerPointData);
// Remove the consumer point from the matchspace
try
{
removeTarget(consumerPointData);
}
catch (MatchingException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.removeConsumerPointMatchTarget",
"1:840:1.117.1.11",
this);
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeConsumerPointMatchTarget", "SICoreException");
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:851:1.117.1.11",
e });
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:859:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeConsumerPointMatchTarget");
}
|
java
|
public ControllableProxySubscription addPubSubOutputHandlerMatchTarget(
PubSubOutputHandler handler,
SIBUuid12 topicSpace,
String discriminator,
boolean foreignSecuredProxy,
String MESubUserId)
throws
SIDiscriminatorSyntaxException,
SISelectorSyntaxException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"addPubSubOutputHandlerMatchTarget",
new Object[] { handler, topicSpace, discriminator, Boolean.valueOf(foreignSecuredProxy), MESubUserId});
// Combine the topicSpace and topic
String topicSpaceStr = topicSpace.toString();
String theTopic = buildAddTopicExpression(topicSpaceStr, discriminator);
ControllableProxySubscription key = new ControllableProxySubscription(handler,
theTopic,
foreignSecuredProxy,
MESubUserId);
// Store the CPS in the MatchSpace
try
{
addTarget(key,
// Use the output handler as key
theTopic,
null, // selector string
null, // selector domain
null, // this'll pick up the default resolver
key, // defect 240115: Store the wrappered PSOH
null,
null); // selector properties
}
catch (QuerySyntaxException e)
{
// No FFDC code needed
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addPubSubOutputHandlerMatchTarget", e);
throw new SISelectorSyntaxException(
nls.getFormattedMessage(
"INVALID_SELECTOR_ERROR_CWSIP0371",
new Object[] { null },
null));
}
catch (InvalidTopicSyntaxException e)
{
// No FFDC code needed
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addPubSubOutputHandlerMatchTarget", e);
throw new SIDiscriminatorSyntaxException(
nls.getFormattedMessage(
"INVALID_TOPIC_ERROR_CWSIP0372",
new Object[] { discriminator },
null));
}
catch (MatchingException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.addPubSubOutputHandlerMatchTarget",
"1:1111:1.117.1.11",
this);
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addPubSubOutputHandlerMatchTarget", e);
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1122:1.117.1.11",
e });
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1130:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addPubSubOutputHandlerMatchTarget", key);
return key;
}
|
java
|
public void removeConsumerDispatcherMatchTarget(ConsumerDispatcher consumerDispatcher, SelectionCriteria selectionCriteria)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"removeConsumerDispatcherMatchTarget",
new Object[] {consumerDispatcher, selectionCriteria});
// Remove the consumer point from the matchspace
// Set the CD and selection criteria into a wrapper that extends MatchTarget
MatchingConsumerDispatcherWithCriteira key = new MatchingConsumerDispatcherWithCriteira (consumerDispatcher,selectionCriteria);
// Reset the CD flag to indicate that this subscription is not in the MatchSpace.
consumerDispatcher.setIsInMatchSpace(false);
try
{
removeTarget(key);
}
catch (MatchingException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.removeConsumerDispatcherMatchTarget",
"1:1312:1.117.1.11",
this);
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeConsumerDispatcherMatchTarget", "SICoreException");
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1323:1.117.1.11",
e });
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1331:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeConsumerDispatcherMatchTarget");
}
|
java
|
public void removePubSubOutputHandlerMatchTarget(
ControllableProxySubscription sub)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removePubSubOutputHandlerMatchTarget", sub);
// Remove the PubSub OutputHandler from the matchspace
try
{
removeTarget(sub);
}
catch (MatchingException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.removePubSubOutputHandlerMatchTarget",
"1:1363:1.117.1.11",
this);
SibTr.exception(tc, e);
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1370:1.117.1.11",
e });
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removePubSubOutputHandlerMatchTarget", "SICoreException");
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1381:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removePubSubOutputHandlerMatchTarget");
}
|
java
|
private String buildSendTopicExpression(
String destName,
String discriminator)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"buildSendTopicExpression",
new Object[] { destName, discriminator });
String combo = null;
if (discriminator == null || discriminator.trim().length() == 0)
combo = destName;
else
combo =
destName
+ MatchSpace.SUBTOPIC_SEPARATOR_CHAR
+ discriminator;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "buildSendTopicExpression", combo);
return combo;
}
|
java
|
public String buildAddTopicExpression(
String destName,
String discriminator) throws SIDiscriminatorSyntaxException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"buildAddTopicExpression",
new Object[] { destName, discriminator });
String combo = null;
if (discriminator == null)
combo =
destName
+ MatchSpace.SUBTOPIC_DOUBLE_SEPARATOR_STOP_STRING;
else if (discriminator.trim().length() == 0)
combo =
destName;
else if (discriminator.startsWith(MatchSpace.SUBTOPIC_DOUBLE_SEPARATOR_STRING))
combo =
destName
+ discriminator;
else if (discriminator.startsWith(""+MatchSpace.SUBTOPIC_SEPARATOR_CHAR))
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "buildAddTopicExpression", "SISelectorSyntaxException");
throw new SIDiscriminatorSyntaxException(
nls.getFormattedMessage(
"INVALID_TOPIC_ERROR_CWSIP0372",
new Object[] { discriminator },
null));
}
else
combo =
destName
+ MatchSpace.SUBTOPIC_SEPARATOR_CHAR
+ discriminator;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "buildAddTopicExpression", combo);
return combo;
}
|
java
|
public ArrayList getAllCDMatchTargets()
{
ArrayList consumerDispatcherList;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getAllCDMatchTargets");
// Get from the HashMap, with synch, there may be other accessors
synchronized(_targets)
{
consumerDispatcherList = new ArrayList(_targets.size());
Iterator itr = _targets.keySet().iterator();
while (itr.hasNext())
{
Object key = itr.next();
if (key instanceof MatchingConsumerDispatcherWithCriteira)
{
consumerDispatcherList.add(((MatchingConsumerDispatcherWithCriteira)key).getConsumerDispatcher());
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getAllCDMatchTargets");
return consumerDispatcherList;
}
|
java
|
public ArrayList getAllCDMatchTargetsForTopicSpace(String tSpace)
{
ArrayList consumerDispatcherList;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getAllCDMatchTargetsForTopicSpace");
// Get from the HashMap, with synch, there may be other accessors
synchronized(_targets)
{
consumerDispatcherList = new ArrayList(_targets.size());
Iterator itr = _targets.keySet().iterator();
while (itr.hasNext())
{
Object key = itr.next();
if (key instanceof MatchingConsumerDispatcherWithCriteira)
{
ConsumerDispatcher cd =(((MatchingConsumerDispatcherWithCriteira)key).getConsumerDispatcher());
String storedDest = cd.getDestination().getName();
if (storedDest.equals(tSpace))
{
consumerDispatcherList.add(cd);
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getAllCDMatchTargetsForTopicSpace");
return consumerDispatcherList;
}
|
java
|
public ArrayList getAllPubSubOutputHandlerMatchTargets()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getAllPubSubOutputHandlerMatchTargets");
ArrayList outputHandlerList;
// Get from the HashMap, with synch, there may be other accessors
synchronized(_targets)
{
outputHandlerList = new ArrayList(_targets.size());
Iterator itr = _targets.keySet().iterator();
while (itr.hasNext())
{
Object key = itr.next();
if (key instanceof ControllableProxySubscription)
outputHandlerList.add(
((ControllableProxySubscription) key).getOutputHandler());
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(
tc,
"getAllPubSubOutputHandlerMatchTargets",
outputHandlerList);
return outputHandlerList;
}
|
java
|
public void addTopicAcl(SIBUuid12 destName, TopicAcl acl)
throws
SIDiscriminatorSyntaxException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "addTopicAcl", new Object[] { destName, acl });
String discriminator = null;
// Postpend # wildcard to the fully qualified topic supplied
// TO DO check the topicsyntax
String theTopic = "";
if(destName != null)
{
String destNameStr = destName.toString();
theTopic = buildAddTopicExpression(destNameStr, acl.getTopic());
}
// Careful, only do this if the original topic is not null
if(acl.getTopic() != null)
{
discriminator = theTopic + "//.";
}
else
{
discriminator = theTopic;
}
// Put the acl into the matchspace
try
{
addTarget(acl, // N.B we use the raw CP as key
discriminator, // wildcarded topic expression
null, // selector string
null, // selector domain
null, // this'll pick up the default resolver
acl,
null,
null); // selector properties
}
catch (QuerySyntaxException e)
{
// No FFDC code needed
}
catch (InvalidTopicSyntaxException e)
{
// No FFDC code needed
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "addTopicAcl", "SIDiscriminatorSyntaxException");
throw new SIDiscriminatorSyntaxException(
nls.getFormattedMessage(
"INVALID_TOPIC_ERROR_CWSIP0372",
new Object[] { theTopic },
null));
}
catch (MatchingException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.addTopicAcl",
"1:1954:1.117.1.11",
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "addTopicAcl", "SIErrorException");
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1962:1.117.1.11",
e });
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:1970:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addTopicAcl");
}
|
java
|
public void removeAllTopicAcls()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeAllTopicAcls");
ArrayList topicAclList = null;
try
{
// Remove from the HashMap, with synch, there may be other accessors
synchronized(_targets)
{
// Build a list of the existing ACLs
topicAclList = new ArrayList(_targets.size());
Iterator itr = _targets.keySet().iterator();
while (itr.hasNext())
{
Object key = itr.next();
if (key instanceof TopicAcl)
{
topicAclList.add(key);
}
}
// Now remove the ACLs from the targets Map
Iterator aclIter = topicAclList.iterator();
while (aclIter.hasNext())
{
Object key = aclIter.next();
removeTarget(key);
}
}
}
catch (MatchingException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.removeAllTopicAcls",
"1:2188:1.117.1.11",
this);
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeAllTopicAcls", "SICoreException");
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:2199:1.117.1.11",
e });
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:2207:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeAllTopicAcls");
}
|
java
|
public void removeApplicationSignatureMatchTarget(ApplicationSignature appSignature)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeApplicationSignatureMatchTarget", appSignature);
// Remove the consumer point from the matchspace
try
{
removeTarget(appSignature);
}
catch (MatchingException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching.removeApplicationSignatureMatchTarget",
"1:3045:1.117.1.11",
this);
SibTr.exception(tc, e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeApplicationSignatureMatchTarget", "SICoreException");
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:3056:1.117.1.11",
e });
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
"1:3064:1.117.1.11",
e },
null),
e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeApplicationSignatureMatchTarget");
}
|
java
|
@Reference(policy = DYNAMIC, policyOption = GREEDY, cardinality = MANDATORY)
protected void setProvider(MetricRecorderProvider provider) {
metricProvider = provider;
}
|
java
|
synchronized public void recover() {
if (tc.isEntryEnabled())
Tr.entry(tc, "recover", this);
final int state = _status.getState();
if (_subordinate) {
// For a subordinate, first check whether the global outcome is known locally.
switch (state) {
// Due to the possibility of recovery being attempted asynchronously to
// an incoming superior request, we must cover the case where the
// transaction has now actually committed already.
case TransactionState.STATE_HEURISTIC_ON_COMMIT:
case TransactionState.STATE_COMMITTED:
case TransactionState.STATE_COMMITTING:
recoverCommit(true);
break;
// Due to the possibility of recovery being attempted asynchronously to
// an incoming superior request, we must cover the case where the
// transaction has now actually rolled back already.
case TransactionState.STATE_HEURISTIC_ON_ROLLBACK:
case TransactionState.STATE_ROLLED_BACK:
case TransactionState.STATE_ROLLING_BACK:
recoverRollback(true);
break;
// For a subordinate, the replay_completion method is invoked on the superior.
// If the number of times the replay_completion has been retried is greater
// than the value specified by COMMITRETRY, then HEURISTICDIRECTION is used
// to determine the transaction outcome.
default:
// If we were imported from a JCA provider, check whether it's still installed.
// If so, we need do nothing here since we expect the RA to complete the transaction.
// Otherwise, we will complete using the configured direction.
if (_JCARecoveryData != null) {
final String id = _JCARecoveryData.getWrapper().getProviderId();
if (TMHelper.isProviderInstalled(id)) {
if (tc.isDebugEnabled())
Tr.debug(tc, "recover", "Do nothing. Expect provider " + id + " will complete.");
// Do nothing. RA is responsible for completing.
} else {
switch (_configProvider.getHeuristicCompletionDirection()) {
case ConfigurationProvider.HEURISTIC_COMPLETION_DIRECTION_COMMIT:
Tr.error(tc, "WTRN0098_COMMIT_RA_UNINSTALLED", new Object[] { getTranName(), id });
recoverCommit(false);
break;
case ConfigurationProvider.HEURISTIC_COMPLETION_DIRECTION_MANUAL:
// do nothing, administrative completion is required
_needsManualCompletion = true;
Tr.info(tc, "WTRN0101_MANUAL_RA_UNINSTALLED", new Object[] { getTranName(), id });
break;
default:
Tr.error(tc, "WTRN0099_ROLLBACK_RA_UNINSTALLED", new Object[] { getTranName(), id });
recoverRollback(false);
}
}
} else {
retryCompletion();
}
break;
}
} else {
// For a top-level Transaction, we will only recover in the case
// where we have successfully prepared. If the state is not committing,
// then assume it is rollback.
if (state == TransactionState.STATE_LAST_PARTICIPANT) {
// LIDB1673-13 lps heuristic completion.
// The transaction was attempting to complete its
// 1PC resource when the server went down.
// Use the lpsHeuristicCompletion flag to determine
// how to complete the tx.
switch (ConfigurationProviderManager.getConfigurationProvider().getHeuristicCompletionDirection()) {
case ConfigurationProvider.HEURISTIC_COMPLETION_DIRECTION_COMMIT:
Tr.error(tc, "WTRN0096_HEURISTIC_MAY_HAVE_OCCURED", getTranName());
recoverCommit(false);
break;
case ConfigurationProvider.HEURISTIC_COMPLETION_DIRECTION_MANUAL:
// do nothing!?
_needsManualCompletion = true;
Tr.info(tc, "WTRN0097_HEURISTIC_MANUAL_COMPLETION", getTranName());
break;
default:
Tr.error(tc, "WTRN0102_HEURISTIC_MAY_HAVE_OCCURED", getTranName());
recoverRollback(false);
}
} else if (state == TransactionState.STATE_COMMITTING)
recoverCommit(false);
else
recoverRollback(false);
}
if (tc.isEntryEnabled())
Tr.exit(tc, "recover");
}
|
java
|
@Override
public void commit() throws RollbackException, HeuristicMixedException, HeuristicRollbackException, SecurityException, IllegalStateException, SystemException {
if (tc.isEntryEnabled())
Tr.entry(tc, "commit (SPI)");
try {
processCommit();
} catch (HeuristicHazardException hhe) {
// Only throw heuristic hazard in the one phase case
// modify the heuristic - note JTA 1.0.1 errata implies this may be reconsidered one day
final HeuristicMixedException hme = new HeuristicMixedException(hhe.getLocalizedMessage());
hme.initCause(hhe.getCause()); //Set the cause to be the cause of the HeuristicHazardException
if (tc.isEntryEnabled())
Tr.exit(tc, "commit", hme);
throw hme;
} finally {
if (tc.isEntryEnabled())
Tr.exit(tc, "commit (SPI)");
}
}
|
java
|
public void commit_one_phase() throws RollbackException, HeuristicMixedException, HeuristicHazardException, HeuristicRollbackException, SecurityException, IllegalStateException, SystemException {
if (tc.isEntryEnabled())
Tr.entry(tc, "commit_one_phase");
// This call is only valid for a single subordinate - treat as a "superior"
_subordinate = false;
try {
processCommit();
} finally {
if (tc.isEntryEnabled())
Tr.exit(tc, "commit_one_phase");
}
}
|
java
|
@Override
public void rollback() throws IllegalStateException, SystemException {
if (tc.isEntryEnabled())
Tr.entry(tc, "rollback (SPI)");
final int state = _status.getState();
//
// We are only called in this method for superiors.
//
if (state == TransactionState.STATE_ACTIVE) {
//
// Cancel timeout prior to completion phase
//
cancelAlarms();
try {
_status.setState(TransactionState.STATE_ROLLING_BACK);
} catch (SystemException se) {
FFDCFilter.processException(se, "com.ibm.tx.jta.TransactionImpl.rollback", "1587", this);
if (tc.isDebugEnabled())
Tr.debug(tc, "Exception caught setting state to ROLLING_BACK!", se);
if (tc.isEntryEnabled())
Tr.exit(tc, "rollback (SPI)");
throw se;
}
try {
internalRollback();
} catch (HeuristicMixedException hme) {
if (tc.isDebugEnabled())
Tr.debug(tc, "HeuristicMixedException caught rollback processing", hme);
// state change handled by notifyCompletion
// Add to list of heuristically completed transactions
addHeuristic();
} catch (HeuristicHazardException hhe) {
if (tc.isDebugEnabled())
Tr.debug(tc, "HeuristicHazardException caught rollback processing", hhe);
// state change handled by notifyCompletion
// Add to list of heuristically completed transactions
addHeuristic();
} catch (HeuristicCommitException hce) {
if (tc.isDebugEnabled())
Tr.debug(tc, "HeuristicHazardException caught rollback processing", hce);
// state change handled by notifyCompletion
// Add to list of heuristically completed transactions
addHeuristic();
} catch (SystemException se) {
FFDCFilter.processException(se, "com.ibm.tx.jta.TransactionImpl.rollback", "1626", this);
if (tc.isEventEnabled())
Tr.event(tc, "SystemException caught during rollback", se);
if (tc.isEntryEnabled())
Tr.exit(tc, "rollback (SPI)");
throw se;
} catch (Throwable ex) {
FFDCFilter.processException(ex, "com.ibm.tx.jta.TransactionImpl.rollback", "1633", this);
if (tc.isEventEnabled())
Tr.event(tc, "Exception caught during rollback", ex);
if (tc.isEntryEnabled())
Tr.exit(tc, "rollback (SPI)");
throw new SystemException(ex.getLocalizedMessage());
} finally {
notifyCompletion();
}
}
//
// Defect 1440
//
// We are not in ACTIVE state so we need to
// throw the appropriate exception.
//
else if (state == TransactionState.STATE_NONE) {
if (tc.isEventEnabled())
Tr.event(tc, "No transaction available!");
if (tc.isEntryEnabled())
Tr.exit(tc, "rollback (SPI)");
throw new IllegalStateException();
} else {
if (tc.isEventEnabled())
Tr.event(tc, "Invalid transaction state:" + state);
if (tc.isEntryEnabled())
Tr.exit(tc, "rollback (SPI)");
throw new SystemException();
}
if (tc.isEntryEnabled())
Tr.exit(tc, "rollback (SPI)");
}
|
java
|
protected void setPrepareXAFailed() // d266464A
{
if (tc.isEntryEnabled())
Tr.entry(tc, "setPrepareXAFailed");
setRBO(); // Ensure native context is informed
if (tc.isEntryEnabled())
Tr.exit(tc, "setPrepareXAFailed");
}
|
java
|
protected boolean prePrepare() {
if (tc.isEntryEnabled())
Tr.entry(tc, "prePrepare");
//
// Cancel timeout prior to completion phase
//
cancelAlarms();
//
// Inform the Synchronisations we are about to complete
//
if (!_rollbackOnly) {
if (_syncs != null) {
_syncs.distributeBefore();
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "prePrepare", !_rollbackOnly);
return !_rollbackOnly;
}
|
java
|
protected boolean distributeEnd() throws SystemException {
if (tc.isEntryEnabled())
Tr.entry(tc, "distributeEnd");
if (!getResources().distributeEnd(XAResource.TMSUCCESS)) {
setRBO();
}
if (_rollbackOnly) {
try {
_status.setState(TransactionState.STATE_ROLLING_BACK);
} catch (SystemException se) {
FFDCFilter.processException(se, "com.ibm.tx.jta.TransactionImpl.distributeEnd", "1731", this);
if (tc.isEntryEnabled())
Tr.exit(tc, "distributeEnd", se);
throw se;
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "distributeEnd", !_rollbackOnly);
return !_rollbackOnly;
}
|
java
|
public Throwable getOriginalException() {
if (tc.isEntryEnabled())
Tr.entry(tc, "getOriginalException");
if (tc.isEntryEnabled())
Tr.exit(tc, "getOriginalException", _originalException);
return _originalException;
}
|
java
|
@Override
public void setRollbackOnly() throws IllegalStateException {
if (tc.isEntryEnabled())
Tr.entry(tc, "setRollbackOnly (SPI)");
final int state = _status.getState();
if (state == TransactionState.STATE_NONE ||
state == TransactionState.STATE_COMMITTED ||
state == TransactionState.STATE_ROLLED_BACK) {
if (tc.isEntryEnabled())
Tr.exit(tc, "setRollbackOnly (SPI)");
throw new IllegalStateException("No transaction available");
}
setRBO();
if (tc.isEntryEnabled())
Tr.exit(tc, "setRollbackOnly (SPI)");
}
|
java
|
public void enlistResource(JTAResource remoteRes) {
if (tc.isEntryEnabled())
Tr.entry(tc, "enlistResource (SPI): args: ", remoteRes);
getResources().addRes(remoteRes);
if (tc.isEntryEnabled())
Tr.exit(tc, "enlistResource (SPI)");
}
|
java
|
protected void logHeuristic(boolean commit) throws SystemException {
if (tc.isEntryEnabled())
Tr.entry(tc, "logHeuristic", commit);
if (_subordinate && _status.getState() != TransactionState.STATE_PREPARING) {
getResources().logHeuristic(commit);
}
if (tc.isEntryEnabled())
Tr.exit(tc, "logHeuristic");
}
|
java
|
@Override
public int getStatus() {
int state = Status.STATUS_UNKNOWN;
switch (_status.getState()) {
case TransactionState.STATE_NONE:
state = Status.STATUS_NO_TRANSACTION;
break;
case TransactionState.STATE_ACTIVE:
if (_rollbackOnly)
state = Status.STATUS_MARKED_ROLLBACK;
else
state = Status.STATUS_ACTIVE;
break;
case TransactionState.STATE_PREPARING:
case TransactionState.STATE_LAST_PARTICIPANT:
state = Status.STATUS_PREPARING;
break;
case TransactionState.STATE_PREPARED:
state = Status.STATUS_PREPARED;
break;
case TransactionState.STATE_COMMITTING:
case TransactionState.STATE_COMMITTING_ONE_PHASE:
state = Status.STATUS_COMMITTING;
break;
case TransactionState.STATE_HEURISTIC_ON_COMMIT:
case TransactionState.STATE_COMMITTED:
state = Status.STATUS_COMMITTED;
break;
case TransactionState.STATE_ROLLING_BACK:
state = Status.STATUS_ROLLING_BACK;
break;
case TransactionState.STATE_HEURISTIC_ON_ROLLBACK:
case TransactionState.STATE_ROLLED_BACK:
state = Status.STATUS_ROLLEDBACK;
break;
}
if (tc.isDebugEnabled())
Tr.debug(tc, "getStatus (SPI)", Util.printStatus(state));
return state;
}
|
java
|
public XidImpl getXidImpl(boolean createIfAbsent) {
if (tc.isEntryEnabled())
Tr.entry(tc, "getXidImpl", new Object[] { this, createIfAbsent });
if (createIfAbsent && (_xid == null)) {
// Create an XID as this transaction identifier.
_xid = new XidImpl(new TxPrimaryKey(_localTID, Configuration.getCurrentEpoch()));
}
if (tc.isEntryEnabled())
Tr.exit(tc, "getXidImpl", _xid);
return (XidImpl) _xid;
}
|
java
|
public void setXidImpl(XidImpl xid) {
if (tc.isDebugEnabled())
Tr.debug(tc, "setXidImpl", new Object[] { xid, this });
_xid = xid;
}
|
java
|
public boolean isJCAImportedAndPrepared(String providerId) {
return _JCARecoveryData != null &&
_status.getState() == TransactionState.STATE_PREPARED &&
_JCARecoveryData.getWrapper().getProviderId().equals(providerId);
}
|
java
|
public void loadKeyStores(Map<String, WSKeyStore> config) {
// now process each keystore in the provided config
for (Entry<String, WSKeyStore> current : config.entrySet()) {
try {
String name = current.getKey();
WSKeyStore keystore = current.getValue();
addKeyStoreToMap(name, keystore);
} catch (Exception e) {
FFDCFilter.processException(e, getClass().getName(), "loadKeyStores", new Object[] { this, config });
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Error loading keystore; " + current.getKey() + " " + e);
}
}
}
}
|
java
|
public InputStream getInputStream(String fileName, boolean create) throws MalformedURLException, IOException {
try {
GetKeyStoreInputStreamAction action = new GetKeyStoreInputStreamAction(fileName, create);
return AccessController.doPrivileged(action);
} catch (PrivilegedActionException e) {
Exception ex = e.getException();
FFDCFilter.processException(e, getClass().getName(), "getInputStream", new Object[] { fileName, Boolean.valueOf(create), this });
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception opening keystore; " + ex);
if (ex instanceof MalformedURLException)
throw (MalformedURLException) ex;
else if (ex instanceof IOException)
throw (IOException) ex;
throw new IOException(ex.getMessage());
}
}
|
java
|
public OutputStream getOutputStream(String fileName) throws MalformedURLException, IOException {
try {
GetKeyStoreOutputStreamAction action = new GetKeyStoreOutputStreamAction(fileName);
return AccessController.doPrivileged(action);
} catch (PrivilegedActionException e) {
Exception ex = e.getException();
FFDCFilter.processException(e, getClass().getName(), "getOutputStream", new Object[] { fileName, this });
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception opening keystore; " + ex);
if (ex instanceof MalformedURLException)
throw (MalformedURLException) ex;
else if (ex instanceof IOException)
throw (IOException) ex;
throw new IOException(ex.getMessage());
}
}
|
java
|
public static String stripLastSlash(String inputString) {
if (null == inputString) {
return null;
}
String rc = inputString.trim();
int len = rc.length();
if (0 < len) {
char lastChar = rc.charAt(len - 1);
if ('/' == lastChar || '\\' == lastChar) {
rc = rc.substring(0, len - 1);
}
}
return rc;
}
|
java
|
public KeyStore getJavaKeyStore(String keyStoreName) throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "getJavaKeyStore: " + keyStoreName);
if (keyStoreName == null || keyStoreName.trim().isEmpty()) {
throw new SSLException("No keystore name provided.");
}
KeyStore javaKeyStore = null;
WSKeyStore ks = keyStoreMap.get(keyStoreName);
if (ks != null) {
javaKeyStore = ks.getKeyStore(false, false);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "getJavaKeyStore: " + javaKeyStore);
return javaKeyStore;
}
|
java
|
public WSKeyStore getWSKeyStore(String keyStoreName) throws SSLException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "getWSKeyStore: " + keyStoreName);
if (keyStoreName == null) {
throw new SSLException("No keystore name provided.");
}
WSKeyStore ks = keyStoreMap.get(keyStoreName);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "getWSKeyStore: " + ks);
return ks;
}
|
java
|
@Override
public Set<String> getDependentApplications() {
Set<String> appsToStop = new HashSet<String>(applications);
applications.clear();
return appsToStop;
}
|
java
|
@Trivial // do our own trace in order to selectively include the value
private <T extends Object> void set(Class<?> clazz, Object clientBuilder, String name, Class<T> type, T value) throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, name + '(' + (name.endsWith("ssword") ? "***" : value) + ')');
Method m;
// timeout properties take an additional parm for time unit
if ((type == long.class) && ((READ_TIMEOUT.equals(name) || CONNECT_TIMEOUT.equals(name)))) {
m = clazz.getMethod(name, type, TimeUnit.class);
m.invoke(clientBuilder, value, TimeUnit.MILLISECONDS);
} else {
m = clazz.getMethod(name, type);
m.invoke(clientBuilder, value);
}
}
|
java
|
@Override
public void libraryNotification() {
// Notify the application recycle coordinator of an incompatible change that requires restarting the application
if (!applications.isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "recycle applications", applications);
ApplicationRecycleCoordinator appRecycleCoord = (ApplicationRecycleCoordinator) componentContext.locateService("appRecycleCoordinator");
Set<String> members = new HashSet<String>(applications);
applications.removeAll(members);
appRecycleCoord.recycleApplications(members);
}
}
|
java
|
public Object getCloudantClient(int resAuth, List<? extends ResourceInfo.Property> loginPropertyList) throws Exception {
AuthData containerAuthData = null;
if (resAuth == ResourceInfo.AUTH_CONTAINER) {
containerAuthData = getContainerAuthData(loginPropertyList);
}
String userName = containerAuthData == null ? (String) props.get(USERNAME) : containerAuthData.getUserName();
String password = null;
if (containerAuthData == null) {
SerializableProtectedString protectedPwd = (SerializableProtectedString) props.get(PASSWORD);
if (protectedPwd != null) {
password = String.valueOf(protectedPwd.getChars());
password = PasswordUtil.getCryptoAlgorithm(password) == null ? password : PasswordUtil.decode(password);
}
} else
password = String.valueOf(containerAuthData.getPassword());
final ClientKey key = new ClientKey(null, userName, password);
return clients.get(key);
}
|
java
|
public synchronized void waitOn() throws InterruptedException
{
if (tc.isEntryEnabled()) SibTr.entry(tc, "waitOn", ""+count);
++count;
if (count > 0)
{
try
{
wait();
}
catch(InterruptedException e)
{
// No FFDC code needed
--count;
throw e;
}
}
if (tc.isEntryEnabled()) SibTr.exit(tc, "waitOn");
}
|
java
|
public synchronized void post()
{
if (tc.isEntryEnabled()) SibTr.entry(tc, "post", ""+count);
--count;
if (count >= 0)
notify();
if (tc.isEntryEnabled()) SibTr.exit(tc, "post");
}
|
java
|
public synchronized void waitOnIgnoringInterruptions()
{
if (tc.isEntryEnabled()) SibTr.entry(tc, "waitOnIgnoringInterruptions");
boolean interrupted;
do
{
interrupted = false;
try
{
waitOn();
}
catch (InterruptedException e)
{
// No FFDC code needed
interrupted = true;
}
}
while(interrupted);
if (tc.isEntryEnabled()) SibTr.exit(tc, "waitOnIgnoringInterruptions");
}
|
java
|
protected void setMemberFactories(FaceletCache.MemberFactory<V> faceletFactory,
FaceletCache.MemberFactory<V> viewMetadataFaceletFactory,
FaceletCache.MemberFactory<V> compositeComponentMetadataFaceletFactory)
{
if (compositeComponentMetadataFaceletFactory == null)
{
throw new NullPointerException("viewMetadataFaceletFactory is null");
}
_compositeComponentMetadataFaceletFactory = compositeComponentMetadataFaceletFactory;
setMemberFactories(faceletFactory, viewMetadataFaceletFactory);
}
|
java
|
@Override
public void close() throws IOException
{
if(this.in != null && this.inStream != null){
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {
logger.logp(Level.FINE, CLASS_NAME,"close", "close called->"+this);
}
this.in.close();
}
else{
super.close();
}
}
|
java
|
@Override
public ArtifactContainer createContainer(File cacheDir, Object containerData) {
if ( !(containerData instanceof File) ) {
return null;
}
File fileContainerData = (File) containerData;
if ( !FileUtils.fileIsFile(fileContainerData) ) {
return null;
}
if ( !isZip(fileContainerData) ) {
return null;
}
return new ZipFileContainer(cacheDir, fileContainerData, this);
}
|
java
|
@Override
public ArtifactContainer createContainer(
File cacheDir,
ArtifactContainer enclosingContainer,
ArtifactEntry entryInEnclosingContainer,
Object containerData) {
if ( (containerData instanceof File) && FileUtils.fileIsFile((File) containerData) ) {
File fileContainerData = (File) containerData;
if ( isZip(fileContainerData) ) {
return new ZipFileContainer(
cacheDir,
enclosingContainer, entryInEnclosingContainer,
fileContainerData,
this);
} else {
return null;
}
} else {
if ( isZip(entryInEnclosingContainer) ) {
return new ZipFileContainer(
cacheDir,
enclosingContainer, entryInEnclosingContainer,
null,
this);
} else {
return null;
}
}
}
|
java
|
private static boolean hasZipExtension(String name) {
int nameLen = name.length();
// Need '.' plus at least three characters.
if ( nameLen < 4 ) {
return false;
}
// Need '.' plus at least six characters for ".spring".
if ( nameLen >= 7 ) {
if ( (name.charAt(nameLen - 7) == '.') &&
name.regionMatches(IGNORE_CASE, nameLen - 6, ZIP_EXTENSION_SPRING, 0, 6) ) {
return true;
}
}
if ( name.charAt(nameLen - 4) != '.' ) {
return false;
} else {
for ( String ext : ZIP_EXTENSIONS ) {
if ( name.regionMatches(IGNORE_CASE, nameLen - 3, ext, 0, 3) ) { // ignore case
return true;
}
}
return false;
}
// return name.matches("(?i:(.*)\\.(ZIP|[SEJRW]AR|E[BS]A|SPRING))");
}
|
java
|
private static boolean isZip(ArtifactEntry artifactEntry) {
if ( !hasZipExtension( artifactEntry.getName() ) ) {
return false;
}
boolean validZip = false;
InputStream entryInputStream = null;
try {
entryInputStream = artifactEntry.getInputStream();
if ( entryInputStream == null ) {
return false;
}
ZipInputStream zipInputStream = new ZipInputStream(entryInputStream);
try {
ZipEntry entry = zipInputStream.getNextEntry();
if ( entry == null ) {
Tr.error(tc, "bad.zip.data", getPhysicalPath(artifactEntry));
} else {
validZip = true;
}
} catch ( IOException e ) {
String entryPath = getPhysicalPath(artifactEntry);
Tr.error(tc, "bad.zip.data", entryPath);
}
try {
// attempt to close the zip, ignoring any error because we can't recover.
zipInputStream.close();
} catch (IOException ioe) {
// FFDC
}
} catch ( IOException e1 ) {
// FFDC
return false;
}
return validZip;
}
|
java
|
@SuppressWarnings("deprecation")
private static String getPhysicalPath(ArtifactEntry artifactEntry) {
String physicalPath = artifactEntry.getPhysicalPath();
if ( physicalPath != null ) {
return physicalPath;
}
String entryPath = artifactEntry.getPath();
String rootPath = artifactEntry.getRoot().getPhysicalPath();
if ( rootPath != null ) {
return rootPath + "!" + entryPath;
}
while ( (artifactEntry = artifactEntry.getRoot().getEntryInEnclosingContainer()) != null ) {
String nextPhysicalPath = artifactEntry.getPhysicalPath();
if ( nextPhysicalPath != null ) {
return nextPhysicalPath + "!" + entryPath;
}
entryPath = artifactEntry.getPath() + "!" + entryPath;
}
return entryPath;
}
|
java
|
@FFDCIgnore( { IOException.class, FileNotFoundException.class } )
private static boolean isZip(File file) {
if ( !hasZipExtension( file.getName() ) ) {
return false;
}
InputStream inputStream = null;
try {
inputStream = new FileInputStream(file); // throws FileNotFoundException
ZipInputStream zipInputStream = new ZipInputStream(inputStream);
try {
ZipEntry entry = zipInputStream.getNextEntry(); // throws IOException
if ( entry == null ) {
Tr.error(tc, "bad.zip.data", file.getAbsolutePath());
return false;
}
return true;
} catch ( IOException e ) {
Tr.error(tc, "bad.zip.data", file.getAbsolutePath());
return false;
}
} catch ( FileNotFoundException e ) {
Tr.error(tc, "Missing zip file " + file.getAbsolutePath());
return false;
} finally {
if ( inputStream != null ) {
try {
inputStream.close();
} catch ( IOException e ) {
// IGNORE
}
}
}
}
|
java
|
public static UpdatedFile fromNode(Node n) {
String id = n.getAttributes().getNamedItem("id") == null ? null : n.getAttributes().getNamedItem("id").getNodeValue();
long size = n.getAttributes().getNamedItem("size") == null ? null : Long.parseLong(n.getAttributes().getNamedItem("size").getNodeValue());
String date = n.getAttributes().getNamedItem("date") == null ? null : n.getAttributes().getNamedItem("date").getNodeValue();
String hash = n.getAttributes().getNamedItem("hash") == null ? n.getAttributes().getNamedItem("MD5hash") == null ? null : n.getAttributes().getNamedItem("MD5hash").getNodeValue() : n.getAttributes().getNamedItem("hash").getNodeValue();
return new UpdatedFile(id, size, date, hash);
}
|
java
|
@Override
public void serverStopping() {
BundleContext bundleContext = componentContext.getBundleContext();
Collection<ServiceReference<EndpointActivationService>> refs;
try {
refs = bundleContext.getServiceReferences(EndpointActivationService.class, null);
} catch (InvalidSyntaxException x) {
FFDCFilter.processException(x, getClass().getName(), "61", this);
throw new RuntimeException(x);
}
for (ServiceReference<EndpointActivationService> ref : refs) {
EndpointActivationService eas = bundleContext.getService(ref);
try {
for (ActivationParams a; null != (a = eas.endpointActivationParams.poll());)
try {
eas.endpointDeactivation((ActivationSpec) a.activationSpec, a.messageEndpointFactory);
} catch (Throwable x) {
FFDCFilter.processException(x, getClass().getName(), "71", this);
}
} finally {
bundleContext.ungetService(ref);
}
}
}
|
java
|
public boolean filterMatches(AbstractItem item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "filterMatches", item);
/* Cast the incoming item to a PersistentStoreReferenceStream object. if it is not, an
* exception will be thrown and the match will fail */
SIMPReferenceStream rstream;
if (item instanceof SIMPReferenceStream) {
rstream = (SIMPReferenceStream) item;
// Check for matching consumer dispatchers
if (rstream == consumerDispatcher.getReferenceStream())
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.TRUE);
return true;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.FALSE);
return false;
}
|
java
|
private ValidatorFactory createValidatorFactory(FacesContext context)
{
Map<String, Object> applicationMap = context.getExternalContext().getApplicationMap();
Object attr = applicationMap.get(VALIDATOR_FACTORY_KEY);
if (attr instanceof ValidatorFactory)
{
return (ValidatorFactory) attr;
}
else
{
synchronized (this)
{
if (_ExternalSpecifications.isBeanValidationAvailable())
{
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
applicationMap.put(VALIDATOR_FACTORY_KEY, factory);
return factory;
}
else
{
throw new FacesException("Bean Validation is not present");
}
}
}
}
|
java
|
private void postSetValidationGroups()
{
if (this.validationGroups == null || this.validationGroups.matches(EMPTY_VALIDATION_GROUPS_PATTERN))
{
this.validationGroupsArray = DEFAULT_VALIDATION_GROUPS_ARRAY;
}
else
{
String[] classes = this.validationGroups.split(VALIDATION_GROUPS_DELIMITER);
List<Class<?>> validationGroupsList = new ArrayList<Class<?>>(classes.length);
for (String clazz : classes)
{
clazz = clazz.trim();
if (!clazz.isEmpty())
{
Class<?> theClass = null;
ClassLoader cl = null;
if (System.getSecurityManager() != null)
{
try
{
cl = AccessController.doPrivileged(new PrivilegedExceptionAction<ClassLoader>()
{
public ClassLoader run() throws PrivilegedActionException
{
return Thread.currentThread().getContextClassLoader();
}
});
}
catch (PrivilegedActionException pae)
{
throw new FacesException(pae);
}
}
else
{
cl = Thread.currentThread().getContextClassLoader();
}
try
{
// Try WebApp ClassLoader first
theClass = Class.forName(clazz,false,cl);
}
catch (ClassNotFoundException ignore)
{
try
{
// fallback: Try ClassLoader for BeanValidator (i.e. the myfaces.jar lib)
theClass = Class.forName(clazz,false, BeanValidator.class.getClassLoader());
}
catch (ClassNotFoundException e)
{
throw new RuntimeException("Could not load validation group", e);
}
}
// the class was found
validationGroupsList.add(theClass);
}
}
this.validationGroupsArray = validationGroupsList.toArray(new Class[validationGroupsList.size()]);
}
}
|
java
|
public void setEnumerators(String[] val) {
enumerators = val;
enumeratorCount = (enumerators != null) ? enumerators.length : 0;
}
|
java
|
public void encodeType(byte[] frame, int[] limits) {
setByte(frame, limits, (byte)ENUM);
setCount(frame, limits, enumeratorCount);
}
|
java
|
public void format(StringBuffer fmt, Set done, Set todo, int indent) {
formatName(fmt, indent);
fmt.append("Enum");
if (enumerators != null) {
fmt.append("{{");
String delim = "";
for (int i = 0; i < enumerators.length; i++) {
fmt.append(delim).append(enumerators[i]);
delim = ",";
}
fmt.append("}}");
}
}
|
java
|
public static _ValueReferenceWrapper resolve(ValueExpression valueExpression, final ELContext elCtx)
{
_ValueReferenceResolver resolver = new _ValueReferenceResolver(elCtx.getELResolver());
ELContext elCtxDecorator = new _ELContextDecorator(elCtx, resolver);
valueExpression.getValue(elCtxDecorator);
while (resolver.lastObject.getBase() instanceof CompositeComponentExpressionHolder)
{
valueExpression = ((CompositeComponentExpressionHolder) resolver.lastObject.getBase())
.getExpression((String) resolver.lastObject.getProperty());
valueExpression.getValue(elCtxDecorator);
}
return resolver.lastObject;
}
|
java
|
@Override
public Object getValue(final ELContext context, final Object base, final Object property)
{
lastObject = new _ValueReferenceWrapper(base, property);
return resolver.getValue(context, base, property);
}
|
java
|
private boolean isApplicationException(Throwable ex, EJBMethodInfoImpl methodInfo) {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "isApplicationException : " + ex.getClass().getName() + ", " + methodInfo);
// d660332
if (ex instanceof Exception && (!ContainerProperties.DeclaredUncheckedAreSystemExceptions || !(ex instanceof RuntimeException))) {
Class<?>[] declaredExceptions = null;
// Checks if the method interface is business or component.
// If it's a component interface, there is only one interface to worry about // d734957
if (ivInterface == WrapperInterface.LOCAL || ivInterface == WrapperInterface.REMOTE) {
declaredExceptions = methodInfo.ivDeclaredExceptionsComp;
} else {
// Determine if there were any declared exceptions for the method
// interface being used. However, if the wrapper is an aggregate
// wrapper (all interfaces), then just find the first set of
// non-null declared exceptions. It is possible (thought not likely)
// this could result in odd behavior, but a warning was logged
// when the wrapper class was created. F743-34304
if (ivBusinessInterfaceIndex == AGGREGATE_LOCAL_INDEX) {
for (Class<?>[] declaredEx : methodInfo.ivDeclaredExceptions) {
if (declaredEx != null) {
declaredExceptions = declaredEx;
break;
}
}
} else {
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "ivBusinessInterfaceIndex=" + ivBusinessInterfaceIndex);
declaredExceptions = methodInfo.ivDeclaredExceptions[ivBusinessInterfaceIndex]; // F743-24429
}
}
if (declaredExceptions != null) {
for (Class<?> declaredException : declaredExceptions) {
if (declaredException.isAssignableFrom(ex.getClass())) {
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "isApplicationException : true");
return true;
}
}
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "isApplicationException : false");
return false;
}
|
java
|
synchronized protected void addMessagingEngine(
final JsMessagingEngine messagingEngine) {
final String methodName = "addMessagingEngine";
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.entry(this, TRACE, methodName, messagingEngine);
}
SibRaMessagingEngineConnection connection = null;
try {
/*
* Get a connection for the messaging engine
*/
connection = getConnection(messagingEngine);
final SICoreConnection coreConnection = connection.getConnection();
if (coreConnection instanceof SICoreConnection) {
/*
* Create destination listener
*/
final DestinationListener destinationListener = new SibRaDestinationListener(
connection, _messageEndpointFactory);
/*
* Determine destination type
*/
final DestinationType destinationType = _endpointConfiguration
.getDestinationType();
/*
* Register destination listener
*/
final SIDestinationAddress[] destinations = coreConnection
.addDestinationListener(null,
destinationListener,
destinationType,
DestinationAvailability.RECEIVE);
/*
* Create a listener for each destination ...
*/
for (int j = 0; j < destinations.length; j++) {
try {
connection.createListener(destinations[j], _messageEndpointFactory);
} catch (final ResourceException exception) {
FFDCFilter.processException(exception, CLASS_NAME + "."
+ methodName, FFDC_PROBE_1, this);
SibTr.error(TRACE, "CREATE_LISTENER_FAILED_CWSIV0803",
new Object[] { exception,
destinations[j].getDestinationName(),
messagingEngine.getName(),
messagingEngine.getBusName() });
}
}
}
} catch (final SIException exception) {
FFDCFilter.processException(exception, CLASS_NAME + "."
+ methodName, FFDC_PROBE_2, this);
SibTr.error(TRACE, "ADD_DESTINATION_LISTENER_FAILED_CWSIV0804",
new Object[] { exception, messagingEngine.getName(),
messagingEngine.getBusName() });
closeConnection(messagingEngine);
} catch (final ResourceException exception) {
FFDCFilter.processException(exception, CLASS_NAME + "."
+ methodName, FFDC_PROBE_3, this);
SibTr.error(TRACE, "CREATE_CONNECTION_FAILED_CWSIV0801",
new Object[] { exception, messagingEngine.getName(),
messagingEngine.getBusName() });
closeConnection(messagingEngine);
}
if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
SibTr.exit(this, TRACE, methodName);
}
}
|
java
|
public void addNotfication(Notification notification) {
Object source = notification.getSource();
NotificationRecord nr;
if (source instanceof ObjectName) {
nr = new NotificationRecord(notification, (ObjectName) source);
} else {
nr = new NotificationRecord(notification, (source != null) ? source.toString() : null);
}
addNotficationRecord(nr);
}
|
java
|
public void addClientNotificationListener(RESTRequest request, NotificationRegistration notificationRegistration, JSONConverter converter) {
String objectNameStr = notificationRegistration.objectName.getCanonicalName();
NotificationTargetInformation nti = toNotificationTargetInformation(request, objectNameStr);
// Get the listener
ClientNotificationListener listener = listeners.get(nti);
if (listener == null) {
listener = new ClientNotificationListener(this);
ClientNotificationListener mapListener = listeners.putIfAbsent(nti, listener);
if (mapListener != null) {
listener = mapListener;
}
}
// Grab the wrapper filter which will be registered in the MBeanServer
NotificationFilter filter = listener.getClientWrapperFilter();
// Check whether the producer of the notification is local or remote.
if (nti.getRoutingInformation() == null) {
// Add the notification in the MBeanServer
MBeanServerHelper.addClientNotification(notificationRegistration.objectName,
listener,
filter,
null,
converter);
} else {
// Add the notification listener to the Target-Client Manager through EventAdmin
MBeanRoutedNotificationHelper helper = MBeanRoutedNotificationHelper.getMBeanRoutedNotificationHelper();
helper.addRoutedNotificationListener(nti, listener, converter);
}
// Add the filters to the listener
listener.addClientNotification(notificationRegistration.filters);
}
|
java
|
public void updateClientNotificationListener(RESTRequest request, String objectNameStr, NotificationFilter[] filters, JSONConverter converter) {
NotificationTargetInformation nti = toNotificationTargetInformation(request, objectNameStr);
ClientNotificationListener listener = listeners.get(nti);
if (listener == null) {
throw ErrorHelper.createRESTHandlerJsonException(new RuntimeException("There are no listeners registered for " + nti), converter, APIConstants.STATUS_BAD_REQUEST);
}
//Make the update
listener.addClientNotification(filters);
}
|
java
|
private Object removeObject(Integer key) {
if (key == null) {
return null;
}
return objectLibrary.remove(key);
}
|
java
|
public void removeClientNotificationListener(RESTRequest request, ObjectName name) {
NotificationTargetInformation nti = toNotificationTargetInformation(request, name.getCanonicalName());
// Remove locally
ClientNotificationListener listener = listeners.remove(nti);
// Check whether the producer of the notification is local or remote.
if (nti.getRoutingInformation() == null) {
// Remove the notification from the MBeanServer
MBeanServerHelper.removeClientNotification(name, listener);
} else {
// Remove the notification listener from the Target-Client Manager through EventAdmin
MBeanRoutedNotificationHelper helper = MBeanRoutedNotificationHelper.getMBeanRoutedNotificationHelper();
helper.removeRoutedNotificationListener(nti, listener);
}
}
|
java
|
public void addServerNotificationListener(RESTRequest request, ServerNotificationRegistration serverNotificationRegistration, JSONConverter converter) {
NotificationTargetInformation nti = toNotificationTargetInformation(request, serverNotificationRegistration.objectName.getCanonicalName());
//Fetch the filter/handback objects
NotificationFilter filter = (NotificationFilter) getObject(serverNotificationRegistration.filterID, serverNotificationRegistration.filter, converter);
Object handback = getObject(serverNotificationRegistration.handbackID, serverNotificationRegistration.handback, converter);
// Check whether the producer of the notification is local or remote.
if (nti.getRoutingInformation() == null) {
//Add to the MBeanServer
MBeanServerHelper.addServerNotification(serverNotificationRegistration.objectName,
serverNotificationRegistration.listener,
filter,
handback,
converter);
} else {
// Add the notification listener to the Target-Client Manager through EventAdmin
MBeanRoutedNotificationHelper helper = MBeanRoutedNotificationHelper.getMBeanRoutedNotificationHelper();
helper.addRoutedServerNotificationListener(nti,
serverNotificationRegistration.listener,
filter,
handback,
converter);
}
//Make the local ServerNotification
ServerNotification serverNotification = new ServerNotification();
serverNotification.listener = serverNotificationRegistration.listener;
serverNotification.filter = serverNotificationRegistration.filterID;
serverNotification.handback = serverNotificationRegistration.handbackID;
//See if there's a list already
List<ServerNotification> list = serverNotifications.get(nti);
if (list == null) {
list = Collections.synchronizedList(new ArrayList<ServerNotification>());
List<ServerNotification> mapList = serverNotifications.putIfAbsent(nti, list);
if (mapList != null) {
list = mapList;
}
}
//Add the new notification into the list
list.add(serverNotification);
}
|
java
|
public synchronized void remoteClientRegistrations(RESTRequest request) {
Iterator<Entry<NotificationTargetInformation, ClientNotificationListener>> clientListeners = listeners.entrySet().iterator();
try {
while (clientListeners.hasNext()) {
Entry<NotificationTargetInformation, ClientNotificationListener> clientListener = clientListeners.next();
NotificationTargetInformation nti = clientListener.getKey();
ClientNotificationListener listener = clientListener.getValue();
// Check whether the producer of the notification is local or remote.
if (nti.getRoutingInformation() == null) {
// Remove the notification from the MBeanServer
ObjectName objName = RESTHelper.objectNameConverter(nti.getNameAsString(), false, null);
if (MBeanServerHelper.isRegistered(objName)) {
try {
MBeanServerHelper.removeClientNotification(objName, listener);
} catch (RESTHandlerJsonException exception) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Received exception while cleaning up: " + exception);
}
}
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "The MBean " + objName + " is not registered with the MBean server.");
}
}
} else {
// Remove the notification listener from the Target-Client Manager through EventAdmin
MBeanRoutedNotificationHelper helper = MBeanRoutedNotificationHelper.getMBeanRoutedNotificationHelper();
helper.removeRoutedNotificationListener(nti, listener);
}
}
} finally {
//Clear the map
listeners.clear();
}
}
|
java
|
public synchronized void remoteServerRegistrations(RESTRequest request) {
Iterator<Entry<NotificationTargetInformation, List<ServerNotification>>> serverNotificationsIter = serverNotifications.entrySet().iterator();
while (serverNotificationsIter.hasNext()) {
Entry<NotificationTargetInformation, List<ServerNotification>> entry = serverNotificationsIter.next();
NotificationTargetInformation nti = entry.getKey();
// Check whether the producer of the notification is local or remote.
if (nti.getRoutingInformation() == null) {
//Traverse the list for that ObjectName
ObjectName objName = RESTHelper.objectNameConverter(nti.getNameAsString(), false, null);
if (MBeanServerHelper.isRegistered(objName)) {
for (ServerNotification notification : entry.getValue()) {
MBeanServerHelper.removeServerNotification(objName,
notification.listener,
(NotificationFilter) getObject(notification.filter, null, null),
getObject(notification.handback, null, null),
null);
}
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "The MBean is not registered with the MBean server.");
}
}
} else {
// Remove the notification listener from the Target-Client Manager through EventAdmin
MBeanRoutedNotificationHelper helper = MBeanRoutedNotificationHelper.getMBeanRoutedNotificationHelper();
for (ServerNotification notification : entry.getValue()) {
helper.removeRoutedServerNotificationListener(nti,
notification.listener,
(NotificationFilter) getObject(notification.filter, null, null),
getObject(notification.handback, null, null),
null);
}
}
}
//Clear the map
serverNotifications.clear();
//We don't have any more server notifications, so we can clear our library
clearObjectLibrary();
}
|
java
|
public void copyHeader(LogRepositoryWriter writer) throws IllegalArgumentException {
if (writer == null) {
throw new IllegalArgumentException("Parameter writer can't be null");
}
writer.setHeader(headerBytes);
}
|
java
|
final Integer getCcsid() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getCcsid");
Integer value = (Integer) jmo.getPayloadPart().getField(JsPayloadAccess.CCSID_DATA);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getCcsid", value);
return value;
}
|
java
|
final Integer getEncoding() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getEncoding");
Integer value = (Integer) jmo.getPayloadPart().getField(JsPayloadAccess.ENCODING_DATA);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getEncoding", value);
return value;
}
|
java
|
final void setCcsid(Object value) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setCcsid", value);
// If the value is null, then clear the field
if (value == null) {
jmo.getPayloadPart().setField(JsPayloadAccess.CCSID, JsPayloadAccess.IS_CCSID_EMPTY);
}
// If it is an Integer, then we just store it
else if (value instanceof Integer) {
jmo.getPayloadPart().setField(JsPayloadAccess.CCSID_DATA, value);
}
// If it is a String (most likely) we have to convert it into an int value first
/*
* else if (value instanceof String) {
* try {
* int ccsid = CCSID.getCCSID((String)value);
* jmo.getPayloadPart().setIntField(JsPayloadAccess.CCSID_DATA, ccsid);
* }
* catch (UnsupportedEncodingException e) {
* // FFDC it, then clear the field
* FFDCFilter.processException(e, "com.ibm.ws.sib.mfp.impl.JsApiHdrsImpl.setCcsid", "866");
* jmo.getPayloadPart().setField(JsPayloadAccess.CCSID, JsPayloadAccess.IS_CCSID_EMPTY);
* }
* }
*/
// If it isn't of a suitable type, clear the field
else {
jmo.getPayloadPart().setField(JsPayloadAccess.CCSID, JsPayloadAccess.IS_CCSID_EMPTY);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setCcsid");
}
|
java
|
final void setEncoding(Object value) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setEncoding", value);
// If the value is null or unsuitable, then clear the field
if ((value == null) || !(value instanceof Integer)) {
jmo.getPayloadPart().setField(JsPayloadAccess.ENCODING, JsPayloadAccess.IS_ENCODING_EMPTY);
}
// If it does exist and is an Integer, then we just store it
else {
jmo.getPayloadPart().setField(JsPayloadAccess.ENCODING_DATA, value);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setEncoding");
}
|
java
|
public void preShutdown(boolean transactionsLeft) throws Exception /* @PK31789C */
{
if (tc.isEntryEnabled())
Tr.entry(tc, "preShutdown", transactionsLeft);
try {
// Terminate partner log activity
getPartnerLogTable().terminate(); // 172471
// If the tranlog is null then we're using in memory logging and
// the work the shutdown the log is not required.
if (_tranLog != null) {
//
// Check if any transactions still active...
//
if (!transactionsLeft) {
if (tc.isDebugEnabled())
Tr.debug(tc, "There is no transaction data requiring future recovery");
if (_tranlogServiceData != null) {
if (tc.isDebugEnabled())
Tr.debug(tc, "Erasing service data from transaction log");
// transactions stopped running now
try {
_tranLog.removeRecoverableUnit(_tranlogServiceData.identity());
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.impl.RecoveryManager.preShutdown", "359", this);
Tr.error(tc, "WTRN0029_ERROR_CLOSE_LOG_IN_SHUTDOWN");
throw e; /* @PK31789A */
}
} else {
if (tc.isDebugEnabled())
Tr.debug(tc, "No service data to erase from transaction log");
}
} else if (_tranlogServiceData != null) // Only update epoch if there is data in the log - d671043
{
// Force the tranlog by rewriting the epoch in the servicedata. This will ensure
// any previous completed transactions will have their end-records forced. Then
// it is safe to remove partner log records. Otherwise, we can get into the state
// of recovering completed txns that are still in-doubt in the txn log but have
// no partner log entries as we've cleaned them up. We can add code to cope with
// this but it gets very messy especially if recovery/shutdown keeps repeating
// itself - we need to check for NPE at every partner log check.
if (tc.isDebugEnabled())
Tr.debug(tc, "There is transaction data requiring future recovery. Updating epoch");
if (_failureScopeController.localFailureScope() || (_tranlogServiceData != null && _tranlogEpochSection != null)) {
try {
_tranlogEpochSection.addData(Util.intToBytes(_ourEpoch));
_tranlogServiceData.forceSections();
} catch (Exception e) {
// We were unable to force the tranlog, so just return as if we had crashed
// (or did an immediate shutdown) and we will recover everything at the next restart.
FFDCFilter.processException(e, "com.ibm.tx.jta.impl.RecoveryManager.preShutdown", "608", this);
if (tc.isDebugEnabled())
Tr.debug(tc, "Exception raised forcing tranlog at shutdown", e);
throw e; /* @PK31789C */
}
} else {
if (tc.isDebugEnabled())
Tr.debug(tc, "No service data to update in transaction log");
}
}
}
} finally {
// If this is a peer server, or a local server where there are no transactions left running
// then close the log. In the case of the local failure scope, we are unable to close the log if
// there are transactions running as this shutdown represents the real server shutdown and
// transactions may still attempt to write to the recovery log. If we close the log now in this
// situation, server shutdown will be peppered with LogClosedException errors. Needs refinement.
if (_tranLog != null && ((!_failureScopeController.localFailureScope()) || (!transactionsLeft))) {
try {
_tranLog.closeLog();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.impl.RecoveryManager.preShutdown", "360", this);
Tr.error(tc, "WTRN0029_ERROR_CLOSE_LOG_IN_SHUTDOWN");
if (tc.isEntryEnabled())
Tr.exit(tc, "preShutdown");
throw e; /* @PK31789A */
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "preShutdown");
}
}
|
java
|
protected void updateTranLogServiceData() throws Exception {
if (tc.isEntryEnabled())
Tr.entry(tc, "updateTranLogServiceData");
try {
//
// Check we have a recoverableUnit and three sections to add the data.
// On recovery we check that all service data sections were recovered.
//
if (_tranlogServiceData == null) {
_tranlogServiceData = _tranLog.createRecoverableUnit();
_tranlogServerSection = _tranlogServiceData.createSection(TransactionImpl.SERVER_DATA_SECTION, true);
_tranlogApplIdSection = _tranlogServiceData.createSection(TransactionImpl.APPLID_DATA_SECTION, true);
_tranlogEpochSection = _tranlogServiceData.createSection(TransactionImpl.EPOCH_DATA_SECTION, true);
// Log this server name
_tranlogServerSection.addData(Utils.byteArray(_failureScopeController.serverName()));
// Log our ApplId
_tranlogApplIdSection.addData(_ourApplId);
}
// Always update this server's current epoch
_tranlogEpochSection.addData(Util.intToBytes(_ourEpoch));
_tranlogServiceData.forceSections();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.impl.RecoveryManager.updateTranLogSeviceData", "1130", this);
if (tc.isEntryEnabled())
Tr.exit(tc, "updateTranLogServiceData", e);
throw e;
}
if (tc.isEntryEnabled())
Tr.exit(tc, "updateTranLogServiceData");
}
|
java
|
protected void updatePartnerServiceData() throws Exception {
if (tc.isEntryEnabled())
Tr.entry(tc, "updatePartnerServiceData");
try {
//
// Check we have a recoverableUnit and three sections to add the data.
// On recovery we check that all service data sections were recovered.
//
if (_partnerServiceData == null) {
if (_recoverXaLog != null)
_partnerServiceData = _recoverXaLog.createRecoverableUnit();
else
_partnerServiceData = _xaLog.createRecoverableUnit();
_partnerServerSection = _partnerServiceData.createSection(TransactionImpl.SERVER_DATA_SECTION, true);
_partnerApplIdSection = _partnerServiceData.createSection(TransactionImpl.APPLID_DATA_SECTION, true);
_partnerEpochSection = _partnerServiceData.createSection(TransactionImpl.EPOCH_DATA_SECTION, true);
_partnerLowWatermarkSection = _partnerServiceData.createSection(TransactionImpl.LOW_WATERMARK_SECTION, true); /* @MD18134A */
_partnerNextIdSection = _partnerServiceData.createSection(TransactionImpl.NEXT_ID_SECTION, true); /* @MD18134A */
// Log this server name
_partnerServerSection.addData(Utils.byteArray(_failureScopeController.serverName()));
// Log our ApplId
_partnerApplIdSection.addData(_ourApplId);
// Low watermark will start at 1
_partnerEntryLowWatermark = 1; /* @MD18134A */
_partnerLowWatermarkSection.addData(Util.intToBytes(_partnerEntryLowWatermark)); /* @MD18134A */
// Next ID will start at 2.
_partnerEntryNextId = 2; /* @MD18134A */
_partnerNextIdSection.addData(Util.intToBytes(_partnerEntryNextId)); /* @MD18134A */
}
// Always update this server's current epoch
_partnerEpochSection.addData(Util.intToBytes(_ourEpoch));
// Update the server state in the log
updateServerState(STARTING);
_partnerServiceData.forceSections();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.tx.jta.impl.RecoveryManager.updatePartnerSeviceData", "1224", this);
if (tc.isEntryEnabled())
Tr.exit(tc, "updatePartnerServiceData", e);
throw e;
}
if (tc.isEntryEnabled())
Tr.exit(tc, "updatePartnerServiceData");
}
|
java
|
public void waitForRecoveryCompletion() {
if (tc.isEntryEnabled())
Tr.entry(tc, "waitForRecoveryCompletion");
if (!_recoveryCompleted) {
try {
if (tc.isEventEnabled())
Tr.event(tc, "starting to wait for recovery completion");
_recoveryInProgress.waitEvent();
if (tc.isEventEnabled())
Tr.event(tc, "completed wait for recovery completion");
} catch (InterruptedException exc) {
FFDCFilter.processException(exc, "com.ibm.tx.jta.impl.RecoveryManager.waitForRecoveryCompletion", "1242", this);
if (tc.isEventEnabled())
Tr.event(tc, "Wait for recovery complete interrupted.");
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "waitForRecoveryCompletion");
}
|
java
|
public void recoveryComplete() /* @LIDB3187C */
{
if (tc.isEntryEnabled())
Tr.entry(tc, "recoveryComplete");
if (!_recoveryCompleted) {
_recoveryCompleted = true;
_recoveryInProgress.post();
}
// Check for null currently required as z/OS creates this object with a null agent reference.
if (_agent != null) {
try {
RecoveryDirectorFactory.recoveryDirector().initialRecoveryComplete(_agent, _failureScopeController.failureScope());
} catch (Exception exc) {
FFDCFilter.processException(exc, "com.ibm.tx.jta.impl.RecoveryManager.recoveryComplete", "1546", this);
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "recoveryComplete");
}
|
java
|
public boolean shutdownInProgress() /* @LIDB3187C */
{
synchronized (_recoveryMonitor) {
if (_shutdownInProgress) {
// Put out a message stating the we are stopping recovery processing. Since this method can
// be called a number of times in succession (to allow nested method calls to bail out by
// calling this method) we only put the message out the first time round.
if (!_recoveryCompleted) {
if (tc.isEventEnabled())
Tr.event(tc, "Shutdown is in progress, stopping recovery processing");
recoveryComplete();
if (_failureScopeController.localFailureScope()) {
TMHelper.asynchRecoveryProcessingComplete(null);
}
}
}
}
return _shutdownInProgress;
}
|
java
|
protected TransactionImpl[] getRecoveringTransactions() {
TransactionImpl[] recoveredTransactions = new TransactionImpl[_recoveringTransactions.size()];
_recoveringTransactions.toArray(recoveredTransactions);
return recoveredTransactions;
}
|
java
|
protected void closeLogs(boolean closeLeaseLog) {
if (tc.isEntryEnabled())
Tr.entry(tc, "closeLogs", new Object[] { this, closeLeaseLog });
if ((_tranLog != null) && (_tranLog instanceof DistributedRecoveryLog)) {
try {
((DistributedRecoveryLog) _tranLog).closeLogImmediate();
} catch (Exception e) {
// No FFDC Needed
}
_tranLog = null;
}
if ((_xaLog != null) && (_xaLog instanceof DistributedRecoveryLog)) {
try {
((DistributedRecoveryLog) _xaLog).closeLogImmediate();
} catch (Exception e) {
// No FFDC Needed
}
_xaLog = null;
}
try {
if (_leaseLog != null && closeLeaseLog) {
_leaseLog.deleteServerLease(_failureScopeController.serverName());
}
} catch (Exception e) {
// TODO Auto-generated catch block
// Do you need FFDC here? Remember FFDC instrumentation and @FFDCIgnore
e.printStackTrace();
}
if (tc.isEntryEnabled())
Tr.exit(tc, "closeLogs");
}
|
java
|
public void registerTransaction(TransactionImpl tran) {
if (tc.isEntryEnabled())
Tr.entry(tc, "registerTransaction", new Object[] { this, tran });
_recoveringTransactions.add(tran);
if (tc.isEntryEnabled())
Tr.exit(tc, "registerTransaction", _recoveringTransactions.size());
}
|
java
|
public void deregisterTransaction(TransactionImpl tran) {
if (tc.isEntryEnabled())
Tr.entry(tc, "deregisterTransaction", new Object[] { this, tran });
_recoveringTransactions.remove(tran);
if (tc.isEntryEnabled())
Tr.exit(tc, "deregisterTransaction", _recoveringTransactions.size());
}
|
java
|
protected boolean recoveryModeTxnsComplete() {
if (tc.isEntryEnabled())
Tr.entry(tc, "recoveryModeTxnsComplete");
if (_recoveringTransactions != null) {
for (TransactionImpl tx : _recoveringTransactions) {
if (tx != null && !tx.isRAImport()) {
if (tc.isEntryEnabled())
Tr.exit(tc, "recoveryModeTxnsComplete", Boolean.FALSE);
return false;
}
}
} // end if
if (tc.isEntryEnabled())
Tr.exit(tc, "recoveryModeTxnsComplete", Boolean.TRUE);
return true;
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.