code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
protected int getAllowCachedTimerData(J2EEName j2eeName) {
Integer allowCachedTimerData = null;
Map<String, Integer> localAllowCachedTimerDataMap = allowCachedTimerDataMap;
if (localAllowCachedTimerDataMap != null) {
allowCachedTimerData = localAllowCachedTimerDataMap.get(j2eeName.toString());
if (allowCachedTimerData == null) {
allowCachedTimerData = localAllowCachedTimerDataMap.get("*");
}
}
return allowCachedTimerData != null ? allowCachedTimerData : 0;
}
|
java
|
public void batchUpdate(HashMap invalidateIdEvents, HashMap invalidateTemplateEvents, ArrayList pushEntryEvents, ArrayList aliasEntryEvents, CacheUnit cacheUnit) { //CCC
// nothing to do for NullNotification
}
|
java
|
public static JCATranWrapper getTxWrapper(Xid xid, boolean addAssociation) throws XAException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getTxWrapper", new Object[] { xid, addAssociation});
final ByteArray key = new ByteArray(xid.getGlobalTransactionId());
final JCATranWrapper txWrapper;
synchronized (txnTable)
{
txWrapper = txnTable.get(key);
if (txWrapper != null)
{
if (addAssociation)
{
if (!txWrapper.hasAssociation())
{
txWrapper.addAssociation();
}
else
{
// Already associated
if (tc.isEntryEnabled()) Tr.exit(tc, "getTxWrapper", "throwing XAER_PROTO");
throw new XAException(XAException.XAER_PROTO);
}
}
}
else
{
if (tc.isEntryEnabled()) Tr.exit(tc, "getTxWrapper", "throwing XAER_NOTA");
throw new XAException(XAException.XAER_NOTA);
}
}
if (tc.isEntryEnabled()) Tr.exit(tc, "getTxWrapper", txWrapper);
return txWrapper;
}
|
java
|
protected JCATranWrapper findTxWrapper(int timeout, Xid xid, String providerId) throws WorkCompletedException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "findTxWrapper", new Object[] { timeout, xid, providerId });
final JCATranWrapper txWrapper;
final ByteArray key = new ByteArray(xid.getGlobalTransactionId());
synchronized (txnTable)
{
if (!txnTable.containsKey(key))
{
// XID has not been encountered - create a new TransactionImpl and add it to the table
// ......unless we're quiescing
if(!((TranManagerSet)TransactionManagerFactory.getTransactionManager()).isQuiesced())
{
final JCARecoveryData jcard = (JCARecoveryData) ((TranManagerSet)TransactionManagerFactory.getTransactionManager()).registerJCAProvider(providerId);
try
{
jcard.logRecoveryEntry();
}
catch(Exception e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "findTxWrapper", e);
throw new WorkCompletedException(e.getLocalizedMessage(), WorkException.TX_RECREATE_FAILED);
}
// Create a new wrapper, suspend any transaction, create the new TransactionImpl and mark associated
txWrapper = createWrapper(timeout, xid, jcard);
txnTable.put(key, txWrapper);
}
else
{
if (tc.isEntryEnabled()) Tr.exit(tc, "findTxWrapper", "quiescing");
throw new WorkCompletedException("In quiesce period", WorkException.TX_RECREATE_FAILED);
}
}
else
{
// XID has already been imported, retrieve JCATranWrapper from table
if (tc.isEventEnabled()) Tr.event(tc, "Already encountered", key);
txWrapper = txnTable.get(key);
// If we already had an association, return null so
// caller knows to throw an exception.
if (!txWrapper.hasAssociation())
{
// If we were already prepared, return null so
// caller knows to throw an exception.
if (!txWrapper.isPrepared())
{
txWrapper.addAssociation();
}
else
{
if (tc.isEntryEnabled()) Tr.exit(tc, "findTxWrapper", "already prepared");
return null;
}
}
else
{
if (tc.isEntryEnabled()) Tr.exit(tc, "findTxWrapper", "already associated");
return null;
}
// d240298 - Suspend any local transaction before we return,
// save it in the wrapper for resuming later
txWrapper.suspend(); // @D240298A
}
}
if (tc.isEntryEnabled()) Tr.exit(tc, "findTxWrapper", txWrapper);
return txWrapper;
}
|
java
|
protected JCATranWrapper createWrapper(int timeout, Xid xid, JCARecoveryData jcard) throws WorkCompletedException /* @512190C*/
{
return new JCATranWrapperImpl(timeout, xid, jcard); // @D240298C
}
|
java
|
public static void addTxn(TransactionImpl txn)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "addTxn", txn);
final ByteArray key = new ByteArray(txn.getXid().getGlobalTransactionId());
synchronized (txnTable)
{
if (!txnTable.containsKey(key))
{
txnTable.put(key, new JCATranWrapperImpl(txn, true, false)); // @LIDB2110C
}
}
if (tc.isEntryEnabled()) Tr.exit(tc, "addTxn");
}
|
java
|
@SuppressWarnings("unchecked")
public K getKey(int index)
{
if ((index < 0) || (index >= size()))
{
throw new IndexOutOfBoundsException();
}
return (K) _array[index * 2];
}
|
java
|
@SuppressWarnings("unchecked")
public V getValue(int index)
{
if ((index < 0) || (index >= size()))
{
throw new IndexOutOfBoundsException();
}
return (V) _array[index * 2 + 1];
}
|
java
|
static public Object get(Object[] array, Object key)
{
Object o = getByIdentity(array, key);
if (o != null)
{
return o;
}
return getByEquality(array, key);
}
|
java
|
static public Object getByIdentity(Object[] array, Object key)
{
if (array != null)
{
int length = array.length;
for (int i = 0; i < length; i += 2)
{
if (array[i] == key)
{
return array[i + 1];
}
}
}
return null;
}
|
java
|
static public Object getByEquality(Object[] array, Object key)
{
if (array != null)
{
int length = array.length;
for (int i = 0; i < length; i += 2)
{
Object targetKey = array[i];
if (targetKey == null)
{
return null;
}
else if (targetKey.equals(key))
{
return array[i + 1];
}
}
}
return null;
}
|
java
|
@SuppressWarnings("unchecked")
public Iterator<K> keys()
{
int size = _size;
if (size == 0)
{
return null;
}
ArrayList<K> keyList = new ArrayList<K>();
int i = (size - 1) * 2;
while (i >= 0)
{
keyList.add((K) _array[i]);
i = i - 2;
}
return keyList.iterator();
}
|
java
|
public static Iterator<Object> getKeys(Object[] array)
{
if (array == null)
{
return null;
}
ArrayList<Object> keyList = new ArrayList<Object>();
int i = array.length - 2;
while (i >= 0)
{
keyList.add(array[i]);
i = i - 2;
}
return keyList.iterator();
}
|
java
|
public static Iterator<Object> getValues(Object[] array)
{
if (array == null)
{
return null;
}
ArrayList<Object> valueList = new ArrayList<Object>();
int i = array.length - 1;
while (i >= 0)
{
valueList.add(array[i]);
i = i - 2;
}
return valueList.iterator();
}
|
java
|
@Override
public void clear()
{
int size = _size;
if (size > 0)
{
size = size * 2;
for (int i = 0; i < size; i++)
{
_array[i] = null;
}
_size = 0;
}
}
|
java
|
private void sendErrorJSON(HttpServletResponse response, int statusCode, String errorCode, String errorDescription) {
final String error = "error";
final String error_description = "error_description";
try {
if (errorCode != null) {
response.setStatus(statusCode);
response.setHeader(ClientConstants.REQ_CONTENT_TYPE_NAME,
"application/json;charset=UTF-8");
JSONObject responseJSON = new JSONObject();
responseJSON.put(error, errorCode);
if (errorDescription != null) {
responseJSON.put(error_description, errorDescription);
}
PrintWriter pw;
pw = response.getWriter();
pw.write(responseJSON.toString());
pw.flush();
} else {
response.sendError(statusCode);
}
} catch (IOException e) {
if (tc.isDebugEnabled())
Tr.debug(tc, "Internal error sending error message", e);
try {
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} catch (IOException ioe) {
if (tc.isDebugEnabled())
Tr.debug(tc, "yet another internal error, give up", ioe);
}
}
}
|
java
|
public boolean first() throws SQLException {
try {
if (dsConfig.get().beginTranForResultSetScrollingAPIs)
getConnectionWrapper().beginTransactionIfNecessary();
return rsetImpl.first();
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.first", "411", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public Array getArray(int arg0) throws SQLException {
try {
Array ra = rsetImpl.getArray(arg0);
if (ra != null && freeResourcesOnClose)
arrays.add(ra);
return ra;
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getArray", "438", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public Blob getBlob(int arg0) throws SQLException {
try {
Blob blob = rsetImpl.getBlob(arg0);
if (blob != null && freeResourcesOnClose)
blobs.add(blob);
return blob;
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getBlob", "754", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public Reader getCharacterStream(int arg0) throws SQLException {
try {
Reader reader = rsetImpl.getCharacterStream(arg0);
if (reader != null && freeResourcesOnClose)
resources.add(reader);
return reader;
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getCharacterStream", "983", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public Clob getClob(int arg0) throws SQLException {
try {
Clob clob = rsetImpl.getClob(arg0);
if (clob != null && freeResourcesOnClose)
clobs.add(clob);
return clob;
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getClob", "1037", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public String getCursorName() throws SQLException {
try {
return rsetImpl.getCursorName();
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getCursorName", "1129", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public int getFetchDirection() throws SQLException {
try {
return rsetImpl.getFetchDirection();
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getFetchDirection", "1336", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public ResultSetMetaData getMetaData() throws SQLException {
if (tc.isEntryEnabled())
Tr.entry(this, tc, "getMetaData");
// First, check if a ResultSetMetaData wrapper for this ResultSet already exists.
ResultSetMetaData rsetMData = null;
try // get a meta data
{
rsetMData = rsetImpl.getMetaData();
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getMetaData", "1579", this);
if (tc.isEntryEnabled())
Tr.exit(this, tc, "getMetaData", "Exception");
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
if (tc.isEntryEnabled())
Tr.exit(this, tc, "getMetaData", "Exception");
throw runtimeXIfNotClosed(nullX);
}
if (tc.isEntryEnabled())
Tr.exit(this, tc, "getMetaData", rsetMData);
return rsetMData;
}
|
java
|
public Object getObject(String arg0) throws SQLException {
try {
Object result = rsetImpl.getObject(arg0);
addFreedResources(result);
return result;
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getObject", "1684", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public Statement getStatement() throws SQLException {
// The parent of a ResultSet may be a Statement or a MetaData.
// For ResultSets created by MetaDatas, the getStatement method should return null,
// unless the result set is closed.
if (state == State.CLOSED || parentWrapper == null)
throw createClosedException("ResultSet");
if (parentWrapper instanceof WSJdbcDatabaseMetaData)
return null;
return (Statement) parentWrapper;
}
|
java
|
public SQLWarning getWarnings() throws SQLException {
try {
return rsetImpl.getWarnings();
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.getWarnings", "2345", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public void setFetchDirection(int direction) throws SQLException {
if (tc.isDebugEnabled())
Tr.debug(this, tc, "setFetchDirection", AdapterUtil.getFetchDirectionString(direction));
try {
rsetImpl.setFetchDirection(direction);
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.setFetchDirection", "2860", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public void setFetchSize(int rows) throws SQLException {
if (tc.isDebugEnabled())
Tr.debug(this, tc, "setFetchSize", rows);
try {
rsetImpl.setFetchSize(rows);
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.setFetchSize", "2891", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public void updateBinaryStream(String arg0, InputStream arg1, int arg2) throws SQLException {
try {
rsetImpl.updateBinaryStream(arg0, arg1, arg2);
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.updateBinaryStream", "3075", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public void updateCharacterStream(String arg0, Reader arg1, int arg2) throws SQLException {
try {
rsetImpl.updateCharacterStream(arg0, arg1, arg2);
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.updateCharacterStream", "3317", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
public void updateObject(int arg0, Object arg1, int arg2) throws SQLException {
try {
rsetImpl.updateObject(arg0, arg1, arg2);
} catch (SQLException ex) {
FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.updateObject", "3737", this);
throw WSJdbcUtil.mapException(this, ex);
} catch (NullPointerException nullX) {
// No FFDC code needed; we might be closed.
throw runtimeXIfNotClosed(nullX);
}
}
|
java
|
@Override
public void afterCompletion(int status) {
logger.log(Level.FINE, "The status of the transaction commit is: " + status);
if (status == Status.STATUS_COMMITTED){
//Save the metrics object after a successful commit
runtimeStepExecution.setCommittedMetrics();
} else{
//status = 4 = STATUS_ROLLEDBACK;
runtimeStepExecution.rollBackMetrics();
}
}
|
java
|
public final Object invokeInterceptor(Object bean, InvocationContext inv, Object[] interceptors) throws Exception {
// Interceptor instance is the bean instance itself if the
// interceptor index is < 0.
Object interceptorInstance = (ivBeanInterceptor) ? bean : interceptors[ivInterceptorIndex];
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) // d367572.7
{
Tr.debug(tc, "invoking " + this);
Tr.debug(tc, "interceptor instance = " + interceptorInstance);
}
// Does interceptor method require InvocationContext as an argument?
if (ivRequiresInvocationContext) {
try {
// Yes it does, so pass it as an argument.
Object[] args = new Object[] { inv }; // d404122
return ivInterceptorMethod.invoke(interceptorInstance, args); // d404122
} catch (IllegalArgumentException ie) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "ivInterceptorMethod: " + ivInterceptorMethod.toString() + " class: " + ivInterceptorMethod.getClass() + " declaring class: "
+ ivInterceptorMethod.getDeclaringClass());
Tr.debug(tc, "interceptorInstance: " + interceptorInstance.toString() + " class: " + interceptorInstance.getClass());
}
throw ie;
}
} else {
// Nope, interceptor method takes no arguments.
return ivInterceptorMethod.invoke(interceptorInstance, NO_ARGS);
}
}
|
java
|
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(this, tc, methodName, args);
Object r = null;
try {
if (args == null || args.length == 0) {
if ("canRegisterSynchronization".equals(methodName))
r = canRegisterSynchronization();
else if ("getCurrentStatus".equals(methodName))
r = getCurrentStatus();
else if ("hashCode".equals(methodName))
r = System.identityHashCode(this);
else if ("retrieveTransactionManager".equals(methodName))
r = retrieveTransactionManager();
else if ("retrieveUserTransaction".equals(methodName))
r = retrieveUserTransaction();
else if ("toString".equals(methodName))
r = new StringBuilder(getClass().getName()).append('@').append(Integer.toHexString(System.identityHashCode(this))).toString();
} else {
if ("equals".equals(methodName))
r = proxy == args[0]; // assumes one proxy per invocation handler
else if ("getTransactionIdentifier".equals(methodName))
r = getTransactionIdentifier((Transaction) args[0]);
else if ("registerSynchronization".equals(methodName))
registerSynchronization((Synchronization) args[0]);
}
} catch (Throwable x) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(this, tc, methodName, x);
throw x;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(this, tc, methodName, r);
return r;
}
|
java
|
protected String getMFMainClass(Container appEntryContainer, String entryPath, boolean required) {
String mfMainClass = null;
try {
String entry = "/META-INF/MANIFEST.MF";
Entry manifestEntry = appEntryContainer.getEntry(entry);
if (manifestEntry != null) {
InputStream is = null;
try {
is = manifestEntry.adapt(InputStream.class);
// "is" is null when MANIFEST.MF is a directory
if (is == null) {
throw new FileNotFoundException(entry);
}
Manifest manifest = new Manifest(is);
mfMainClass = manifest.getMainAttributes().getValue(Attributes.Name.MAIN_CLASS);
if ("".equals(mfMainClass)) {
mfMainClass = null;
}
} finally {
if (is != null) {
try {
is.close();
} catch (IOException io) {
/* do nothing */
}
}
}
}
if (mfMainClass == null && required) {
Tr.error(_tc, "error.module.manifest.read.no.mainclass", getName(), entryPath);
}
} catch (IOException ioe) {
Tr.error(_tc, "error.module.manifest.read.failed", getName(), entryPath, ioe);
} catch (UnableToAdaptException uae) {
Tr.error(_tc, "error.module.manifest.read.failed", getName(), entryPath, uae);
}
return mfMainClass;
}
|
java
|
protected int insert(SpdData elt) {
if (members.isEmpty()) {
members.add(elt);
return 0;
}
int first = 0;
SpdData firstElt = (SpdData) members.get(first);
int last = members.size() - 1;
SpdData lastElt = (SpdData) members.get(last);
if (elt.compareTo(firstElt) < 0) {
members.add(first, elt);
return first;
} else if (elt.compareTo(lastElt) > 0) {
members.add(last + 1, elt);
return last + 1;
}
while (last > (first + 1)) {
int middle = (first + last) / 2;
SpdData midElt = (SpdData) members.get(middle);
if (midElt.compareTo(elt) > 0) {
last = middle;
lastElt = midElt;
} else {
first = middle;
firstElt = midElt;
}
}
if ((elt.compareTo(firstElt) == 0) ||
(elt.compareTo(lastElt) == 0)) {
return -1;
} else {
members.add(last, elt);
return last;
}
}
|
java
|
public synchronized boolean addSorted(SpdData data) {
if (data == null) {
return false;
} else if (members.contains(data)) {
return false;
} else {
return (insert(data) != -1);
}
}
|
java
|
public synchronized boolean add(SpdData data) {
if (data == null) {
return false;
} else if (members.contains(data)) {
return false;
} else {
return members.add(data);
}
}
|
java
|
private void collectFeatureInfos(Map<String, ProductInfo> productInfos,
Map<String, FeatureInfo> featuresBySymbolicName) {
ManifestFileProcessor manifestFileProcessor = new ManifestFileProcessor();
for (Map.Entry<String, Map<String, ProvisioningFeatureDefinition>> productEntry : manifestFileProcessor.getFeatureDefinitionsByProduct().entrySet()) {
String productName = productEntry.getKey();
Map<String, ProvisioningFeatureDefinition> features = productEntry.getValue();
ContentBasedLocalBundleRepository repository;
if (productName.equals(ManifestFileProcessor.CORE_PRODUCT_NAME)) {
repository = BundleRepositoryRegistry.getInstallBundleRepository();
} else if (productName.equals(ManifestFileProcessor.USR_PRODUCT_EXT_NAME)) {
repository = BundleRepositoryRegistry.getUsrInstallBundleRepository();
} else {
repository = manifestFileProcessor.getBundleRepository(productName, null);
}
ProductInfo productInfo = new ProductInfo(repository);
productInfos.put(productName, productInfo);
for (Map.Entry<String, ProvisioningFeatureDefinition> featureEntry : features.entrySet()) {
String featureSymbolicName = featureEntry.getKey();
ProvisioningFeatureDefinition feature = featureEntry.getValue();
FeatureInfo featureInfo = new FeatureInfo(productInfo, feature);
featuresBySymbolicName.put(featureSymbolicName, featureInfo);
String shortName = feature.getIbmShortName();
if (shortName != null) {
productInfo.featuresByShortName.put(shortName, featureInfo);
}
}
}
}
|
java
|
private FeatureInfo getFeatureInfo(String name,
Map<String, ProductInfo> productInfos,
Map<String, FeatureInfo> featuresBySymbolicName) {
String productName, featureName;
int index = name.indexOf(':');
if (index == -1) {
FeatureInfo featureInfo = featuresBySymbolicName.get(name);
if (featureInfo != null) {
return featureInfo;
}
productName = ManifestFileProcessor.CORE_PRODUCT_NAME;
featureName = name;
} else {
productName = name.substring(0, index);
featureName = name.substring(index + 1);
}
ProductInfo product = productInfos.get(productName);
return product == null ? null : product.featuresByShortName.get(featureName);
}
|
java
|
private void collectAPIJars(FeatureInfo featureInfo,
Map<String, FeatureInfo> allowedFeatures,
Set<File> apiJars) {
for (SubsystemContentType contentType : JAR_CONTENT_TYPES) {
for (FeatureResource resource : featureInfo.feature.getConstituents(contentType)) {
if (APIType.getAPIType(resource) == APIType.API) {
File file = featureInfo.productInfo.repository.selectBundle(resource.getLocation(), resource.getSymbolicName(), resource.getVersionRange());
if (file != null) {
apiJars.add(file);
}
}
}
}
for (FeatureResource resource : featureInfo.feature.getConstituents(SubsystemContentType.FEATURE_TYPE)) {
String name = resource.getSymbolicName();
FeatureInfo childFeatureInfo = allowedFeatures.get(name);
if (childFeatureInfo != null && APIType.API.matches(resource)) {
allowedFeatures.remove(name);
collectAPIJars(childFeatureInfo, allowedFeatures, apiJars);
}
}
}
|
java
|
private void createClasspathJar(File outputFile, String classpath) throws IOException {
FileOutputStream out = new FileOutputStream(outputFile);
try {
Manifest manifest = new Manifest();
Attributes attrs = manifest.getMainAttributes();
attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0");
attrs.put(Attributes.Name.CLASS_PATH, classpath);
new JarOutputStream(out, manifest).close();
} finally {
out.close();
}
}
|
java
|
public void setupDiscProcess() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "setupDiscProcess");
}
ChannelData list[] = chainData.getChannelList();
Class<?> discriminatoryType = null;
DiscriminationProcessImpl dp = null;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Get the channels started");
}
// Set up discrimination process for framework and start the channels.
for (int i = 0; i < list.length; i++) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Set up disc process for channel, " + list[i].getName());
}
// Don't set up a disc process for the last channel in the chain.
if (list.length != i + 1) {
dp = (DiscriminationProcessImpl) ((InboundChannel) channels[i]).getDiscriminationProcess();
if (dp == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Create a discrimination process for channel, "
+ channels[i].getName());
}
// Create a discrimination process for the framework
discriminatoryType = ((InboundChannel) channels[i]).getDiscriminatoryType();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Discriminatory type: " + discriminatoryType);
}
dp = new DiscriminationProcessImpl(discriminatoryType, list[i].getName());
((InboundChannel) channels[i]).setDiscriminationProcess(dp);
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Found DP: " + dp);
}
}
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Last channel in chain, " + list[i].getName());
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "setupDiscProcess");
}
}
|
java
|
public void startDiscProcessBetweenChannels(InboundChannel appChannel, InboundChannel devChannel,
int discWeight) throws ChainException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "startDiscProcessBetweenChannels");
}
// Get the discriminator for the app channel. Protect from misc exceptions being thrown.
Discriminator d = null;
Exception discException = null;
try {
d = appChannel.getDiscriminator();
if (d == null) {
discException = new Exception("Null discriminator extracted from channel " + appChannel.getName());
}
} catch (Exception e) {
// No FFDC needed. Done a couple lines down.
discException = e;
}
if (null != discException) {
// Even though rethrowing exception, must FFDC now to capture stack trace.
FFDCFilter.processException(discException,
getClass().getName() + ".startDiscProcessBetweenChannels",
"234", this, new Object[] { appChannel, devChannel, Integer.valueOf(discWeight) });
throw new ChainException(
"Unable to get discriminator from " + appChannel.getName(),
discException);
}
// Get the discrimination group from the former channel in the chain.
DiscriminationGroup prevDg = (DiscriminationGroup) devChannel.getDiscriminationProcess();
// Check to see if the disc group already includes the discriminator.
if (!((DiscriminationProcessImpl) prevDg).containsDiscriminator(d)) {
// Add this discriminator or create a new one?
if (!(prevDg.getDiscriminators().isEmpty())) {
// Add a new DiscriminationProcess to a started channel
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Create new dp for channel, " + devChannel.getName());
}
DiscriminationGroup newDg =
new DiscriminationProcessImpl(devChannel.getDiscriminatoryType(), prevDg);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Add in discriminator from channel, " + appChannel.getName());
}
newDg.addDiscriminator(d, discWeight);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Set dp into channel, " + devChannel.getName());
}
newDg.start();
devChannel.setDiscriminationProcess(newDg);
} else {
// Enable the previous channel in the chain to communication with this one.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc,
"Add in disc from channel, "
+ appChannel.getName()
+ " into dp of channel, "
+ devChannel.getName());
}
prevDg.addDiscriminator(d, discWeight);
prevDg.start();
}
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Found discriminator in dp, " + appChannel.getName());
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "startDiscProcessBetweenChannels");
}
}
|
java
|
public void disableChannel(Channel inputChannel)
throws InvalidChannelNameException, DiscriminationProcessException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "disableChannel: " + inputChannel.getName());
}
synchronized (state) {
if (RuntimeState.STARTED.equals(state) || RuntimeState.QUIESCED.equals(state)) {
String targetName = inputChannel.getName();
int index = 0;
InboundChannel prevChannel = null;
// Find the index of the input channel in this chain.
for (; index < channels.length; index++) {
if (channels[index].getName().equals(targetName)) {
break;
}
prevChannel = (InboundChannel) channels[index];
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Index of channel, " + index);
}
if (channels.length == index) {
// Never found the channel. Log an error.
InvalidChannelNameException e =
new InvalidChannelNameException(
"ERROR: can't unlink unknown channel, " + targetName);
FFDCFilter.processException(e, getClass().getName() + ".disableChannel",
"319", this, new Object[] { inputChannel });
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "disableChannel");
}
throw e;
} else if (null != prevChannel) {
// Note: do nothing if the index was zero, meaning input channel is a connector.
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Previous channel, " + prevChannel.getName());
}
// Discriminator was only added after the chain was started.
Class<?> discriminatoryType = prevChannel.getDiscriminatoryType();
DiscriminationProcessImpl newDp = new DiscriminationProcessImpl(
discriminatoryType,
(DiscriminationGroup) prevChannel.getDiscriminationProcess());
newDp.removeDiscriminator(((InboundChannel) inputChannel).getDiscriminator());
prevChannel.setDiscriminationProcess(newDp);
}
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "RuntimeState invalid to disable channel: "
+ inputChannel.getName() + ", chain state: " + state.ordinal);
}
}
} // End synchronize
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "disableChannel");
}
}
|
java
|
@Override
public void writeSilence(MessageItem m)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "writeSilence", new Object[] { m });
JsMessage jsMsg = m.getMessage();
// There may be Completed ticks after the Value, if so then
// write these into the stream too
long stamp = jsMsg.getGuaranteedValueValueTick();
long ends = jsMsg.getGuaranteedValueEndTick();
if (ends < stamp)
ends = stamp;
TickRange tr =
new TickRange(
TickRange.Completed,
jsMsg.getGuaranteedValueStartTick(),
ends);
// Update the stream
writeSilenceInternal(tr, false);
/*
* PM71430.DEV : We have to send the ACK control message for the messages which are to be silenced.
* Otherwise, if for some reason, source side ME stops sending the ACKEXPECTED control messages,
* target ME will never send ACK for these messages. This will result into messages getting piled
* on the source ME and never get removed.
*
* ACK message is not sent for silence message. Instead, it is sent only after a gap of 50 (default)
* messages from the last ACKED message.
*
* If any consumers come up in between, this method is not
* called to write silence. In this case, ACK is always sent during batch commit call back.
*
* Please note this piece of code has been written to handle specific scenario when there are no
* local consumers on the target side for a long time which results in never acknowledging any of
* the ticks and the local completed prefix keeps moving ahead.
*/
long gapFromPreviousAck = ends - this._lastAckedTick;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "gap from the previous ack: " + gapFromPreviousAck + " lastAckedTick: " + this._lastAckedTick);
if (gapFromPreviousAck >= this.ACK_GAP_FOR_SILENCE_TICKS) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "sending the ACK message for the batch of silence message ", new Object[] { m });
sendAck();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "writeSilence");
}
|
java
|
private void handleNewGap(long startstamp, long endstamp)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"handleNewGap",
new Object[] { Long.valueOf(startstamp), Long.valueOf(endstamp) });
TickRange tr = new TickRange(TickRange.Requested, startstamp, endstamp);
oststream.writeRange(tr);
// SIB0115
// Update Health State due to detected gap
getControlAdapter().getHealthState().updateHealth(HealthStateListener.GAP_DETECTED_STATE,
HealthState.AMBER);
NRTExpiryHandle nexphandle = new NRTExpiryHandle(tr, this);
nexphandle.timer =
am.create(mp.getCustomProperties().getGapCuriosityThreshold(), nexphandle);
addAlarm(this, nexphandle);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "handleNewGap");
}
|
java
|
protected static void addAlarm(Object key, Object alarmObject)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "addAlarm", new Object[] { key, alarmObject });
synchronized (pendingAlarms)
{
Set alarms = null;
if (pendingAlarms.containsKey(key))
alarms = (Set) pendingAlarms.get(key);
else
{
alarms = new HashSet();
pendingAlarms.put(key, alarms);
}
alarms.add(alarmObject);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addAlarm");
}
|
java
|
protected static void removeAlarm(Object key, Object alarmObject)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeAlarm", new Object[] { key, alarmObject });
synchronized (pendingAlarms)
{
if (pendingAlarms.containsKey(key))
((Set) pendingAlarms.get(key)).remove(alarmObject);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeAlarm");
}
|
java
|
protected static Iterator getAlarms(Object key)
{
synchronized (pendingAlarms)
{
if (pendingAlarms.containsKey(key))
return ((Set) pendingAlarms.get(key)).iterator();
return new GTSIterator();
}
}
|
java
|
private boolean isStreamBlocked()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isStreamBlocked");
SibTr.exit(tc, "isStreamBlocked", new Object[] { Boolean.valueOf(isStreamBlocked),
Long.valueOf(linkBlockingTick) });
}
return this.isStreamBlocked;
}
|
java
|
private boolean isStreamBlockedUnexpectedly()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isStreamBlockedUnexpectedly");
SibTr.exit(tc, "isStreamBlockedUnexpectedly", Boolean.valueOf(unexpectedBlock));
}
return unexpectedBlock;
}
|
java
|
private boolean streamCanAcceptNewMessage(MessageItem msgItem, long valueTick) throws SIException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "streamCanAcceptNewMessage", new Object[] { msgItem, Long.valueOf(valueTick) });
boolean allowSend = false;
if (isStreamBlocked())
{
//once the stream is blocked, only an AckExpected message or a Silence on the blocking tick
//can unset it - therefore we do not re-check and we only allow this message through if it fills a gap.
if (valueTick <= valueHorizon)
{
//the message might fill in a gap so we allow it through
allowSend = true;
}
}
else
{
//the stream is not currently blocked.
//However, the destination might no longer be able to accept messages, in which case
//we should update the flag and only allow the send if the message fills a gap.
JsMessage msg = msgItem.getMessage();
int blockingReason = deliverer.checkAbleToAcceptMessage(msg.getRoutingDestination());
if (blockingReason != DestinationHandler.OUTPUT_HANDLER_FOUND)
{
//We might still be able to let this message through if it
//fills in a gap
if (valueTick <= valueHorizon)
{
//the message might fill in a gap so we allow it through
allowSend = true;
}
else
{
// The stream is now blocked
setStreamIsBlocked(true, blockingReason, null, msg.getRoutingDestination());
// Keep track of the value tick. We may subsequently get a SILENCE for the
// tick signalling that the associated message has been deleted from the
// source and that the stream may be marked as unblocked.
linkBlockingTick = valueTick;
}
}
else
{
allowSend = true;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "streamCanAcceptNewMessage", Boolean.valueOf(allowSend));
return allowSend;
}
|
java
|
public static UOWManager getUOWManager()
{
if (tc.isEntryEnabled())
Tr.entry(tc, "getUOWManager");
final UOWManager uowm = com.ibm.ws.uow.embeddable.UOWManagerFactory.getUOWManager();
if (tc.isEntryEnabled())
Tr.exit(tc, "getUOWManager", uowm);
return uowm;
}
|
java
|
String getProcErrorOutput(Process proc) throws IOException {
StringBuffer output = new StringBuffer();
InputStream procIn = proc.getInputStream();
int read;
// Dump the data printed by the process
do {
byte[] buffer = new byte[BUFFER_SIZE];
read = procIn.read(buffer);
String s = new String(buffer);
output.append(s);
} while (read == BUFFER_SIZE);
return output.toString();
}
|
java
|
public void init(boolean useDirect, int outSize, int inSize, int cacheSize) {
super.init(useDirect, outSize, inSize, cacheSize);
}
|
java
|
public void setDeferredTrailer(HeaderKeys hdr, HttpTrailerGenerator htg) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "setDeferredTrailer(HeaderKeys): " + hdr);
}
if (null == hdr) {
throw new IllegalArgumentException("Null header name");
}
if (null == htg) {
throw new IllegalArgumentException("Null value generator");
}
this.knownTGs.put(hdr, htg);
}
|
java
|
public void computeRemainingTrailers() {
if (tc.isEntryEnabled()) {
Tr.entry(tc, "computeRemainingTrailers");
}
Iterator<HeaderKeys> knowns = this.knownTGs.keySet().iterator();
while (knowns.hasNext()) {
HeaderKeys key = knowns.next();
setHeader(key, this.knownTGs.get(key).generateTrailerValue(key, this));
}
if (tc.isEntryEnabled()) {
Tr.exit(tc, "computeRemainingTrailers");
}
}
|
java
|
public void destroy() {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Destroy trailers: " + this);
}
super.destroy();
if (null != this.myFactory) {
this.myFactory.releaseTrailers(this);
this.myFactory = null;
}
}
|
java
|
public HttpTrailersImpl duplicate() {
if (null == this.myFactory) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Null factory, unable to duplicate: " + this);
}
return null;
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Duplicating the trailer headers: " + this);
}
computeRemainingTrailers();
HttpTrailersImpl msg = this.myFactory.getTrailers();
super.duplicate(msg);
return msg;
}
|
java
|
public static boolean isPathContained(List<String> allowedPaths, String targetPath) {
if (allowedPaths == null || allowedPaths.isEmpty() || targetPath == null) {
return false;
}
//Remove trailing slashes, if applicable
if (!targetPath.isEmpty() &&
targetPath.charAt(targetPath.length() - 1) == '/' &&
targetPath.length() > 1 &&
!isWindowsRootDirectory(targetPath)) {
targetPath = targetPath.substring(0, targetPath.length() - 1);
}
while (targetPath != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Target path: " + targetPath);
}
for (int i = 0; i < allowedPaths.size(); i++) {
//String allowedPath = it.next();
String allowedPath = allowedPaths.get(i);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Checking path: " + allowedPath);
}
//When we have a configuration that explicitly sets an empty read or write list, then we get a non-empty set
//with a single empty string. So we must catch empty cases here, otherwise the comparisons below might be incorrect.
if ("".equals(allowedPath)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Skipping an empty path");
}
continue;
}
//We are always doing case-insensitive comparisons because we can't reliably find out
//if the windows machine has changed its registry key to allow sensitivity, nor do we
//know if the remote host is a certain OS. For the purposes of this method (checking for access
//to a directory) it is safe to assume case insensitivity.
if (allowedPath.equalsIgnoreCase(targetPath)) {
return true;
}
}
// We'll check 'up' the target path's parent chain to see if that's
// covered by the allowed paths.
targetPath = getNormalizedParent(targetPath);
}
return false;
}
|
java
|
public StatisticImpl getStatistic() {
if (enabled) {
long curTime = stat.updateIntegral();
stat.setLastSampleTime(curTime);
return stat;
} else {
return stat;
}
}
|
java
|
public void combine(SpdLoad other) {
if (other == null)
return;
if (stat.isEnabled() && other.isEnabled())
//stat.combine((BoundedRangeStatisticImpl)other.getStatistic());
stat.combine(other.getStatistic());
}
|
java
|
private String getProperty(String variable, EvaluationContext context, boolean ignoreWarnings, boolean useEnvironment) throws ConfigEvaluatorException {
return stringUtils.convertToString(getPropertyObject(variable, context, ignoreWarnings, useEnvironment));
}
|
java
|
Object processVariableLists(Object rawValue, ExtendedAttributeDefinition attributeDef,
EvaluationContext context, boolean ignoreWarnings) throws ConfigEvaluatorException {
if (attributeDef != null && !attributeDef.resolveVariables())
return rawValue;
if (rawValue instanceof List) {
List<Object> returnList = new ArrayList<Object>();
List<Object> values = (List<Object>) rawValue;
for (Object o : values) {
Object processed = processVariableLists(o, attributeDef, context, ignoreWarnings);
if (processed instanceof List)
returnList.addAll((List<Object>) processed);
else
returnList.add(processed);
}
return returnList;
} else if (rawValue instanceof String) {
// Look for functions of the form ${list(variableName)} first
Matcher matcher = XMLConfigConstants.VAR_LIST_PATTERN.matcher((String) rawValue);
if (matcher.find()) {
String var = matcher.group(1);
String rep = getProperty(var, context, ignoreWarnings, true);
return rep == null ? rawValue : MetaTypeHelper.parseValue(rep);
} else {
return rawValue;
}
} else {
return rawValue;
}
}
|
java
|
ContentMatcher nextMatcher(Conjunction selector, ContentMatcher oldMatcher) {
return Factory.createMatcher(ordinalPosition, selector, oldMatcher);
}
|
java
|
private void syncToOSThread(WebSecurityContext webSecurityContext) throws SecurityViolationException {
try {
Object token = ThreadIdentityManager.setAppThreadIdentity(subjectManager.getInvocationSubject());
webSecurityContext.setSyncToOSThreadToken(token);
} catch (ThreadIdentityException tie) {
SecurityViolationException secVE = convertWebSecurityException(new WebSecurityCollaboratorException(tie.getMessage(), DENY_AUTHZ_FAILED, webSecurityContext));
throw secVE;
}
}
|
java
|
private void resetSyncToOSThread(WebSecurityContext webSecurityContext) throws ThreadIdentityException {
Object token = webSecurityContext.getSyncToOSThreadToken();
if (token != null) {
ThreadIdentityManager.resetChecked(token);
}
}
|
java
|
public AuthenticationResult authenticateRequest(WebRequest webRequest) {
WebAuthenticator authenticator = getWebAuthenticatorProxy();
return authenticator.authenticate(webRequest);
}
|
java
|
public boolean authorize(AuthenticationResult authResult, String appName, String uriName, Subject previousCaller, List<String> requiredRoles) {
// Set the authorized subject on the thread
subjectManager.setCallerSubject(authResult.getSubject());
boolean isAuthorized = authorize(authResult, appName, uriName, requiredRoles);
if (isAuthorized) {
// at this point set invocation subject = caller subject.
// delegation may change the invocation subject later
subjectManager.setInvocationSubject(authResult.getSubject());
} else {
subjectManager.setCallerSubject(previousCaller);
}
return isAuthorized;
}
|
java
|
public WebReply performInitialChecks(WebRequest webRequest, String uriName) {
WebReply webReply = null;
HttpServletRequest req = webRequest.getHttpServletRequest();
String methodName = req.getMethod();
if (uriName == null || uriName.length() == 0) {
return new DenyReply("Invalid URI passed to Security Collaborator.");
}
if (unsupportedAuthMech() == true) {
return new DenyReply("Authentication Failed : DIGEST not supported");
}
if (wasch.isSSLRequired(webRequest, uriName)) {
return httpsRedirectHandler.getHTTPSRedirectWebReply(req);
}
webReply = unprotectedSpecialURI(webRequest, uriName, methodName);
if (webReply != null) {
return webReply;
}
webReply = unprotectedResource(webRequest);
if (webReply == PERMIT_REPLY) {
if (shouldWePerformTAIForUnProtectedURI(webRequest))
return null;
else
return webReply;
}
return null;
}
|
java
|
private WebReply unprotectedSpecialURI(WebRequest webRequest, String uriName, String methodName) {
LoginConfiguration loginConfig = webRequest.getLoginConfig();
if (loginConfig == null)
return null;
String authenticationMethod = loginConfig.getAuthenticationMethod();
FormLoginConfiguration formLoginConfig = loginConfig.getFormLoginConfiguration();
if (formLoginConfig == null || authenticationMethod == null)
return null;
String loginPage = formLoginConfig.getLoginPage();
String errorPage = formLoginConfig.getErrorPage();
// We check to see if we are either a FORM or CLIENT_CERT auth method.
// These are the only valid auth methods supported (CLIENT_CERT can
// fail over to FORM).
if (isValidAuthMethodForFormLogin(authenticationMethod) && loginPage != null && errorPage != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, " We have a custom login or error page request, web app login URL:[" + loginPage
+ "], errorPage URL:[" + errorPage + "], and the requested URI:[" + uriName + "]");
}
if (loginPage.equals(uriName) || errorPage.equals(uriName)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "authorize, login or error page[" + uriName + "] requested, permit: ", PERMIT_REPLY);
return PERMIT_REPLY;
} else if ((uriName != null && uriName.equals("/j_security_check")) &&
(methodName != null && methodName.equals("POST"))) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "authorize, login or error page[" + uriName + "] requested, permit: ", PERMIT_REPLY);
return PERMIT_REPLY;
}
} else {
if (webRequest.getHttpServletRequest().getDispatcherType().equals(DispatcherType.ERROR)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "authorize, error page[" + uriName + "] requested, permit: ", PERMIT_REPLY);
return PERMIT_REPLY;
}
}
return null;
}
|
java
|
private boolean isServletSpec31() {
if (com.ibm.ws.webcontainer.osgi.WebContainer.getServletContainerSpecLevel() >= 31)
return true;
return false;
}
|
java
|
private void notifyWebAppSecurityConfigChangeListeners(List<String> delta) {
WebAppSecurityConfigChangeEvent event = new WebAppSecurityConfigChangeEventImpl(delta);
for (WebAppSecurityConfigChangeListener listener : webAppSecurityConfigchangeListenerRef.services()) {
listener.notifyWebAppSecurityConfigChanged(event);
}
}
|
java
|
private String toStringFormChangedPropertiesMap(Map<String, String> delta) {
if (delta == null || delta.isEmpty()) {
return "";
}
StringBuffer sb = new StringBuffer();
for (Map.Entry<String, String> entry : delta.entrySet()) {
if (sb.length() > 0) {
sb.append(",");
}
sb.append(entry.getKey()).append("=").append(entry.getValue());
}
return sb.toString();
}
|
java
|
private void logAuditEntriesBeforeAuthn(WebReply webReply, Subject receivedSubject, String uriName, WebRequest webRequest) {
AuthenticationResult authResult;
if (webReply instanceof PermitReply) {
authResult = new AuthenticationResult(AuthResult.SUCCESS, receivedSubject, null, null, AuditEvent.OUTCOME_SUCCESS);
} else {
authResult = new AuthenticationResult(AuthResult.FAILURE, receivedSubject, null, null, AuditEvent.OUTCOME_FAILURE);
}
int statusCode = Integer.valueOf(webReply.getStatusCode());
Audit.audit(Audit.EventID.SECURITY_AUTHN_01, webRequest, authResult, statusCode);
Audit.audit(Audit.EventID.SECURITY_AUTHZ_01, webRequest, authResult, uriName, statusCode);
}
|
java
|
private void postRoutedNotificationListenerRegistrationEvent(String operation, NotificationTargetInformation nti) {
Map<String, Object> props = createListenerRegistrationEvent(operation, nti);
safePostEvent(new Event(REGISTER_JMX_NOTIFICATION_LISTENER_TOPIC, props));
}
|
java
|
private void postRoutedServerNotificationListenerRegistrationEvent(String operation, NotificationTargetInformation nti, ObjectName listener,
NotificationFilter filter, Object handback) {
Map<String, Object> props = createServerListenerRegistrationEvent(operation, nti, listener, filter, handback);
safePostEvent(new Event(REGISTER_JMX_NOTIFICATION_LISTENER_TOPIC, props));
}
|
java
|
private void safePostEvent(Event event) {
EventAdmin ea = eventAdminRef.getService();
if (ea != null) {
ea.postEvent(event);
} else if (tc.isEventEnabled()) {
Tr.event(tc, "The EventAdmin service is unavailable. Unable to post the Event: " + event);
}
}
|
java
|
public void enableDestinationCreation(SICoreConnectionFactory siccf)
{
if (tcInt.isEntryEnabled())
SibTr.entry(tcInt, "enableDestinationCreation");
try
{
if (admin == null)
{
if (tcInt.isDebugEnabled())
SibTr.debug(tcInt, "Setting up destination definition objects.");
// The same object implements the admin interface...
admin = ((SIMPAdmin)siccf).getAdministrator();
if (tcInt.isDebugEnabled())
SibTr.debug(tcInt, "DestinationDefinition objects complete");
}//if
} catch(Exception e)
{
// No FFDC code needed
if (tcInt.isDebugEnabled())
SibTr.debug(tcInt, "Exception enabling destination creation", e);
}//try
if (tcInt.isEntryEnabled())
SibTr.exit(tcInt, "enableDestinationCreation");
}
|
java
|
private void createDestination(String name,
com.ibm.wsspi.sib.core.DestinationType destType,
Reliability defaultReliability)
throws JMSException
{
if (tcInt.isEntryEnabled())
SibTr.entry(tcInt, "createDestination(String, DestinationType)");
if (tcInt.isDebugEnabled())
{
SibTr.debug(tcInt, "name: "+name);
SibTr.debug(tcInt, "type: "+destType);
}
try
{
try
{
// Obtain information about the destination from the core connection.
SIDestinationAddress sida = JmsServiceFacade.getSIDestinationAddressFactory().createSIDestinationAddress(name, null);
DestinationConfiguration dc = coreConnection.getDestinationConfiguration(sida);
// If the Destination exists, then recreate it.
if (dc != null)
{
String uuid = dc.getUUID();
if (tcInt.isDebugEnabled()) SibTr.debug(tcInt, "delete UUID: "+uuid);
// The destination has been found, so delete it.
admin.deleteDestinationLocalization(uuid, null);
} else
{
if (tcInt.isDebugEnabled())
SibTr.debug(tcInt, "No object was returned from getDestinationConfiguration");
}
} catch(SINotPossibleInCurrentConfigurationException f)
{
// No FFDC code needed
// This is OK. No action required.
}
//lohith liberty change
com.ibm.ws.sib.admin.DestinationDefinition adminDDF = null ; //JsAdminFactory.getInstance(.createDestinationDefinition(destType, name);
adminDDF.setMaxReliability(Reliability.ASSURED_PERSISTENT);
adminDDF.setDefaultReliability(defaultReliability);
// Set the default exception destination
String excDestinationName = SIMPConstants.SYSTEM_DEFAULT_EXCEPTION_DESTINATION+getMEName();
adminDDF.setExceptionDestination(excDestinationName);
//lohith liberty change
LocalizationDefinition dloc = null; // JsAdminFactory.getInstance().createLocalizationDefinition(name);
// Make sure the max message count is outside the range used by the tests.
dloc.setDestinationHighMsgs(30000);
//lohith liberty change
admin.createDestinationLocalization(adminDDF, dloc ); //, null, null, null, null);
} catch (Exception se)
{
// No FFDC code needed
if (tcInt.isDebugEnabled())
SibTr.debug(tcInt, "Exception creating", se);
// NB. No need to NLS this because it is only for unit test.
JMSException jmse =
new JMSException("Exception received creating destination");
jmse.setLinkedException(se);
jmse.initCause(se);
if (tcInt.isEntryEnabled())
SibTr.exit(tcInt, "createDestination(String, DestinationDefinition)");
throw jmse;
}
if (tcInt.isEntryEnabled())
SibTr.exit(tcInt, "createDestination(String, DestinationDefinition)");
}
|
java
|
private DirContext bind(String bindDn, ProtectedString bindPw) throws NamingException {
Hashtable<Object, Object> env = new Hashtable<Object, Object>();
String url = this.idStoreDefinition.getUrl();
if (url == null || url.isEmpty()) {
throw new IllegalArgumentException("No URL was provided to the LdapIdentityStore.");
}
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, url);
boolean sslEnabled = url != null && url.startsWith("ldaps");
if (sslEnabled) {
env.put("java.naming.ldap.factory.socket", "com.ibm.ws.ssl.protocol.LibertySSLSocketFactory");
env.put(Context.SECURITY_PROTOCOL, "ssl");
}
/*
* Add credentials.
*/
if (bindDn != null && !bindDn.isEmpty() && bindPw != null) {
/*
* Support encoded passwords.
*/
String decodedBindPw = PasswordUtil.passwordDecode(new String(bindPw.getChars()).trim());
if (decodedBindPw == null || decodedBindPw.isEmpty()) {
throw new IllegalArgumentException("An empty password is invalid.");
}
env.put(Context.SECURITY_PRINCIPAL, bindDn);
env.put(Context.SECURITY_CREDENTIALS, decodedBindPw);
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "JNDI_CALL bind", new Object[] { bindDn, url });
}
return getDirContext(env);
}
|
java
|
private Set<String> getGroups(DirContext context, String callerDn) {
Set<String> groups = null;
String groupSearchBase = idStoreDefinition.getGroupSearchBase();
String groupSearchFilter = idStoreDefinition.getGroupSearchFilter();
if (groupSearchBase.isEmpty() || groupSearchFilter.isEmpty()) {
groups = getGroupsByMembership(context, callerDn);
} else {
groups = getGroupsByMember(context, callerDn, groupSearchBase, groupSearchFilter);
}
return groups;
}
|
java
|
private Set<String> getGroupsByMember(DirContext context, String callerDn, String groupSearchBase, String groupSearchFilter) {
String groupNameAttribute = idStoreDefinition.getGroupNameAttribute();
String[] attrIds = { groupNameAttribute };
long limit = Long.valueOf(idStoreDefinition.getMaxResults());
int timeOut = idStoreDefinition.getReadTimeout();
int scope = getSearchScope(idStoreDefinition.getGroupSearchScope());
SearchControls controls = new SearchControls(scope, limit, timeOut, attrIds, false, false);
String filter = getFormattedFilter(groupSearchFilter, callerDn, idStoreDefinition.getGroupMemberAttribute());
Set<String> groupNames = new HashSet<String>();
try {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "JNDI_CALL search", new Object[] { groupSearchBase, filter, printControls(controls) });
}
NamingEnumeration<SearchResult> ne = context.search(new LdapName(groupSearchBase), filter, controls);
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Iterate through the search results");
}
while (ne.hasMoreElements()) {
SearchResult sr = ne.nextElement();
String groupDn = sr.getNameInNamespace();
if (groupNameAttribute.equalsIgnoreCase("dn")) {
groupNames.add(groupDn);
} else {
Attribute groupNameAttr = sr.getAttributes().get(groupNameAttribute);
if (groupNameAttr == null) {
Tr.warning(tc, "JAVAEESEC_WARNING_MISSING_GROUP_ATTR", new Object[] { groupDn, groupNameAttribute });
continue;
}
NamingEnumeration<?> ne2 = groupNameAttr.getAll();
if (ne2.hasMoreElements()) {
groupNames.add((String) ne2.nextElement());
}
}
}
} catch (NamingException e) {
Tr.error(tc, "JAVAEESEC_ERROR_EXCEPTION_ON_GROUP_SEARCH", new Object[] { callerDn, e });
throw new IllegalStateException(e);
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "getGroupsByMember", groupNames);
}
return groupNames;
}
|
java
|
private String getFormattedFilter(String searchFilter, String caller, String attribute) {
//Allow %v in addition to %s for string replacement
String filter = searchFilter.replaceAll("%v", "%s");
if (!(filter.startsWith("(") && filter.endsWith(")")) && !filter.isEmpty()) {
filter = "(" + filter + ")";
}
if (filter.contains("%s")) {
filter = String.format(filter, caller);
} else {
filter = "(&" + filter + "(" + attribute + "=" + caller + "))";
}
return filter;
}
|
java
|
private Set<String> getGroupsByMembership(DirContext context, String callerDn) {
String memberOfAttribute = idStoreDefinition.getGroupMemberOfAttribute();
String groupNameAttribute = idStoreDefinition.getGroupNameAttribute();
Attributes attrs;
Set<String> groupDns = new HashSet<String>();
if (tc.isDebugEnabled()) {
Tr.debug(tc, "JNDI_CALL getAttributes", new Object[] { callerDn, memberOfAttribute });
}
try {
attrs = context.getAttributes(callerDn, new String[] { memberOfAttribute });
Attribute groupSet = attrs.get(memberOfAttribute);
if (groupSet != null) {
NamingEnumeration<?> ne = groupSet.getAll();
while (ne.hasMoreElements()) {
groupDns.add((String) ne.nextElement());
}
}
} catch (NamingException e) {
Tr.warning(tc, "JAVAEESEC_WARNING_EXCEPTION_ON_GETATTRIBUTES", new Object[] { callerDn, memberOfAttribute, e });
}
if (groupNameAttribute.equalsIgnoreCase("dn")) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "getGroupsByMembership", groupDns);
}
return groupDns;
}
Set<String> groupNames = new HashSet<String>();
String groupDn = null;
Iterator<String> it = groupDns.iterator();
try {
while (it.hasNext()) {
groupDn = it.next();
if (tc.isDebugEnabled()) {
Tr.debug(tc, "JNDI_CALL getAttributes", new Object[] { groupDn, groupNameAttribute });
}
Attributes groupNameAttrs = context.getAttributes(groupDn, new String[] { groupNameAttribute });
Attribute groupNameAttr = groupNameAttrs.get(groupNameAttribute);
if (groupNameAttr == null) {
Tr.warning(tc, "JAVAEESEC_WARNING_MISSING_GROUP_ATTR", new Object[] { groupDn, groupNameAttribute });
continue;
}
NamingEnumeration<?> ne = groupNameAttr.getAll();
if (ne.hasMoreElements()) {
groupNames.add((String) ne.nextElement());
}
}
} catch (NamingException e) {
Tr.warning(tc, "JAVAEESEC_WARNING_EXCEPTION_ON_GETATTRIBUTES", new Object[] { groupDn, groupNameAttribute, e });
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "getGroupsByMembership", groupNames);
}
return groupNames;
}
|
java
|
@Deprecated
public static ValidatorFactory getValidatorFactory()
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "getValidatorFactory");
ValidatorFactory validatorFactory = AbstractBeanValidation.getValidatorFactory();
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "getValidatorFactory: " + Util.identity(validatorFactory));
return validatorFactory;
}
|
java
|
public void message(MessageType type, String me, TraceComponent tc, String msgKey, Object objs, Object[] formattedMessage)
{
switch(type)
{
case AUDIT : if (TraceComponent.isAnyTracingEnabled() && myTc.isAuditEnabled()) Tr.audit(myTc, SIB_MESSAGE, formattedMessage);
break;
case ERROR : Tr.error(myTc, SIB_MESSAGE, formattedMessage);
break;
case FATAL : Tr.fatal(myTc, SIB_MESSAGE, formattedMessage);
break;
case INFO : Tr.info(myTc, SIB_MESSAGE, formattedMessage);
break;
case WARNING: Tr.warning(myTc, SIB_MESSAGE, formattedMessage);
break;
}
}
|
java
|
public final static void fireProbe(long probeId, Object instance, Object target, Object args) {
// Load statics onto the stack to avoid a window where they can be cleared
// between the test for null and the invocation of the method
Object proxyTarget = fireProbeTarget;
Method method = fireProbeMethod;
if (proxyTarget == null || method == null) {
return;
}
try {
method.invoke(proxyTarget, probeId, instance, target, args);
} catch (Throwable t) {
t.printStackTrace();
}
}
|
java
|
public synchronized void releaseId(short id) throws IdAllocatorException
{
if (tc.isEntryEnabled()) SibTr.entry(tc, "releaseId", ""+id);
deallocate(id);
// If we are releasing the id 1 less than the next id, set the next id to this one
if (id == (nextId - 1))
{
nextId = id;
// Ensure the next free id is not this as well
if (nextId == lastFreeId)
{
lastFreeId = NULL_ID;
}
}
// Otherwise save this id away so we can allocate it quickly
else
{
lastFreeId = id;
}
if (tc.isEntryEnabled()) SibTr.exit(tc, "releaseId");
}
|
java
|
private String firstConstantOfEnum()
{
Object[] enumConstants = targetClass.getEnumConstants();
if (enumConstants.length != 0)
{
return enumConstants[0].toString();
}
return ""; // if empty Enum
}
|
java
|
void checkTopicPublishPermission(String topic) {
SecurityManager sm = System.getSecurityManager();
if (sm == null)
return;
sm.checkPermission(new TopicPermission(topic, PUBLISH));
}
|
java
|
@Activate
protected void activate(ComponentContext componentContext, Map<String, Object> props) {
this.componentContext = componentContext;
// // Parse the configuration that we've been provided
// Dictionary<?, ?> configProperties = componentContext.getProperties();
// processConfigProperties(configProperties);
// Hold a reference to the bundle context
bundleContext = componentContext.getBundleContext();
// Start listening to the framework events so we can publish them
// as specified in section 113.6.3
frameworkEventAdapter = new FrameworkEventAdapter(this);
bundleContext.addFrameworkListener(frameworkEventAdapter);
// Start listening to the bundle events so we can publish them
// as specified in section 113.6.4
bundleEventAdapter = new BundleEventAdapter(this);
bundleContext.addBundleListener(bundleEventAdapter);
// Start listening to the service events so we can publish them
// as specified in section 113.6.5
serviceEventAdapter = new ServiceEventAdapter(this);
bundleContext.addServiceListener(serviceEventAdapter);
processConfigProperties(props);
}
|
java
|
@Deactivate
protected void deactivate(ComponentContext componentContext) {
// Remove the framework event adapter
bundleContext.removeFrameworkListener(frameworkEventAdapter);
frameworkEventAdapter = null;
// Remove the bundle event adapter
bundleContext.removeBundleListener(bundleEventAdapter);
bundleEventAdapter = null;
// Remove the service event adapter
bundleContext.removeServiceListener(serviceEventAdapter);
serviceEventAdapter = null;
bundleContext = null;
this.componentContext = null;
}
|
java
|
public void addTopic(String topic)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "addTopic", topic);
SelectionCriteria criteria = _messageProcessor.
getSelectionCriteriaFactory().
createSelectionCriteria(topic,
null,
SelectorDomain.SIMESSAGE);
if (_subscriptionState == null)
{
_subscriptionState =
new ConsumerDispatcherState(_destinationHandler.getUuid(), criteria, _destName, _busName);
}
else
_subscriptionState.addSelectionCriteria(criteria);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addTopic");
}
|
java
|
public void removeTopic(String topic)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeTopic", topic);
if (_subscriptionState == null)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "removeTopic", "Topic not found");
}
else
_subscriptionState.removeTopic(topic);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeTopic");
}
|
java
|
public String[] getTopics()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getTopics");
String[] topics = null;
if (_subscriptionState != null)
topics = _subscriptionState.getTopics();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getTopics", topics);
return topics;
}
|
java
|
public SIBUuid12 getTopicSpaceUuid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getTopicSpaceUuid");
SIBUuid12 retval = _destinationHandler.getUuid();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getTopicSpaceUuid", retval);
return retval;
}
|
java
|
void processAckExpected(
long ackExpStamp,
int priority,
Reliability reliability,
SIBUuid12 stream)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "processAckExpected", new Long(ackExpStamp));
_internalOutputStreamManager.processAckExpected(ackExpStamp, priority, reliability, stream);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "processAckExpected");
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.