code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public static <T> T findFirstNextByType(FaceletHandler nextHandler, Class<T> type)
{
if (type.isAssignableFrom(nextHandler.getClass()))
{
return (T)nextHandler;
}
else if (nextHandler instanceof javax.faces.view.facelets.CompositeFaceletHandler)
{
for (FaceletHandler handler :
((javax.faces.view.facelets.CompositeFaceletHandler)nextHandler).getHandlers())
{
if (type.isAssignableFrom(handler.getClass()))
{
return (T)handler;
}
}
}
return null;
} | java |
public static boolean tryToClose(Closeable closeable) {
Object token = ThreadIdentityManager.runAsServer();
try {
if (closeable != null) {
try {
closeable.close();
return true;
} catch (IOException e) {
// ignore
}
}
} finally {
ThreadIdentityManager.reset(token);
}
return false;
} | java |
private static void setDefaultDiscoveryProperties() {
defaultDiscoveryProperties.put(KEY_OIDC_RESPONSE_TYPES_SUPP, new String[] { "code", "token", "id_token token" });
defaultDiscoveryProperties.put(KEY_OIDC_SUB_TYPES_SUPP, new String[] { "public" });
defaultDiscoveryProperties.put(KEY_OIDC_ID_TOKEN_SIGNING_ALG_VAL_SUPP, new String[] { "HS256" });
defaultDiscoveryProperties.put(KEY_OIDC_SCOPES_SUPP, new String[] { "openid", "general", "profile", "email", "address", "phone" });
defaultDiscoveryProperties.put(KEY_OIDC_CLAIMS_SUPP,
new String[] { "sub", "groupIds", "name", "preferred_username", "picture", "locale", "email", "profile" });
defaultDiscoveryProperties.put(KEY_OIDC_RESP_MODES_SUPP, new String[] { "query", "fragment", "form_post" });
defaultDiscoveryProperties.put(KEY_OIDC_GRANT_TYPES_SUPP, new String[] { "authorization_code", "implicit", "refresh_token", "client_credentials", "password",
"urn:ietf:params:oauth:grant-type:jwt-bearer" });
defaultDiscoveryProperties.put(KEY_OIDC_TOKEN_EP_AUTH_METHODS_SUPP, new String[] { "client_secret_post", "client_secret_basic" });
defaultDiscoveryProperties.put(KEY_OIDC_DISPLAY_VAL_SUPP, new String[] { "page" });
defaultDiscoveryProperties.put(KEY_OIDC_CLAIM_TYPES_SUPP, new String[] { "normal" });
defaultDiscoveryClaimsParmSupp = false;
defaultDiscoveryRequestParmSupp = false;
defaultDiscoveryRequestUriParmSupp = false;
defaultDiscoveryRequireRequestUriRegistrationSupp = false;
} | java |
public void populateCustomRequestParameterMap(ConfigurationAdmin configAdmin, HashMap<String, String> paramMapToPopulate, String[] configuredCustomRequestParams, String configAttrName, String configAttrValue) {
if (configuredCustomRequestParams == null) {
return;
}
for (String configuredParameter : configuredCustomRequestParams) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Configured custom request param [" + configuredParameter + "]");
}
Configuration config = getConfigurationFromConfigAdmin(configAdmin, configuredParameter);
if (config != null) {
addCustomRequestParameterValueToMap(config, paramMapToPopulate, configAttrName, configAttrValue);
}
}
} | java |
public void stopModule(EJBModuleMetaDataImpl mmd) {
try { //210058
uninstall(mmd, false);
} catch (Throwable t) { //210058
FFDCFilter.processException(t, CLASS_NAME + ".stop", "3059", this);
throw new ContainerEJBException("Failed to stop - caught Throwable", t);
}
} | java |
protected void bindInterfaces(NameSpaceBinder<?> binder, BeanMetaData bmd) throws Exception {
HomeWrapperSet homeSet = null;
EJSHome home = bmd.homeRecord.getHome();
if (home != null) {
homeSet = home.getWrapperSet();
}
int numRemoteInterfaces = countInterfaces(bmd, false);
int numLocalInterfaces = countInterfaces(bmd, true);
boolean singleGlobalInterface = (numRemoteInterfaces + numLocalInterfaces) == 1;
bindInterfaces(binder, bmd, homeSet, false, numRemoteInterfaces, singleGlobalInterface);
bindInterfaces(binder, bmd, homeSet, true, numLocalInterfaces, singleGlobalInterface);
} | java |
private int countInterfaces(BeanMetaData bmd, boolean local) // F743-23167
{
// Note that these variables must be kept in sync with bindInterfaces.
String homeInterfaceClassName = local ? bmd.localHomeInterfaceClassName : bmd.homeInterfaceClassName;
boolean hasLocalBean = local && bmd.ivLocalBean;
String[] businessInterfaceNames = local ? bmd.ivBusinessLocalInterfaceClassNames : bmd.ivBusinessRemoteInterfaceClassNames;
int result = (homeInterfaceClassName == null ? 0 : 1) +
(hasLocalBean ? 1 : 0) +
(businessInterfaceNames == null ? 0 : businessInterfaceNames.length);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "countInterfaces: " + bmd.j2eeName + ", local=" + local + ", result=" + result);
return result;
} | java |
private void bindInterfaces(NameSpaceBinder<?> binder,
BeanMetaData bmd,
HomeWrapperSet homeSet,
boolean local,
int numInterfaces,
boolean singleGlobalInterface) // F743-23167
throws NamingException, RemoteException, CreateException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "bindInterfaces: " + bmd.j2eeName +
", deferred=" + (homeSet == null) +
", local=" + local);
// Note that these variables must be kept in sync with countInterfaces.
String homeInterfaceClassName = local ? bmd.localHomeInterfaceClassName : bmd.homeInterfaceClassName;
boolean hasLocalBean = local && bmd.ivLocalBean;
String[] businessInterfaceNames = local ? bmd.ivBusinessLocalInterfaceClassNames : bmd.ivBusinessRemoteInterfaceClassNames;
// If we have multiple interfaces (e.g., a home and one business
// interface, or multiple business interfaces), and simple binding name
// was specified, then issue a warning message that simple binding name
// is misused.
if (numInterfaces > 1 && bmd.simpleJndiBindingName != null) {
Tr.warning(tc, "SIMPLE_BINDING_NAME_MISSUSED_CNTR0168W",
new Object[] { bmd.enterpriseBeanName, bmd._moduleMetaData.ivName, bmd._moduleMetaData.ivAppName });
}
HomeRecord hr = bmd.homeRecord;
// Bind the home interface, if any.
if (homeInterfaceClassName != null) {
bindInterface(binder, hr, homeSet, numInterfaces, singleGlobalInterface,
homeInterfaceClassName, -1, local);
}
// Bind the no-interface view, if any.
int interfaceIndex = 0;
if (hasLocalBean) {
bindInterface(binder, hr, homeSet, numInterfaces, singleGlobalInterface,
bmd.enterpriseBeanClassName, interfaceIndex, local);
interfaceIndex++;
}
// Bind business interfaces, if any.
if (businessInterfaceNames != null) {
for (String businessInterfaceName : businessInterfaceNames) {
bindInterface(binder, hr, homeSet, numInterfaces, singleGlobalInterface,
businessInterfaceName, interfaceIndex, local);
interfaceIndex++;
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "bindInterfaces");
} | java |
private <T> void bindInterface(NameSpaceBinder<T> binder,
HomeRecord hr,
HomeWrapperSet homeSet,
int numInterfaces,
boolean singleGlobalInterface,
String interfaceName,
int interfaceIndex,
boolean local) throws NamingException, RemoteException, CreateException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "bindInterface: " + hr.getJ2EEName() +
", " + interfaceIndex +
", " + interfaceName +
", local=" + local);
// Create the object to be bound.
T bindingObject = binder.createBindingObject(hr, homeSet, interfaceName, interfaceIndex, local);
// Bind the object to configured locations.
boolean deferred = homeSet == null;
if (hr.bindToContextRoot()) // F743-34301
{
binder.bindBindings(bindingObject, // F69147.2
hr, numInterfaces, singleGlobalInterface,
interfaceIndex, interfaceName, local, deferred);
}
// Bind session and managed bean objects to java:global/app/module.
if (hr.bindToJavaNameSpaces()) // F743-34301, d660700
{
T javaBindingObject = binder.createJavaBindingObject(hr, homeSet, interfaceName, interfaceIndex, local, bindingObject); // F69147.2
bindObjectToJavaNameSpaces(binder, javaBindingObject, hr, singleGlobalInterface, interfaceName, interfaceIndex, local);
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "bindInterface");
} | java |
protected void bindAllRemoteInterfacesToContextRoot() {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "bindAllRemoteInterfacesToContextRoot");
Map<EJBModuleMetaDataImpl, NameSpaceBinder<?>> binders = new HashMap<EJBModuleMetaDataImpl, NameSpaceBinder<?>>();
// Start with the list of all HomeRecords. Not all of these beans may have
// started, but this is the complete set of everything that would have been
// bound into some naming context. The container may not be available yet
// if the EJB feature is just starting, but then there is nothing to do.
HomeOfHomes homeOfHomes = (ivContainer != null) ? ivContainer.getHomeOfHomes() : null;
if (homeOfHomes != null) {
List<HomeRecord> hrs = ivContainer.getHomeOfHomes().getAllHomeRecords();
for (HomeRecord hr : hrs) {
if (hr.bindToContextRoot()) {
BeanMetaData bmd = hr.getBeanMetaData();
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "processing bindings for " + bmd.j2eeName);
if (bmd.homeInterfaceClassName != null) {
bindRemoteInterfaceToContextRoot(binders, hr, bmd.homeInterfaceClassName, -1);
}
if (bmd.ivBusinessRemoteInterfaceClassNames != null) {
int interfaceIndex = 0;
for (String remoteInterfaceName : bmd.ivBusinessRemoteInterfaceClassNames) {
bindRemoteInterfaceToContextRoot(binders, hr, remoteInterfaceName, interfaceIndex++);
}
}
}
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "bindAllRemoteInterfacesToContextRoot");
} | java |
protected void addHome(BeanMetaData bmd) throws ContainerException {
try {
EJSContainer.homeOfHomes.addHome(bmd); //d200714 d429866.2 F743-26072
} catch (Throwable ex) {
ContainerException ex2 = new ContainerException(ex);
Tr.error(tc, "CAUGHT_EXCEPTION_THROWING_NEW_EXCEPTION_CNTR0035E",
new Object[] { ex, ex2.toString() });
throw ex2;
}
} | java |
protected EJSHome initializeDeferredEJBImpl(HomeRecord hr) throws ContainerException, EJBConfigurationException {
BeanMetaData bmd = hr.getBeanMetaData();
Object originalLoader = ThreadContextAccessor.UNCHANGED;
try {
if (!bmd.fullyInitialized) // d664917.1
{
// The server class loader must be used during metadata processing
// for XML parsing classes. d200714, PM57099
originalLoader = svThreadContextAccessor.pushContextClassLoader(getServerClassLoader()); // d278756, d334557, PK83186, d640395.1
//------------------------------------------------------------------------
// WARNING: We MUST reload WCCM object pointers here in case the module was
// unloaded. The WAS runtime code has an alarm thread which unloads
// the module after a fixed time. In the case of deferred EJB init
// processing it is up to us to "touch" the DeployedModule which will
// cause WCCM to completely reload a new set of WCCM objects for us.
//------------------------------------------------------------------------
bmd.wccm.reload(); // F743-18775
finishBMDInit(bmd); //497153
}
//d200714 start
// We must ensure that the application classloader is in force prior to starting
// the home.
originalLoader = svThreadContextAccessor.repushContextClassLoader(originalLoader, hr.getClassLoader());
//d200714 end
return fireMetaDataCreatedAndStartBean(bmd); // d648522, d739043
} finally {
svThreadContextAccessor.popContextClassLoader(originalLoader);
// d659020 - If an error occurs while initializing, then the wccm
// field will not be cleared, so we need to unload its references.
// The next attempt to initialize the bean will reload them again.
if (bmd.wccm != null) {
bmd.wccm.unload();
}
}
} | java |
protected ReferenceContext createReferenceContext(BeanMetaData bmd) // F743-29417
{
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "createReferenceContext: " + bmd.j2eeName);
if (bmd.ivReferenceContext == null) {
bmd.ivReferenceContext = getInjectionEngine().createReferenceContext();
bmd.ivReferenceContext.add(new ComponentNameSpaceConfigurationProviderImpl(bmd, this)); // F85115
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "createReferenceContext", bmd.ivReferenceContext);
return bmd.ivReferenceContext;
} | java |
private void finishBMDInit(BeanMetaData bmd) throws ContainerException, EJBConfigurationException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "finishBMDInit: " + bmd.j2eeName); // d640935.1
// First, create the reference context for the bean if we haven't already
// done so.
createReferenceContext(bmd); // F743-29417
ivEJBMDOrchestrator.finishBMDInitWithReferenceContext(bmd);
// Free resources in EJBModuleMetaData if all beans have been initialized.
bmd._moduleMetaData.freeResourcesAfterAllBeansInitialized(bmd); //d462512
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "finishBMDInit");
} | java |
public ComponentNameSpaceConfiguration finishBMDInitForReferenceContext(BeanMetaData bmd) throws EJBConfigurationException, ContainerException {
return ivEJBMDOrchestrator.finishBMDInitForReferenceContext(bmd,
ivDefaultDataSourceJNDIName,
ivWebServicesHandlerResolver);
} | java |
private EJSHome fireMetaDataCreatedAndStartBean(BeanMetaData bmd) // d648522
throws ContainerException {
if (!bmd.isManagedBean()) // F743-34301.1
{
try {
// Fire the ComponentMetaData event to the listeners
// (ie. we have loaded a new bean folks... )
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "startBean: Fire Component Metadata created event to listeners for: " + bmd.j2eeName);
bmd.ivMetaDataDestroyRequired = true; //d505055
fireMetaDataCreated(bmd);
} catch (Throwable t) //197547
{
FFDCFilter.processException(t, CLASS_NAME + "startBean", "445", this);
throw new ContainerException("Failed to start " + bmd.j2eeName, t);
}
}
return startBean(bmd); // d739043
} | java |
protected int createNonPersistentAutomaticTimers(String appName, String moduleName, List<AutomaticTimerBean> timerBeans) {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "createNonPersistentAutomaticTimers: " + moduleName);
int numCreated = 0;
for (AutomaticTimerBean timerBean : timerBeans) {
if (timerBean.getNumNonPersistentTimers() != 0) {
for (TimerMethodData timerMethod : timerBean.getMethods()) {
for (TimerMethodData.AutomaticTimer timer : timerMethod.getAutomaticTimers()) {
if (!timer.isPersistent()) {
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "creating non-persistent automatic timer " + timer);
createNonPersistentAutomaticTimer(timerBean, timer, timerMethod);
numCreated++;
}
}
}
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "createNonPersistentAutomaticTimers: " + numCreated);
return numCreated;
} | java |
protected Timer createNonPersistentCalendarTimer(BeanO beanO, ParsedScheduleExpression parsedExpr, Serializable info) {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled();
if (isTraceOn && tc.isDebugEnabled())
Tr.entry(tc, "createNonPersistentCalendarTimer : " + beanO);
// create the non-persistent Timer
TimerNpImpl timer = new TimerNpImpl(beanO.getId(), parsedExpr, info);
// queue timer to start (or start immediately if not in a global tran)
queueOrStartNpTimer(beanO, timer);
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "createNonPersistentCalendarTimer : " + timer);
return timer;
} | java |
private synchronized final boolean _declareDiscardable()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "_declareDiscardable");
boolean linkHasBecomeReleasable = false;
// Only discardable if storage managed (items and item references only).
// Putting this check in here liberates the logic which changes the state of the
// items from knowing about storage management
if (_isStorageManaged)
{
if (!_itemIsDiscardableIfPersistentRepresentationStable)
{
// if we have become non-discardable, and we were
// releasable (stable) then we must notify the cache
linkHasBecomeReleasable = _persistentRepresentationIsStable;
// 274012
if (linkHasBecomeReleasable)
{
// Defect 601995
_strongReferenceToItem = NULL_STRONG_REF;
}
// This flag must not be set if the item is not storage managed.
// Otherwise, we could inadvertently start discarding and restoring
// streams.
_itemIsDiscardableIfPersistentRepresentationStable = true;
}
}
else
{
// Just to make sure :-)
_itemIsDiscardableIfPersistentRepresentationStable = false;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "_declareDiscardable", Boolean.valueOf(linkHasBecomeReleasable));
return linkHasBecomeReleasable;
} | java |
private synchronized final boolean _declareNotDiscardable(AbstractItem item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "_declareNotDiscardable");
boolean notifyRequired = false;
// we are going to need the item in memory, so we make sure that
// we pin it with a hard reference
_strongReferenceToItem = item;
if (_itemIsDiscardableIfPersistentRepresentationStable)
{
// if we have become discardable, and we were
// releasable (stable) then we must notify the cache
notifyRequired = _persistentRepresentationIsStable;
_itemIsDiscardableIfPersistentRepresentationStable = false;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "_declareNotDiscardable", Boolean.valueOf(notifyRequired));
return notifyRequired;
} | java |
private final AbstractItem _getAndAssertItem() throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "_getAndAssertItem");
AbstractItem item = null;
synchronized (this)
{
item = _strongReferenceToItem;
}
// Defect 601995
if (item == NULL_STRONG_REF)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "_getAndAssertItem");
throw new SevereMessageStoreException("_getAndAssertItem");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "_getAndAssertItem", item);
return item;
} | java |
@Override
public final void persistRedeliveredCount(int redeliveredCount) throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "persistRedeliveredCount");
PersistentTransaction msTran = (PersistentTransaction) getMessageStore().getTransactionFactory().createAutoCommitTransaction();
// Set the value in the Persistable
Persistable perTuple = getTuple();
perTuple.setRedeliveredCount(redeliveredCount);
// Create the persist task
final Task persistTask = new PersistRedeliveredCount(this);
// Add the task to worklist. Since this is an auto-commit transaction,
// the task is run immediately and value is persisted.
try {
msTran.addWork(persistTask);
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.persistRedeliveredCount", "1:1198:1.241", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
SibTr.event(this, tc, "Exception caught persisting redelivery count!", e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "persistRedeliveredCount");
} | java |
final void cmdAdd(final LinkOwner stream, long lockID, final PersistentTransaction transaction) throws StreamIsFull, ProtocolException, TransactionException, SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "cmdAdd", new Object[] { "Item Link: " + this, "Stream Link: " + stream, formatLockId(lockID), "Transaction: " + transaction });
synchronized (this)
{
if (ItemLinkState.STATE_NOT_STORED == _itemLinkState)
{
ListStatistics stats = getParentStatistics();
stream._assertCanAddChild(transaction, stats);
// Defect 510343.1
stats.incrementAdding(_inMemoryItemSize);
_lockID = lockID;
_transactionId = transaction.getPersistentTranId();
if (NO_LOCK_ID == lockID)
{
_itemLinkState = ItemLinkState.STATE_ADDING_UNLOCKED;
}
else
{
_itemLinkState = ItemLinkState.STATE_ADDING_LOCKED;
}
}
else
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
SibTr.event(this, tc, "Invalid Item state: " + _itemLinkState);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "cmdAdd");
throw new StateException(_itemLinkState.toString());
}
}
final Task task = new AddTask(this);
transaction.addWork(task);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "cmdAdd");
} | java |
final void cmdRemoveExpiring(final long lockId, final PersistentTransaction transaction) throws ProtocolException, TransactionException, SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "cmdRemoveExpiring", new Object[] { "Item Link: " + this, "Stream Link: " + _owningStreamLink, formatLockId(lockId),
"Transaction: " + transaction });
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "expiring item " + _tuple.getUniqueId());
synchronized (this)
{
if (ItemLinkState.STATE_LOCKED_FOR_EXPIRY == _itemLinkState)
{
if (_lockID != lockId)
{
throw new LockIdMismatch(_lockID, lockId);
}
ListStatistics stats = getParentStatistics();
synchronized (stats)
{
stats.decrementExpiring();
stats.incrementRemoving();
}
_transactionId = transaction.getPersistentTranId();
_itemLinkState = ItemLinkState.STATE_REMOVING_EXPIRING;
}
else
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
SibTr.event(this, tc, "Invalid Item state: " + _itemLinkState);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "cmdRemoveExpiring");
throw new StateException(_itemLinkState.toString());
}
}
final Task task = new RemoveLockedTask(this);
transaction.addWork(task);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "cmdRemoveExpiring");
} | java |
private synchronized final boolean isStateLocked()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isStateLocked");
SibTr.exit(this, tc, "isStateLocked", _itemLinkState);
}
if (_itemLinkState == ItemLinkState.STATE_LOCKED)
{
return true;
}
else
{
return false;
}
} | java |
public final AbstractItem getItem() throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getItem");
AbstractItem item = _getItemNoRestore();
synchronized (this)
{
if (isExpired())
{
item = null;
}
else
{
// if we did not have a reference to the item then we try to recreate
if (null == item)
{
try
{
item = _restoreItem();
} catch (SevereMessageStoreException e)
{
// No FFDC Code Needed.
// PK54812 Ensure we dump a suitable FFDC containing all of the message store
// information required in order to identify the rows etc. related to this entry.
try
{
StringWriter stringWriter = new StringWriter();
FormattedWriter writer = new FormattedWriter(stringWriter);
this.xmlWriteOn(writer);
FFDCFilter.processException(e, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.getItem", "1:2252:1.241", this, new Object[] { stringWriter });
writer.close();
} catch (IOException ioe)
{
FFDCFilter.processException(ioe, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.getItem", "1:2257:1.241", this);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
SibTr.event(this, tc, "RuntimeException caught restoring Item!", e);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getItem");
throw e;
} catch (RuntimeException re)
{
// No FFDC Code Needed.
// PK54812 Ensure we dump a suitable FFDC containing all of the message store
// information required in order to identify the rows etc. related to this entry.
try
{
StringWriter stringWriter = new StringWriter();
FormattedWriter writer = new FormattedWriter(stringWriter);
this.xmlWriteOn(writer);
FFDCFilter.processException(re, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.getItem", "1:2274:1.241", this, new Object[] { stringWriter });
writer.close();
} catch (IOException ioe)
{
FFDCFilter.processException(ioe, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.getItem", "1:2279:1.241", this);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
SibTr.event(this, tc, "RuntimeException caught restoring Item!", re);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getItem");
throw re;
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getItem", item);
}
return item;
} | java |
private final void setInMemoryItemSize(AbstractItem item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setInMemoryItemSize", item);
// If we have an Item, we can ask it for its estimated size.
if (item != null) {
_inMemoryItemSize = item.getInMemoryDataSize();
}
// Otherwise, we just use its persisted size & our standard multiplier.
else {
_inMemoryItemSize = _tuple.getPersistentSize() * MEMORY_SIZE_MULTIPLIER;
}
// Set the value on the Tuple.
_tuple.setInMemoryByteSize(_inMemoryItemSize);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setInMemoryItemSize", _inMemoryItemSize);
} | java |
final boolean isExpired() throws SevereMessageStoreException
{ // 182086
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "isExpired");
if (isAvailable() && internalCanExpire())
{
// we can only expire if we are available
long expiryTime = _tuple.getExpiryTime();
if (expiryTime != 0 && expiryTime <= Expirer.timeNow())
{
// we are due to expire
boolean hasBecomeNonReleasable = false;
synchronized (this)
{
if (ItemLinkState.STATE_AVAILABLE == _itemLinkState)
{
// force item to be present
AbstractItem item = _getItemNoRestore();
if (null == item)
{
item = _restoreItem();
}
ListStatistics stats = getParentStatistics();
synchronized (stats)
{
stats.incrementExpiring();
stats.decrementAvailable();
}
_lockID = AbstractItemLink.EXPIRY_LOCK_ID;
hasBecomeNonReleasable = _declareNotDiscardable(item);
_itemLinkState = ItemLinkState.STATE_LOCKED_FOR_EXPIRY;
}
}
if (hasBecomeNonReleasable)
{
_declareNotReleasable();
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "isExpired", Boolean.valueOf(isExpiring()));
return isExpiring();
} | java |
public final AbstractItem matches(final Filter filter, boolean allowUnavailable) throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "matches", new Object[] { filter, Boolean.valueOf(allowUnavailable) });
AbstractItem foundItem = null;
if (allowUnavailable || isAvailable())
{
if (!isExpired())
{
AbstractItem item = getItem();
if (null == item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "item does not exist");
}
else
{
try
{
if (null == filter || filter.filterMatches(item))
{
foundItem = item;
}
} catch (Exception e)
{
//No FFDC Code Needed.
// assume exception is false return
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "matches", foundItem);
return foundItem;
} | java |
@Override
public final void persistLock(final Transaction transaction) throws ProtocolException, TransactionException, SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "persistLock", transaction);
if (null != transaction)
{
PersistentTransaction mstran = (PersistentTransaction) transaction;
cmdPersistLock(mstran);
getTuple().setLockID(getLockID());
final Task task = new PersistLock(this);
mstran.addWork(task);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "persistLock");
} | java |
@Override
public final List<DataSlice> readDataFromPersistence() throws SevereMessageStoreException
{
List<DataSlice> dataSlices;
// lazy restoration only needed if the item was stored. There is
// no point trying to restore if there is no data.
PersistentMessageStore pm = getMessageStoreImpl().getPersistentMessageStore();
try
{
dataSlices = pm.readDataOnly(getTuple());
} catch (PersistenceException pe)
{
com.ibm.ws.ffdc.FFDCFilter.processException(pe, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.readDataFromPersistence", "1:3271:1.241", this);
throw new SevereMessageStoreException(pe);
}
return dataSlices;
} | java |
public final void releaseItem() throws SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "releaseItem");
synchronized (this)
{
_strongReferenceToItem = NULL_STRONG_REF;
}
if (_softReferenceToItem != null)
{
_softReferenceToItem.clear();
}
// Defect 601995
if (_isStorageManaged && (_itemCacheManagedReference != NULL_CACHE_REF))
{
_itemCache.unmanage(this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(this, tc, "release item(" + getID() + ":" + _inMemoryItemSize + ") new cacheSize = " + _itemCache.getCurrentSize());
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "releaseItem");
} | java |
@Override
public final void releaseIfDiscardable() throws SevereMessageStoreException
{
boolean unlink = false; // flag so we can unlink outside sync block
if (isStoreNever())
{
synchronized (this)
{
if (ItemLinkState.STATE_AVAILABLE == _itemLinkState)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(this, tc, "removing STORE_NEVER item as a result of discard");
ListStatistics stats = getParentStatistics();
synchronized (stats)
{
stats.decrementAvailable();
stats.decrementTotal(_inMemoryItemSize);
}
_itemLinkState = ItemLinkState.STATE_NOT_STORED;
unlink = true;
}
}
}
if (unlink)
{
getMessageStoreImpl().unregister(this);
unlink();
}
} | java |
public final AbstractItem removeIfMatches(final Filter filter, PersistentTransaction transaction) throws ProtocolException, TransactionException, SevereMessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "removeIfMatches", new Object[] { filter, transaction });
AbstractItem foundItem = cmdRemoveIfMatches(filter, transaction);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "removeIfMatches", foundItem);
return foundItem;
} | java |
private Lifecycle _getLifecycle(FacesContext facesContext)
{
LifecycleFactory factory = (LifecycleFactory) FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
String id = facesContext.getExternalContext().getInitParameter(FacesServlet.LIFECYCLE_ID_ATTR);
if (id == null)
{
id = LifecycleFactory.DEFAULT_LIFECYCLE;
}
return factory.getLifecycle(id);
} | java |
private boolean locationInOutputDir(String location) {
String expandedOutputLocation = cfgSvc.resolveString(LibertyConstants.DEFAULT_OUTPUT_LOCATION);
return location.startsWith(LibertyConstants.DEFAULT_OUTPUT_LOCATION)
|| location.startsWith(expandedOutputLocation);
} | java |
private void setLocation(String _location) {
String res = null;
File resFile = null;
boolean relativePath = true;
boolean defaultPath = false;
// try as "absolute" resource (contains symbol, or absolute path)
try {
res = cfgSvc.resolveString(_location);
resFile = new File(res);
relativePath = !resFile.isAbsolute();
} catch (IllegalStateException e) {
// ignore
}
if (resFile == null || (!resFile.isFile() && relativePath)) {
// look for resource in server config location
try {
res = cfgSvc.resolveString(LibertyConstants.DEFAULT_CONFIG_LOCATION + _location);
resFile = new File(res);
} catch (IllegalStateException e) {
// ignore
}
if (resFile == null || !resFile.isFile()) {
// fall back to creating for resource in shared output location
try {
res = cfgSvc.resolveString(LibertyConstants.DEFAULT_OUTPUT_LOCATION + _location);
resFile = new File(res);
defaultPath = true;
} catch (IllegalStateException e) {
// ignore
}
}
}
// Work against the symbol in the original location
// The original location may be been
if (isDefault && (defaultPath || locationInOutputDir(_location))) {
this.initializeAtStartup = true;
}
// reset location w/ resolved value
// isDefault tested because the default path's file may not exists (and that's OK)
if ((res != null && resFile.isFile()) || isDefault) {
this.location = res;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Found store under [" + location + "]");
}
} else {
// If it wasn't found then it's likely going to trigger
// the load.error later. Issue a warning to explain the file
// could not be found.
Tr.warning(tc, "ssl.keystore.not.found.warning", res, name);
}
} | java |
private void setFileBased(Boolean flag) {
this.fileBased = flag;
setProperty(Constants.SSLPROP_KEY_STORE_FILE_BASED, flag.toString());
} | java |
private void setReadOnly(Boolean flag) {
this.readOnly = flag;
setProperty(Constants.SSLPROP_KEY_STORE_READ_ONLY, flag.toString());
} | java |
private void setInitializeAtStartup(Boolean flag) {
this.initializeAtStartup = flag;
setProperty(Constants.SSLPROP_KEY_STORE_INITIALIZE_AT_STARTUP, flag.toString());
} | java |
public String getLocation() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "getLocation -> " + location);
}
return this.location;
} | java |
public long getPollingRate() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getPollingRate returning " + pollingRate);
return this.pollingRate;
} | java |
public String getTrigger() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getTrigger returning " + trigger);
return this.trigger;
} | java |
public KeyStore getKeyStore(boolean reinitialize, boolean createIfNotPresent) throws Exception {
if (myKeyStore == null || reinitialize) {
myKeyStore = do_getKeyStore(reinitialize, createIfNotPresent);
}
return myKeyStore;
} | java |
public void store() throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "store");
try {
String name = getProperty(Constants.SSLPROP_KEY_STORE_NAME);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Storing KeyStore " + name);
String SSLKeyFile = getProperty(Constants.SSLPROP_KEY_STORE);
String SSLKeyPassword = decodePassword(getProperty(Constants.SSLPROP_KEY_STORE_PASSWORD));
String SSLKeyStoreType = getProperty(Constants.SSLPROP_KEY_STORE_TYPE);
boolean readOnly = Boolean.parseBoolean(getProperty(Constants.SSLPROP_KEY_STORE_READ_ONLY));
boolean fileBased = Boolean.parseBoolean(getProperty(Constants.SSLPROP_KEY_STORE_FILE_BASED));
String SSLKeyStoreStash = getProperty(Constants.SSLPROP_KEY_STORE_CREATE_CMS_STASH);
KeyStore ks = getKeyStore(false, false);
if (ks != null && !readOnly) {
if (fileBased) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Storing filebased keystore type " + SSLKeyStoreType);
String keyStoreLocation = SSLKeyFile;
String keyStorePassword = SSLKeyPassword;
final FileOutputStream fos = new FileOutputStream(keyStoreLocation);
try {
ks.store(fos, keyStorePassword.toCharArray());
} finally {
fos.close();
}
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Storing non-filebased keystore type " + SSLKeyStoreType);
String keyStoreLocation = SSLKeyFile;
String keyStorePassword = SSLKeyPassword;
URL ring = new URL(keyStoreLocation);
URLConnection ringConnect = ring.openConnection();
final OutputStream fos = ringConnect.getOutputStream();
try {
ks.store(fos, keyStorePassword.toCharArray());
} finally {
fos.close();
}
}
}
// we will likely have to store other types too
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception storing KeyStore; " + e);
FFDCFilter.processException(e, getClass().getName(), "store", this);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "store");
} | java |
public void initializeKeyStore(boolean reinitialize) throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "initializeKeyStore");
try {
String initAtStartup = getProperty(Constants.SSLPROP_KEY_STORE_INITIALIZE_AT_STARTUP);
boolean createIfMissing = LibertyConstants.DEFAULT_KEYSTORE_REF_ID.equals(getProperty("id"));
if (Boolean.parseBoolean(initAtStartup) || reinitialize) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Initializing keystore at startup.");
getKeyStore(reinitialize, createIfMissing);
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception initializing KeyStore; " + e);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "initializeKeyStore");
} | java |
public void provideExpirationWarnings(int daysBeforeExpireWarning, String keyStoreName) throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "provideExpirationWarnings", Integer.valueOf(daysBeforeExpireWarning));
KeyStore keystore = getKeyStore(false, false);
if (keystore != null) {
try {
Enumeration<String> e = keystore.aliases();
if (e != null) {
for (; e.hasMoreElements();) {
String alias = e.nextElement();
if (null == alias)
continue;
Certificate[] cert_chain = keystore.getCertificateChain(alias);
if (null == cert_chain)
continue;
for (int i = 0; i < cert_chain.length; i++) {
printWarning(daysBeforeExpireWarning, keyStoreName, alias, (X509Certificate) cert_chain[i]);
}
}
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception validating KeyStore expirations; " + e);
FFDCFilter.processException(e, getClass().getName(), "provideExpirationWarnings", this);
throw e;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "provideExpirationWarnings");
} | java |
public void printWarning(int daysBeforeExpireWarning, String keyStoreName, String alias, X509Certificate cert) {
try {
long millisDelta = ((((daysBeforeExpireWarning * 24L) * 60L) * 60L) * 1000L);
long millisBeforeExpiration = cert.getNotAfter().getTime() - System.currentTimeMillis();
long daysLeft = ((((millisBeforeExpiration / 1000L) / 60L) / 60L) / 24L);
// cert is already expired
if (millisBeforeExpiration < 0) {
Tr.error(tc, "ssl.expiration.expired.CWPKI0017E", new Object[] { alias, keyStoreName });
} else if (millisBeforeExpiration < millisDelta) {
Tr.warning(tc, "ssl.expiration.warning.CWPKI0016W", new Object[] { alias, keyStoreName, Long.valueOf(daysLeft) });
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "The certificate with alias " + alias + " from keyStore " + keyStoreName + " has " + daysLeft + " days left before expiring.");
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception reading KeyStore certificates during expiration check; " + e);
FFDCFilter.processException(e, getClass().getName(), "printWarning", this);
}
} | java |
public static InputStream openKeyStore(String fileName) throws MalformedURLException, IOException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "openKeyStore: " + fileName);
URL urlFile = null;
// Check if the filename exists as a File.
File kfile = new File(fileName);
if (kfile.exists() && kfile.length() == 0) {
throw new IOException("Keystore file exists, but is empty: " + fileName);
} else if (!kfile.exists()) {
urlFile = new URL(fileName);
} else {
// kfile exists
urlFile = new URL("file:" + kfile.getCanonicalPath());
}
// Finally open the file.
InputStream fis = urlFile.openStream();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "openKeyStore: " + (null != fis));
return fis;
} | java |
public void setCertificateEntry(String alias, Certificate cert) throws KeyStoreException, KeyException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(this, tc, "setCertificateEntry", new Object[] { alias, cert });
}
if (Boolean.parseBoolean(getProperty(Constants.SSLPROP_KEY_STORE_READ_ONLY))) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Unable to update readonly store");
}
throw new KeyStoreException("Unable to add to read-only store");
}
final KeyStoreManager mgr = KeyStoreManager.getInstance();
try {
KeyStore jKeyStore = getKeyStore(false, false);
if (null == jKeyStore) {
final String keyStoreLocation = getProperty(Constants.SSLPROP_KEY_STORE);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Cannot load the Java keystore at location \"" + keyStoreLocation + "\"");
}
throw new KeyStoreException("Cannot load the Java keystore at location \"" + keyStoreLocation + "\"");
}
// store the cert... errors are thrown if conflicts or errors occur
jKeyStore.setCertificateEntry(alias, cert);
try {
store();
} catch (IOException e) {
// Note: debug + ffdc in store() itself
// on z/OS we have an issue where the certificate may be stored but the
// alias
// already exists in RACF so the keystore API will through an
// IOException
// we need to catch this condition on z/OS and if the certs is in the
// keystore
// prior after adding the certificate then we know the cert was actually
// added and its not
// a true failure. If the cert was not added then we need to rethrow the
// exception.
final String ksType = getProperty(Constants.SSLPROP_KEY_STORE_TYPE);
if ((ksType.equals(Constants.KEYSTORE_TYPE_JCERACFKS) || ksType.equals(Constants.KEYSTORE_TYPE_JCECCARACFKS)
|| ksType.equals(Constants.KEYSTORE_TYPE_JCEHYBRIDRACFKS))) {
KeyStore ks = getKeyStore(true, false);
if (mgr.checkIfSignerAlreadyExistsInTrustStore((X509Certificate) cert, ks)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Certificate already exists in RACF: " + e.getMessage());
}
} else {
throw new KeyException(e.getMessage(), e);
}
} else {
throw new KeyException(e.getMessage(), e);
}
}
} catch (KeyStoreException kse) {
throw kse;
} catch (KeyException ke) {
throw ke;
} catch (Exception e) {
throw new KeyException(e.getMessage(), e);
}
// after adding the certificate, clear the keystore and SSL caches so it
// reloads it.
AbstractJSSEProvider.clearSSLContextCache();
mgr.clearJavaKeyStoresFromKeyStoreMap();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(this, tc, "setCertificateEntry");
}
} | java |
private SerializableProtectedString getKeyPassword(String alias) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getKeyPassword " + alias);
SerializableProtectedString keyPass = certAliasInfo.get(alias);
if (keyPass != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getKeyPassword entry found.");
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getKeyPassword -> null");
}
return keyPass;
} | java |
private void validateServerVariables(ValidationHelper helper, Context context, Set<String> variables, Server t) {
ServerVariables serverVariables = t.getVariables();
for (String variable : variables) {
if (serverVariables == null || !serverVariables.containsKey(variable)) {
final String message = Tr.formatMessage(tc, "serverVariableNotDefined", variable);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation("variables"), message));
}
}
} | java |
private Set<String> validateURL(ValidationHelper helper, Context context, String url) {
String pathToCheck = url;
Set<String> serverVariables = new HashSet<String>();
while (pathToCheck.contains("{")) {
if (!pathToCheck.contains("}")) {
final String message = Tr.formatMessage(tc, "serverInvalidURL", pathToCheck);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation("url"), message));
return serverVariables;
}
int firstIndex = pathToCheck.indexOf("{");
int lastIndex = pathToCheck.indexOf("}");
if (firstIndex > lastIndex) {
final String message = Tr.formatMessage(tc, "serverInvalidURL", pathToCheck);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation("url"), message));
return serverVariables;
}
String variable = pathToCheck.substring(firstIndex + 1, lastIndex);
if (variable.isEmpty() || variable.contains("{") || variable.contains("/")) {
final String message = Tr.formatMessage(tc, "serverInvalidURL", pathToCheck);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation("url"), message));
return serverVariables;
}
serverVariables.add(variable);
pathToCheck = pathToCheck.substring(lastIndex + 1);
}
if (pathToCheck.contains("}")) {
final String message = Tr.formatMessage(tc, "serverInvalidURL", pathToCheck);
helper.addValidationEvent(new ValidationEvent(ValidationEvent.Severity.ERROR, context.getLocation("url"), message));
return serverVariables;
}
return serverVariables;
} | java |
public int findFirstEyeCatcher(byte[] buffer, int off, int len) {
if (off < 0 || off >= buffer.length) {
throw new IllegalArgumentException("Offset should be in the buffer boundaries");
}
if (off + len > buffer.length) {
len = buffer.length - off;
}
// i - pointer in eyeCatcher, p - in the buffer.
int p = off + EYE_CATCHER.length - 1;
for (int i=EYE_CATCHER.length-1; i>=0; i--, p--) {
if (p >= off + len) {
return -1;
}
byte b = buffer[p];
if (b != EYE_CATCHER[i]) {
if (i == EYE_CATCHER.length-1) {
// Check if the byte is from the middle of the EYE_CATCHER
for (i--; i>=0; i--) {
if (b == EYE_CATCHER[i]) {
break;
}
}
// shift buffer to have the byte in i-th position
p += EYE_CATCHER.length - i;
} else {
// the whole buffer should be shifted due to the assumption.
p += EYE_CATCHER.length * 2 - i;
}
i = EYE_CATCHER.length;
}
}
return p+1;
} | java |
private void initialize()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "initialize");
subsets = new ReliabilitySubset[maxReliabilityIndex + 1];
subsetIDs = new long[maxReliabilityIndex + 1];
for(int i=0;i<subsetIDs.length;i++)
{
subsetIDs[i] = NO_ID;
}
createControlAdapter();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "initialize");
} | java |
protected void setStream(
int priority,
Reliability reliability,
Stream stream) throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"setStream",
new Object[] { new Integer(priority), reliability, stream });
ReliabilitySubset subset = getSubset(reliability);
subset.setStream(priority, stream);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "setStream");
} | java |
public void updateCellule( SIBUuid8 newRemoteMEUuid)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "updateCellule", newRemoteMEUuid);
this.remoteMEUuid = newRemoteMEUuid;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "updateCellule");
} | java |
private ReliabilitySubset createPersistentSubset(Reliability reliability,
TransactionCommon tran) throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "createPersistentSubset", new Object[] { reliability });
ReliabilitySubset subset = new ReliabilitySubset(reliability, initialData);
subsets[getIndex(reliability)] = subset;
if(reliability.compareTo(Reliability.BEST_EFFORT_NONPERSISTENT) > 0)
{
try
{
Transaction msTran = txManager.resolveAndEnlistMsgStoreTransaction(tran);
itemStream.addItem(subset, msTran);
subsetIDs[getIndex(reliability)] = subset.getID();
}
catch (MessageStoreException e)
{
// FFDC
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.gd.StreamSet.createPersistentSubset",
"1:398:1.67",
this);
//not sure if this default is needed but better safe than sorry
subsetIDs[getIndex(reliability)] = NO_ID;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.exception(tc, e);
SibTr.exit(tc, "createPersistentSubset", e);
}
}
}
else
{
subsetIDs[getIndex(reliability)] = NO_ID;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createPersistentSubset", subset);
return subset;
} | java |
private void createNonPersistentSubsets()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "createNonPersistentSubsets");
for(int i=0; i<subsets.length; i++)
{
createNonPersistentSubset(getReliability(i));
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createNonPersistentSubsets");
} | java |
private ReliabilitySubset createNonPersistentSubset(Reliability reliability)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"createNonPersistentSubset",
new Object[] { reliability });
ReliabilitySubset subset = new ReliabilitySubset(reliability, initialData);
subsets[getIndex(reliability)] = subset;
subsetIDs[getIndex(reliability)] = NO_ID;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "createNonPersistentSubset", subset);
return subset;
} | java |
public Stream getStream(int priority, Reliability reliability) throws SIResourceException
{
return getSubset(reliability).getStream(priority);
} | java |
public SIBUuid12 getDestUuid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getDestUuid");
SibTr.exit(tc, "getDestUuid", destID);
}
return destID;
} | java |
protected void setDestUuid(SIBUuid12 destID)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setDestUuid", destID);
this.destID = destID;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setDestUuid");
} | java |
public SIBUuid8 getBusUuid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getBusUuid");
SibTr.exit(tc, "getBusUuid", busID);
}
return busID;
} | java |
public boolean isPersistent()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isPersistent");
SibTr.exit(tc, "isPersistent", Boolean.valueOf(persistent));
}
return persistent;
} | java |
public SIBUuid12 getStreamID()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getStreamID");
SibTr.exit(tc, "getStreamID", streamID);
}
return streamID;
} | java |
protected void setPersistentData(int priority,
Reliability reliability,
long completedPrefix) throws SIResourceException
{
getSubset(reliability).setPersistentData(priority, completedPrefix);
} | java |
protected long getPersistentData(int priority, Reliability reliability) throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"getPersistentData",
new Object[] { new Integer(priority), reliability });
long prefix = getSubset(reliability).getPersistentData(priority);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getPersistentData", new Long(prefix));
return prefix;
} | java |
private boolean isOverFileLimit(int addition) {
if (LogFile.UNLIMITED == getMaximumSize()) {
return false;
}
// Note: to do this properly, we need to know if the admin updates the
// file externally, i.e. 'cat /dev/null > file' to clear it out. Windows
// JDK filechannel.size() was a buffered value (AIX was not), but the
// file.length() call on each checked the real value each time. This is
// a slight performance hit but it's the only 100% guarentee of being
// accurate.
long newlen = this.myFile.length() + addition;
return (newlen > getMaximumSize() || 0 > newlen);
} | java |
private void renameFile(File source, File target) {
if (!source.exists()) {
// don't do anything if the source file doesn't exist
return;
}
if (target.exists()) {
target.delete();
}
boolean rc = source.renameTo(target);
if (!rc) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, getFileName() + ": Unable to rename " + source + " to " + target);
}
}
} | java |
private void addBackup() {
// move the current log file to the newly formatted backup name
String newname = this.fileinfo + this.myFormat.format(new Date(HttpDispatcher.getApproxTime())) + this.extensioninfo;
File newFile = new File(newname);
renameFile(this.myFile, newFile);
// now see if we need to delete an existing backup to make room
if (this.backups.size() == getMaximumBackupFiles()) {
File oldest = this.backups.removeLast();
if (null != oldest && oldest.exists()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, getFileName() + ": Purging oldest backup-> " + oldest.getName());
}
oldest.delete();
}
}
this.backups.addFirst(newFile);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, getFileName() + ": number of backup files-> " + this.backups.size());
}
} | java |
private void rotate() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, getFileName() + ": Rotating output log");
}
try {
this.myChannel.close();
} catch (IOException ioe) {
FFDCFilter.processException(ioe, getClass().getName() + ".rotate", "424", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, getFileName() + ": Failed to close the output file; " + ioe);
}
}
try {
if (0 < getMaximumBackupFiles()) {
// add the new backup file to the stored list
addBackup();
}
this.myChannel = new FileOutputStream(this.myFile, true).getChannel();
} catch (SecurityException se) {
FFDCFilter.processException(se, getClass().getName() + ".rotate", "436", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, getFileName() + ": security error in rotate; " + se);
}
} catch (Throwable t) {
FFDCFilter.processException(t, getClass().getName() + ".rotate", "441", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, getFileName() + ": error in rotate; " + t);
}
}
} | java |
public static void binToHex(byte[] bin, int start, int length, StringBuffer hex) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "binToHex", new Object[]{bin, Integer.valueOf(start), Integer.valueOf(length), hex});
/* Constant for binary to Hex conversion */
final char BIN2HEX[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
int binByte;
for (int i=start; i<start+length; i++)
{
binByte = bin[i];
/* SibTreat the byte as unsigned */
if (binByte < 0) binByte += 256;
/* Convert and append each digit */
hex.append(BIN2HEX[binByte/16]);
hex.append(BIN2HEX[binByte%16]);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "binToHex", hex);
} | java |
public static String binToHex(byte[] bin)
{
StringBuffer hex = new StringBuffer();
binToHex(bin,0,bin.length,hex);
return hex.toString();
} | java |
public static byte[] hexToBin(String hex, int start) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "hexToBin", new Object[]{hex, Integer.valueOf(start)});
int digit1, digit2;
int length = (hex.length() - start); // no of characters to be processed
// Handle the special case when there is no data
if (length == 0) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "hexToBin");
return new byte[0];
}
// It's an error if we have an odd number of hex characters
if ((length < 0) || ((length % 2) != 0)) {
String nlsMsg = nls.getFormattedMessage("BAD_HEX_STRING_CWSIU0200"
,new Object[]{hex}
,"The hexadecimal string " + hex + " is incorrectly formatted."
);
IllegalArgumentException e = new IllegalArgumentException(nlsMsg);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "hexToBin", e);
throw e;
}
// Change length from number of characters to number of bytes to be produced
length /= 2;
// Allocate a buffer to hold the result
byte[] retval = new byte[length];
// Convert from HexString to a byte array
for (int i = 0; i < length; i++) {
digit1 = (Character.digit(hex.charAt(2 * i + start), 16)) << 4;
digit2 = Character.digit(hex.charAt(2 * i + start + 1), 16);
// The Character.digit() method signals an error by returning -1, so we have
// to test for it here
if ((digit1 < 0) || (digit2 < 0)) {
String nlsMsg = nls.getFormattedMessage("BAD_HEX_STRING_CWSIF0200"
,new Object[]{hex}
,"The hexadecimal string " + hex + " is incorrectly formatted."
);
IllegalArgumentException e = new IllegalArgumentException(nlsMsg);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "hexToBin", e);
throw e;
}
retval[i] = (byte) (digit1 + digit2);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "hexToBin");
return retval;
} | java |
public FilterCell findNextCell(int nextValue) {
if (nextCell == null) {
return null;
}
return (FilterCell) (nextCell.get(nextValue));
} | java |
static void rcvCloseProducerSess(CommsByteBuffer request, Conversation conversation,
int requestNumber, boolean allocatedFromBufferPool,
boolean partOfExchange)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "rcvCloseProducerSess",
new Object[]
{
request,
conversation,
"" + requestNumber,
"" + allocatedFromBufferPool,
"" + partOfExchange
});
ConversationState convState = (ConversationState) conversation.getAttachment();
short connectionObjectID = request.getShort(); // BIT16 ConnectionObjectId
short producerObjectID = request.getShort(); // BIT16 SyncProducerSessionId
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, "connectionObjectID", connectionObjectID);
SibTr.debug(tc, "producerObjectID", producerObjectID);
}
ProducerSession producerSession = ((ProducerSession) convState.getObject(producerObjectID));
try
{
producerSession.close();
convState.removeObject(producerObjectID);
try
{
conversation.send(poolManager.allocate(),
JFapChannelConstants.SEG_CLOSE_PRODUCER_SESS_R,
requestNumber,
JFapChannelConstants.PRIORITY_MEDIUM,
true,
ThrottlingPolicy.BLOCK_THREAD,
null);
} catch (SIException e)
{
FFDCFilter.processException(e,
CLASS_NAME + ".rcvCloseProducerSess",
CommsConstants.STATICCATPRODUCER_CLOSE_01);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, e.getMessage(), e);
SibTr.error(tc, "COMMUNICATION_ERROR_SICO2024", e);
}
} catch (SIException e)
{
//No FFDC code needed - processor will have already FFDC'ed any interesting ones....
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, e.getMessage(), e);
StaticCATHelper.sendExceptionToClient(e,
CommsConstants.STATICCATPRODUCER_CLOSE_02, // d186970
conversation, requestNumber); // f172297
}
request.release(allocatedFromBufferPool);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "rcvCloseProducerSess");
} | java |
static void rcvSendSessMsg(CommsServerByteBuffer request,
Conversation conversation,
int requestNumber,
boolean allocatedFromBufferPool,
boolean partOfExchange)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "rcvSendSessMsg");
final boolean optimizedTx = CommsUtils.requiresOptimizedTransaction(conversation);
sendSessMsg(request, conversation, requestNumber, partOfExchange,
allocatedFromBufferPool, true, optimizedTx);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "rcvSendSessMsg");
} | java |
RegistryEntry getRegistryEntry(String pid) {
if (pid == null) {
return null;
}
return entryMap.get(pid);
} | java |
private void processReferencedTypes(RegistryEntry pidEntry) {
//parent first, AD has a reference pid
for (ExtendedAttributeDefinition ad : pidEntry.getAttributeMap().values()) {
if (ad.getType() == MetaTypeFactory.PID_TYPE) {
if (ad.getReferencePid() != null) {
RegistryEntry other = getRegistryEntry(ad.getReferencePid());
if (other != null) {
PidReference ref = new PidReference(other, pidEntry, ad.getID(), true);
other.addReferencingEntry(ref);
pidEntry.addReferencedEntry(ref);
}
} else if (ad.getService() != null) {
addServiceUse(ad.getService(), pidEntry);
} else {
// Error.. should always be caught by metatype validation.. warn anyway?
}
}
}
//child first, child has a parentPid
if (pidEntry.getObjectClassDefinition().getParentPID() != null) {
RegistryEntry other = getRegistryEntry(pidEntry.getObjectClassDefinition().getParentPID());
if (other != null) {
pidEntry.addReferencingEntry(new PidReference(pidEntry, other, pidEntry.getChildAlias(), false));
}
//else.... this should go into invalidParentEntryMap
}
//see if anyone is referencing us.
for (RegistryEntry other : entryMap.values()) {
if (pidEntry.getPid().equals(other.getObjectClassDefinition().getParentPID())) {
other.addReferencingEntry(new PidReference(other, pidEntry, other.getChildAlias(), false));
}
for (ExtendedAttributeDefinition ad : other.getAttributeMap().values()) {
if (ad.getType() == MetaTypeFactory.PID_TYPE) {
if (pidEntry.getPid().equals(ad.getReferencePid())) {
pidEntry.addReferencingEntry(new PidReference(pidEntry, other, ad.getID(), true));
//TODO deal with service/objectclass here?
}
}
}
}
} | java |
protected final void unLock(ObjectManagerState objectManagerState)
{
synchronized (objectManagerState.transactionUnlockSequenceLock) {
unlockSequence = objectManagerState.getNewGlobalTransactionUnlockSequence();
lockingTransaction = null;
} // synchronized.
} | java |
protected void validateCertificate(X509Certificate[] chain) throws com.ibm.wsspi.security.wim.exception.CertificateMapFailedException {
// validate the certificate array
if (chain == null || chain.length == 0) {
throw new com.ibm.wsspi.security.wim.exception.CertificateMapFailedException();
}
for (X509Certificate cert : chain) {
if (cert == null) {
throw new com.ibm.wsspi.security.wim.exception.CertificateMapFailedException();
}
}
} | java |
protected IDAndRealm separateIDAndRealm(String inputString) throws WIMException {
// initialize the method name
String methodName = "seperateIDAndRealm";
if (tc.isDebugEnabled()) {
Tr.debug(tc, methodName + " " + "inputString = \"" + inputString + "\"");
}
String defaultRealm = getDefaultRealmName();
if (tc.isDebugEnabled()) {
Tr.debug(tc, methodName + " " + "Default realm name = \"" + defaultRealm + "\"");
}
String defaultRealmDelimiter = getCoreConfiguration().getDefaultDelimiter();
Set<String> virtualRealms = getCoreConfiguration().getRealmNames(); //will not be null since set will always be returned
Map<String, String> virtualRealmsDelimiter = new HashMap<String, String>();
for (Iterator<String> itr = virtualRealms.iterator(); itr.hasNext();) {
String virtualRealm = itr.next();
String delimiter = getCoreConfiguration().getDelimiter(virtualRealm);
virtualRealmsDelimiter.put(virtualRealm, delimiter);
}
//add default/UR realm to the list of realms to handle no VMM realm scenorio
if (virtualRealms.size() == 0) {
virtualRealms = new HashSet(); //if empty it will be a abstract set.So need to initialize, else will fail while adding element to it.
virtualRealms.add(defaultRealm);
virtualRealmsDelimiter.put(defaultRealm, defaultRealmDelimiter);
}
return seperateIDAndRealm(inputString, defaultRealm, defaultRealmDelimiter, virtualRealms,
virtualRealmsDelimiter);
} | java |
public boolean isIdentifierTypeProperty(String inputProperty) {
// initialize the return value
boolean returnValue = false;
// test the property
if ((inputProperty != null)
&& ((inputProperty.equals(Service.PROP_UNIQUE_ID)) || (inputProperty.equals(Service.PROP_UNIQUE_NAME))
|| (inputProperty.equals(Service.PROP_EXTERNAL_ID)) || (inputProperty.equals(Service.PROP_EXTERNAL_NAME)))) {
returnValue = true;
}
return returnValue;
} | java |
protected void createRealmDataObject(Root inputRootObject, String inputRealm) {
// use the root DataGraph to create a Context DataGraph
List<Context> contexts = inputRootObject.getContexts();
if (contexts != null) {
Context ctx = new Context();
// set "WIM.Realm" in the Context DataGraph to the realm
ctx.setKey(Service.VALUE_CONTEXT_REALM_KEY);
ctx.setValue(inputRealm);
contexts.add(ctx);
}
} | java |
protected void createPropertyControlDataObject(Root inputRootDataObject, String inputProperty) {
// use the root DataGraph to create a PropertyControl DataGraph
List<Control> propertyControls = inputRootDataObject.getControls();
PropertyControl propCtrl = null;
if (propertyControls != null) {
propCtrl = new PropertyControl();
propertyControls.add(propCtrl);
}
// add the requested property to the return list of properties
if (propCtrl != null) {
propCtrl.getProperties().add(inputProperty);
}
} | java |
protected String getRealInputAttrName(String inputAttrName, String id, boolean isUser) {
boolean isInputAttrValueDN = UniqueNameHelper.isDN(id) != null;
boolean isInputAttrIdentifier = isIdentifierTypeProperty(inputAttrName);
if (!isInputAttrIdentifier && isInputAttrValueDN) {
// To suppress the below message from coming in trace.log due to defect 94474
/*
* if (tc.isWarningEnabled()) {
* //Tr.warning(tc, "the propertyForInput " + inputAttrName + " doesn't match the format of input value " + id + ", switch to uniqueName");
* Tr.warning(tc, WIMMessageKey.INVALID_PROPERTY_VALUE_FORMAT, inputAttrName);
* }
*/
inputAttrName = "uniqueName";
//take it as uniqueName because we don't know if it's externalName or uniqueName value
} else if (isInputAttrIdentifier && !isInputAttrValueDN) {
// if dealing with LoginAccount or Group
if (isUser) {
// To suppress the below message from coming in trace.log due to defect 94474
/*
* if (tc.isWarningEnabled()) {
* //Tr.warning(tc, "the propertyForInput " + inputAttrName + " doesn't match the format of input value " + id + ", switch to principalName");
* Tr.warning(tc, WIMMessageKey.INVALID_PROPERTY_VALUE_FORMAT, inputAttrName);
* }
*/
inputAttrName = "principalName"; // loginaccounts
}
//OR
else {
// To suppress the below message from coming in trace.log due to defect 94474
/*
* if (tc.isWarningEnabled()) {
* //Tr.warning(tc, "the propertyForInput " + inputAttrName + " doesn't match the format of input value " + id + ", swith to cn");
* Tr.warning(tc, WIMMessageKey.INVALID_PROPERTY_VALUE_FORMAT, inputAttrName);
* }
*/
inputAttrName = "cn"; // groups
}
}
return inputAttrName;
} | java |
public String getDefaultRealmName() {
String returnRealm = getCoreConfiguration().getDefaultRealmName();
if (returnRealm == null) {
returnRealm = urRealmName;
}
return returnRealm;
} | java |
private final Properties loadPropertiesFile(WsResource res) throws IOException {
Properties props = new Properties();
InputStream is = res.get();
try {
props.load(is);
} catch (IOException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "Error loading properties; " + e);
}
throw e;
} finally {
if (is != null)
try {
is.close();
} catch (IOException e) {
}
}
return props;
} | java |
final WsResource getLTPAKeyFileResource(WsLocationAdmin locService, String ltpaKeyFile) {
WsResource ltpaFile = locService.resolveResource(ltpaKeyFile);
if (ltpaFile != null && ltpaFile.exists()) {
return ltpaFile;
} else {
// The file does not exist so return null
return null;
}
} | java |
void cleanupBoxedCache(int boxedAccessor) {
for (int i = 0; i < boxedCache.length; i++)
if (boxed[i][0] == boxedAccessor)
boxedCache[i] = null;
} | java |
private JSON getJSON() throws JSONMarshallException {
if (json == null) {
JSONSettings settings = new JSONSettings(Include.NON_NULL);
json = JSONFactory.newInstance(settings);
}
return json;
} | java |
public void setSubscriptionIDFilter(String subscriptionId)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "setSubscriptionIDFilter", subscriptionId);
this._subscriptionId = subscriptionId;
this._destination = null;
this._consumerDispatcherState = null;
if (tc.isEntryEnabled())
SibTr.exit(tc, "setSubscriptionIDFilter");
} | java |
public void setDestinationFilter(SIBUuid12 destination)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "setDestinationFilter", destination);
this._destination = destination;
this._subscriptionId = null;
this._consumerDispatcherState = null;
if (tc.isEntryEnabled())
SibTr.exit(tc, "setDestinationFilter");
} | java |
public void setConsumerDispatcherStateFilter(ConsumerDispatcherState consumerDispatcherState)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "setConsumerDispatcherStateFilter", consumerDispatcherState);
this._consumerDispatcherState = consumerDispatcherState;
this._subscriptionId = null;
this._destination = null;
if (tc.isEntryEnabled())
SibTr.exit(tc, "setConsumerDispatcherStateFilter");
} | java |
public boolean filterMatches(AbstractItem item)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "filterMatches", item);
/* Cast the incoming item to a subscriptionState object. if it is not, an
* exception will be thrown and the match will fail */
ConsumerDispatcherState subState = null;
if (item instanceof DurableSubscriptionItemStream)
{
try
{
subState = ((DurableSubscriptionItemStream) item).getConsumerDispatcherState();
}
catch (Exception e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.store.filters.SubscriptionStateFilter.filterMatches",
"1:180:1.33.1.1",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", e);
return false;
}
/* If this filter is a subscriptionId filter, check for a match */
if (_subscriptionId != null)
{
boolean retval = (subState.getSubscriberID().equals(_subscriptionId));
if (tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.valueOf(retval));
return retval;
}
/* If this filter is a destination name filter, check for a match */
if (_destination != null)
{
boolean retval = (subState.getTopicSpaceUuid().equals(_destination));
if (tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.valueOf(retval));
return retval;
}
/* If this filter is for a specific consumer dispatcher state object, check for a match */
if (_consumerDispatcherState != null)
{
boolean retval = (subState == _consumerDispatcherState);
if (tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.valueOf(retval));
return retval;
}
//The match succeeds if its a durable subscription and no specific matching is requested
if ((_destination == null) && (_subscriptionId == null) && (_consumerDispatcherState == null))
{
if (tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.TRUE);
return true;
}
}
/* If filter type has not been set, the match fails */
if (tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", Boolean.FALSE);
return false;
} | java |
public boolean matchesToMicros(LibertyVersion other) {
if (other == null) {
return true;
}
return this.major == other.major && this.minor == other.minor && this.micro == other.micro;
} | java |
public void putCustomizedProperty(String key, Object obj) {
if (key == null || obj == null)
return;
customizedProperties.put(key, obj);
} | java |
PartialMatch newPartialMatch(char[] key, PartialMatch pm) {
if (tc.isEntryEnabled())
tc.entry(this,cclass, "newPartialMatch", "key: "+new String(key)+", pm:"+pm);
PartialMatch ans = new PartialMatch(key, pm, owner);
if (tc.isEntryEnabled())
tc.exit(this,cclass, "newPartialMatch", ans);
return ans;
} | java |
void put(PatternWrapper pattern, Conjunction selector, MatchTarget object,
InternTable subExpr) throws MatchingException {
if (tc.isEntryEnabled())
tc.entry(this,cclass, "put", new Object[]{pattern,selector,object,subExpr});
switch (pattern.getState()) {
case PatternWrapper.FINAL_EXACT:
exactChild = owner.nextMatcher(selector, exactChild);
exactChild.put(selector, object, subExpr);
break;
case PatternWrapper.FINAL_MANY:
if(hasMidClauses(pattern))
{
// We have multiple multi-level wildcarding and need to work with the
// matchManyChildren list
ContentMatcher next = null;
MatchManyWrapper wrapper= findMatchManyWrapper(pattern);
if(wrapper != null)
next = wrapper.matcher;
ContentMatcher newNext = owner.nextMatcher(selector, next);
if (newNext != next)
{
if (matchManyChildren == null)
matchManyChildren = new ArrayList(3); // 3 is somewhat arbitrary
MatchManyWrapper matchManyElement = new MatchManyWrapper(pattern, newNext);
matchManyChildren.add(matchManyElement);
}
newNext.put(selector, object, subExpr);
}
else
{
// Simpler case where there is a single multi-level wildcard
singleMatchManyChild = owner.nextMatcher(selector, singleMatchManyChild);
singleMatchManyChild.put(selector, object, subExpr);
}
break;
case PatternWrapper.PREFIX_CHARS:
case PatternWrapper.SUFFIX_CHARS:
PartialMatch pm = findOrCreate(pattern.getChars());
pm.put(pattern, selector, object, subExpr);
break;
case PatternWrapper.SKIP_ONE_PREFIX:
case PatternWrapper.SKIP_ONE_SUFFIX:
if (matchOneChild == null)
matchOneChild = newPartialMatch();
pattern.advance();
matchOneChild.put(pattern, selector, object, subExpr);
break;
case PatternWrapper.SWITCH_TO_SUFFIX:
if (suffix == null)
suffix = newPartialMatch();
pattern.advance();
suffix.put(pattern, selector, object, subExpr);
break;
}
if (tc.isEntryEnabled())
tc.exit(this,cclass, "put");
} | java |