code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
static Class<?> getTypeFromMember(Member member) throws InjectionException {
Class<?> memberType = null;
if (member instanceof Field) {
memberType = ((Field) member).getType();
} else if (member instanceof Method) {
Method method = (Method) member;
if (method.getParameterTypes() == null || method.getParameterTypes().length != 1) {
String msg = Tr.formatMessage(tc, "error.service.ref.member.level.annotation.wrong.method.name",
method.getName(), method.getDeclaringClass().getName());
throw new InjectionException(msg);
}
memberType = method.getParameterTypes()[0];
}
return memberType;
}
|
java
|
public static void sendExceptionToClient(Throwable throwable, String probeId,
Conversation conversation, int requestNumber) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "sendExceptionToClient",
new Object[]
{
throwable,
probeId,
conversation,
requestNumber
});
CommsByteBuffer buffer = poolManager.allocate();
buffer.putException(throwable, probeId, conversation);
// defect 99984 checking whether jmsServer feature is intact or its removed
if (CommsServerServiceFacade.getJsAdminService() != null)
{
try {
conversation.send(buffer,
JFapChannelConstants.SEG_EXCEPTION,
requestNumber,
JFapChannelConstants.PRIORITY_MEDIUM,
true,
ThrottlingPolicy.BLOCK_THREAD,
null);
} catch (SIException c) {
FFDCFilter.processException(c, CLASS_NAME + ".sendExceptionToClient",
CommsConstants.STATICCATHELPER_SEND_EXCEP_01);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2023", c);
}
}
else
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "conversation send is not being called as jmsadminService is null");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "sendExceptionToClient");
}
|
java
|
public static void sendAsyncExceptionToClient(Throwable throwable,
String probeId, short clientSessionId,
Conversation conversation, int requestNumber) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "sendAsyncExceptionToClient",
new Object[]
{
throwable,
probeId,
"" + clientSessionId,
conversation,
"" + requestNumber
});
// BIT16 ConnectionObjectId
// BIT16 Event Id
// BIT16 ConsumerSessionId
// Exception...
CommsByteBuffer buffer = poolManager.allocate();
buffer.putShort(0); // We do not need the connection object ID on the client
buffer.putShort(CommsConstants.EVENTID_ASYNC_EXCEPTION); // Async exception
buffer.putShort(clientSessionId);
buffer.putException(throwable, probeId, conversation);
try {
conversation.send(buffer,
JFapChannelConstants.SEG_EVENT_OCCURRED,
requestNumber,
JFapChannelConstants.PRIORITY_MEDIUM,
true,
ThrottlingPolicy.BLOCK_THREAD,
null);
} catch (SIException c) {
FFDCFilter.processException(c, CLASS_NAME + ".sendAsyncExceptionToClient",
CommsConstants.STATICCATHELPER_SEND_ASEXCEP_01);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2023", c);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "sendAsyncExceptionToClient");
}
|
java
|
public static void sendSessionCreateResponse(int segmentType, int requestNumber,
Conversation conversation, short sessionId,
DestinationSession session,
SIDestinationAddress originalDestinationAddr) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "sendSessionCreateResponse");
CommsByteBuffer buffer = poolManager.allocate();
// Add the Message processor session id if we are sending back a consumer response
if (segmentType == JFapChannelConstants.SEG_CREATE_CONS_FOR_DURABLE_SUB_R ||
segmentType == JFapChannelConstants.SEG_CREATE_CONSUMER_SESS_R) {
long id = 0;
try {
id = ((ConsumerSession) session).getId();
} catch (SIException e) {
//No FFDC code needed
//Only FFDC if we haven't received a meTerminated event.
if (!((ConversationState) conversation.getAttachment()).hasMETerminated()) {
FFDCFilter.processException(e, CLASS_NAME + ".sendSessionCreateResponse",
CommsConstants.STATICCATHELPER_SENDSESSRESPONSE_02);
}
// Not a lot we can do here - so just debug the error
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Unable to get session id", e);
}
buffer.putLong(id);
}
if (segmentType == JFapChannelConstants.SEG_CREATE_CONSUMER_SESS_R) {
buffer.putShort(CommsConstants.CF_UNICAST);
}
buffer.putShort(sessionId);
// Now get the destination address from the session so we can get sizes
JsDestinationAddress destAddress = (JsDestinationAddress) session.getDestinationAddress();
// We should only send back the destination address if it is different from the original.
// To do this, we can do a simple compare on their toString() methods.
if (originalDestinationAddr == null ||
(!originalDestinationAddr.toString().equals(destAddress.toString()))) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Destination address is different: Orig, New",
new Object[]
{
originalDestinationAddr,
destAddress
});
buffer.putSIDestinationAddress(destAddress, conversation.getHandshakeProperties().getFapLevel());
}
try {
// Send the response to the client.
conversation.send(buffer,
segmentType,
requestNumber,
JFapChannelConstants.PRIORITY_MEDIUM,
true,
ThrottlingPolicy.BLOCK_THREAD,
null);
} catch (SIException e) {
FFDCFilter.processException(e,
CLASS_NAME + ".sendSessionCreateResponse",
CommsConstants.STATICCATHELPER_SENDSESSRESPONSE_01);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, e.getMessage(), e);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2023", e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "sendSessionCreateResponse");
}
|
java
|
private static JavaDumper createInstance() {
try {
// Try to find IBM Java dumper class.
Class<?> dumpClass = Class.forName("com.ibm.jvm.Dump");
try {
// Try to find the IBM Java 7.1 dump methods.
Class<?>[] paramTypes = new Class<?>[] { String.class };
Method javaDumpToFileMethod = dumpClass.getMethod("javaDumpToFile", paramTypes);
Method heapDumpToFileMethod = dumpClass.getMethod("heapDumpToFile", paramTypes);
Method systemDumpToFileMethod = dumpClass.getMethod("systemDumpToFile", paramTypes);
return new IBMJavaDumperImpl(javaDumpToFileMethod, heapDumpToFileMethod, systemDumpToFileMethod);
} catch (NoSuchMethodException e) {
return new IBMLegacyJavaDumperImpl(dumpClass);
}
} catch (ClassNotFoundException ex) {
// Try to find HotSpot MBeans.
ObjectName diagName;
ObjectName diagCommandName;
try {
diagName = new ObjectName("com.sun.management:type=HotSpotDiagnostic");
diagCommandName = new ObjectName("com.sun.management:type=DiagnosticCommand");
} catch (MalformedObjectNameException ex2) {
throw new IllegalStateException(ex2);
}
MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
if (!mbeanServer.isRegistered(diagName)) {
diagName = null;
}
if (!mbeanServer.isRegistered(diagCommandName)) {
diagCommandName = null;
}
return new HotSpotJavaDumperImpl(mbeanServer, diagName, diagCommandName);
}
}
|
java
|
private Map<String, String> filterProps(Map<String, Object> props) {
HashMap<String, String> filteredProps = new HashMap<>();
Iterator<String> it = props.keySet().iterator();
boolean debug = tc.isDebugEnabled() && TraceComponent.isAnyTracingEnabled();
while (it.hasNext()) {
String key = it.next();
String newKey = null;
if (debug) {
Tr.debug(tc, "key: " + key + " value: " + props.get(key));
}
// skip stuff we don't care about
if (propertiesToRemove.contains(key)) {
continue;
}
// convert from shorthand key (timeout) to actual prop name (com.ibm.way.too.long.name.timeout)
// note that this swap is NOT case sensitive.
newKey = key;
if (propsToTranslate.containsKey(key.toLowerCase())) {
newKey = propsToTranslate.get(key.toLowerCase());
if (debug) {
Tr.debug(tc, " translated " + key + " to " + newKey);
}
}
filteredProps.put(newKey, props.get(key).toString());
// special case for authnToken
if (newKey.compareTo("authnToken") == 0) {
String replacementKey = validateAuthn(props.get(key).toString());
if (replacementKey != null) {
filteredProps.remove(newKey);
filteredProps.put(replacementKey, "true");
} else {
filteredProps.remove(newKey); // invalid token type, back it out.
}
}
}
return filteredProps;
}
|
java
|
private String validateAuthn(String value) {
// for now, if we got here we're validating an authnToken
String result = null;
String valueLower = value.toLowerCase();
do {
if (valueLower.equals("saml")) {
result = JAXRSClientConstants.SAML_HANDLER;
break;
}
if (valueLower.equals("oauth")) {
result = JAXRSClientConstants.OAUTH_HANDLER;
break;
}
if (valueLower.equals("ltpa")) {
result = JAXRSClientConstants.LTPA_HANDLER;
}
} while (false);
if (result == null) {
Tr.warning(tc, "warn.invalid.authorization.token.type", value); // CWWKW0061W
}
return result;
}
|
java
|
private String getURI(Map<String, Object> props) {
if (props == null)
return null;
if (props.keySet().contains(URI)) {
return (props.get(URI).toString());
} else {
return null;
}
}
|
java
|
private static XMLInputFactory getXMLInputFactory() {
if (SAFE_INPUT_FACTORY != null) {
return SAFE_INPUT_FACTORY;
}
XMLInputFactory f = NS_AWARE_INPUT_FACTORY_POOL.poll();
if (f == null) {
f = createXMLInputFactory(true);
}
return f;
}
|
java
|
public static void copy(XMLStreamReader reader, XMLStreamWriter writer) throws XMLStreamException {
copy(reader, writer, false, false);
}
|
java
|
public static QName readQName(XMLStreamReader reader) throws XMLStreamException {
String value = reader.getElementText();
if (value == null) {
return null;
}
value = value.trim();
int index = value.indexOf(":");
if (index == -1) {
return new QName(value);
}
String prefix = value.substring(0, index);
String localName = value.substring(index + 1);
String ns = reader.getNamespaceURI(prefix);
if ((!StringUtils.isEmpty(prefix) && ns == null) || localName == null) {
throw new RuntimeException("Invalid QName in mapping: " + value);
}
if (ns == null) {
return new QName(localName);
}
return new QName(ns, localName, prefix);
}
|
java
|
public boolean addReference(ServiceReference<T> reference) {
if (reference == null)
return false;
ConcurrentServiceReferenceElement<T> element = new ConcurrentServiceReferenceElement<T>(referenceName, reference);
synchronized (elementMap) {
ConcurrentServiceReferenceElement<T> oldElement = elementMap.put(reference, element);
if (oldElement != null) {
if (!element.getRanking().equals(oldElement.getRanking())) {
elementSetUnsorted = true;
}
return true;
}
elementSet.add(element);
}
return false;
}
|
java
|
public boolean removeReference(ServiceReference<T> reference) {
synchronized (elementMap) {
ConcurrentServiceReferenceElement<T> element = elementMap.remove(reference);
if (element == null) {
return false;
}
elementSet.remove(element);
return true;
}
}
|
java
|
private Iterator<ConcurrentServiceReferenceElement<T>> elements() {
Collection<ConcurrentServiceReferenceElement<T>> set;
synchronized (elementMap) {
if (elementSetUnsorted) {
elementSet = new ConcurrentSkipListSet<ConcurrentServiceReferenceElement<T>>(elementMap.values());
elementSetUnsorted = false;
}
set = elementSet;
}
return set.iterator();
}
|
java
|
public void setChannelData(ChannelData data) throws ChannelException {
this.channelData = data;
setValues(data.getPropertyBag());
if (tc.isDebugEnabled())
outputConfigToTrace();
}
|
java
|
public void setChannelReceiveBufferSize(int size) {
this.channelReceiveBufferSize = size;
if (size < 0 || size > UDPConfigConstants.MAX_UDP_PACKET_SIZE) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Channel Receive buffer size not within Limits: " + size + " setting to default: " + UDPConfigConstants.MAX_UDP_PACKET_SIZE);
}
this.channelReceiveBufferSize = UDPConfigConstants.MAX_UDP_PACKET_SIZE;
}
}
|
java
|
public void addSICoreConnection(SICoreConnection conn, Conversation conversation) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "addSICoreConnection");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
SibTr.debug(tc, "Params: connection, conversation",
new Object[] { conn, conversation });
}
conversationTable.put(conn, conversation);
// At this point, if the me has previously been terminated, we know it is
// back up - so make sure we remove if from our quiesce and terminated table
// so that if it goes down again, we can notify the clients.
quiesceNotif.remove(conn.getMeUuid());
termNotif.remove(conn.getMeUuid());
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addSICoreConnection");
}
|
java
|
@Override
public void asynchronousException(ConsumerSession session, Throwable e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "asynchronousException",
new Object[]
{
session,
e
});
FFDCFilter.processException(e,
CLASS_NAME + ".asynchronousException",
CommsConstants.SERVERSICORECONNECTIONLISTENER_ASYNC_01,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Caught an async exception:", e);
try {
sendMeNotificationEvent(CommsConstants.EVENTID_ASYNC_EXCEPTION, null, session, e);
} catch (SIException e2) {
FFDCFilter.processException(e,
CLASS_NAME + ".asynchronousException",
CommsConstants.SERVERSICORECONNECTIONLISTENER_ASYNC_02,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, e.getMessage(), e);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2018", e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "asynchronousException");
}
|
java
|
@Override
public void meTerminated(SICoreConnection conn) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "meTerminated");
//Remember the fact that the ME has terminated so we don't issue spurious FFDCs
final Conversation conversation = conversationTable.get(conn);
//If conversation is null we do nothing.
if (conversation != null) {
final ConversationState convState = (ConversationState) conversation.getAttachment();
convState.setMETerminated();
}
// Right, so the ME that the core connection is connected to
// is dead. First of all get the ME Uuid that the connection
// refers to
String meUuid = conn.getMeUuid();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "ME Uuid: ", meUuid);
// Have we already sent a notification about this ME terminating
// to the client?
if (termNotif.get(meUuid) == null) {
// No we have not. So, get the Conversation and send the client
// the message about this ME. It will be up to the client to fan
// out this message to other clients connected to this ME.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "We have not sent a notification about this ME");
try {
sendMeNotificationEvent(CommsConstants.EVENTID_ME_TERMINATED, conn, null, null);
// and save that we have sent a response concerning this ME
// Note, just using a Hashtable for fast searching.
termNotif.put(meUuid, new Object());
} catch (SIException e) {
FFDCFilter.processException(e,
CLASS_NAME + ".meTerminated",
CommsConstants.SERVERSICORECONNECTIONLISTENER_MET_01,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, e.getMessage(), e);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2018", e);
}
} else {
// Yes we have - so do not do anything more
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Already sent notification about this ME");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "meTerminated");
}
|
java
|
@Override
public void commsFailure(SICoreConnection conn, SIConnectionLostException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "commsFailure",
new Object[]
{
conn,
e
});
FFDCFilter.processException(e,
CLASS_NAME + ".commsFailure",
CommsConstants.SERVERSICORECONNECTIONLISTENER_COMMS_01,
this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "Caught a comms exception:", e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "commsFailure");
}
|
java
|
public String getRequestURL()
{
HttpServletRequest httpReq = getRequest();
if (httpReq==null)
return null;
else
return httpReq.getRequestURL().toString();
}
|
java
|
public HttpServletRequest getRequest()
{
// moved as part of LIDB-3598 to ServletUtil
/*
ServletRequest r = _req;
while (!(r instanceof HttpServletRequest))
{
if (r instanceof ServletRequestWrapper)
{
r = ((ServletRequestWrapper) r).getRequest();
}
}
return (HttpServletRequest) r;
*/
//begin 311003, 61FVT:Simple SIP request generating exception
ServletRequest sReq = null;
if (_req==null)
return null;
try {
sReq = ServletUtil.unwrapRequest(_req);
}
catch (RuntimeException re){
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"getRequest","Caught RuntimeException unwrapping the request",re);
return null;
}
//end 311003, 61FVT:Simple SIP request generating exception
if (sReq instanceof HttpServletRequest)
return (HttpServletRequest) sReq;
else
return null;
}
|
java
|
public HttpServletResponse getResponse()
{
// moved as part of LIDB-3598 to ServletUtil
/*
ServletResponse r = _resp;
while (!(r instanceof HttpServletResponse))
{
if (r instanceof ServletResponseWrapper)
{
r = ((ServletResponseWrapper) r).getResponse();
}
}
return (HttpServletResponse) r;
*/
//begin 311003, 61FVT:Simple SIP request generating exception
ServletResponse sRes = null;
if (_resp==null)
return null;
try {
sRes = ServletUtil.unwrapResponse(_resp);
}
catch (RuntimeException re){
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"getResponse","Caught RuntimeException unwrapping the response",re);
return null;
}
//end 311003, 61FVT:Simple SIP request generating exception
if (sRes instanceof HttpServletResponse)
return (HttpServletResponse) sRes;
else
return null;
}
|
java
|
public boolean isAvailableInPlatform(String p) {
if (this.platform.equals(PLATFORM_ALL))
return true;
else
return (this.platform.equals(p));
}
|
java
|
protected byte[] loadClassDataFromFile(String fileName) {
byte[] classBytes = null;
try {
InputStream in = getResourceAsStream(fileName);
if (in == null) {
return null;
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte buf[] = new byte[1024];
for (int i = 0;(i = in.read(buf)) != -1;)
baos.write(buf, 0, i);
in.close();
baos.close();
classBytes = baos.toByteArray();
}
catch (Exception ex) {
return null;
}
return classBytes;
}
|
java
|
private final Object typeCheck(Object value, int type) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "typecheck: value = " + value + ", " + value.getClass() + " , type=" + type);
switch (type) {
/* No checking, just return the value */
case Selector.UNKNOWN:
return value;
/* STRING - simple! */
case Selector.STRING:
return (value instanceof String) ? value : null;
/* BOOLEAN - Boolean or BooleanValue are suitable */
case Selector.BOOLEAN:
return (value instanceof Boolean) ? value : null;
/* Any numeric - any Number or a NumericValue are suitable */
default:
return (value instanceof Number) ? value : null;
}
}
|
java
|
final Serializable restoreMapObject(byte[] mapItemArray) throws IOException, ClassNotFoundException {
Serializable item = null;;
/* If it is a real byte array, we need to return a safe copy with the */
/* header bytes removed. */
if ((mapItemArray[0] == HEADER_BYTE_0) && (mapItemArray[1] == HEADER_BYTE_1)) {
item = new byte[mapItemArray.length - 2];
System.arraycopy(mapItemArray, 2, item, 0, ((byte[]) item).length);
}
/* Anything else needs deserializing. */
else {
ByteArrayInputStream bai = new ByteArrayInputStream(mapItemArray);
ObjectInputStream wsin = null;
if (RuntimeInfo.isThinClient() || RuntimeInfo.isFatClient()) {
//thin client environment. create ObjectInputStream from factory method.
//As of now getting twas factory class.
//Hard coding now.. once when Libery thin client get developed, this can be taken to a factory type class.
Class<?> clazz = Class.forName("com.ibm.ws.util.WsObjectInputStream");
try {
wsin = (ObjectInputStream) clazz.getConstructor(ByteArrayInputStream.class).newInstance(bai);
} catch (Exception e) {
// No FFDC code needed
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "Exception closing the ObjectInputStream", e);
}
} else {
//Liberty server environment
ClassLoader cl = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>()
{
@Override
public ClassLoader run() {
return Thread.currentThread().getContextClassLoader();
}
});
wsin = new DeserializationObjectInputStream(bai, cl);
}
item = (Serializable) wsin.readObject();
try {
if (wsin != null) {
wsin.close();
}
} catch (IOException ex) {
// No FFDC code needed
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "Exception closing the ObjectInputStream", ex);
}
}
return item;
}
|
java
|
final void setTransportVersion(Object value) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setTransportVersion", value);
getHdr2().setField(JsHdr2Access.TRANSPORTVERSION_DATA, value);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setTransportVersion");
}
|
java
|
final void clearTransportVersion() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "clearTransportVersion");
getHdr2().setChoiceField(JsHdr2Access.TRANSPORTVERSION, JsHdr2Access.IS_TRANSPORTVERSION_EMPTY);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "clearTransportVersion");
}
|
java
|
public Object getInstanceOf(String key){
try {
ClassLoader loader = Thread.currentThread().getContextClassLoader();
return Class.forName((String)classesMap.get(key),true,loader).newInstance();
} catch (IllegalAccessException e) {
logger.logp(Level.SEVERE,"JspClassFactory","getInstanceOf","jsp.error.function.classnotfound",(String) classesMap.get(key));
} catch (InstantiationException e) {
logger.logp(Level.SEVERE,"JspClassFactory","getInstanceOf","jsp.error.function.classnotfound",(String) classesMap.get(key));
} catch (ClassNotFoundException e) {
logger.logp(Level.SEVERE,"JspClassFactory","getInstanceOf","jsp.error.function.classnotfound",(String) classesMap.get(key));
}
return null;
}
|
java
|
static ImmutableAttributes loadAttributes(String repoType, File featureFile, ProvisioningDetails details) throws IOException {
// This will throw exceptions if required attributes mismatch or are missing
details.ensureValid();
// retrieve the symbolic name and feature manifest version
String symbolicName = details.getNameAttribute(null);
int featureVersion = details.getIBMFeatureVersion();
// Directive names are name attributes, but end with a colon
Visibility visibility = Visibility.fromString(details.getNameAttribute("visibility:"));
boolean isSingleton = Boolean.parseBoolean(details.getNameAttribute("singleton:"));
// ignore short name for features that are not public
String shortName = (visibility != Visibility.PUBLIC ? null : details.getMainAttributeValue(SHORT_NAME));
// retrieve the feature/subsystem version
Version version = VersionUtility.stringToVersion(details.getMainAttributeValue(VERSION));
// retrieve the app restart header
AppForceRestart appRestart = AppForceRestart.fromString(details.getMainAttributeValue(IBM_APP_FORCE_RESTART));
String subsystemType = details.getMainAttributeValue(TYPE);
String value = details.getCachedRawHeader(IBM_PROVISION_CAPABILITY);
boolean isAutoFeature = value != null && SubsystemContentType.FEATURE_TYPE.getValue().equals(subsystemType);
value = details.getCachedRawHeader(IBM_API_SERVICE);
boolean hasApiServices = value != null;
value = details.getCachedRawHeader(IBM_API_PACKAGE);
boolean hasApiPackages = value != null;
value = details.getCachedRawHeader(IBM_SPI_PACKAGE);
boolean hasSpiPackages = value != null;
EnumSet<ProcessType> processTypes = ProcessType.fromString(details.getCachedRawHeader(IBM_PROCESS_TYPES));
ImmutableAttributes iAttr = new ImmutableAttributes(emptyIfNull(repoType),
symbolicName,
nullIfEmpty(shortName),
featureVersion,
visibility,
appRestart,
version,
featureFile,
featureFile == null ? -1 : featureFile.lastModified(),
featureFile == null ? -1 : featureFile.length(),
isAutoFeature, hasApiServices,
hasApiPackages, hasSpiPackages, isSingleton,
processTypes);
// Link the details object and immutable attributes (used for diagnostic purposes:
// the immutable attribute values are necessary for meaningful error messages)
details.setImmutableAttributes(iAttr);
return iAttr;
}
|
java
|
static ImmutableAttributes loadAttributes(String line,
ImmutableAttributes cachedAttributes) {
// Builder pattern for Immutable attributes
// This parses a cache line that looks like this:
// repoType|symbolicName=Lots;of;attribtues
int index = line.indexOf('=');
String key = line.substring(0, index);
String repoType = FeatureDefinitionUtils.EMPTY;
String symbolicName = key;
// Do we have a prefix repoType? If so, split the key.
int pfxIndex = key.indexOf(':');
if (pfxIndex > -1) {
repoType = key.substring(0, pfxIndex);
symbolicName = key.substring(pfxIndex + 1);
}
// Now let's work on the value half...
String[] parts = splitPattern.split(line.substring(index + 1));
// Old or mismatched cache
if (parts.length < 9)
return null;
String path = parts[0];
// Make sure file information from cache line is still accurate
// i.e. the file exists, and the modification time and size have not changed.
File featureFile = new File(path);
if (featureFile.exists()) {
// Did we have a previous entry in the cache already?
// This will happen on a subsequent feature update operation (post-initial provisioning)
if (cachedAttributes != null) {
return cachedAttributes;
}
// Assuming we're still good, but didn't have a cache entry, we should read the rest
// of the attributes..
long lastModified = getLongValue(parts[1], -1);
long fileSize = getLongValue(parts[2], -1);
String shortName = parts[3];
int featureVersion = getIntegerValue(parts[4], 2);
Visibility visibility = Visibility.fromString(parts[5]);
AppForceRestart appRestart = AppForceRestart.fromString(parts[6]);
Version version = VersionUtility.stringToVersion(parts[7]);
String flags = parts[8];
boolean isAutoFeature = toBoolean(flags.charAt(0));
boolean hasApiServices = toBoolean(flags.charAt(1));
boolean hasApiPackages = toBoolean(flags.charAt(2));
boolean hasSpiPackages = toBoolean(flags.charAt(3));
boolean isSingleton = flags.length() > 4 ? toBoolean(flags.charAt(4)) : false;
EnumSet<ProcessType> processTypes = ProcessType.fromString(parts.length > 9 ? parts[9] : null);
// Everything is ok with the cache contents,
// make a new subsystem definition from the cached information
return new ImmutableAttributes(emptyIfNull(repoType),
symbolicName,
nullIfEmpty(shortName),
featureVersion,
visibility,
appRestart,
version,
featureFile,
lastModified,
fileSize,
isAutoFeature, hasApiServices,
hasApiPackages, hasSpiPackages, isSingleton,
processTypes);
}
// The definition in the filesystem has been deleted: return null to remove it from the cache
return null;
}
|
java
|
public final synchronized void commitDecrementReferenceCount(PersistentTransaction transaction) throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "commitDecrementReferenceCount");
if (_referenceCount < 1)
{
SevereMessageStoreException e = new SevereMessageStoreException("Reference count decrement cannot be committed");
FFDCFilter.processException(e, "com.ibm.ws.sib.msgstore.cache.links.ItemLink.commitDecrementReferenceCount", "1:131:1.104.1.1");
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Reference count decrement cannot be committed");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "commitDecrementReferenceCount");
throw e;
}
_referenceCount--;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "reference count dropped to: " + _referenceCount);
if (0 == _referenceCount)
{
// This causes the item's itemReferencesDroppedToZero to be called after
// completion of this transaction
transaction.registerCallback(this);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "commitDecrementReferenceCount");
}
|
java
|
public final synchronized void incrementReferenceCount() throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "incrementReferenceCount");
if (_referenceCountIsDecreasing)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot increment! Reference count has begun decreasing.");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementReferenceCount");
throw new SevereMessageStoreException("Cannot add more references to an item after one has been removed");
}
_referenceCount++;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementReferenceCount");
}
|
java
|
public final synchronized void rollbackIncrementReferenceCount(PersistentTransaction transaction) throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "rollbackIncrementReferenceCount");
if (_referenceCount < 1)
{
SevereMessageStoreException e = new SevereMessageStoreException("Reference count increment cannot be rolled back");
FFDCFilter.processException(e, "com.ibm.ws.sib.msgstore.cache.links.ItemLink.rollbackIncrementReferenceCount", "1:212:1.104.1.1");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Reference count increment cannot be rolled back");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollbackIncrementReferenceCount");
throw e;
}
_referenceCount--;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollbackIncrementReferenceCount");
}
|
java
|
@Override
public void performFileBasedAction(Collection<File> modifiedFiles) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "performFileBasedAction", new Object[] { modifiedFiles });
try {
com.ibm.ws.ssl.config.KeyStoreManager.getInstance().clearJavaKeyStoresFromKeyStoreMap(modifiedFiles);
com.ibm.ws.ssl.provider.AbstractJSSEProvider.clearSSLContextCache(modifiedFiles);
com.ibm.ws.ssl.config.SSLConfigManager.getInstance().resetDefaultSSLContextIfNeeded(modifiedFiles);
Tr.audit(tc, "ssl.keystore.modified.CWPKI0811I", modifiedFiles.toArray());
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception while trying to reload keystore file, exception is: " + e.getMessage());
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "performFileBasedAction");
}
|
java
|
protected void unsetFileMonitorRegistration() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "unsetFileMonitorRegistration");
}
if (keyStoreFileMonitorRegistration != null) {
keyStoreFileMonitorRegistration.unregister();
keyStoreFileMonitorRegistration = null;
}
}
|
java
|
protected void setFileMonitorRegistration(ServiceRegistration<FileMonitor> keyStoreFileMonitorRegistration) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "setFileMonitorRegistration");
}
this.keyStoreFileMonitorRegistration = keyStoreFileMonitorRegistration;
}
|
java
|
private void createFileMonitor(String ID, String keyStoreLocation, String trigger, long interval) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "createFileMonitor", new Object[] { ID, keyStoreLocation, trigger, interval });
try {
keyStoreFileMonitor = new SecurityFileMonitor(this);
setFileMonitorRegistration(keyStoreFileMonitor.monitorFiles(ID, Arrays.asList(keyStoreLocation), interval, trigger));
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception creating the keystore file monitor.", e);
}
FFDCFilter.processException(e, getClass().getName(), "createFileMonitor", this, new Object[] { ID, keyStoreLocation, interval });
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "createFileMonitor");
}
|
java
|
protected void unsetKeyringMonitorRegistration() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "unsetKeyringMonitorRegistration");
}
if (keyringMonitorRegistration != null) {
keyringMonitorRegistration.unregister();
keyringMonitorRegistration = null;
}
}
|
java
|
protected void setKeyringMonitorRegistration(ServiceRegistration<KeyringMonitor> keyringMonitorRegistration) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "setKeyringMonitorRegistration");
}
this.keyringMonitorRegistration = keyringMonitorRegistration;
}
|
java
|
private void createKeyringMonitor(String ID, String trigger, String keyStoreLocation) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "createKeyringMonitor", new Object[] { ID, trigger });
try {
KeyringMonitor = new KeyringMonitorImpl(this);
setKeyringMonitorRegistration(KeyringMonitor.monitorKeyRings(ID, trigger, keyStoreLocation));
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception creating the keyring monitor.", e);
}
FFDCFilter.processException(e, getClass().getName(), "createKeyringMonitor", this, new Object[] { ID, keyStoreLocation });
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "createKeyringMonitor");
}
|
java
|
public static byte[] encodeDN(Codec codec, String distinguishedName) throws Exception {
X500Principal issuer = new X500Principal(distinguishedName);
X509CertSelector certSelector = new X509CertSelector();
certSelector.setIssuer(issuer);
byte[] asnX501DN = certSelector.getIssuerAsBytes();
Any a = ORB.init().create_any();
X501DistinguishedNameHelper.insert(a, asnX501DN);
return codec.encode_value(a);
}
|
java
|
public static String decodeDN(Codec codec, byte[] encodedDN) throws SASException {
String dn = null;
try {
Any any = codec.decode_value(encodedDN, X501DistinguishedNameHelper.type());
byte[] asnX501DN = X501DistinguishedNameHelper.extract(any);
X500Principal x500Principal = new X500Principal(asnX501DN);
// To maintain compatibility with tWAS, the toString() method
// "is intentionally used because this is the only method which decodes extended attributes"
dn = x500Principal.toString();
} catch (Exception e) {
throw new SASException(1, e);
}
return dn;
}
|
java
|
private static String upperCaseIndexString(String iiopName) {
StringBuilder StringBuilder = new StringBuilder();
for (int i = 0; i < iiopName.length(); i++) {
char c = iiopName.charAt(i);
if (Character.isUpperCase(c)) {
StringBuilder.append('_').append(i);
}
}
return StringBuilder.toString();
}
|
java
|
private static String replace(String source, char oldChar, String newString) {
StringBuilder StringBuilder = new StringBuilder(source.length());
for (int i = 0; i < source.length(); i++) {
char c = source.charAt(i);
if (c == oldChar) {
StringBuilder.append(newString);
} else {
StringBuilder.append(c);
}
}
return StringBuilder.toString();
}
|
java
|
private static String buildOverloadParameterString(Class<?> parameterType) {
String name = "_";
int arrayDimensions = 0;
while (parameterType.isArray()) {
arrayDimensions++;
parameterType = parameterType.getComponentType();
}
// arrays start with org_omg_boxedRMI_
if (arrayDimensions > 0) {
name += "_org_omg_boxedRMI";
}
// IDLEntity types must be prefixed with org_omg_boxedIDL_
if (IDLEntity.class.isAssignableFrom(parameterType)) {
name += "_org_omg_boxedIDL";
}
// add package... some types have special mappings in corba
String packageName = specialTypePackages.get(parameterType.getName());
if (packageName == null) {
packageName = getPackageName(parameterType.getName());
}
if (packageName.length() > 0) {
name += "_" + packageName;
}
// arrays now contain a dimension indicator
if (arrayDimensions > 0) {
name += "_" + "seq" + arrayDimensions;
}
// add the class name
String className = specialTypeNames.get(parameterType.getName());
if (className == null) {
className = buildClassName(parameterType);
}
name += "_" + className;
return name;
}
|
java
|
private static String buildClassName(Class<?> type) {
if (type.isArray()) {
throw new IllegalArgumentException("type is an array: " + type);
}
// get the classname
String typeName = type.getName();
int endIndex = typeName.lastIndexOf('.');
if (endIndex < 0) {
return typeName;
}
StringBuilder className = new StringBuilder(typeName.substring(endIndex + 1));
// for innerclasses replace the $ separator with two underscores
// we can't just blindly replace all $ characters since class names can contain the $ character
if (type.getDeclaringClass() != null) {
String declaringClassName = getClassName(type.getDeclaringClass());
assert className.toString().startsWith(declaringClassName + "$");
className.replace(declaringClassName.length(), declaringClassName.length() + 1, "__");
}
// if we have a leading underscore prepend with J
if (className.charAt(0) == '_') {
className.insert(0, "J");
}
return className.toString();
}
|
java
|
public List<Persistence.PersistenceUnit> getPersistenceUnit() {
if (persistenceUnit == null) {
persistenceUnit = new ArrayList<Persistence.PersistenceUnit>();
}
return this.persistenceUnit;
}
|
java
|
public final static PersistenceType getPersistenceType(Byte aValue) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc,"Value = " + aValue);
return set[aValue.intValue()];
}
|
java
|
protected void register(String[] specificPackageList)
{
if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.entry(_tc, "register", new Object[] { this, specificPackageList });
synchronized(SibDiagnosticModule.class)
{
if (!_registeredMasterDiagnosticModule)
{
SibDiagnosticModule masterModule = new SibDiagnosticModule();
masterModule.registerModule(SIB_PACKAGE_LIST);
_registeredMasterDiagnosticModule = true;
}
}
this.registerModule(specificPackageList);
if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.exit(_tc, "register");
}
|
java
|
protected void captureDefaultInformation(IncidentStream is, Throwable th)
{
is.writeLine("Platform Messaging :: Messaging engine:", SibTr.getMEName(null));
// is.writeLine("Platform Messaging :: Release name: ", BuildInfo.getBuildRelease());
// is.writeLine("Platform Messaging :: Level name: ", BuildInfo.getBuildLevel());
if (th != null)
{
StackTraceElement[] ste = th.getStackTrace();
Set classes = new HashSet();
for (int i = 0; i < ste.length; i++)
{
final StackTraceElement elem = ste[i];
try
{
String className = elem.getClassName();
// We only care about .sib. classes
if (className.indexOf(SIB_PACKAGE_NAME)>=0)
{
if (!classes.contains(className))
{
//Kavitha - commenting out as ClassUtil removed
/* String sccid = (String)AccessController.doPrivileged(new GetClassSccsidPrivilegedOperation(className)) ;
if (sccid != null)
{
is.writeLine(className, sccid);
}*/
classes.add(className);
}
}
}
catch (Exception exception)
{
// No FFDC code needed
}
}
}
}
|
java
|
public void ffdcDumpDefault(Throwable t, IncidentStream is, Object callerThis, Object[] objs, String sourceId)
{
is.writeLine("SIB FFDC dump for:", t);
captureDefaultInformation(is,t);
if (callerThis != null)
{
is.writeLine("SibDiagnosticModule :: Dump of callerThis (DiagnosticModule)", toFFDCString(callerThis)); //255802
is.introspectAndWriteLine("Introspection of callerThis:", callerThis); //255802
}
if (objs != null)
{
for (int i = 0; i < objs.length; i++)
{
is.writeLine("callerArg (DiagnosticModule) [" + i + "]", //255802
toFFDCString(objs[i])); //287897
is.introspectAndWriteLine("callerArg [" + i + "] (Introspection)", objs[i]); //255802
}
}
}
|
java
|
public final String toFFDCString(Object obj)
{
if (obj instanceof Map)
{
return toFFDCString((Map) obj);
}
else if (obj instanceof Collection)
{
return toFFDCString((Collection) obj);
}
else if (obj instanceof Object[])
{
return toFFDCString((Object[]) obj);
}
return toFFDCStringSingleObject(obj);
}
|
java
|
protected String toFFDCStringSingleObject(Object obj)
{
if (obj == null)
{
return "<null>";
}
else if (obj instanceof Traceable)
{
return ((Traceable) obj).toTraceString();
}
else if (obj instanceof String)
{
return ((String) obj);
}
else if (obj instanceof byte[])
{
return toFFDCString((byte[]) obj);
}
else
{
return obj.toString();
}
}
|
java
|
public final String toFFDCString(Collection aCollection)
{
StringBuffer buffer = new StringBuffer();
buffer.append('{');
if (aCollection == null)
{
buffer.append("<null>");
}
else
{
Iterator i = aCollection.iterator();
boolean hasNext = i.hasNext();
int ctr = 0;
while (hasNext)
{
Object value = i.next();
buffer.append((value == aCollection ? "<this list>" : toFFDCStringSingleObject(value)) + lineSeparator);
hasNext = i.hasNext();
if (ctr > multiple_object_count_to_ffdc)
{
buffer.append("........contd");
hasNext = false;
}
}
}
buffer.append('}');
return buffer.toString();
}
|
java
|
public final String toFFDCString(Map aMap)
{
StringBuffer buffer = new StringBuffer();
buffer.append('{');
if (aMap == null)
{
buffer.append("<null>");
}
else
{
Iterator i = aMap.entrySet().iterator();
boolean hasNext = i.hasNext();
int ctr = 0;
while (hasNext)
{
Map.Entry entry = (Map.Entry) (i.next());
Object key = entry.getKey();
Object value = entry.getValue();
buffer.append((key == aMap ? "<this map>" : toFFDCStringSingleObject(key)) + "="
+ (value == aMap ? "<this map>" : toFFDCStringSingleObject(value)) + lineSeparator);
hasNext = i.hasNext();
if (ctr > multiple_object_count_to_ffdc)
{
buffer.append("........contd");
hasNext = false;
}
}
}
buffer.append('}');
return buffer.toString();
}
|
java
|
private boolean removeComments(DocumentBuilder parser, Document doc) {
try {
// Check for the traversal module
DOMImplementation impl = parser.getDOMImplementation();
if (!impl.hasFeature("traversal", "2.0")) {
// DOM implementation does not support traversal unable to remove comments
return false;
}
Node root = doc.getDocumentElement();
DocumentTraversal traversable = (DocumentTraversal) doc;
NodeIterator iterator = traversable.createNodeIterator(root, NodeFilter.SHOW_COMMENT, null, true);
Node node = null;
while ((node = iterator.nextNode()) != null) {
if (node.getNodeValue().trim().compareTo("Properties") != 0) {
root.removeChild(node);
}
}
} catch (FactoryConfigurationError e) {
return false;
}
return true;
}
|
java
|
public static void nodeListRemoveAll(Element xEml, NodeList nodes) {
int cnt = nodes.getLength();
for (int i = 0; i < cnt; i++)
xEml.removeChild(nodes.item(0));
}
|
java
|
private ServiceRegistration<?> registerMBeanService(String jmsResourceName, BundleContext bundleContext) {
Dictionary<String, String> props = new Hashtable<String, String>();
props.put(KEY_SERVICE_VENDOR, "IBM");
JmsServiceProviderMBeanImpl jmsProviderMBean = new JmsServiceProviderMBeanImpl(getServerName(), KEY_JMS2_PROVIDER);
props.put(KEY_JMX_OBJECTNAME, jmsProviderMBean.getobjectName());
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "JmsQueueMBeanImpl=" + jmsProviderMBean.getobjectName() + " props=" + props);
}
return bundleContext.registerService(JmsServiceProviderMBeanImpl.class, jmsProviderMBean, props);
}
|
java
|
private static Object invokeDefaultMethodUsingPrivateLookup(Class<?> declaringClass, Object o, Method m,
Object[] params) throws WrappedException, NoSuchMethodException {
try {
final Method privateLookup = MethodHandles
.class
.getDeclaredMethod("privateLookupIn", Class.class, MethodHandles.Lookup.class);
return ((MethodHandles.Lookup)privateLookup
.invoke(null, declaringClass, MethodHandles.lookup()))
.unreflectSpecial(m, declaringClass)
.bindTo(o)
.invokeWithArguments(params);
} catch (NoSuchMethodException t) {
throw t;
} catch (Throwable t) {
throw new WrappedException(t);
}
}
|
java
|
@Override
public WsByteBuffer buildFrameForWrite() {
WsByteBuffer[] output = buildFrameArrayForWrite();
int size = 0;
for (WsByteBuffer b : output) {
if (b != null) {
size += b.remaining();
}
}
WsByteBuffer singleBuffer = this.getBuffer(size);
singleBuffer.put(output);
singleBuffer.flip();
return singleBuffer;
}
|
java
|
public EJSHome create(BeanMetaData beanMetaData)
throws RemoteException
{
J2EEName name = beanMetaData.j2eeName;
HomeRecord hr = beanMetaData.homeRecord;
StatelessBeanO homeBeanO = null;
EJSHome result = null;
try {
result = (EJSHome) beanMetaData.homeBeanClass.newInstance();
homeBeanO = (StatelessBeanO) beanOFactory.create(container, null, false);
homeBeanO.setEnterpriseBean(result);
} catch (Exception ex) {
FFDCFilter.processException(ex, CLASS_NAME + ".create", "90", this);
throw new InvalidEJBClassNameException("", ex);
}
homeBeanO.reentrant = true;
hr.beanO = homeBeanO; //LIDB859-4
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "created new home bean", name);
return result;
}
|
java
|
public void addHome(BeanMetaData bmd) // F743-26072
throws RemoteException
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "addHome : " + bmd.j2eeName);
if (homesByName.get(bmd.j2eeName) != null) {
throw new DuplicateHomeNameException(bmd.j2eeName.toString());
}
homesByName.put(bmd.j2eeName, bmd.homeRecord); // d366845.3
J2EEName j2eeName = bmd.j2eeName;
String application = j2eeName.getApplication();
AppLinkData linkData;
// F743-26072 - Use AppLinkData
synchronized (ivAppLinkData)
{
linkData = ivAppLinkData.get(application);
if (linkData == null)
{
if (isTraceOn && tc.isEntryEnabled())
Tr.debug(tc, "adding application link data for " + application);
linkData = new AppLinkData();
ivAppLinkData.put(application, linkData);
}
}
updateAppLinkData(linkData, true, j2eeName, bmd);
// For version cable modules, the serialized BeanId will contain the
// unversioned (or base) name, so a map is created from unversioned to
// active to enable properly routing incoming requests. F54184
if (bmd._moduleMetaData.isVersionedModule())
{
EJBModuleMetaDataImpl mmd = bmd._moduleMetaData;
bmd.ivUnversionedJ2eeName = j2eeNameFactory.create(mmd.ivVersionedAppBaseName,
mmd.ivVersionedModuleBaseName,
j2eeName.getComponent());
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "Versioned Mapping Added : " + bmd.ivUnversionedJ2eeName + " -> " + j2eeName);
J2EEName dupBaseName = ivVersionedModuleNames.put(bmd.ivUnversionedJ2eeName, j2eeName);
if (dupBaseName != null) // F54184.2
{
ivVersionedModuleNames.put(bmd.ivUnversionedJ2eeName, dupBaseName);
throw new DuplicateHomeNameException("Base Name : " + bmd.ivUnversionedJ2eeName);
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "addHome");
}
|
java
|
private void updateAppLinkData(AppLinkData linkData, boolean add, J2EEName j2eeName, BeanMetaData bmd) // F743-26072
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "updateAppLinkData: " + j2eeName + ", add=" + add);
int numBeans;
synchronized (linkData)
{
linkData.ivNumBeans += add ? 1 : -1;
numBeans = linkData.ivNumBeans;
// Update the table of bean names for this application, in support
// of ejb-link. d429866.1
updateAppLinkDataTable(linkData.ivBeansByName, add, j2eeName.getComponent(), j2eeName, "ivBeansByName");
// Update the table of bean interfaces for this application, in support
// of auto-link. d429866.2
updateAutoLink(linkData, add, j2eeName, bmd);
// F743-25385CodRv d648723
// Update the table of logical-to-physical module names, in support of
// ejb-link.
// F743-26072 - This will redundantly add the same entry for every
// bean in the module, but it will remove the entry for the first bean
// to be removed. In other words, we do not support removing a single
// bean from a module.
updateAppLinkDataTable(linkData.ivModulesByLogicalName, add,
bmd._moduleMetaData.ivLogicalName, j2eeName.getModule(), "ivModulesByLogicalName");
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "updateAppLinkData: " + j2eeName + ", add=" + add + ", numBeans=" + numBeans);
}
|
java
|
private static <T> void updateAppLinkDataTable(Map<String, Set<T>> table,
boolean add,
String key,
T value,
String tracePrefix) // F743-26072
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
Set<T> values = table.get(key);
if (add)
{
if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
Tr.debug(tc, tracePrefix + ": adding " + key + " = " + value);
if (values == null)
{
values = new LinkedHashSet<T>();
table.put(key, values);
}
values.add(value);
}
else
{
if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
Tr.debug(tc, tracePrefix + ": removing " + key + " = " + value);
if (values != null) // d657052
{
values.remove(value);
if (values.size() == 0) // d657052
{
if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
Tr.debug(tc, tracePrefix + ": removing " + key);
table.remove(key);
}
}
else
{
if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
Tr.debug(tc, tracePrefix + ": key not found: " + key);
}
}
}
|
java
|
private void updateAutoLink(AppLinkData linkData, boolean add, J2EEName j2eeName, BeanMetaData bmd)
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "updateAutoLink");
String module = j2eeName.getModule();
String beanInterface = null;
// -----------------------------------------------------------------------
// Locate the table of interfaces for the module and application d446993
// -----------------------------------------------------------------------
Map<String, Set<J2EEName>> appTable = linkData.ivBeansByType;
Map<String, Set<J2EEName>> moduleTable = linkData.ivBeansByModuleByType.get(module);
if (moduleTable == null)
{
moduleTable = new HashMap<String, Set<J2EEName>>(7);
linkData.ivBeansByModuleByType.put(module, moduleTable);
}
// -----------------------------------------------------------------------
// Add all of the interfaces of the EJB which may be injected/looked up
// -----------------------------------------------------------------------
beanInterface = bmd.homeInterfaceClassName;
if (beanInterface != null)
{
updateAppLinkDataTable(appTable, add, beanInterface, j2eeName, "ivBeansByType");
updateAppLinkDataTable(moduleTable, add, beanInterface, j2eeName, null);
}
beanInterface = bmd.localHomeInterfaceClassName;
if (beanInterface != null)
{
updateAppLinkDataTable(appTable, add, beanInterface, j2eeName, "ivBeansByType");
updateAppLinkDataTable(moduleTable, add, beanInterface, j2eeName, null);
}
String[] businessRemoteInterfaceName = bmd.ivBusinessRemoteInterfaceClassNames;
if (businessRemoteInterfaceName != null)
{
for (String remoteInterface : businessRemoteInterfaceName)
{
updateAppLinkDataTable(appTable, add, remoteInterface, j2eeName, "ivBeansByType");
updateAppLinkDataTable(moduleTable, add, remoteInterface, j2eeName, null);
}
}
String[] businessLocalInterfaceName = bmd.ivBusinessLocalInterfaceClassNames;
if (businessLocalInterfaceName != null)
{
for (String localInterface : businessLocalInterfaceName)
{
updateAppLinkDataTable(appTable, add, localInterface, j2eeName, "ivBeansByType");
updateAppLinkDataTable(moduleTable, add, localInterface, j2eeName, null);
}
}
// F743-1756 - Also add No-Interface View to maps for injection/lookup
if (bmd.ivLocalBean)
{
beanInterface = bmd.enterpriseBeanClassName;
updateAppLinkDataTable(appTable, add, beanInterface, j2eeName, "ivBeansByType");
updateAppLinkDataTable(moduleTable, add, beanInterface, j2eeName, null);
}
// F743-26072 - If this was the last bean in the module type table, then
// remove the module type table.
if (moduleTable.isEmpty())
{
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "ivBeansByModuleByType: removing " + module);
linkData.ivBeansByModuleByType.remove(module);
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "updateAutoLink");
}
|
java
|
@Override
public BeanO createBeanO(EJBThreadData threadData, ContainerTx tx, BeanId id)
throws RemoteException
{
J2EEName homeKey = id.getJ2EEName(); // d366845.3
HomeRecord hr = homesByName.get(homeKey); // d366845.3
BeanO result = null; // d199071
if (hr != null) { // d199071
result = hr.beanO; // d199071
}
if (result == null)
{
// This will only ever occur when an attempt is being made to
// invoke a method on a home wrapper, where the home has been
// uninstalled since the wrapper was obtained. Doing nothing
// would result in an NPE, so instead, a meaningful exception
// should be reported. d547849
// If HR exists, but no beanO, then the application was started
// again, but the bean hasn't started yet, still an error. d716824
String msgTxt =
"The referenced version of the " + homeKey.getComponent() +
" bean in the " + homeKey.getApplication() +
" application has been stopped and may no longer be used. " +
"If the " + homeKey.getApplication() +
" application has been started again, a new reference for " +
"the new image of the " + homeKey.getComponent() +
" bean must be obtained. Local references to a bean or home " +
"are no longer valid once the application has been stopped.";
throw new EJBStoppedException(msgTxt);
}
return result;
}
|
java
|
@Override
public String getEnterpriseBeanClassName(Object homeKey)
{
HomeRecord hr = homesByName.get(homeKey); // d366845.3
return hr.homeInternal.getEnterpriseBeanClassName(homeKey);
}
|
java
|
public Object resolveVariable(String pName) throws ELException {
ELContext ctx = this.getELContext();
return ctx.getELResolver().getValue(ctx, null, pName);
}
|
java
|
private void copyTagToPageScope(int scope) {
Iterator iter = null;
switch (scope) {
case VariableInfo.NESTED:
if (nestedVars != null) {
iter = nestedVars.iterator();
}
break;
case VariableInfo.AT_BEGIN:
if (atBeginVars != null) {
iter = atBeginVars.iterator();
}
break;
case VariableInfo.AT_END:
if (atEndVars != null) {
iter = atEndVars.iterator();
}
break;
}
while ((iter != null) && iter.hasNext()) {
String varName = (String) iter.next();
Object obj = getAttribute(varName);
varName = findAlias(varName);
if (obj != null) {
invokingJspCtxt.setAttribute(varName, obj);
} else {
invokingJspCtxt.removeAttribute(varName, PAGE_SCOPE);
}
}
}
|
java
|
private void saveNestedVariables() {
if (nestedVars != null) {
Iterator iter = nestedVars.iterator();
while (iter.hasNext()) {
String varName = (String) iter.next();
varName = findAlias(varName);
Object obj = invokingJspCtxt.getAttribute(varName);
if (obj != null) {
originalNestedVars.put(varName, obj);
}
}
}
}
|
java
|
private void restoreNestedVariables() {
if (nestedVars != null) {
Iterator iter = nestedVars.iterator();
while (iter.hasNext()) {
String varName = (String) iter.next();
varName = findAlias(varName);
Object obj = originalNestedVars.get(varName);
if (obj != null) {
invokingJspCtxt.setAttribute(varName, obj);
} else {
invokingJspCtxt.removeAttribute(varName, PAGE_SCOPE);
}
}
}
}
|
java
|
public RangeObject getNext()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getNext", Integer.valueOf(cursor));
int curr = cursor;
cursor = cursor < (blockVector.size() - 1) ? cursor + 1 : cursor;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getNext", new Object[] {blockVector.get(curr), Integer.valueOf(cursor)});
return (RangeObject) blockVector.get(curr);
}
|
java
|
public void replacePrefix(RangeObject w)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "replacePrefix", w);
long lstamp = w.endstamp;
// Set index to position of lstamp.
int lindex;
RangeObject lastro;
for (lindex = 0;; lindex++)
{
lastro = (RangeObject) blockVector.get(lindex);
if ((lstamp <= lastro.endstamp) && (lstamp >= lastro.startstamp))
break;
}
if (lstamp < lastro.endstamp)
{
// lastro will not be removed so change its range
// lastro = (RangeObject) lastro.clone();
lastro.startstamp = lstamp + 1;
// blockVector.m_data[lindex] = lastro;
// figure out how much space to add or remove
if (lindex == 0)
{ // need to create 1 space
blockVector.insertNullElementsAt(0, 1);
}
else
{ // remove lindex - 1 elements
if ((lindex - 1) > 0)
blockVector.removeElementsAt(0, lindex - 1);
}
}
else
{ // everything upto and including lindex will be discarded
if (lindex > 0)
blockVector.removeElementsAt(0, lindex);
}
blockVector.set(0, w);
cursor = 0;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "replacePrefix");
}
|
java
|
protected final int getIndex(long stamp)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getIndex", Long.valueOf(stamp));
int first = 0;
int last = blockVector.size();
int index = linearSearch(stamp, first, last - 1);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getIndex", index);
return index;
}
|
java
|
protected void handleJwtRequest(HttpServletRequest request, HttpServletResponse response,
ServletContext servletContext, JwtConfig jwtConfig, EndpointType endpointType) throws IOException {
if (jwtConfig == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "No JwtConfig object provided");
}
return;
}
switch (endpointType) {
case jwk:
processJWKRequest(response, jwtConfig);
return;
case token:
try {
if (!isTransportSecure(request)) {
String url = request.getRequestURL().toString();
Tr.error(tc, "SECURITY.JWT.ERROR.WRONG.HTTP.SCHEME", new Object[] { url });
response.sendError(HttpServletResponse.SC_NOT_FOUND,
Tr.formatMessage(tc, "SECURITY.JWT.ERROR.WRONG.HTTP.SCHEME", new Object[] { url }));
return;
}
boolean result = request.authenticate(response);
if (tc.isDebugEnabled()) {
Tr.debug(tc, "request.authenticate result: " + result);
}
// if false, then not authenticated,
// a 401 w. auth challenge will be sent back and
// the response will be committed.
// Requester can then try again with creds on a new request.
if (result == false) {
return;
}
} catch (ServletException e) {
// ffdc
return;
}
processTokenRequest(response, jwtConfig);
return;
default:
break;
}
}
|
java
|
private boolean isTransportSecure(HttpServletRequest req) {
String url = req.getRequestURL().toString();
if (req.getScheme().equals("https")) {
return true;
}
String value = req.getHeader("X-Forwarded-Proto");
if (value != null && value.toLowerCase().equals("https")) {
return true;
}
return false;
}
|
java
|
private void processTokenRequest(HttpServletResponse response, JwtConfig jwtConfig) throws IOException {
String tokenString = new TokenBuilder().createTokenString(jwtConfig);
addNoCacheHeaders(response);
response.setStatus(200);
if (tokenString == null) {
return;
}
try {
PrintWriter pw = response.getWriter();
response.setHeader(WebConstants.HTTP_HEADER_CONTENT_TYPE, WebConstants.HTTP_CONTENT_TYPE_JSON);
pw.write("{\"token\": \"" + tokenString + "\"}");
pw.flush();
pw.close();
} catch (IOException e) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Caught an exception attempting to get the response writer: " + e.getLocalizedMessage());
}
}
}
|
java
|
private void processJWKRequest(HttpServletResponse response, JwtConfig jwtConfig) throws IOException {
/*
* if (!jwtConfig.isJwkEnabled()) { String errorMsg =
* Tr.formatMessage(tc, "JWK_ENDPOINT_JWK_NOT_ENABLED", new Object[] {
* jwtConfig.getId() }); Tr.error(tc, errorMsg);
* response.sendError(HttpServletResponse.SC_BAD_REQUEST, errorMsg);
* return; }
*/
String signatureAlg = jwtConfig.getSignatureAlgorithm();
if (!Constants.SIGNATURE_ALG_RS256.equals(signatureAlg)) {
String errorMsg = Tr.formatMessage(tc, "JWK_ENDPOINT_WRONG_ALGORITHM",
new Object[] { jwtConfig.getId(), signatureAlg, Constants.SIGNATURE_ALG_RS256 });
Tr.error(tc, errorMsg);
response.sendError(HttpServletResponse.SC_BAD_REQUEST, errorMsg);
return;
}
String jwkString = jwtConfig.getJwkJsonString();
addNoCacheHeaders(response);
response.setStatus(200);
if (jwkString == null) {
return;
}
try {
PrintWriter pw = response.getWriter();
response.setHeader(WebConstants.HTTP_HEADER_CONTENT_TYPE, WebConstants.HTTP_CONTENT_TYPE_JSON);
pw.write(jwkString);
pw.flush();
pw.close();
} catch (IOException e) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Caught an exception attempting to get the response writer: " + e.getLocalizedMessage());
}
}
}
|
java
|
protected void addNoCacheHeaders(HttpServletResponse response) {
String cacheControlValue = response.getHeader(WebConstants.HEADER_CACHE_CONTROL);
if (cacheControlValue != null && !cacheControlValue.isEmpty()) {
cacheControlValue = cacheControlValue + ", " + WebConstants.CACHE_CONTROL_NO_STORE;
} else {
cacheControlValue = WebConstants.CACHE_CONTROL_NO_STORE;
}
response.setHeader(WebConstants.HEADER_CACHE_CONTROL, cacheControlValue);
response.setHeader(WebConstants.HEADER_PRAGMA, WebConstants.PRAGMA_NO_CACHE);
}
|
java
|
protected void activate() throws Exception {
// If the ProbeProxy class is available, check it's version
String runtimeVersion = getRuntimeClassVersion();
if (runtimeVersion != null && !runtimeVersion.equals(getCurrentVersion())) {
// TODO: Use a compatibility check instead
throw new IllegalStateException("Incompatible proxy code (version " + runtimeVersion + ")");
}
// Find or create the proxy jar if the runtime code isn't loaded
if (runtimeVersion == null) {
JarFile proxyJar = getBootProxyJarIfCurrent();
if (proxyJar == null) {
proxyJar = createBootProxyJar();
}
instrumentation.appendToBootstrapClassLoaderSearch(proxyJar);
}
// Hook up the proxies
activateProbeProxyTarget();
activateClassAvailableProxyTarget();
}
|
java
|
@FFDCIgnore(Exception.class)
String getRuntimeClassVersion() {
String runtimeVersion = null;
try {
Class<?> clazz = Class.forName(PROBE_PROXY_CLASS_NAME);
Field version = ReflectionHelper.getDeclaredField(clazz, VERSION_FIELD_NAME);
runtimeVersion = (String) version.get(null);
} catch (Exception e) {
}
return runtimeVersion;
}
|
java
|
JarFile getBootProxyJarIfCurrent() {
File dataFile = bundleContext.getDataFile("boot-proxy.jar");
if (!dataFile.exists()) {
return null;
}
JarFile jarFile = null;
try {
jarFile = new JarFile(dataFile);
Manifest manifest = jarFile.getManifest();
Attributes attrs = manifest.getMainAttributes();
String jarVersion = attrs.getValue(MONITORING_VERSION_MANIFEST_HEADER);
if (!getCurrentVersion().equals(jarVersion)) {
jarFile.close();
jarFile = null;
}
} catch (Exception e) {
}
return jarFile;
}
|
java
|
JarFile createBootProxyJar() throws IOException {
File dataFile = bundleContext.getDataFile("boot-proxy.jar");
// Create the file if it doesn't already exist
if (!dataFile.exists()) {
dataFile.createNewFile();
}
// Generate a manifest
Manifest manifest = createBootJarManifest();
// Create the file
FileOutputStream fileOutputStream = new FileOutputStream(dataFile, false);
JarOutputStream jarOutputStream = new JarOutputStream(fileOutputStream, manifest);
// Add the jar path entries to reduce class load times
createDirectoryEntries(jarOutputStream, BOOT_DELEGATED_PACKAGE);
// Map the template classes into the delegation package and add to the jar
Bundle bundle = bundleContext.getBundle();
Enumeration<?> entryPaths = bundle.getEntryPaths(TEMPLATE_CLASSES_PATH);
if (entryPaths != null) {
while (entryPaths.hasMoreElements()) {
URL sourceClassResource = bundle.getEntry((String) entryPaths.nextElement());
if (sourceClassResource != null)
writeRemappedClass(sourceClassResource, jarOutputStream, BOOT_DELEGATED_PACKAGE);
}
}
jarOutputStream.close();
fileOutputStream.close();
return new JarFile(dataFile);
}
|
java
|
public void createDirectoryEntries(JarOutputStream jarStream, String packageName) throws IOException {
StringBuilder entryName = new StringBuilder(packageName.length());
for (String str : packageName.split("\\.")) {
entryName.append(str).append("/");
JarEntry jarEntry = new JarEntry(entryName.toString());
jarStream.putNextEntry(jarEntry);
}
}
|
java
|
private void writeRemappedClass(URL classUrl, JarOutputStream jarStream, String targetPackage) throws IOException {
InputStream inputStream = classUrl.openStream();
String sourceInternalName = getClassInternalName(classUrl);
String targetInternalName = getTargetInternalName(sourceInternalName, targetPackage);
SimpleRemapper remapper = new SimpleRemapper(sourceInternalName, targetInternalName);
ClassReader reader = new ClassReader(inputStream);
ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES);
ClassRemapper remappingVisitor = new ClassRemapper(writer, remapper);
ClassVisitor versionVisitor = new AddVersionFieldClassAdapter(remappingVisitor, VERSION_FIELD_NAME, getCurrentVersion());
reader.accept(versionVisitor, ClassReader.EXPAND_FRAMES);
JarEntry jarEntry = new JarEntry(targetInternalName + ".class");
jarStream.putNextEntry(jarEntry);
jarStream.write(writer.toByteArray());
}
|
java
|
String getTargetInternalName(String sourceInternalName, String targetPackage) {
StringBuilder targetInternalName = new StringBuilder();
targetInternalName.append(targetPackage.replaceAll("\\.", "/"));
int lastSlashIndex = sourceInternalName.lastIndexOf('/');
targetInternalName.append(sourceInternalName.substring(lastSlashIndex));
return targetInternalName.toString();
}
|
java
|
void activateProbeProxyTarget() throws Exception {
Method method = ReflectionHelper.getDeclaredMethod(
probeManagerImpl.getClass(),
ProbeMethodAdapter.FIRE_PROBE_METHOD_NAME,
long.class, Object.class, Object.class, Object.class);
ReflectionHelper.setAccessible(method, true);
if (!Type.getMethodDescriptor(method).equals(ProbeMethodAdapter.FIRE_PROBE_METHOD_DESC)) {
throw new IncompatibleClassChangeError("Proxy method signature does not match byte code");
}
findProbeProxySetFireProbeTargetMethod().invoke(null, probeManagerImpl, method);
}
|
java
|
@Override
public void setWebApp(com.ibm.ws.webcontainer.webapp.WebApp webApp)
{
super.setWebApp((WebApp)webApp);
}
|
java
|
public static boolean isBeanValidationAvailable()
{
if (beanValidationAvailable == null)
{
try
{
try
{
beanValidationAvailable = (Class.forName("javax.validation.Validation") != null);
}
catch(ClassNotFoundException e)
{
beanValidationAvailable = Boolean.FALSE;
}
if (beanValidationAvailable)
{
try
{
// Trial-error approach to check for Bean Validation impl existence.
// If any Exception occurs here, we assume that Bean Validation is not available.
// The cause may be anything, i.e. NoClassDef, config error...
_ValidationUtils.tryBuildDefaultValidatorFactory();
}
catch (Throwable t)
{
log.log(Level.FINE, "Error initializing Bean Validation (could be normal)", t);
beanValidationAvailable = false;
}
}
}
catch (Throwable t)
{
log.log(Level.FINE, "Error loading class (could be normal)", t);
beanValidationAvailable = false;
}
//log.info("MyFaces Bean Validation support " + (beanValidationAvailable ? "enabled" : "disabled"));
}
return beanValidationAvailable;
}
|
java
|
void handleRollback(SubscriptionMessage subMessage,
LocalTransaction transaction)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "handleRollback", new Object[] { subMessage, transaction });
try
{
if (transaction != null)
{
try
{
transaction.rollback();
}
catch (SIException e)
{
// If there are any exceptions, then this is bad, log a FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.proxyhandler.NeighbourProxyListener.handleRollback",
"1:330:1.73",
this);
SibTr.exception(tc, e);
}
}
Transaction msTran = iProxyHandler.getMessageProcessor().resolveAndEnlistMsgStoreTransaction(transaction);
switch (subMessage.getSubscriptionMessageType().toInt())
{
case SubscriptionMessageType.CREATE_INT :
// Remove any created Proxy subscriptions
iProxyHandler.remoteUnsubscribeEvent(iAddTopicSpaces,
iAddTopics,
subMessage.getBus(),
msTran,
false);
break;
case SubscriptionMessageType.DELETE_INT :
// Create any removed Proxy subscriptions
iProxyHandler.remoteSubscribeEvent(iDeleteTopicSpaces,
iDeleteTopics,
subMessage.getBus(),
msTran,
false);
break;
case SubscriptionMessageType.RESET_INT :
// Remove any created Proxy subscriptions
iProxyHandler.remoteUnsubscribeEvent(iAddTopicSpaces,
iAddTopics,
subMessage.getBus(),
msTran,
false);
// Create any removed Proxy subscriptions
iProxyHandler.remoteSubscribeEvent(iDeleteTopicSpaces,
iDeleteTopics,
subMessage.getBus(),
msTran,
false);
break;
default :
// Log Message
break;
}
}
catch (SIException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.proxyhandler.NeighbourProxyListener.handleRollback",
"1:392:1.73",
this);
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "handleRollback");
}
|
java
|
void handleDeleteProxySubscription(SubscriptionMessage deleteMessage,
Transaction transaction) throws SIResourceException
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "handleDeleteProxySubscription",
new Object[] { deleteMessage, transaction });
// Get the iterators that we require for this method
final Iterator topics = deleteMessage.getTopics().iterator();
final Iterator topicSpaces = deleteMessage.getTopicSpaces().iterator();
final Iterator topicSpaceMappings = deleteMessage.getTopicSpaceMappings().iterator();
// Get the Me name and ME uuid
final byte[] meUUIDArr = deleteMessage.getMEUUID();
final SIBUuid8 meUUID = new SIBUuid8(meUUIDArr);
// Get the bus that this message arrived from
final String busId = deleteMessage.getBusName();
//now we have the relevant information we
//can delete the proxy subscription
deleteProxySubscription(topics,
topicSpaces, topicSpaceMappings, meUUID, busId, transaction);
if (tc.isEntryEnabled())
SibTr.exit(tc, "handleDeleteProxySubscription");
}
|
java
|
public void setKerberosConnection() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "setting this mc to indicate it was gotten using kerberos");
kerberosConnection = true;
}
|
java
|
public void markStale() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "mark mc stale");
_mcStale = true;
}
|
java
|
private final void addHandle(WSJdbcConnection handle) throws ResourceException {
(numHandlesInUse < handlesInUse.length - 1 ? handlesInUse : resizeHandleList())[numHandlesInUse++] = handle;
if (!inRequest && dsConfig.get().enableBeginEndRequest)
try {
inRequest = true;
mcf.jdbcRuntime.beginRequest(sqlConn);
} catch (SQLException x) {
FFDCFilter.processException(x, getClass().getName(), "548", this);
throw new DataStoreAdapterException("DSA_ERROR", x, getClass());
}
}
|
java
|
public void connectionClosed(javax.sql.ConnectionEvent event) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
Tr.event(this, tc, "connectionClosed", "Notification of connection closed received from the JDBC driver", AdapterUtil.toString(event.getSource()));
// We have intentionally removed our connection event listener prior to closing the
// underlying connection. Therefore, if this event ever occurs, it indicates a
// scenario where the connection has been closed unexpectedly by the JDBC driver
// or database. We will treat this as a connection error.
if(isAborted()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "The connection was aborted, so this event will not be processed");
} else {
processConnectionErrorOccurredEvent(null, event.getSQLException());
}
}
|
java
|
private void destroyStatement(Object unwantedStatement) {
try {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc,
"Statement cache at capacity. Discarding a statement.",
AdapterUtil.toString(unwantedStatement));
((Statement) unwantedStatement).close();
} catch (SQLException closeX) {
FFDCFilter.processException(
closeX, getClass().getName() + ".discardStatement", "511", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "Error closing statement", AdapterUtil.toString(unwantedStatement), closeX);
}
}
|
java
|
final void detectMultithreadedAccess() {
Thread currentThreadID = Thread.currentThread();
if (currentThreadID == threadID)
return;
if (threadID == null)
threadID = currentThreadID;
else {
mcf.detectedMultithreadedAccess = true;
java.io.StringWriter writer = new java.io.StringWriter();
new Error().printStackTrace(new java.io.PrintWriter(writer));
Tr.warning(tc, "MULTITHREADED_ACCESS_DETECTED",
this,
Integer.toHexString(threadID.hashCode()) + ' ' + threadID,
Integer.toHexString(currentThreadID.hashCode()) + ' ' + currentThreadID,
writer.getBuffer().delete(0, "java.lang.Error".length())
);
}
}
|
java
|
public void dissociateConnections() throws ResourceException
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(this, tc, "dissociateConnections");
// The first exception to occur while dissociating connection handles.
ResourceException firstX = null;
// Indicate that we are cleaning up handles, so we know not to send events for
// operations done in the cleanup.
cleaningUpHandles = true;
for (int i = numHandlesInUse; i > 0;)
try
{
handlesInUse[--i].dissociate();
handlesInUse[i] = null;
} catch (ResourceException dissociationX) {
// No FFDC code needed because the following method does any FFDC that might
// be necessary.
dissociationX = processHandleDissociationError(i, dissociationX);
if (firstX == null)
firstX = dissociationX;
}
numHandlesInUse = 0;
cleaningUpHandles = false;
// - need to dissociate the cachedConnection too
// - we can't dissocate the cachedConnection because DB2 has direct access to our WSJccConnection
// and the preparedStatement wrapper. They can't follow the normal jdbc model because the sqlj engine
// was written by Oracle. Therefore, we put the restriction that the BMP must run in a unshareable mode
// it caches the handle. In this case, we never need to dissociate the cached handle.
/*
* try
* if (cachedConnection != null)
* ((Reassociateable)cachedConnection).dissociate();
* }catch (ResourceException dissociationX2)
* // No FFDC code needed because the following method does any FFDC that might
* // be necessary.
* dissociationX2 = processHandleDissociationError2((Reassociateable)cachedConnection, dissociationX2);
* if (firstX == null) firstX = dissociationX2;
*/
if (firstX != null) {
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(this, tc, "dissociateConnections", firstX);
throw firstX;
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(this, tc, "dissociateConnections");
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.