code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public void modifyAttributes(String name, ModificationItem[] mods) throws NamingException, WIMException {
TimedDirContext ctx = iContextManager.getDirContext();
// checkWritePermission(ctx); TODO Why are we not checking for permission here?
try {
try {
ctx.modifyAttributes(new LdapName(name), mods);
} catch (NamingException e) {
if (!ContextManager.isConnectionException(e)) {
throw e;
}
ctx = iContextManager.reCreateDirContext(ctx, e.toString());
ctx.modifyAttributes(new LdapName(name), mods);
}
} catch (NameNotFoundException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)));
throw new EntityNotFoundException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
} catch (NamingException e) {
throw e;
} finally {
iContextManager.releaseDirContext(ctx);
}
}
|
java
|
public void modifyAttributes(String dn, int mod_op, Attributes attrs) throws NamingException, WIMException {
TimedDirContext ctx = iContextManager.getDirContext();
iContextManager.checkWritePermission(ctx);
try {
try {
ctx.modifyAttributes(new LdapName(dn), mod_op, attrs);
} catch (NamingException e) {
if (!ContextManager.isConnectionException(e)) {
throw e;
}
ctx = iContextManager.reCreateDirContext(ctx, e.toString());
ctx.modifyAttributes(new LdapName(dn), mod_op, attrs);
}
} catch (NameNotFoundException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)));
throw new EntityNotFoundException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
} catch (NamingException e) {
throw e;
}
finally {
iContextManager.releaseDirContext(ctx);
}
}
|
java
|
public void rename(String dn, String newDn) throws WIMException {
TimedDirContext ctx = iContextManager.getDirContext();
iContextManager.checkWritePermission(ctx);
try {
try {
ctx.rename(dn, newDn);
} catch (NamingException e) {
if (!ContextManager.isConnectionException(e)) {
throw e;
}
ctx = iContextManager.reCreateDirContext(ctx, e.toString());
ctx.rename(dn, newDn);
}
} catch (NamingException e) {
String msg = Tr.formatMessage(tc, WIMMessageKey.NAMING_EXCEPTION, WIMMessageHelper.generateMsgParms(e.toString(true)));
throw new WIMSystemException(WIMMessageKey.NAMING_EXCEPTION, msg, e);
} finally {
iContextManager.releaseDirContext(ctx);
}
}
|
java
|
protected final void addConverter(String name, String converterId)
{
_factories.put(name, new ConverterHandlerFactory(converterId));
}
|
java
|
protected final void addConverter(String name, String converterId, Class<? extends TagHandler> type)
{
_factories.put(name, new UserConverterHandlerFactory(converterId, type));
}
|
java
|
protected final void addTagHandler(String name, Class<? extends TagHandler> handlerType)
{
_factories.put(name, new HandlerFactory(handlerType));
}
|
java
|
protected final void addUserTag(String name, URL source)
{
if (_strictJsf2FaceletsCompatibility == null)
{
MyfacesConfig config = MyfacesConfig.getCurrentInstance(
FacesContext.getCurrentInstance().getExternalContext());
_strictJsf2FaceletsCompatibility = config.isStrictJsf2FaceletsCompatibility();
}
if (Boolean.TRUE.equals(_strictJsf2FaceletsCompatibility))
{
_factories.put(name, new LegacyUserTagFactory(source));
}
else
{
_factories.put(name, new UserTagFactory(source));
}
}
|
java
|
@Reference(policy = ReferencePolicy.DYNAMIC, cardinality = ReferenceCardinality.MULTIPLE, target = "(!(com.ibm.ws.security.registry.type=QuickStartSecurityRegistry))")
protected synchronized void setUserRegistry(ServiceReference<UserRegistry> ref) {
urs.add(ref);
unregisterQuickStartSecurityRegistryConfiguration();
unregisterQuickStartSecurityAdministratorRole();
}
|
java
|
@Reference(policy = ReferencePolicy.DYNAMIC, cardinality = ReferenceCardinality.MULTIPLE,
target = "(!(com.ibm.ws.management.security.role.name=QuickStartSecurityAdministratorRole))")
protected synchronized void setManagementRole(ServiceReference<ManagementRole> ref) {
managementRoles.add(ref);
unregisterQuickStartSecurityRegistryConfiguration();
unregisterQuickStartSecurityAdministratorRole();
}
|
java
|
@Modified
protected synchronized void modify(QuickStartSecurityConfig config) {
this.config = config;
validateConfigurationProperties();
if (urConfigReg == null) {
registerQuickStartSecurityRegistryConfiguration();
} else {
updateQuickStartSecurityRegistryConfiguration();
}
unregisterQuickStartSecurityAdministratorRole();
registerQuickStartSecurityAdministratorRole();
}
|
java
|
@Trivial
private boolean isStringValueUndefined(Object str) {
if (str instanceof SerializableProtectedString) {
// Avoid constructing a String from a ProtectedString
char[] contents = ((SerializableProtectedString) str).getChars();
for (char ch : contents)
if (ch > '\u0020')
return false; // See the description of String.trim()
return true;
} else {
return (str == null || ((String) str).trim().isEmpty());
}
}
|
java
|
private Dictionary<String, Object> buildUserRegistryConfigProps() {
Hashtable<String, Object> properties = new Hashtable<String, Object>();
properties.put("config.id", QUICK_START_SECURITY_REGISTRY_ID);
properties.put("id", QUICK_START_SECURITY_REGISTRY_ID);
properties.put(UserRegistryService.REGISTRY_TYPE, QUICK_START_SECURITY_REGISTRY_TYPE);
properties.put(CFG_KEY_USER, config.userName());
properties.put("service.vendor", "IBM");
return properties;
}
|
java
|
private void registerQuickStartSecurityRegistryConfiguration() {
if (bc == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "BundleContext is null, we must be deactivated.");
}
return;
}
if (urConfigReg != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "QuickStartSecurityRegistry configuration is already registered.");
}
return;
}
if (isStringValueUndefined(config.userName()) || isStringValueUndefined(config.userPassword())) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Incomplete configuration. This should already have been reported. Will not register QuickStartSecurityRegistry configuration.");
}
return;
}
if (config.UserRegistry() != null && config.UserRegistry().length > 0) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Other UserRegistryConfiguration are present, will not register the QuickStartSecurityRegistry configuration.");
}
return;
}
if (!managementRoles.isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Other ManagementRole are present, will not register the QuickStartSecurityRegistry configuration.");
}
return;
}
Dictionary<String, Object> props = buildUserRegistryConfigProps();
quickStartRegistry = new QuickStartSecurityRegistry(config.userName(), Password.create(config.userPassword()));
urConfigReg = bc.registerService(UserRegistry.class,
quickStartRegistry,
props);
}
|
java
|
private void unregisterQuickStartSecurityRegistryConfiguration() {
if (urConfigReg != null) {
urConfigReg.unregister();
urConfigReg = null;
quickStartRegistry = null;
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "QuickStartSecurityRegistry configuration is not registered.");
}
}
}
|
java
|
private void registerQuickStartSecurityAdministratorRole() {
if (bc == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "BundleContext is null, we must be deactivated.");
}
return;
}
if (managementRoleReg != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "QuickStartSecurityAdministratorRole is already registered.");
}
return;
}
if (urConfigReg == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "QuickStartSecurityRegistry configuration is not registered, will not register QuickStartSecurityAdministratorRole.");
}
return;
}
if (isStringValueUndefined(config.userName())) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "User is not set, can not register the QuickStartSecurityAdministratorRole");
}
return;
}
if (!managementRoles.isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Other managment roles are present, will not register the QuickStartSecurityAdministratorRole");
}
return;
}
Dictionary<String, Object> props = new Hashtable<String, Object>();
props.put(ManagementRole.MANAGEMENT_ROLE_NAME, QUICK_START_ADMINISTRATOR_ROLE_NAME);
props.put("service.vendor", "IBM");
managementRole = new QuickStartSecurityAdministratorRole(config.userName());
managementRoleReg = bc.registerService(ManagementRole.class,
managementRole,
props);
}
|
java
|
static long roundUpDelay(long delay, TimeUnit unit, long now) {
if (delay < 0) {
// Negative is treated as 0.
delay = 0;
}
long target = now + unit.toMillis(delay);
if (target < now) {
// We can't add the delay to the current time without overflow.
// Return the delay unaltered.
return delay;
}
long remainder = target % PERIOD_MILLISECONDS;
if (remainder == 0) {
// Already rounded.
return delay;
}
long extra = PERIOD_MILLISECONDS - remainder;
long newDelay = delay + unit.convert(extra, TimeUnit.MILLISECONDS);
if (newDelay < delay) {
// We can't round up without overflow. Return the delay unaltered.
return delay;
}
return newDelay;
}
|
java
|
public static void copyStream(InputStream from, OutputStream to) throws IOException {
byte buffer[] = new byte[2048];
int bytesRead;
while ((bytesRead = from.read(buffer)) != -1) {
to.write(buffer, 0, bytesRead);
}
from.close();
}
|
java
|
public static void copyReader(Reader from, Writer to) throws IOException {
char buffer[] = new char[2048];
int charsRead;
while ((charsRead = from.read(buffer)) != -1) {
to.write(buffer, 0, charsRead);
}
from.close();
to.flush();
}
|
java
|
public void activate() {
// if no handlers are currently running, start one now
if (this.numHandlersInFlight.getInt() == 0) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Activating result handler: " + this.completionPort);
}
startHandler();
}
}
|
java
|
public static void setConnectionHandle(VirtualConnection vc, ConnectionHandle handle) {
if (vc == null || handle == null) {
return;
}
Map<Object, Object> map = vc.getStateMap();
// set connection handle into VC
Object vcLock = vc.getLockObject();
synchronized (vcLock) {
Object tmpHandle = map.get(CONNECTION_HANDLE_VC_KEY);
// If this connection already has a unique handle when we get here,
// something went wrong.
if (tmpHandle != null) {
throw new IllegalStateException("Connection " + tmpHandle + " has already been created");
}
map.put(CONNECTION_HANDLE_VC_KEY, handle);
}
}
|
java
|
protected void setConnectionType(VirtualConnection vc) {
if (this.myType == 0 || vc == null) {
ConnectionType newType = ConnectionType.getVCConnectionType(vc);
this.myType = (newType == null) ? 0 : newType.export();
}
}
|
java
|
public static void processException(Throwable th, String sourceId, String probeId, Object callerThis) {
FFDCConfigurator.getDelegate().processException(th, sourceId, probeId, callerThis);
}
|
java
|
void close() {
if (logger.isLoggable(Level.FINER)) {
logger.logp(Level.FINER, logger.getName(), "close", "Close called for " + RESTClientMessagesUtil.getObjID(this) + " within connection: "
+ connector.getConnectionId());
}
closePollingThread();
if (notificationRegistry != null) {
notificationRegistry.close();
}
if (connector.logFailovers()) {
String disconnectMsg = RESTClientMessagesUtil.getMessage(RESTClientMessagesUtil.MEMBER_DISCONNECT, connector.getCurrentEndpoint());
logger.logp(Level.INFO, logger.getName(), "close", disconnectMsg);
}
disconnect();
}
|
java
|
@Trivial
private File getArchiveFile() {
String methodName = "getArchiveFile";
if ( archiveFileLock != null ) {
synchronized ( archiveFileLock ) {
if ( (archiveFile == null) && !archiveFileFailed ) {
try {
archiveFile = extractEntry( entryInEnclosingContainer, getCacheDir() );
// 'extractEntry' throws IOException
if ( archiveFile != null ) {
archiveFilePath = archiveFile.getAbsolutePath();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
Tr.debug(tc, methodName + " Archive file [ " + archiveFilePath + " ]");
}
} else {
archiveFileFailed = true;
Tr.error(tc, "extract.cache.null", entryInEnclosingContainer.getPath());
}
} catch ( IOException e ) {
archiveFileFailed = true;
Tr.error(tc, "extract.cache.fail", e.getMessage());
}
}
}
}
return archiveFile;
}
|
java
|
private String getArchiveFilePath() {
if ( archiveFileLock == null ) {
return archiveFilePath;
} else {
synchronized( archiveFileLock ) {
@SuppressWarnings("unused")
File useArchiveFile = getArchiveFile();
return archiveFilePath;
}
}
}
|
java
|
ZipFileHandle getZipFileHandle() throws IOException {
synchronized( zipFileHandleLock ) {
if ( zipFileHandleFailed ) {
return null;
} else if ( zipFileHandle != null ) {
return zipFileHandle;
}
File useArchiveFile = getArchiveFile();
if ( useArchiveFile == null ) {
zipFileHandleFailed = true;
throw new FileNotFoundException( entryInEnclosingContainer.getPath() );
}
try {
String useCanonicalPath = getCanonicalPath(useArchiveFile); // throws IOException
zipFileHandle = getZipFileHandle(useCanonicalPath); // throws IOException
} catch ( IOException e ) {
zipFileHandleFailed = true;
throw e;
}
return zipFileHandle;
}
}
|
java
|
@Trivial
protected ZipFileEntry createEntry(String entryName, String a_entryPath) {
ZipEntryData[] useZipEntries = getZipEntryData();
if ( useZipEntries.length == 0 ) {
return null;
}
String r_entryPath = a_entryPath.substring(1);
int location = locatePath(r_entryPath);
ZipEntryData entryData;
if ( location < 0 ) {
location = ( (location + 1) * -1 );
entryData = null;
} else {
entryData = useZipEntries[location];
}
return createEntry(
null,
entryName, a_entryPath,
entryData);
}
|
java
|
URI createEntryUri(String r_entryPath, File useArchiveFile) {
URI archiveUri = getURI(useArchiveFile);
if ( archiveUri == null ) {
return null;
}
if ( r_entryPath.isEmpty() ) {
return null;
}
// URLs for jar/zip data now use wsjar to avoid locking issues via jar protocol.
//
// The single string constructor is used to control the encoding an ddecoding.
//
// The return value of 'parentUri.toString()' is an encoded string. The
// handler (usually WSJarURLStreamHandler) must decode that string.
//
// See: http://stackoverflow.com/questions/9419658/normalising-possibly-encoded-uri-strings-in-java.
String encodedUriText =
getProtocol() + ":" +
archiveUri.toString() + "!/" +
ParserUtils.encode(r_entryPath);
try {
return new URI(encodedUriText);
} catch ( URISyntaxException e ) {
// FFDC
return null;
}
}
|
java
|
@Trivial
private static URI getURI(final File file) {
return AccessController.doPrivileged( new PrivilegedAction<URI>() {
@Override
public URI run() {
return file.toURI();
}
} );
}
|
java
|
private ExtractionGuard placeExtractionGuard(String path) {
boolean isPrimary;
CountDownLatch completionLatch;
synchronized( extractionsLock ) {
completionLatch = extractionLocks.get(path);
if ( completionLatch != null ) {
isPrimary = false;
} else {
isPrimary = true;
completionLatch = new CountDownLatch(1);
extractionLocks.put(path, completionLatch);
}
}
return new ExtractionGuard(path, isPrimary, completionLatch);
}
|
java
|
private void releaseExtractionGuard(ExtractionGuard extractionLatch) {
synchronized( extractionsLock ) {
extractionLocks.remove( extractionLatch.path );
}
extractionLatch.completionLatch.countDown();
}
|
java
|
private boolean isModified(ArtifactEntry entry, File file) {
long fileLastModified = FileUtils.fileLastModified(file);
long entryLastModified = entry.getLastModified();
// File 100K entry 10K delta 90k true (entry is much older than the file)
// File 10k entry 100k delta 90k true (file is much older than the entry)
// File 10k entry 9k delta 1k false (entry is slightly older than the file)
// File 9k entry 10k delta 1k false (file is slightly older than the entry)
// File 9k entry 9k delta 0k false (file and entry are exactly the same age)
return ( Math.abs(fileLastModified - entryLastModified) >= 1010L );
}
|
java
|
@Trivial
private boolean deleteAll(File rootFile) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
Tr.debug(tc, "Delete [ " + rootFile.getAbsolutePath() + " ]");
}
if ( FileUtils.fileIsFile(rootFile) ) {
boolean didDelete = FileUtils.fileDelete(rootFile);
if ( !didDelete ) {
Tr.error(tc, "Could not delete file [ " + rootFile.getAbsolutePath() + " ]");
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
Tr.debug(tc, "Deleted");
}
}
return didDelete;
} else {
boolean didDeleteAll = true;
int deleteCount = 0;
File childFiles[] = FileUtils.listFiles(rootFile);
int childCount;
if ( childFiles != null ) {
childCount = childFiles.length;
for ( File childFile : childFiles ) {
// Keep iterating even if one of the deletes fails.
// Delete as much as possible.
if ( !deleteAll(childFile) ) {
didDeleteAll = false;
} else {
deleteCount++;
}
}
} else {
childCount = 0;
deleteCount = 0;
}
if ( didDeleteAll ) {
didDeleteAll = FileUtils.fileDelete(rootFile);
}
if ( !didDeleteAll ) {
Tr.error(tc, "Could not delete directory [ " + rootFile.getAbsolutePath() + " ]");
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
Tr.debug(tc, "Deleted [ " + Integer.valueOf(deleteCount) + " ]" +
" of [ " + Integer.valueOf(childCount) + " ]");
}
return didDeleteAll;
}
}
|
java
|
public void startRecovery(RecoveryLogFactory fac) {
if (tc.isEntryEnabled())
Tr.entry(tc, "startRecovery", fac);
// This is a stand alone server. HA can never effect this server so direct local recovery now.
RecoveryDirector director = null;
try {
director = RecoveryDirectorFactory.recoveryDirector(); /* @LI1578-22A */
director.setRecoveryLogFactory(fac);
((RecoveryDirectorImpl) director).driveLocalRecovery();/* @LI1578-22C */
} catch (RecoveryFailedException exc) {
FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecLogServiceImpl.startRecovery", "421", this);
if (tc.isDebugEnabled())
Tr.debug(tc, "Local recovery failed.");
// if (tc.isEntryEnabled()) Tr.exit(tc, "start", "RuntimeError");
// throw new RuntimeError("Unable to complete local recovery processing", exc);
} catch (InternalLogException ile) {
FFDCFilter.processException(ile, "com.ibm.ws.recoverylog.spi.RecLogServiceImpl.startRecovery", "478", this);
if (tc.isDebugEnabled())
Tr.debug(tc, "Local recovery not attempted.", ile);
// if (tc.isEntryEnabled()) Tr.exit(tc, "start", "RuntimeError");
// throw new RuntimeError("Unable to complete local recovery processing", ile);
}
if (director != null && _isPeerRecoverySupported) // used to test _recoveryGroup != null
{
if (checkPeersAtStartup()) {
try {
if (director instanceof LibertyRecoveryDirectorImpl) {
((LibertyRecoveryDirectorImpl) director).drivePeerRecovery();
}
} catch (RecoveryFailedException exc) {
FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecLogServiceImpl.startRecovery", "421", this);
if (tc.isDebugEnabled())
Tr.debug(tc, "Local peer failed.");
}
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "startRecovery");
}
|
java
|
private boolean checkPeersAtStartup() {
if (tc.isEntryEnabled())
Tr.entry(tc, "checkPeersAtStartup");
boolean checkAtStartup;
try {
checkAtStartup = AccessController.doPrivileged(
new PrivilegedExceptionAction<Boolean>() {
@Override
public Boolean run() {
return Boolean.getBoolean("com.ibm.ws.recoverylog.spi.CheckPeersAtStartup");
}
});
} catch (PrivilegedActionException e) {
if (tc.isDebugEnabled())
Tr.debug(tc, "checkPeersAtStartup", e);
checkAtStartup = false;
}
if (tc.isEntryEnabled())
Tr.exit(tc, "checkPeersAtStartup", checkAtStartup);
return checkAtStartup;
}
|
java
|
public synchronized void writeHeader(long timestamp) throws IOException {
if (writer == null && headerBytes != null) {
writer = createNewWriter(manager.startNewFile(timestamp));
writer.write(headerBytes);
manager.notifyOfFileAction(LogEventListener.EVENTTYPEROLL) ;
}
}
|
java
|
public synchronized void stop() {
if (writer != null) {
try {
writer.close(headerBytes);
writer = null;
} catch (IOException ex) {
// No need to crash on this error even if the tail won't be written
// since reading logic can take care of that.
}
}
// Ensure that timer is stopped as well.
disableFileSwitch();
headerBytes = null;
// Don't stop manager here since it can be reused for a different repository writer.
//manager.stop();
}
|
java
|
public void enableFileSwitch(int switchHour) {
if(fileSwitchTimer == null){
fileSwitchTimer = AccessHelper.createTimer();
}
//set calendar instance to the specified configuration hour for cutting
//default to midnight when the passed in value is invalid, or midnight is specified (to avoid negative value when 1 is subtracted
if(switchHour < MIN_SWITCH_HOUR || switchHour > MAX_SWITCH_HOUR ){
// It's OK to use logger here since adding logging record will not result in changing
// file switching configuration.
logger.logp(Level.WARNING, className, "enableFileSwitch", "HPEL_IncorrectSwitchHour", new Object[]{switchHour,MIN_SWITCH_HOUR, MAX_SWITCH_HOUR,MIN_SWITCH_HOUR});
switchHour = MIN_SWITCH_HOUR;
}
//Note: We will set the file cutting time to match the exact hour that was specified, but it's possible for the timestamp attribute of the file
//to go beyond the switchTime, as the final writes to close the file will alter the timestamp attribute.
//For example, if a fileSwitch was set to midnight, log records that are written after midnight will go to a new file, but it's possible for the
//previous file being closed to have a midnight timestamp attribute.
Calendar currentTime = Calendar.getInstance();
Calendar switchTime = currentTime;
switchTime.set(Calendar.HOUR_OF_DAY, switchHour);
switchTime.set(Calendar.MINUTE, 00);
switchTime.set(Calendar.SECOND, 00);
//if the time has already passed, then set to the next day. Otherwise
//the timer will catch up on the missed tasks that would've been executed.
//For example: If the switchTime was set to 11 (for 11AM), and the server gets started after 11AM, we do not want the file switch
//to occur until 11AM of the following day.
if(currentTime.after(switchTime)){
switchTime.add(Calendar.DATE, 1);
}
fileSwitchTime.setTime(switchTime.getTimeInMillis());
fileSwitchTimer.scheduleAtFixedRate(fileSwitchTask, fileSwitchTime, SWITCH_PERIOD);
}
|
java
|
private X509TrustManager createPromptingTrustManager() {
TrustManager[] trustManagers = null;
try {
String defaultAlg = TrustManagerFactory.getDefaultAlgorithm();
TrustManagerFactory tmf = TrustManagerFactory.getInstance(defaultAlg);
tmf.init((KeyStore) null);
trustManagers = tmf.getTrustManagers();
} catch (KeyStoreException e) {
// Unable to initialize the default trust managers.
// This is not a problem as PromptX509rustManager can handle null.
} catch (NoSuchAlgorithmException e) {
// Unable to get default trust managers.
// This is not a problem as PromptX509rustManager can handle null.
}
boolean autoAccept = Boolean.valueOf(System.getProperty(SYS_PROP_AUTO_ACCEPT, "false"));
return new PromptX509TrustManager(stdin, stdout, trustManagers, autoAccept);
}
|
java
|
private SSLSocketFactory setUpSSLContext() throws NoSuchAlgorithmException, KeyManagementException {
SSLContext ctx = SSLContext.getInstance("SSL");
ctx.init(null, new TrustManager[] { createPromptingTrustManager() }, null);
return ctx.getSocketFactory();
}
|
java
|
private HashMap<String, Object> createJMXEnvironment(final String user, final String password, final SSLSocketFactory sslSF) {
HashMap<String, Object> environment = new HashMap<String, Object>();
environment.put("jmx.remote.protocol.provider.pkgs", "com.ibm.ws.jmx.connector.client");
environment.put(JMXConnector.CREDENTIALS, new String[] { user, password });
environment.put(ClientProvider.READ_TIMEOUT, 2 * 60 * 1000);
environment.put(ConnectorSettings.DISABLE_HOSTNAME_VERIFICATION, Boolean.TRUE);
environment.put(ConnectorSettings.CUSTOM_SSLSOCKETFACTORY, sslSF);
environment.put("isCollectiveUtil", Boolean.TRUE);
return environment;
}
|
java
|
private JMXConnector getMBeanServerConnection(String controllerHost, int controllerPort, HashMap<String, Object> environment) throws MalformedURLException, IOException {
JMXServiceURL serviceURL = new JMXServiceURL("REST", controllerHost, controllerPort, "/IBMJMXConnectorREST");
return new ClientProvider().newJMXConnector(serviceURL, environment);
}
|
java
|
public JMXConnector getJMXConnector(String controllerHost, int controllerPort, String user, String password) throws NoSuchAlgorithmException, KeyManagementException, MalformedURLException, IOException {
HashMap<String, Object> environment = createJMXEnvironment(user, password, setUpSSLContext());
JMXConnector connector = getMBeanServerConnection(controllerHost, controllerPort, environment);
connector.connect();
return connector;
}
|
java
|
public synchronized void commit()
throws SIIncorrectCallException,
SIRollbackException,
SIResourceException,
SIConnectionLostException,
SIErrorException
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "commit");
if (!valid)
{
throw new SIIncorrectCallException(
nls.getFormattedMessage("TRANSACTION_COMPLETE_SICO1022", null, null)
);
}
// Mark this as invalid
valid = false;
CommsByteBuffer request = getCommsByteBuffer();
request.putShort(getConnectionObjectID());
request.putInt(getTransactionId());
CommsByteBuffer reply = null;
try
{
// Pass on call to server
reply = jfapExchange(request,
JFapChannelConstants.SEG_COMMIT_TRANSACTION,
lowestPriority,
true);
short err = reply.getCommandCompletionCode(JFapChannelConstants.SEG_COMMIT_TRANSACTION_R);
if (err != CommsConstants.SI_NO_EXCEPTION)
{
checkFor_SIIncorrectCallException(reply, err);
checkFor_SIRollbackException(reply, err);
checkFor_SIResourceException(reply, err);
checkFor_SIConnectionLostException(reply, err);
checkFor_SIErrorException(reply, err);
defaultChecker(reply, err);
}
}
catch (SIConnectionDroppedException e)
{
// No FFDC Code needed
// In this case we translate this to an SIConnectionLostException - as transactions aren't
// tided to a particular connection
throw new SIConnectionLostException(e.getMessage(), e);
}
finally
{
if (reply != null) reply.release();
}
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "commit");
}
|
java
|
public synchronized void rollback()
throws SIIncorrectCallException,
SIResourceException,
SIConnectionLostException,
SIErrorException
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "rollback");
if (!valid)
{
throw new SIIncorrectCallException(
nls.getFormattedMessage("TRANSACTION_COMPLETE_SICO1022", null, null)
);
}
// Mark this as invalid
valid = false;
CommsByteBuffer request = getCommsByteBuffer();
request.putShort(getConnectionObjectID());
request.putInt(getTransactionId());
CommsByteBuffer reply = null;
try
{
// Pass on call to server
reply = jfapExchange(request,
JFapChannelConstants.SEG_ROLLBACK_TRANSACTION,
lowestPriority,
true);
// Inform any associated consumers of the rollback, in case there are
// redelivery ordering considerations. We do this regardless of the
// success of the rollback, but need to do it after the rollback has
// been sent to the ME.
informConsumersOfRollback();
short err = reply.getCommandCompletionCode(JFapChannelConstants.SEG_ROLLBACK_TRANSACTION_R);
if (err != CommsConstants.SI_NO_EXCEPTION)
{
checkFor_SIIncorrectCallException(reply, err);
checkFor_SIResourceException(reply, err);
checkFor_SIConnectionLostException(reply, err);
checkFor_SIErrorException(reply, err);
defaultChecker(reply, err);
}
}
catch (SIConnectionDroppedException e)
{
// No FFDC Code needed
// PK60857: The connection broke on us, but the ME side will eventually timeout
// and assume rollback. So we can safely consume this exception. We previously
// threw an exception here but that leaked a connection from the pool because
// the tx never completed.
if (tc.isDebugEnabled()) SibTr.debug(this, tc, "Connection failure during rollback.");
}
finally
{
if (reply != null) reply.release();
}
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
}
|
java
|
public synchronized boolean isValid()
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "isValid");
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "isValid", ""+valid);
return valid;
}
|
java
|
public short getLowestMessagePriority()
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "getLowestMessagePriority");
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "getLowestMessagePriority", ""+lowestPriority);
return lowestPriority;
}
|
java
|
public void updateLowestMessagePriority(short messagePriority)
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "updateLowestMessagePriority",
new Object[] {""+messagePriority});
// Only update if the message priority is lower than another message
if (messagePriority < this.lowestPriority)
{
if (tc.isDebugEnabled()) SibTr.debug(this, tc, "Updating lowest priority");
this.lowestPriority = messagePriority;
}
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "updateLowestMessagePriority");
}
|
java
|
public void associateConsumer(ConsumerSessionProxy consumer) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "associateConsumer", new Object[]{consumer, Boolean.valueOf(strictRedeliveryOrdering)});
// This is a no-op if strict redelivery ordering is disabled
if (strictRedeliveryOrdering && consumer != null) {
synchronized (associatedConsumersLock) {
associatedConsumers.add(consumer);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "associateConsumer");
}
|
java
|
public void informConsumersOfRollback() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "informConsumersOfRollback", new Object[]{Boolean.valueOf(strictRedeliveryOrdering)});
if (strictRedeliveryOrdering) {
// Take a copy of the set of consumers, to avoid additional locking
// when we call into the consumers to inform them of a rollback.
ConsumerSessionProxy[] consumersToNotify;
synchronized(associatedConsumersLock) {
consumersToNotify =
new ConsumerSessionProxy[associatedConsumers.size()];
consumersToNotify = (ConsumerSessionProxy[])
associatedConsumers.toArray(consumersToNotify);
}
// Callback each consumer to inform them of the rollback
for (int i = 0; i < consumersToNotify.length; i++) {
try {
consumersToNotify[i].rollbackOccurred();
}
catch (SIException e) {
// FFDC for the error, but do not re-throw.
// Most likely the connection to the ME is unavailable, or the
// consumer has been closed and cleaned up.
// In these cases the consumer will not be able to consume any
// more messages - so redelivery ordering is not an issue.
FFDCFilter.processException(e, CLASS_NAME + ".informConsumersOfRollback",
CommsConstants.TRANSACTION_INFORMCONSUMERSOFROLLBACK_01, this);
if (tc.isDebugEnabled()) SibTr.debug(tc, "Encountered error informing consumer of rollback: " + consumersToNotify[i]);
if (tc.isEventEnabled()) SibTr.exception(tc, e);
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "informConsumersOfRollback");
}
|
java
|
static void unboundSfsbFromExtendedPC(JPAExPcBindingContext bindingContext)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "unboundSfsbFromExtendedPC : " + bindingContext);
JPAPuId puIds[] = bindingContext.getExPcPuIds();
long bindId = bindingContext.getBindId();
// New this binding key only once and update the puid in the loop
ExPcBindingKey bindingKey = new ExPcBindingKey(bindId, null);
for (JPAPuId puId : puIds)
{
bindingKey.puId = puId;
ExPcBindingInfo exPcBindingInfo = svExPcBindingMap.remove(bindingKey);
if (exPcBindingInfo != null)
{
// JPA 5.9.1 Container Responsibilities
//
// The container closes the entity manager by calling EntityManager.close after the
// stateful session bean and all other stateful session beans that have inherited
// the same persistence context as the EntityManager have been removed.
if (exPcBindingInfo.removeRemovedOrDiscardedSfsb(bindingKey) == 0)
{
EntityManager em = exPcBindingInfo.getEntityManager();
if (em != null)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "All SFSBs using the same extend-scoped persistence "
+ "context have been removed, closing EntityManager " + em);
if (em.isOpen()) // d442445
em.close();
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.exit(tc, "unboundSfsbFromExtendedPC : exPcBindMap size=" + svExPcBindingMap.size());
}
|
java
|
private static final boolean parentHasSameExPc(JPAPuId parentPuIds[], JPAPuId puId)
{
for (JPAPuId parentPuId : parentPuIds)
{
if (parentPuId.equals(puId))
{
return true;
}
}
return false;
}
|
java
|
public void queue(JFapByteBuffer bufferData,
int segmentType,
int requestNumber,
int priority,
SendListener sendListener,
Conversation conversation,
Connection connection,
int conversationId,
boolean pooledBuffers,
boolean partOfExchange,
long size,
boolean terminal,
ThrottlingPolicy throttlingPolicy)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "queue");
TransmissionDataIterator iterator =
TransmissionDataIterator.allocateFromPool(connection,
bufferData,
priority,
pooledBuffers,
partOfExchange,
segmentType,
conversationId,
requestNumber,
conversation,
sendListener,
terminal,
(int)size);
// begin F193735.3
if (type == Conversation.ME) meQueuedBytes += size;
else if (type == Conversation.CLIENT) clientQueuedBytes += size;
// end F193735.3
queueInternal(iterator, throttlingPolicy, terminal);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "queue");
}
|
java
|
public TransmissionData dequeue()
throws SIConnectionDroppedException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dequeue");
TransmissionData retValue = null;
Queue queue = null;
synchronized(queueMonitor)
{
if (state == CLOSED)
{
throw new SIConnectionDroppedException(TraceNLS.getFormattedMessage(JFapChannelConstants.MSG_BUNDLE, "PRIORITY_QUEUE_PURGED_SICJ0077", null, "PRIORITY_QUEUE_PURGED_SICJ0077"));
}
else
{
// Find the highest non-empty priority
int priority = JFapChannelConstants.MAX_PRIORITY_LEVELS-1;
while((priority >= 0) && (queueArray[priority].depth == 0)) --priority;
if (priority >= 0)
{
queue = queueArray[priority];
// Dequeue the data and update the queue appropriately.
TransmissionDataIterator iterator = queue.head(); // D217401
retValue = iterator.next();
queue.bytes -= retValue.getSize();
// If there is no more data left to iterate over then remove the
// transmission data from the queue and update the depth counters.
if (!iterator.hasNext())
{
queue.dequeue(); // D217401
--queue.depth;
--totalQueueDepth;
}
// If the priority queue is in closing state and we have just emptied
// the queue, mark the queue as closed and unblock anyone waiting for the
// queue to close.
if ((totalQueueDepth == 0) && (state == CLOSING))
{
state = CLOSED; // Transition to the close state
closeWaitersMonitor.setActive(false); // Unblock anyone waiting for the close
// Un-block any queue monitors, in case other threads are blocked waiting
// to try and queue data.
for (int i=0; i < JFapChannelConstants.MAX_PRIORITY_LEVELS; ++i)
queueArray[i].monitor.setActive(false);
}
// If dequeueing the data caused a change in capacity then
// take the appropriate actions
if (!queue.hasCapacity &&
(queue.bytes < maxQueueBytes) &&
queue.depth < maxQueueDepth)
{
// Mark the queue as having capacity
queue.hasCapacity = true;
// If the change in capacity results in more priority levels having capacity then...
if (priority < lowestPriorityWithCapacity)
{
// Unblock any threads waiting on the lower capacity levels
int newLowestPriorityWithCapacity = priority;
while((newLowestPriorityWithCapacity > 0) &&
queueArray[newLowestPriorityWithCapacity-1].hasCapacity)
{
queueArray[newLowestPriorityWithCapacity].monitor.setActive(false);
--newLowestPriorityWithCapacity;
}
lowestPriorityWithCapacity = newLowestPriorityWithCapacity;
queueArray[lowestPriorityWithCapacity].monitor.setActive(false);
}
}
}
}
}
if (retValue != null)
{
if (type == Conversation.CLIENT)
clientQueuedBytes -= retValue.getSize();
else
meQueuedBytes -= retValue.getSize();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dequeue", retValue);
return retValue;
}
|
java
|
public boolean hasCapacity(int priority)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "hasCapacity", ""+priority);
boolean result;
synchronized(queueMonitor)
{
result = priority >= lowestPriorityWithCapacity;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "hasCapacity", ""+result);
return result;
}
|
java
|
public void close(boolean immediate)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "close", ""+immediate);
synchronized(queueMonitor)
{
if (immediate || (totalQueueDepth == 0))
{
state = CLOSED;
closeWaitersMonitor.setActive(false);
}
else
state = CLOSING;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "close");
}
|
java
|
public void purge()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "purge");
synchronized(queueMonitor)
{
state = CLOSED;
for (int i=0; i < JFapChannelConstants.MAX_PRIORITY_LEVELS-1; ++i)
{
queueArray[i].monitor.setActive(false);
}
closeWaitersMonitor.setActive(false);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "purge");
}
|
java
|
public void waitForCloseToComplete()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "waitForCloseToComplete");
closeWaitersMonitor.waitOn();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "waitForCloseToComplete");
}
|
java
|
public boolean isEmpty() throws SIConnectionDroppedException
{
synchronized(queueMonitor)
{
if (state == CLOSED) throw new SIConnectionDroppedException(TraceNLS.getFormattedMessage(JFapChannelConstants.MSG_BUNDLE, "PRIORITY_QUEUE_PURGED_SICJ0077", null, "PRIORITY_QUEUE_PURGED_SICJ0077"));
return totalQueueDepth == 0;
}
}
|
java
|
private static boolean isGABuild() {
boolean result = true;
final Properties props = new Properties();
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
try {
final File version = new File(getInstallDir(), "lib/versions/WebSphereApplicationServer.properties");
Reader r = new InputStreamReader(new FileInputStream(version), "UTF-8");
props.load(r);
r.close();
} catch (IOException e) {
// ignore because we fail safe. Returning true will result in a GA suitable schema
}
return null;
}
});
String v = props.getProperty("com.ibm.websphere.productVersion");
if (v != null) {
int index = v.indexOf('.');
if (index != -1) {
try {
int major = Integer.parseInt(v.substring(0, index));
if (major > 2012) {
result = false;
}
} catch (NumberFormatException nfe) {
// ignore because we fail safe. True for this hides stuff
}
}
}
return result;
}
|
java
|
public void setFfdcAlready(boolean ffdcAlready) {
this.ffdcAlready = ffdcAlready;
if (tc.isDebugEnabled()) {
Tr.debug(tc, "ffdc already handled? " + ffdcAlready);
}
}
|
java
|
private static String getResource(Bundle myBundle, String resourcePath) {
if (myBundle == null)
return null;
String bundleShortDescription = getBundleDescription(myBundle);
StringBuilder responseString = new StringBuilder();
URL bundleResource = myBundle.getResource(resourcePath);
if (bundleResource != null) {
BufferedReader br = null;
try { // read the requested resource from the bundle
br = new BufferedReader(new InputStreamReader(bundleResource.openConnection().getInputStream(), "UTF-8"));
while (br.ready()) {
responseString.append(br.readLine());
}
br.close();
} catch (Exception e) { // shouldn't happen
if (OpenAPIUtils.isEventEnabled(tc)) {
Tr.event(tc, "Exception trying to read resource at " + resourcePath + " from bundle " + bundleShortDescription);
}
}
} else {
if (OpenAPIUtils.isEventEnabled(tc)) {
Tr.event(tc, "Unexpected error getting resource from WAB bundle.");
}
}
return responseString.toString();
}
|
java
|
private static void harvestPackageList(BundlePackages packages, Bundle bundle) {
// Double check that the bundle is (still) installed:
if (bundle.getLocation() != null && bundle.getState() != Bundle.UNINSTALLED) {
BundleManifest manifest = new BundleManifest(bundle);
/*
* Only bundles with a bundle vendor of IBM should count as internal.
* We definitely don't want to be filtering out user bundles in the shared bundle space.
* This filter might catch stack products, which is probably a good thing
* if it happens.
* We also want to count the system bundle as internal. Some of
* the bundles with higher IDs aren't ours, but since we rebuild them
* with bnd, they get an IBM vendor header.
*/
if (bundle.getBundleId() == 0 || IBM.equals(manifest.getBundleVendor()) || IBM.equals(manifest.getBundleDistributor())) {
packages.addPackages(manifest);
}
}
}
|
java
|
public static String extractPackageFromStackTraceElement(StackTraceElement element) {
String className = element.getClassName();
int lastDotIndex = className.lastIndexOf(".");
String packageName;
if (lastDotIndex > 0) {
packageName = className.substring(0, lastDotIndex);
} else {
packageName = className;
}
return packageName;
}
|
java
|
public boolean isSpecOrThirdPartyOrBootDelegationPackage(String packageName) {
SharedPackageInspector inspector = st.getService();
if (inspector != null) {
PackageType type = inspector.getExportedPackageType(packageName);
if (type != null && type.isSpecApi()) {
return true;
}
}
boolean isBundlePackage = false;
// Check the boot delegation packages second, since they're patterns, and slower
for (Pattern pattern : bootDelegationPackages) {
isBundlePackage = pattern.matcher(packageName).matches();
if (isBundlePackage) {
return isBundlePackage;
}
}
// If we can't work it out, assume things aren't spec packages
return false;
}
|
java
|
public static Properties jslPropertiesToJavaProperties(
final JSLProperties xmlProperties) {
final Properties props = new Properties();
for (final Property prop : xmlProperties.getPropertyList()) {
props.setProperty(prop.getName(), prop.getValue());
}
return props;
}
|
java
|
public static JSLProperties javaPropsTojslProperties(final Properties javaProps) {
JSLProperties newJSLProps = jslFactory.createJSLProperties();
Enumeration<?> keySet = javaProps.propertyNames();
while (keySet.hasMoreElements()) {
String key = (String)keySet.nextElement();
String value = javaProps.getProperty(key);
Property newProperty = jslFactory.createProperty();
newProperty.setName(key);
newProperty.setValue(value);
newJSLProps.getPropertyList().add(newProperty);
}
return newJSLProps;
}
|
java
|
@Override
public Logger getLogger(String name) {
// get the logger from the super impl
Logger logger = super.getLogger(name);
// At this point we don't know which concrete class to use until the
// ras/logging provider is initialized enough to provide a
// wsLogger class
if (wsLogger == null) {
return logger;
}
// The Java Logging (JSR47) spec requires that the method,
// LogManager.getLogManager().getLogger(...) returns null if the logger
// with the passed in name does not exist. However, the method
// Logger.getLogger(...)
// calls this method in order to create a new Logger object. In WAS, we
// always want the call to Logger.getLogger(...) to return an instance
// of WsLogger. If this method returns null to it (as the spec requires),
// then Logger.getLogger() would return an instance of java.util.logging.Logger
// rather than our WsLogger.
// To account for this "issue", we need to return null when a customer
// calls this method and passes in a non-existent logger name, but must
// create a new WsLogger when Logger.getLogger() calls this method. As
// such, the following code will get the current thread's stack trace
// and look for a pattern like:
// ...
// at com.ibm.ws.bootstrap.WsLogManager.getLogger ...
// at java.util.logging.Logger.getLogger ...
// ...
// If it identifies this pattern in the stacktrace, this method will
// create a new logger. If not, it will return null.
if (logger == null) {
boolean createNewLogger = false;
boolean foundCaller = false;
Exception ex = new Exception();
StackTraceElement[] ste = ex.getStackTrace();
Class<?> caller = null;
int i = 0;
while (!foundCaller && i < ste.length) {
StackTraceElement s = ste[i++];
// A) look for com.ibm.ws.bootstrap.WsLogManager.getLogger
if (s.getClassName().equals(CLASS_NAME) && s.getMethodName().equals("getLogger")) {
// B) java.util.logging.Logger.getLogger
while (!foundCaller && i < ste.length) {
s = ste[i++];
if (s.getClassName().equals("java.util.logging.Logger") && s.getMethodName().equals("getLogger")) {
createNewLogger = true;
} else if (createNewLogger) {
caller = StackFinderSingleton.instance.getCaller(i, s.getClassName());
foundCaller = caller != null;
}
}
}
}
if (createNewLogger) {
try {
logger = (Logger) wsLogger.newInstance(name, caller, null);
// constructing the new logger will add the logger to the log manager
// See the constructor com.ibm.ws.logging.internal.WsLogger.WsLogger(String, Class<?>, String)
// This is pretty unfortunate escaping of 'this' out of the constructor, but may be risky to try and fix that.
// Instead add a hack here to double check that another thread did not win in creating and adding the WsLogger instance
Logger checkLogger = super.getLogger(name);
if (checkLogger != null) {
// Simply reassign because checkLogger is for sure the one that got added.
// Not really sure what it would mean if null was returned from super.getLogger, but do nothing in that case
logger = checkLogger;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
return logger;
}
|
java
|
public ServiceRegistration<KeyringMonitor> monitorKeyRings(String ID, String trigger, String keyStoreLocation) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "monitorKeyRing registration for", ID);
}
BundleContext bundleContext = actionable.getBundleContext();
final Hashtable<String, Object> keyRingMonitorProps = new Hashtable<String, Object>();
keyRingMonitorProps.put(KeyringMonitor.MONITOR_KEYSTORE_CONFIG_ID, ID);
keyRingMonitorProps.put(KeyringMonitor.KEYSTORE_LOCATION, keyStoreLocation);
if (!(trigger.equalsIgnoreCase("disabled")) && trigger.equals("polled")) {
Tr.warning(tc, "Cannot have polled trigger for keyRing ID: ", ID);
}
return bundleContext.registerService(KeyringMonitor.class, this, keyRingMonitorProps);
}
|
java
|
public void start() throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "start");
synchronized (this)
{
active = true;
// start the liveness timer for sending ControlRequestHighestGeneratedTick, if needed
if (!completedTicksInitialized)
{
if (initRequestId == -1)
initRequestId = parent.generateUniqueValue();
requestHighestGeneratedTickTimer = new RequestHighestGeneratedTick();
//we call the alarm directly
requestHighestGeneratedTickTimer.alarm(null);
}
if (parent.getCardinalityOne() && !isFlushed)
{
inactivityTimer =
am.create(
mp.getCustomProperties().get_remote_consumer_cardinality_inactivity_interval(),
inactivityHandler);
}
if (resetRequestAckSender != null)
{
boolean done = resetRequestAckSender.start();
if (done)
resetRequestAckSender = null;
}
// start all the liveness timers for value ticks
dem.startTimer();
if (imeRestorationHandler!=null)
imeRestorationHandler.startTimer();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "start");
}
|
java
|
public void stop()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "stop");
synchronized (this)
{
active = false;
// stop the liveness timer for sending ControlRequestHighestGeneratedTick, if needed
//NOTE: the requestHighestGeneratedTickTimer will stop of its own accord once the
//stream is noticed to be
if (initRepeatHandler != null)
{
initRepeatHandler.cancel();
}
if (inactivityTimer != null)
{
inactivityTimer.cancel();
inactivityTimer = null;
}
if (resetRequestAckSender != null)
{
resetRequestAckSender.stop();
}
// stop all the liveness timers for value ticks
dem.stopTimer();
if (imeRestorationHandler!=null)
imeRestorationHandler.stopTimer();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "stop");
}
|
java
|
public void processTimedoutEntries(List timedout)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "processTimedoutEntries", new Object[] {this,timedout});
boolean sendMsg = false;
synchronized (this)
{
if (active && completedTicksInitialized && !timedout.isEmpty())
{
sendMsg = true;
}
}
if (sendMsg)
parent.sendDecisionExpected(remoteMEUuid, gatheringTargetDestUuid, streamId, timedout);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "processTimedoutEntries");
}
|
java
|
public final void expiredRequest(long tick)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "expiredRequest", Long.valueOf(tick));
expiredRequest(tick, false);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "expiredRequest");
}
|
java
|
public final void removeConsumerKey(String selector, JSRemoteConsumerPoint aock)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeConsumerKey", new Object[] { selector, aock });
synchronized (this)
{
JSRemoteConsumerPoint aock2 = (JSRemoteConsumerPoint) consumerKeyTable.get(selector);
if (aock2 == aock)
{ // the object is still in the table
consumerKeyTable.remove(selector);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeConsumerKey");
}
|
java
|
public synchronized long getNumberOfRequestsInState(int requiredState)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getNumberOfRequestsInState", Integer.valueOf(requiredState));
//Count the number of tick range objects that are in the
//specified state
long requestCount=0;
// Initial range in stream is always completed Range
stream.setCursor(0);
// skip this and move to next range
stream.getNext();
// Get the first TickRange after completed range and move cursor to the next one
TickRange tr = stream.getNext();
// Iterate until we reach final Unknown range
while (tr.endstamp < RangeList.INFINITY)
{
if((tr.type == requiredState) )
{
requestCount++;
}
tr = stream.getNext();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getNumberOfRequestsInState", Long.valueOf(requestCount));
return requestCount;
}
|
java
|
public final void unlockRejectedTick(TransactionCommon t, AOValue storedTick) throws MessageStoreException, SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "unlockRejectedTick");
try {
SIMPMessage msg =
consumerDispatcher.getMessageByValue(storedTick);
Transaction msTran = mp.resolveAndEnlistMsgStoreTransaction(t);
if(msg != null)
{
// Set the rme unlock count into the Messageitem so it can be taken into
// account on further rollback threshold checks. (Note we take one off
// because the following operation will perform an unlock itself)
// 488794.
boolean incrementCount = false;
// TODO: THIS DOESN'T WORK - MsgStore does not support the use of 'don't increment count'
// when unlocking a persistently locked message (i.e. one of these). So the count will
// get incremented anyway. So if the message has been rejected because it was never consumed
// (and therefore, shouldn't have the count incremented) the unlock count WILL be incremented
// which could cause us to exception it.
// TODO: However, this is still an improvement on the pre-V7 logic and not a regression
// so we'll leave it as is unless someone complains.
// TODO: I also doubt all this logic as the rmeUnlockCount is only transient, if MsgStore
// chooses to un-cache this message we'll lose the extra count info. Although I guess it does
// solve the case when the RME has rolled it back enough to reach the max failure limit, so I
// guess we leave it as is.
if(storedTick.rmeUnlockCount > 0)
{
incrementCount = true;
msg.setRMEUnlockCount(storedTick.rmeUnlockCount - 1);
}
if (msg.getLockID()==storedTick.getPLockId())
msg.unlockMsg(storedTick.getPLockId(), msTran, incrementCount);
}
storedTick.lockItemIfAvailable(controlItemLockID); // should always be successful
storedTick.remove(msTran, controlItemLockID);
}
catch (MessageStoreException e)
{
// No FFDC code needed
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "unlockRejectedTick", e);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "unlockRejectedTick");
}
|
java
|
public final void consumeAcceptedTick(TransactionCommon t, AOValue storedTick) throws Exception
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "consumeAcceptedTick", storedTick);
try {
SIMPMessage msg =
consumerDispatcher.getMessageByValue(storedTick);
Transaction msTran = mp.resolveAndEnlistMsgStoreTransaction(t);
// PK67067 We may not find a message in the store for this tick, because
// it may have been removed using the SIBQueuePoint MBean
if (msg != null) {
msg.remove(msTran, storedTick.getPLockId());
}
storedTick.lockItemIfAvailable(controlItemLockID); // should always be successful
storedTick.remove(msTran, controlItemLockID);
}
catch (Exception e)
{
// No FFDC code needed
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "consumeAcceptedTick", e);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "consumeAcceptedTick");
}
|
java
|
public FileChannel getFileChannel() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "getFileChannel(): " + fc);
}
return this.fc;
}
|
java
|
private void convertBufferIfNeeded() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "convertBufferIfNeeded status: " + status);
}
if (isFCEnabled()) {
// TRANSFER_TO status is currently on, so turn if OFF
status = status & (~WsByteBuffer.STATUS_TRANSFER_TO);
// and turn on BUFFER status
status = status | WsByteBuffer.STATUS_BUFFER;
try {
// save so we can restore the current position
int bufPosition = (int) fc.position();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "creating a MappedByteBuffer from the FileChannel. position: " + 0 + " size: " + fc.size());
}
// map entire FileChannel buffer to ByteBuffer
try {
oByteBuffer = fc.map(MapMode.PRIVATE, 0, fc.size());
} catch (NonWritableChannelException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "FileChannel is readonly");
}
oByteBuffer = fc.map(MapMode.READ_ONLY, 0, fc.size());
setReadOnly(true);
}
// The mapped byte buffer returned by this method will have a
// position of zero and a limit and capacity of size;
// its mark will be undefined.
// The buffer and the mapping that it represents will
// remain valid until the buffer itself is garbage-collected.
// restore the position and limit
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "set MappedByteBuffer position to: " + bufPosition + " limit to: " + fcLimit);
}
position(bufPosition);
limit(fcLimit);
} catch (IOException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "got IOException: " + e);
}
FFDCFilter.processException(e, CLASS_NAME + ".convertBufferIfNeeded", "112", this);
throw new RuntimeException(e);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "convertBufferIfNeeded status: " + status);
}
}
|
java
|
public void checkType(JSField elem, int indir) throws JMFSchemaViolationException {
if (!equivFields(element, elem) || indir != indirect)
throw new JMFSchemaViolationException("Incorrect list element types");
}
|
java
|
private boolean equivFields(JSField one, JSField two) {
if (one instanceof JSDynamic) {
return two instanceof JSDynamic;
}
else if (one instanceof JSEnum) {
return two instanceof JSEnum;
}
else if (one instanceof JSPrimitive) {
return (two instanceof JSPrimitive)
&& ((JSPrimitive)one).getTypeCode() == ((JSPrimitive)two).getTypeCode();
}
else if (one instanceof JSVariant) {
// we assume without checking that JSVariants in this context must be boxed
return (two instanceof JSVariant)
&& ((JSVariant)one).getBoxed().getID() == ((JSVariant)two).getBoxed().getID();
}
else
return false;
}
|
java
|
int reallocate(int fieldOffset) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.entry(this, tc, "reallocate", new Object[]{Integer.valueOf(offset)});
byte[] oldContents = contents;
int oldOffset = offset;
contents = new byte[length];
System.arraycopy(oldContents, offset, contents, 0, length);
offset = 0;
int result = fieldOffset - oldOffset;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "reallocate", Integer.valueOf(result));
return result;
}
|
java
|
void reallocated(byte[] newContents, int newOffset) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.entry(this, tc, "reallocated", new Object[]{newContents, Integer.valueOf(newOffset)});
if (contents != null) {
contents = newContents;
offset = newOffset + 8;
sharedContents = false;
// Now we must run through the cache any pass the changes down to any depenedent
// JSMessageData parts we find.
// d282049: respect implicit state invariant implied by JSMessageData#unassemble
// that an unassembled List can have no assembled contents
if (cache != null) {
for (int i = 0; i < cache.length; i++) {
try {
Object entry = cache[i];
if (entry != null && entry instanceof JSMessageData) {
((JSMessageData)entry).reallocated(newContents, getAbsoluteOffset(i));
}
} catch (JMFUninitializedAccessException e) {
// No FFDC code needed - this cannot occur as we know the JSMessageData part is present
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "reallocated");
}
|
java
|
static int getSize(Object agg) throws JMFSchemaViolationException {
if (agg == null) {
return 0;
}
else if (agg instanceof Collection) {
return ((Collection)agg).size();
}
else if (agg.getClass().isArray()) {
return Array.getLength(agg);
}
else {
throw new JMFSchemaViolationException(agg.getClass().getName());
}
}
|
java
|
static Iterator getIterator(Object agg) throws JMFSchemaViolationException {
if (agg instanceof Collection) {
return ((Collection)agg).iterator();
}
else if (agg.getClass().isArray()) {
return new LiteIterator(agg);
}
else {
throw new JMFSchemaViolationException(agg.getClass().getName());
}
}
|
java
|
public AppValidator failsWith(String expectedFailure) {
stringsToFind.add(expectedFailure);
stringsToFind.add(APP_FAIL_CODE);
server.addIgnoredErrors(Collections.singletonList(expectedFailure));
return this;
}
|
java
|
private int acquireExpedite() {
int a;
while ((a = expeditesAvailable.get()) > 0 && !expeditesAvailable.compareAndSet(a, a - 1));
return a; // returning the value rather than true/false will enable better debug
}
|
java
|
@Trivial
private void decrementWithheldConcurrency() {
int w;
while ((w = withheldConcurrency.get()) > 0 && !withheldConcurrency.compareAndSet(w, w - 1));
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "withheld concurrency " + w + " --> " + (w == 0 ? 0 : (w - 1)));
}
|
java
|
@Override
@FFDCIgnore(value = { RejectedExecutionException.class })
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, PolicyTaskCallback[] callbacks) throws InterruptedException, ExecutionException {
int taskCount = tasks.size();
// Special case to run a single task on the current thread if we can acquire a permit, if a permit is required
if (taskCount == 1) {
boolean havePermit = false;
if (maxPolicy == MaxPolicy.loose || (havePermit = maxConcurrencyConstraint.tryAcquire())) // use current thread
try {
if (state.get() != State.ACTIVE)
throw new RejectedExecutionException(Tr.formatMessage(tc, "CWWKE1202.submit.after.shutdown", identifier));
// startTimeout does not apply because the task starts immediately
PolicyTaskFutureImpl<T> taskFuture = new PolicyTaskFutureImpl<T>(this, tasks.iterator().next(), callbacks == null ? null : callbacks[0], -1);
taskFuture.accept(true);
runTask(taskFuture);
// raise InterruptedException if current thread is interrupted
taskFuture.throwIfInterrupted();
return taskFuture.get();
} finally {
if (havePermit)
transferOrReleasePermit();
}
} else if (taskCount == 0)
throw new IllegalArgumentException();
InvokeAnyLatch latch = new InvokeAnyLatch(taskCount);
ArrayList<PolicyTaskFutureImpl<T>> futures = new ArrayList<PolicyTaskFutureImpl<T>>(taskCount);
try {
// create futures in advance, which gives the callback an opportunity to reject
int t = 0;
for (Callable<T> task : tasks) {
PolicyTaskCallback callback = callbacks == null ? null : callbacks[t++];
PolicyExecutorImpl executor = callback == null ? this : (PolicyExecutorImpl) callback.getExecutor(this);
long startTimeoutNS = callback == null ? startTimeout : callback.getStartTimeout(executor.startTimeout);
futures.add(new PolicyTaskFutureImpl<T>(executor, task, callback, startTimeoutNS, latch));
}
// enqueue all tasks
for (PolicyTaskFutureImpl<T> taskFuture : futures) {
// check if done before enqueuing more tasks
if (latch.getCount() == 0)
break;
taskFuture.executor.enqueue(taskFuture, taskFuture.executor.maxWaitForEnqueueNS.get(), false); // never run on the current thread because it would prevent timeout
}
// wait for completion
return latch.await(-1, futures);
} catch (RejectedExecutionException x) {
if (x.getCause() instanceof InterruptedException) {
throw (InterruptedException) x.getCause();
} else
throw x;
} catch (TimeoutException x) {
throw new RuntimeException(x); // should be unreachable with infinite timeout
} finally {
for (Future<?> f : futures)
f.cancel(true);
}
}
|
java
|
void runTask(PolicyTaskFutureImpl<?> future) {
running.add(future); // intentionally done before checking state to avoid missing cancels on shutdownNow
int runCount = runningCount.incrementAndGet();
try {
Callback callback = cbLateStart.get();
if (callback != null) {
long delay = future.nsQueueEnd - future.nsAcceptBegin;
if (delay > callback.threshold
&& cbLateStart.compareAndSet(callback, null)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "callback: late start " + delay + "ns > " + callback.threshold + "ns", callback.runnable);
globalExecutor.submit(callback.runnable);
}
}
callback = cbConcurrency.get();
if (callback != null
&& runCount > callback.threshold
&& cbConcurrency.compareAndSet(callback, null)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "callback: concurrency > " + callback.threshold, callback.runnable);
globalExecutor.submit(callback.runnable);
}
if (state.get().canStartTask) {
future.run();
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "Cancel task due to policy executor state " + state);
future.nsRunEnd = System.nanoTime();
future.cancel(false);
if (future.callback != null)
future.callback.onEnd(future.task, future, null, true, 0, null); // aborted, queued task will never run
}
} catch (Error x) {
// auto FFDC
} catch (RuntimeException x) {
// auto FFDC
} finally {
runningCount.decrementAndGet();
running.remove(future);
}
}
|
java
|
@Trivial
private void transferOrReleasePermit() {
maxConcurrencyConstraint.release();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(this, tc, "expedites/maxConcurrency available",
expeditesAvailable, maxConcurrencyConstraint.availablePermits());
// The permit might be needed to run tasks on the global executor,
if (!queue.isEmpty() && withheldConcurrency.get() > 0 && maxConcurrencyConstraint.tryAcquire()) {
decrementWithheldConcurrency();
if (acquireExpedite() > 0)
expediteGlobal(new GlobalPoolTask());
else
enqueueGlobal(new GlobalPoolTask());
}
}
|
java
|
public void closeConnection()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "closeConnection");
try
{
if(_XAResourceFactory != null && _XARes != null)
{
((XAResourceFactory)_XAResourceFactory).destroyXAResource(_XARes);
}
}
catch(Throwable t)
{
FFDCFilter.processException(t, "com.ibm.ws.Transaction.JTA.XARminst.closeConnection", "250", this);
Tr.audit(tc, "WTRN0038_ERR_DESTROYING_XARESOURCE", t);
}
if (tc.isEntryEnabled()) Tr.exit(tc, "closeConnection");
}
|
java
|
protected VirtualConnection readInternal(long numBytes, TCPReadCompletedCallback readCallback, boolean forceQueue, int timeout) {
if (timeout == IMMED_TIMEOUT) {
immediateTimeout();
return null;
}
if (timeout == ABORT_TIMEOUT) {
abort();
immediateTimeout();
return null;
}
setIOAmount(numBytes);
setLastIOAmt(0);
setIODoneAmount(0);
setReadCompletedCallback(readCallback);
setForceQueue(forceQueue);
setTimeoutTime(timeout);
// IMPROVEMENT: buffers should be preprocessed before calling read,
// postprocessed after
return processAsyncReadRequest();
}
|
java
|
public boolean isFileServingEnabled() {
// PK54499 START
disallowAllFileServingProp = WCCustomProperties.DISALLOW_ALL_FILE_SERVING;
if (disallowAllFileServingProp != null && !this.getApplicationName().equalsIgnoreCase("isclite")) {
try
{
if (Boolean.valueOf(disallowAllFileServingProp).booleanValue())
{
this.fileServingEnabled = Boolean.FALSE;
}
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
{
logger.logp(Level.FINE, CLASS_NAME, "isFileServing", "PK54499: disallowAllFileServingProp set to " + disallowAllFileServingProp + " for application: "
+ this.getApplicationName());
}
}
catch (Exception x)
{
logger.logp(Level.SEVERE, CLASS_NAME, "isFileServing", "Illegal value set for property com.ibm.ws.webcontainer.disallowallfileserving");
}
}
// PK54499 END
if (this.fileServingEnabled != null)
return this.fileServingEnabled.booleanValue();
return WCCustomProperties.FILE_SERVING_ENABLED;
}
|
java
|
public Map<String, String> getJspAttributes() {
if (null == this.jspAttributes) {
this.jspAttributes = new HashMap<String, String>();
}
return this.jspAttributes;
}
|
java
|
public IServletConfig getServletInfo(String string) {
if (string == null || string.isEmpty()){
Tr.debug(tc, "getServletInfo", "servlet name is null/empty. Use internal servlet name " + NULLSERVLETNAME);
string = NULLSERVLETNAME;
}
return (IServletConfig) this.servletInfo.get(string);
}
|
java
|
public boolean isServeServletsByClassnameEnabled() {
// PK52059 START
disallowServeServletsByClassnameProp = WCCustomProperties.DISALLOW_SERVE_SERVLETS_BY_CLASSNAME_PROP;
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
logger.logp(Level.FINE, CLASS_NAME, "isServeServletsByClassnameEnabled", "disallowServeServletsByClassnameProp = " + disallowServeServletsByClassnameProp);
}
if (disallowServeServletsByClassnameProp != null) {
try {
if (Boolean.valueOf(disallowServeServletsByClassnameProp).booleanValue()) {
this.serveServletsByClassnameEnabled = Boolean.FALSE;
}
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
logger.logp(Level.FINE, CLASS_NAME, "isServeServletsByClassnameEnabled", "PK52059: disallowServeServletsByClassnameProp set to "
+ disallowServeServletsByClassnameProp
+ " for application: " + this.getApplicationName());
}
} catch (Exception x) {
logger.logp(Level.SEVERE, CLASS_NAME, "isServeServletsByClassnameEnabled",
"Illegal value set for property com.ibm.ws.webcontainer.disallowserveservletsbyclassname");
}
} // PK52059 END
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
logger.logp(Level.FINE, CLASS_NAME, "isServeServletsByClassnameEnabled", "value = " + (this.serveServletsByClassnameEnabled != null ? this.serveServletsByClassnameEnabled.booleanValue() : WCCustomProperties.SERVE_SERVLETS_BY_CLASSNAME_ENABLED));
}
if (this.serveServletsByClassnameEnabled != null)
return this.serveServletsByClassnameEnabled.booleanValue();
return WCCustomProperties.SERVE_SERVLETS_BY_CLASSNAME_ENABLED;
}
|
java
|
public void setMimeFilters(HashMap mimeFilters) {
if (mimeFilters != null && mimeFilters.size() > 0) {
this.isMimeFilteringEnabled = true;
}
this.mimeFilters = mimeFilters;
}
|
java
|
public String getApplicationName() {
if (this.applicationName != null)
return this.applicationName;
else if (webApp != null)
return this.webApp.getApplicationName();
else
return null;
}
|
java
|
public void setDisableStaticMappingCache(){
if (this.contextParams != null){
String value = (String) this.contextParams.get("com.ibm.ws.webcontainer.DISABLE_STATIC_MAPPING_CACHE");
if (value != null ){
if (value.equalsIgnoreCase("true")){
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"setDisableStaticMappingCache", "cxtParam disable static mapping cache for application -> "+ applicationName);
this.setDisableStaticMappingCache(true);
}
return;
}
}
if (WCCustomProperties.DISABLE_STATIC_MAPPING_CACHE != null){
String disableStaticMappingCacheApp = WCCustomProperties.DISABLE_STATIC_MAPPING_CACHE;
if (disableStaticMappingCacheApp.equals("*")){
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"setDisableStaticMappingCache", "disable static mapping cache for all apps.");
this.setDisableStaticMappingCache(true);
return;
}
else{
String [] parsedStr = disableStaticMappingCacheApp.split(",");
for (String toCheckStr:parsedStr){
toCheckStr = toCheckStr.trim();
if (applicationName != null && applicationName.equalsIgnoreCase(toCheckStr)){
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"setDisableStaticMappingCache", "disable static mapping cache for application -> "+ applicationName);
this.setDisableStaticMappingCache(true);
return;
}
}
}
}
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.