code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
private void parseAccessLog(Map<String, Object> config) {
String filename = (String) config.get("access.filePath");
if (null == filename || 0 == filename.trim().length()) {
return;
}
try {
this.ncsaLog = new AccessLogger(filename.trim());
} catch (Throwable t) {
FFDCFilter.processException(t, getClass().getName() + ".parseAccessLog", "1", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Logging service was unable to open a file: " + filename + "; " + t);
}
return;
}
// save the NCSA format value
String format = (String) config.get("access.logFormat");
this.ncsaLog.setFormat(LogUtils.convertNCSAFormat(format));
// now check for the maximum file size
String size = (String) config.get("access.maximumSize");
if (null != size) {
// convert from MB to bytes
if (!this.ncsaLog.setMaximumSize(convertInt(size, 0) * 1048576L)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Logging service has invalid access log size: " + size);
}
}
}
// check for the max backup files
String backups = (String) config.get("access.maximumBackupFiles");
if (null != backups) {
this.ncsaLog.setMaximumBackupFiles(convertInt(backups, 1));
}
}
|
java
|
private void parseErrorLog(Map<String, Object> config) {
String filename = (String) config.get("error.filePath");
if (null == filename || 0 == filename.trim().length()) {
return;
}
try {
this.debugLog = new DebugLogger(filename);
} catch (Throwable t) {
FFDCFilter.processException(t, getClass().getName() + ".parseErrorLog", "1", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Logging service was unable to open debug file: " + filename + "; " + t);
}
return;
}
// check the debug log level setting
String levelName = (String) config.get("error.logLevel");
this.debugLog.setCurrentLevel(LogUtils.convertDebugLevel(levelName));
String size = (String) config.get("error.maximumSize");
if (null != size) {
// convert from MB to bytes
if (!this.debugLog.setMaximumSize(convertInt(size, 0) * 1048576L)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Logging service has invalid error log size: " + size);
}
}
}
// check for the max backup files
String backups = (String) config.get("error.maximumBackupFiles");
if (null != backups) {
this.debugLog.setMaximumBackupFiles(convertInt(backups, 1));
}
}
|
java
|
public void stop() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "stop");
}
if (this.bRunning) {
this.bRunning = false;
this.ncsaLog.stop();
this.frcaLog.stop();
this.debugLog.stop();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "stop");
}
}
|
java
|
public void destroy() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "destroy");
}
this.bRunning = false;
this.ncsaLog.disable();
this.frcaLog.disable();
this.debugLog.disable();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "destroy");
}
}
|
java
|
private int convertInt(String input, int defaultValue) {
try {
return Integer.parseInt(input.trim());
} catch (NumberFormatException nfe) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Malformed input: " + input);
}
return defaultValue;
}
}
|
java
|
public void findClients(@Observes @WithAnnotations({RegisterRestClient.class}) ProcessAnnotatedType<?> pat) {
Class<?> restClient = pat.getAnnotatedType().getJavaClass();
if (restClient.isInterface()) {
restClientClasses.add(restClient);
pat.veto();
} else {
errors.add(new IllegalArgumentException("The class " + restClient
+ " is not an interface"));
}
}
|
java
|
protected void setOpen () {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setOpen");
closed = false;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setOpen");
}
|
java
|
public boolean isClosed()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isClosed");
boolean retValue = false;
if (connectionProxy == null)
{
retValue = closed;
}
else
{
retValue = closed || connectionProxy.isClosed();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isClosed", ""+retValue);
return retValue;
}
|
java
|
protected void setClosed()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setClosed");
closed = true;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setClosed");
}
|
java
|
public short getProxyID()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getProxyID");
if (!proxyIDSet)
{
// Someone is trying to use the ID of this proxy object but it has not been set yet. This
// is an error as the ID will be invalid anyway.
SIErrorException e = new SIErrorException(
nls.getFormattedMessage("PROXY_ID_NOT_SET_SICO1052", null, null)
);
FFDCFilter.processException(e, CLASS_NAME + ".getProxyID",
CommsConstants.PROXY_GETPROXYID_01, this);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getProxyID", ""+proxyID);
return proxyID;
}
|
java
|
protected ConnectionProxy getConnectionProxy()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getConnectionProxy");
if (connectionProxy == null)
{
// Someone is trying to use the connection proxy associated with this proxy object but it
// has not been set or has been nulled out.
SIErrorException e = new SIErrorException(
nls.getFormattedMessage("CONNECTION_PROXY_NOT_SET_SICO1053", null, null)
);
FFDCFilter.processException(e, CLASS_NAME + ".getConnectionProxy",
CommsConstants.PROXY_GETCONNECTIONPROXY_01, this);
throw e;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getConnectionProxy", connectionProxy);
return connectionProxy;
}
|
java
|
protected void setProxyID(short s)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setProxyID", ""+s);
proxyID = s;
proxyIDSet = true;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setProxyID");
}
|
java
|
@Override
public InputStream getAttachment(final Asset asset, final Attachment attachment) throws IOException, BadVersionException, RequestFailureException {
final ZipFile repoZip = createZipFile();
if (null == repoZip) {
return null;
}
InputStream retInputStream = null;
String attachmentId = attachment.get_id();
try {
if (attachmentId.contains("#")) {
String assetId = asset.get_id();
// new funky code to get an input stream to the license *inside* the main attachment. The start of
// the assetId will point to the main attachment file.
ZipEntry entry = createFromRelative(assetId);
// If the entry wasn't found return null
if (null == entry) {
return null;
}
// Get zip input stream to the asset inside the zip
ZipInputStream zis = new ZipInputStream(repoZip.getInputStream(entry));
// Get the input stream to the attachment inside the zip
retInputStream = getInputStreamToLicenseInsideZip(zis, assetId, attachmentId);
} else {
// Get input stream to the attachment
ZipEntry entry = createFromRelative(attachmentId);
retInputStream = repoZip.getInputStream(entry);
}
} finally {
// If we are throwing an exception the InputStream is never created so the logic below
// to close the ZipFile when the InputStream is closed will never be called. So lets close
// the ZipFile now as there is no InputStream to read from.
if (retInputStream == null) {
repoZip.close();
}
}
// When the input stream gets closed we also need to close the ZipFile, however
// the caller only has the input stream. So lets wrap the input stream and close
// both the inputStream and the ZipFile when the caller calls close on the wrapped
// input stream
final InputStream is = retInputStream;
InputStream wrappedIs = new InputStream() {
/** {@inheritDoc} */
@Override
public int read(byte[] b) throws IOException {
return is.read(b);
}
/** {@inheritDoc} */
@Override
public int read(byte[] b, int off, int len) throws IOException {
return is.read(b, off, len);
}
/** {@inheritDoc} */
@Override
public long skip(long n) throws IOException {
return is.skip(n);
}
/** {@inheritDoc} */
@Override
public int available() throws IOException {
return is.available();
}
/** {@inheritDoc} */
@Override
public synchronized void mark(int readlimit) {
is.mark(readlimit);
}
/** {@inheritDoc} */
@Override
public synchronized void reset() throws IOException {
is.reset();
}
/** {@inheritDoc} */
@Override
public boolean markSupported() {
return is.markSupported();
}
/** {@inheritDoc} */
@Override
public int read() throws IOException {
return is.read();
}
/** {@inheritDoc} */
@Override
public void close() throws IOException {
// When the input stream is closed, also close the zip file
is.close();
repoZip.close();
}
};
return wrappedIs;
}
|
java
|
@Override
protected boolean hasChildren(final String relative) throws IOException {
ZipFile zip = createZipFile();
if (null == zip) {
return false;
}
Enumeration<? extends ZipEntry> entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if ((relative.equals("")) || entry.getName().startsWith(relative + File.separator)) {
return true;
}
}
zip.close();
return false;
}
|
java
|
@Override
protected Collection<String> getChildren(final String relative) throws IOException {
ZipFile zip = createZipFile();
if (null == zip) {
return Collections.emptyList();
}
Collection<String> children = new ArrayList<String>();
Enumeration<? extends ZipEntry> entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (entry.isDirectory()) {
continue;
}
if ((relative.equals("")) || entry.getName().startsWith(relative + File.separator)) {
children.add(entry.getName());
}
}
zip.close();
return children;
}
|
java
|
@Override
protected long getSize(final String relative) {
ZipEntry entry = createFromRelative(relative);
return (entry == null ? 0 : entry.getSize());
}
|
java
|
final JMFNativePart getEncodingMessage() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.entry(this, tc, "getEncodingMessage");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "getEncodingMessage", encoding);
return encoding;
}
|
java
|
public static String getRuntimeProperty(String property, String defaultValue)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "getRuntimeProperty", new Object[] {property, defaultValue});
String runtimeProp = RuntimeInfo.getPropertyWithMsg(property, defaultValue);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getRuntimeProperty", runtimeProp);
return runtimeProp;
}
|
java
|
public static boolean getRuntimeBooleanProperty(String property, String defaultValue)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "getRuntimeBooleanProperty", new Object[] {property, defaultValue});
boolean runtimeProp = Boolean.valueOf(RuntimeInfo.getPropertyWithMsg(property, defaultValue)).booleanValue();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getRuntimeBooleanProperty", ""+runtimeProp);
return runtimeProp;
}
|
java
|
public static void checkFapLevel(HandshakeProperties handShakeProps, short fapLevel)
throws SIIncorrectCallException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "checkFapLevel", ""+fapLevel);
short actualFapVersion = handShakeProps.getFapLevel();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Actual FAP Level: ", ""+actualFapVersion);
if (fapLevel > actualFapVersion)
{
throw new SIIncorrectCallException(
nls.getFormattedMessage("CALL_NOT_SUPPORTED_AT_FAP_LEVEL_SICO0101",
new Object[] {"" + actualFapVersion},
"CALL_NOT_SUPPORTED_AT_FAP_LEVEL_SICO0101")
);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "checkFapLevel");
}
|
java
|
public static boolean isRecoverable(final SIBusMessage mess, final Reliability maxUnrecoverableReliability)
{
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "isRecoverable", new Object[] {mess, maxUnrecoverableReliability});
final Reliability messageReliability = mess.getReliability();
if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Message Reliability: ", messageReliability);
final boolean recoverable = messageReliability.compareTo(maxUnrecoverableReliability) > 0;
if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "isRecoverable", recoverable);
return recoverable;
}
|
java
|
protected ThirdPartyAlpnNegotiator tryToRegisterAlpnNegotiator(SSLEngine engine, SSLConnectionLink link, boolean useAlpn) {
if (isNativeAlpnActive()) {
if (useAlpn) {
registerNativeAlpn(engine);
}
} else if (isIbmAlpnActive()) {
registerIbmAlpn(engine, useAlpn);
} else if (this.isJettyAlpnActive() && useAlpn) {
return registerJettyAlpn(engine, link);
} else if (this.isGrizzlyAlpnActive() && useAlpn) {
return registerGrizzlyAlpn(engine, link);
}
return null;
}
|
java
|
protected void tryToRemoveAlpnNegotiator(ThirdPartyAlpnNegotiator negotiator, SSLEngine engine, SSLConnectionLink link) {
// the Java 9 and IBM JSSE ALPN implementations don't use a negotiator object
if (negotiator == null && isNativeAlpnActive()) {
getNativeAlpnChoice(engine, link);
} else if (negotiator == null && isIbmAlpnActive()) {
getAndRemoveIbmAlpnChoice(engine, link);
} else if (negotiator != null && isJettyAlpnActive() && negotiator instanceof JettyServerNegotiator) {
((JettyServerNegotiator) negotiator).removeEngine();
} else if (negotiator != null && isGrizzlyAlpnActive() && negotiator instanceof GrizzlyAlpnNegotiator) {
((GrizzlyAlpnNegotiator) negotiator).removeServerNegotiatorEngine();
}
}
|
java
|
protected void getAndRemoveIbmAlpnChoice(SSLEngine engine, SSLConnectionLink link) {
if (this.isIbmAlpnActive()) {
try {
// invoke ALPNJSSEExt.get(engine)
String[] alpnResult = (String[]) ibmAlpnGet.invoke(null, engine);
// invoke ALPNJSSEExt.delete(engine)
ibmAlpnDelete.invoke(null, engine);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
StringBuilder sb = new StringBuilder();
sb.append("getAndRemoveIbmAlpnChoice");
if (alpnResult != null && alpnResult.length > 0) {
sb.append(" results:");
for (String s : alpnResult) {
sb.append(" " + s);
}
sb.append(" " + engine);
} else {
sb.append(": ALPN not used for " + engine);
}
Tr.debug(tc, sb.toString());
}
if (alpnResult != null && alpnResult.length == 1 && h2.equals(alpnResult[0])) {
if (link.getAlpnProtocol() == null) {
link.setAlpnProtocol(h2);
}
}
} catch (InvocationTargetException ie) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "getAndRemoveIbmAlpnChoice exception: " + ie.getTargetException());
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "getAndRemoveIbmAlpnChoice exception: " + e);
}
}
}
}
|
java
|
protected GrizzlyAlpnNegotiator registerGrizzlyAlpn(SSLEngine engine, SSLConnectionLink link) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "registerGrizzlyAlpn entry " + engine);
}
if (grizzlyNegotiationSupport != null && grizzlyAlpnClientNegotiator != null && grizzlyAlpnServerNegotiator != null && grizzlyNegotiationSupportObject != null) {
try {
GrizzlyAlpnNegotiator negotiator = new GrizzlyAlpnNegotiator(engine, link);
if (!engine.getUseClientMode()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "initializeAlpn invoke AlpnServerNegotiator " + engine);
}
// client mode is disabled; call NegotiationSuppoer.addNegotiator(SSLEngine, (AlpnServerNegotiator) this)
Method m = grizzlyNegotiationSupport.getMethod("addNegotiator", SSLEngine.class, grizzlyAlpnServerNegotiator);
m.invoke(grizzlyNegotiationSupportObject, new Object[] { engine, java.lang.reflect.Proxy.newProxyInstance(
grizzlyAlpnServerNegotiator.getClassLoader(),
new java.lang.Class[] { grizzlyAlpnServerNegotiator },
negotiator) });
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "initializeAlpn invoke AlpnClientNegotiator " + engine);
}
// client mode is enabled; call NegotiationSuppoer.addNegotiator(SSLEngine, (AlpnClientNegotiator) this)
Method m = grizzlyNegotiationSupport.getMethod("addNegotiator", SSLEngine.class, grizzlyAlpnClientNegotiator);
m.invoke(grizzlyNegotiationSupportObject, new Object[] { engine, java.lang.reflect.Proxy.newProxyInstance(
grizzlyAlpnClientNegotiator.getClassLoader(),
new java.lang.Class[] { grizzlyAlpnClientNegotiator },
negotiator) });
}
return negotiator;
} catch (InvocationTargetException ie) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "registerGrizzlyAlpn exception: " + ie.getTargetException());
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "registerGrizzlyAlpn grizzly-npn exception: " + e);
}
}
}
return null;
}
|
java
|
protected JettyServerNegotiator registerJettyAlpn(final SSLEngine engine, SSLConnectionLink link) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "registerJettyAlpn entry " + engine);
}
try {
JettyServerNegotiator negotiator = new JettyServerNegotiator(engine, link);
// invoke ALPN.put(engine, provider(this))
Method m = jettyAlpn.getMethod("put", SSLEngine.class, jettyProviderInterface);
m.invoke(null, new Object[] { engine, java.lang.reflect.Proxy.newProxyInstance(
jettyServerProviderInterface.getClassLoader(),
new java.lang.Class[] { jettyServerProviderInterface },
negotiator) });
return negotiator;
} catch (InvocationTargetException ie) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "registerJettyAlpn exception: " + ie.getTargetException());
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "registerJettyAlpn jetty-alpn exception: " + e);
}
}
return null;
}
|
java
|
public void addCase(JMFType theCase) {
if (theCase == null)
throw new NullPointerException("Variant case cannot be null");
JSType newCase = (JSType)theCase;
if (cases == null)
cases = new JSType[1];
else {
JSType[] oldCases = cases;
cases = new JSType[oldCases.length + 1];
System.arraycopy(oldCases, 0, cases, 0, oldCases.length);
}
newCase.parent = this;
newCase.siblingPosition = cases.length - 1;
cases[newCase.siblingPosition] = newCase;
}
|
java
|
BigInteger setMultiChoiceCount() {
if (boxed == null) {
multiChoiceCount = BigInteger.ZERO;
for (int i = 0; i < cases.length; i++)
multiChoiceCount = multiChoiceCount.add(cases[i].setMultiChoiceCount());
}
return multiChoiceCount;
}
|
java
|
public JSVariant[] getDominatedVariants(int i) {
if (dominated == null)
dominated = new JSVariant[cases.length][];
if (dominated[i] == null) {
JSType acase = cases[i];
if (acase instanceof JSVariant)
dominated[i] = new JSVariant[] {(JSVariant)acase };
else if (acase instanceof JSTuple)
dominated[i] = ((JSTuple)acase).getDominatedVariants();
else
// Other cases don't dominate any unboxed variants (JSRepeated always boxes any
// variants under it)
dominated[i] = new JSVariant[0];
}
return dominated[i];
}
|
java
|
JSchema box(Map context) {
if (boxed != null)
return boxed; // only do it once
JSVariant subTop = new JSVariant();
subTop.cases = cases;
subTop.boxedBy = this;
boxed = (JSchema)context.get(subTop);
if (boxed == null) {
boxed = new JSchema(subTop, context);
for (int i = 0; i < cases.length; i++)
cases[i].parent = subTop;
context.put(subTop, boxed);
}
return boxed;
}
|
java
|
public int getBoxAccessor(JMFSchema schema) {
for (Accessor acc = boxAccessor; acc != null; acc = acc.next)
if (schema == acc.schema)
return acc.accessor;
return -1;
}
|
java
|
public void setPrimaryRolePlayer(com.ibm.wsspi.security.wim.model.RolePlayer value) {
this.primaryRolePlayer = value;
}
|
java
|
public List<com.ibm.wsspi.security.wim.model.RolePlayer> getRelatedRolePlayer() {
if (relatedRolePlayer == null) {
relatedRolePlayer = new ArrayList<com.ibm.wsspi.security.wim.model.RolePlayer>();
}
return this.relatedRolePlayer;
}
|
java
|
void stop() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Stopping the HPEL managed service");
}
// disconnect from the config admin
this.configRef.unregister();
}
|
java
|
private static void reconcile(JSType top, List defs, Map refs) {
List unres = (List) refs.get(top.getFeatureName());
if (unres != null)
for (Iterator iter = unres.iterator(); iter.hasNext(); )
((JSDynamic) iter.next()).setExpectedType(top);
for (Iterator iter = defs.iterator(); iter.hasNext(); ) {
JSType one = (JSType) iter.next();
List ur = (List) refs.get(one.getFeatureName());
if (ur != null)
for (Iterator jter = ur.iterator(); jter.hasNext(); )
((JSDynamic) jter.next()).setExpectedType(one);
}
}
|
java
|
private static void addRef(Map refs, String key, JSDynamic unres) {
List thisKey = (List) refs.get(key);
if (thisKey == null) {
thisKey = new ArrayList();
refs.put(key, thisKey);
}
thisKey.add(unres);
}
|
java
|
private RepositoryResource getNewerResource(RepositoryResource res1, RepositoryResource res2) throws RepositoryResourceValidationException {
// if one of the resources is beta and the other not, return the non-beta one
RepositoryResource singleNonBetaResource = returnNonBetaResourceOrNull(res1, res2);
if (singleNonBetaResource != null) {
return singleNonBetaResource;
}
if (res1.getType() == ResourceType.INSTALL) {
// have two String versions .. convert them into Version objects,checking that they are valid versions in the process
Version4Digit res1Version = null;
Version4Digit res2Version = null;
try {
res1Version = new Version4Digit(((ProductResourceWritable) res1).getProductVersion());
} catch (IllegalArgumentException iae) {
// the version was not a proper osgi version
throw new RepositoryResourceValidationException("The product version was invalid: " + res1Version, res1.getId(), iae);
}
try {
res2Version = new Version4Digit(((ProductResourceWritable) res2).getProductVersion());
} catch (IllegalArgumentException iae) {
// the version was not a proper osgi version
throw new RepositoryResourceValidationException("The product version was invalid: " + res2Version, res2.getId(), iae);
}
if (res1Version.compareTo(res2Version) > 0) {
return res1;
} else {
return res2;
}
} else if (res1.getType() == ResourceType.TOOL) {
// tools don't have product versions or applies to so just return res1
return res1;
} else {
return compareNonProductResourceAppliesTo(res1, res2);
}
}
|
java
|
private RepositoryResource compareNonProductResourceAppliesTo(RepositoryResource res1, RepositoryResource res2) {
// all types other than INSTALLS or TOOLS use appliesTo to determine which is the higher level
String res1AppliesTo = ((ApplicableToProduct) res1).getAppliesTo();
String res2AppliesTo = ((ApplicableToProduct) res2).getAppliesTo();
// on the basis that we will work with the appliesTo of a resource, if we find one that has an applies to
// and one that doesn't we will the one WITH the applies to is assumed to be newer (if both null we look
// at the version field)
if (res1AppliesTo == null && res2AppliesTo == null) {
// if both appliesTo are null look at the versions
return getNonProductResourceWithHigherVersion(res1, res2);
} else if (res1AppliesTo == null || res2AppliesTo == null) {
// if one of them is null we can't compare them so return res1
return res1;
}
MinAndMaxVersion res1MinMax = getMinAndMaxAppliesToVersionFromAppliesTo(res1AppliesTo);
MinAndMaxVersion res2MinMax = getMinAndMaxAppliesToVersionFromAppliesTo(res2AppliesTo);
// compare the versions and return the resource that applies to the higher minimum version
if (res1MinMax.min.compareTo(res2MinMax.min) > 0) {
return res1;
} else if (res1MinMax.min.compareTo(res2MinMax.min) == 0) {
// if they apply to the same minimum version then select the one with the highest max versions
if (res1MinMax.max.compareTo(res2MinMax.max) > 0) {
return res1;
} else if (res1MinMax.max.compareTo(res2MinMax.max) < 0) {
return res2;
} else {
// if they are still the same decide on the version
return getNonProductResourceWithHigherVersion(res1, res2);
}
} else {
return res2;
}
}
|
java
|
private RepositoryResource getNonProductResourceWithHigherVersion(RepositoryResource res1, RepositoryResource res2) {
if (res1.getVersion() == null || res2.getVersion() == null) {
return res1; // don't have two versions so can't compare
}
// have two String versions .. convert them into Version objects,checking that they are valid versions in the process
Version4Digit res1Version = null;
Version4Digit res2Version = null;
try {
res1Version = new Version4Digit(res1.getVersion());
res2Version = new Version4Digit(res2.getVersion());
} catch (IllegalArgumentException iae) {
// at least one of the one or more of Versions is not a proper osgi
// version so we cannot compare the version fields. Just return res1.
return res1;
}
if (res1Version.compareTo(res2Version) > 0) {
return res1;
} else {
return res2;
}
}
|
java
|
private MinAndMaxVersion getMinAndMaxAppliesToVersionFromAppliesTo(String appliesTo) {
List<AppliesToFilterInfo> res1Filters = AppliesToProcessor.parseAppliesToHeader(appliesTo);
Version4Digit highestVersion = null;
Version4Digit lowestVersion = null;
for (AppliesToFilterInfo f : res1Filters) {
Version4Digit vHigh = (f.getMaxVersion() == null) ? MAX_VERSION : new Version4Digit(f.getMaxVersion().getValue());
Version4Digit vLow = (f.getMinVersion() == null) ? MIN_VERSION : new Version4Digit(f.getMinVersion().getValue());
if (highestVersion == null || vHigh.compareTo(highestVersion) > 0) {
highestVersion = vHigh;
lowestVersion = vLow;
} else if (vHigh.compareTo(highestVersion) == 0) {
if (lowestVersion == null || vLow.compareTo(lowestVersion) > 0) {
highestVersion = vHigh;
lowestVersion = vLow;
}
}
}
return new MinAndMaxVersion(lowestVersion, highestVersion);
}
|
java
|
public boolean rarFileExists() {
final File zipFile = new File(rarFilePath);
return AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return zipFile.exists();
}
});
}
|
java
|
public ClassLoader getClassLoader() throws UnableToAdaptException, MalformedURLException {
lock.readLock().lock();
try {
if (classloader != null)
return classloader;
} finally {
lock.readLock().unlock();
}
if (!rarFileExists())
return null;
lock.writeLock().lock();
try {
if (classloader == null) {
classloader = createRarClassLoader();
}
return classloader;
} finally {
lock.writeLock().unlock();
}
}
|
java
|
private ProtectionDomain getProtectionDomain(Container rarContainer) throws UnableToAdaptException, MalformedURLException {
PermissionCollection perms = new Permissions();
CodeSource codeSource;
try {
// codesource must start file:///
// assume loc starts with 0 or 1 /
String loc = rarFilePath;
codeSource = new CodeSource(new URL("file://" + (loc.startsWith("/") ? "" : "/") + loc), (java.security.cert.Certificate[]) null);
} catch (MalformedURLException e) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "CodeSource could not be created for RA file path of: rarFilePath", e);
}
throw e;
}
if (!java2SecurityEnabled()) {
perms.add(new AllPermission());
} else {
PermissionsConfig permissionsConfig = null;
try {
permissionsConfig = rarContainer.adapt(PermissionsConfig.class);
} catch (UnableToAdaptException ex) {
//J2CA8817E: Resource adapter {0} encountered a parse error when processing deployment descriptor {1}: {2}
Tr.error(tc, "J2CA8817.parse.deployment.descriptor.failed", rarContainer.getName(), "META-INF/permissions.xml", ex);
throw ex;
}
if (permissionsConfig != null) {
List<com.ibm.ws.javaee.dd.permissions.Permission> configuredPermissions = permissionsConfig.getPermissions();
addPermissions(codeSource, configuredPermissions);
}
ArrayList<Permission> mergedPermissions = permissionManager.getEffectivePermissions(rarFilePath);
int count = mergedPermissions.size();
for (int i = 0; i < count; i++)
perms.add(mergedPermissions.get(i));
}
return new ProtectionDomain(codeSource, perms);
}
|
java
|
private boolean deleteBundleCacheDir(File path) {
final boolean trace = TraceComponent.isAnyTracingEnabled();
if (FileUtils.fileExists(path)) {
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Path specified exists: " + path.getPath());
}
} else {
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Path specified does not exist: " + path.getPath());
}
return true;
}
boolean deleteWorked = true;
for (File file : FileUtils.listFiles(path)) {
if (FileUtils.fileIsDirectory(file)) {
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Delete directory contents: " + file.toString());
}
deleteWorked &= deleteBundleCacheDir(file);
} else {
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Delete file: " + file.toString());
}
if (!FileUtils.fileDelete(file)) {
deleteWorked = false;
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Directory or file not deleted");
}
}
}
}
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Delete path: " + path);
}
if (!FileUtils.fileDelete(path)) {
deleteWorked = false;
if (trace && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Path not deleted");
}
}
return deleteWorked;
}
|
java
|
@Override
public boolean addTransformer(final ClassFileTransformer cft) {
boolean added = false;
for (ClassLoader loader : followOnClassLoaders) {
if (loader instanceof SpringLoader) {
added |= ((SpringLoader) loader).addTransformer(cft);
}
}
return added;
}
|
java
|
@Override
public ClassLoader getThrowawayClassLoader() {
ClassLoader newParent = getThrowawayVersion(getParent());
ClassLoader[] newFollowOns = new ClassLoader[followOnClassLoaders.size()];
for (int i = 0; i < newFollowOns.length; i++) {
newFollowOns[i] = getThrowawayVersion(followOnClassLoaders.get(i));
}
return new UnifiedClassLoader(newParent, newFollowOns);
}
|
java
|
public void throwing(
Level level,
String sourceClass,
String sourceMethod,
Throwable thrown
)
{
logp(level, sourceClass, sourceMethod, null, thrown);
}
|
java
|
public Dispatchable addDispatchableForLocalTransaction(int clientTransactionId) {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "addDispatchableForLocalTransaction", "" + clientTransactionId);
if (idToFirstLevelEntryMap.containsKey(clientTransactionId)) {
final SIErrorException exception = new SIErrorException(CommsConstants.TRANTODISPATCHMAP_ADDDISPATCHLOCALTX_01);
FFDCFilter.processException(exception, CLASS_NAME + ".addDispatchableForLocalTransaction",
CommsConstants.TRANTODISPATCHMAP_ADDDISPATCHLOCALTX_01,
new Object[] { "" + clientTransactionId, idToFirstLevelEntryMap, this });
if (tc.isEventEnabled())
SibTr.exception(this, tc, exception);
throw exception;
}
LocalFirstLevelMapEntry entry = new LocalFirstLevelMapEntry();
Dispatchable result = entry.getDispatchable();
idToFirstLevelEntryMap.put(clientTransactionId, entry);
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "addDispatchableForLocalTransaction", result);
return result;
}
|
java
|
public Dispatchable addEnlistedDispatchableForGlobalTransaction(int clientXAResourceId, XidProxy xid) {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "addEnlistedDispatchableForGlobalTransaction", new Object[] { "" + clientXAResourceId });
AbstractFirstLevelMapEntry firstLevelEntry = null;
// Locate the first level map entry - if there is one.
if (idToFirstLevelEntryMap.containsKey(clientXAResourceId)) {
firstLevelEntry =
(AbstractFirstLevelMapEntry) idToFirstLevelEntryMap.get(clientXAResourceId);
}
GlobalFirstLevelMapEntry entry = null;
if (firstLevelEntry == null) {
// If there is no first level map entry for this SIXAResource - create one
entry = new GlobalFirstLevelMapEntry();
idToFirstLevelEntryMap.put(clientXAResourceId, entry);
} else {
// This SIXAResource has already particiapted in work - as there is already
// an instance - check that it isn't for a local transaction (which would
// indicate a programming error).
if (firstLevelEntry.isLocalTransaction()) {
final SIErrorException exception = new SIErrorException(CommsConstants.TRANTODISPATCHMAP_ADDENLISTEDGLOBALTX_01);
FFDCFilter.processException(exception, CLASS_NAME + ".addEnlistedDispatchableForGlobalTransaction",
CommsConstants.TRANTODISPATCHMAP_ADDENLISTEDGLOBALTX_01,
new Object[] { "" + clientXAResourceId, idToFirstLevelEntryMap, this });
if (tc.isEventEnabled())
SibTr.exception(this, tc, exception);
throw exception;
}
entry = (GlobalFirstLevelMapEntry) firstLevelEntry;
}
final Dispatchable result = entry.createNewEnlistedDispatchable(xid);
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "addEnlistedDispatchableForGlobalTransaction", result);
return result;
}
|
java
|
public Dispatchable getDispatchable(int clientId) {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "getDispatchable", "" + clientId);
AbstractFirstLevelMapEntry firstLevelEntry = null;
if (idToFirstLevelEntryMap.containsKey(clientId)) {
firstLevelEntry =
(AbstractFirstLevelMapEntry) idToFirstLevelEntryMap.get(clientId);
}
final Dispatchable result;
if (firstLevelEntry == null) {
result = null;
} else if (firstLevelEntry.isLocalTransaction()) {
result = ((LocalFirstLevelMapEntry) firstLevelEntry).getDispatchable();
} else {
result = ((GlobalFirstLevelMapEntry) firstLevelEntry).getEnlistedDispatchable();
}
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "getDispatchable", result);
return result;
}
|
java
|
public Dispatchable removeDispatchableForLocalTransaction(int clientId) {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "removeDispatchableForLocalTransaction", "" + clientId);
AbstractFirstLevelMapEntry firstLevelEntry = null;
if (idToFirstLevelEntryMap.containsKey(clientId)) {
firstLevelEntry =
(AbstractFirstLevelMapEntry) idToFirstLevelEntryMap.get(clientId);
}
final Dispatchable result;
if (firstLevelEntry == null) {
result = null;
} else {
if (firstLevelEntry.isLocalTransaction()) {
result = ((LocalFirstLevelMapEntry) firstLevelEntry).getDispatchable();
idToFirstLevelEntryMap.remove(clientId);
} else {
final SIErrorException exception = new SIErrorException(CommsConstants.TRANTODISPATCHMAP_REMOVEFORLOCALTX_01);
FFDCFilter.processException(exception, CLASS_NAME + ".removeDispatchableForLocalTransaction",
CommsConstants.TRANTODISPATCHMAP_REMOVEFORLOCALTX_01,
new Object[] { "" + clientId, firstLevelEntry, idToFirstLevelEntryMap, this });
if (tc.isEventEnabled())
SibTr.exception(this, tc, exception);
throw exception;
}
}
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "removeDispatchableForLocalTransaction", result);
return result;
}
|
java
|
public void removeAllDispatchablesForTransaction(int clientId) {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "removeAllDispatchablesForTransaction", clientId);
idToFirstLevelEntryMap.remove(clientId);
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "removeAllDispatchablesForTransaction");
}
|
java
|
public Dispatchable addDispatchableForOptimizedLocalTransaction(int transactionId) {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "addDispatchableForOptimizedLocalTransaction", "" + transactionId);
final Dispatchable result = addDispatchableForLocalTransaction(transactionId);
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "addDispatchableForOptimizedLocalTransaction", result);
return result;
}
|
java
|
public int getTotalDispatchables() {
int count = 0;
Iterator i = idToFirstLevelEntryMap.iterator();
while (i.hasNext())
++count;
return count;
}
|
java
|
@SuppressWarnings("unchecked")
protected <T extends RepositoryResourceImpl> T createNewResource() {
T result;
if (null == getType()) {
result = (T) createTestResource(getRepositoryConnection());
} else {
result = ResourceFactory.getInstance().createResource(getType(), getRepositoryConnection(), null);
}
return result;
}
|
java
|
public MatchResult matches(ProductDefinition def) {
Collection<AppliesToFilterInfo> atfiList = _asset.getWlpInformation().getAppliesToFilterInfo();
if (atfiList == null || atfiList.isEmpty()) {
return MatchResult.NOT_APPLICABLE;
}
MatchResult matchResult = MatchResult.MATCHED;
for (AppliesToFilterInfo atfi : atfiList) {
if (!!!atfi.getProductId().equals(def.getId())) {
// This one isn't applicable, maybe the next one is
matchResult = MatchResult.NOT_APPLICABLE;
continue;
} else {
if (def.getVersion() != null && !def.getVersion().isEmpty()) {
Version checkVersion = new Version(def.getVersion());
VersionRange vr = FilterVersion.getFilterRange(atfi.getMinVersion(), atfi.getMaxVersion());
if (!vr.includes(checkVersion)) {
return MatchResult.INVALID_VERSION;
}
}
if (atfi.getRawEditions() != null && !!!atfi.getRawEditions().isEmpty() && !!!atfi.getRawEditions().contains(def.getEdition())) {
return MatchResult.INVALID_EDITION;
}
if (atfi.getInstallType() != null && !!!atfi.getInstallType().equals(def.getInstallType())) {
return MatchResult.INVALID_INSTALL_TYPE;
}
// Got here so this must have been a match, only need one of the array to match, not all
return MatchResult.MATCHED;
}
}
return matchResult;
}
|
java
|
private synchronized void readAttachmentsFromAsset(Asset ass) {
Collection<Attachment> attachments = ass.getAttachments();
_attachments = new HashMap<String, AttachmentResourceImpl>();
if (attachments != null) {
for (Attachment at : attachments) {
_attachments.put(at.getName(), new AttachmentResourceImpl(at));
if (at.getType() == AttachmentType.CONTENT) {
_contentAttached = true;
}
}
}
}
|
java
|
public UpdateType updateRequired(RepositoryResourceImpl matching) {
if (null == matching) {
// No matching asset found
return UpdateType.ADD;
}
if (equivalentWithoutAttachments(matching)) {
return UpdateType.NOTHING;
} else {
// As we are doing an update set our id to be the one we found in massive
// Not needed now, we are merging both assets
_asset.set_id(matching.getId());
return UpdateType.UPDATE;
}
}
|
java
|
public RepositoryResourceMatchingData createMatchingData() {
RepositoryResourceMatchingData matchingData = new RepositoryResourceMatchingData();
matchingData.setName(getName());
matchingData.setProviderName(getProviderName());
matchingData.setType(getType());
return matchingData;
}
|
java
|
public List<RepositoryResourceImpl> findMatchingResource() throws RepositoryResourceValidationException, RepositoryBackendException, RepositoryBadDataException, RepositoryResourceNoConnectionException {
List<RepositoryResourceImpl> matchingRes;
try {
matchingRes = performMatching();
if (matchingRes != null && matchingRes.size() > 1) {
StringBuilder warningMessage = new StringBuilder("More than one match found for " + getName() + ":");
for (RepositoryResourceImpl massiveResource : matchingRes) {
warningMessage.append("\n\t" + massiveResource.getName() + " (" + massiveResource.getId() + ")");
}
logger.warning(warningMessage.toString());
}
} catch (BadVersionException bvx) {
throw new RepositoryBadDataException("BadDataException accessing asset", getId(), bvx);
} catch (RequestFailureException bfe) {
throw new RepositoryBackendRequestFailureException(bfe, getRepositoryConnection());
}
return matchingRes;
}
|
java
|
protected void copyFieldsFrom(RepositoryResourceImpl fromResource, boolean includeAttachmentInfo) {
setName(fromResource.getName()); // part of the identification so locked
setDescription(fromResource.getDescription());
setShortDescription(fromResource.getShortDescription());
setProviderName(fromResource.getProviderName()); // part of the identification so locked
setProviderUrl(fromResource.getProviderUrl());
setVersion(fromResource.getVersion());
setDownloadPolicy(fromResource.getDownloadPolicy());
setLicenseId(fromResource.getLicenseId());
setLicenseType(fromResource.getLicenseType());
setMainAttachmentSize(fromResource.getMainAttachmentSize());
setMainAttachmentSHA256(fromResource.getMainAttachmentSHA256());
setFeaturedWeight(fromResource.getFeaturedWeight());
setDisplayPolicy(fromResource.getDisplayPolicy());
setVanityURL(fromResource.getVanityURL());
setWlpInformationVersion(fromResource.getWlpInformationVersion());
setMavenCoordinates(fromResource.getMavenCoordinates());
if (includeAttachmentInfo) {
setMainAttachmentSize(fromResource.getMainAttachmentSize());
}
_asset.getWlpInformation().setAppliesToFilterInfo(fromResource.getAsset().getWlpInformation().getAppliesToFilterInfo());
}
|
java
|
public void overWriteAssetData(RepositoryResourceImpl fromResource, boolean includeAttachmentInfo) throws RepositoryResourceValidationException {
// Make sure we are dealing with the same type....this
// should never happen
if (!fromResource.getClass().getName().equals(getClass().getName())) {
throw new RepositoryResourceValidationException("Expected class of type " + getClass().getName()
+ " but was " + fromResource.getClass().getName(), this.getId());
}
// copy the stuff into target
fromResource.copyFieldsFrom(this, includeAttachmentInfo);
// Now use target
_asset = fromResource._asset;
}
|
java
|
public void moveToState(State state) throws RepositoryBackendException, RepositoryResourceException {
if (getState() == null) {
return;
}
int counter = 0;
while (getState() != state) {
counter++;
StateAction nextAction = getState().getNextAction(state);
performLifeCycle(nextAction);
if (counter >= 10) {
throw new RepositoryResourceLifecycleException("Unable to move to state " + state +
" after 10 state transistion attempts. Resource left in state " + getState(), getId(), getState(), nextAction);
}
}
}
|
java
|
public boolean equivalent(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
RepositoryResourceImpl other = (RepositoryResourceImpl) obj;
if (_asset == null) {
if (other._asset != null)
return false;
} else if (!_asset.equivalent(other._asset))
return false;
return true;
}
|
java
|
private static long getCRC(InputStream is) throws IOException {
CheckedInputStream check = new CheckedInputStream(is, new CRC32());
BufferedInputStream in = new BufferedInputStream(check);
while (in.read() != -1) {
// Read file in completely
}
long crc = check.getChecksum().getValue();
return crc;
}
|
java
|
public boolean record(String holderName, String heldName) {
return i_record(internHolder(holderName, Util_InternMap.DO_FORCE),
internHeld(heldName, Util_InternMap.DO_FORCE));
}
|
java
|
private static TraceComponent getTc() {
if (tc == null) {
tc = Tr.register(FileLogHolder.class, null, "com.ibm.ws.logging.internal.resources.LoggingMessages");
}
return tc;
}
|
java
|
private PrintStream getPrimaryStream(boolean showError) {
File primaryFile = getPrimaryFile();
setStreamFromFile(primaryFile, false, primaryFile.length(), showError);
return currentPrintStream;
}
|
java
|
@Override
public ManagedServiceFactory addingService(ServiceReference<ManagedServiceFactory> reference) {
String[] factoryPids = getServicePid(reference);
if (factoryPids == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "handleRegistration(): Invalid service.pid type: " + reference);
}
return null;
}
ManagedServiceFactory msf = context.getService(reference);
if (msf == null)
return null;
synchronized (caFactory.getConfigurationStore()) {
for (String factoryPid : factoryPids) {
add(reference, factoryPid, msf);
}
}
return msf;
}
|
java
|
@Override
public void removedService(ServiceReference<ManagedServiceFactory> reference, ManagedServiceFactory service) {
String[] factoryPids = getServicePid(reference);
if (factoryPids == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "removedService(): Invalid service.pid type: " + reference);
}
return;
}
synchronized (caFactory.getConfigurationStore()) {
for (String pid : factoryPids) {
remove(reference, pid);
}
}
context.ungetService(reference);
}
|
java
|
private Container getContainerRootParent(Container base) {
Container puBase = base.getEnclosingContainer();
while (puBase != null && !puBase.isRoot()) {
puBase = puBase.getEnclosingContainer();
}
if (puBase != null && puBase.isRoot()) {
Container parent = puBase.getEnclosingContainer();
if (parent != null) {
puBase = parent;
}
}
return puBase;
}
|
java
|
protected boolean isAutocompleteOff(FacesContext facesContext, UIComponent component)
{
if (component instanceof HtmlInputText)
{
String autocomplete = ((HtmlInputText)component).getAutocomplete();
if (autocomplete != null)
{
return autocomplete.equals(AUTOCOMPLETE_VALUE_OFF);
}
}
return false;
}
|
java
|
private MasterEntry updateLpMaps(LWMConfig lp) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, "updateLpMaps", lp);
}
SIBLocalizationPoint lpConfig = ((SIBLocalizationPoint) lp);
// Create a new LocalizationDefinition and update the lpMap with it
String lpName = lpConfig.getIdentifier();
if (lpMap.containsKey(lpName)) {
lpMap.remove(lpName);
}
LocalizationDefinition ld = ((JsAdminFactoryImpl) jsaf).createLocalizationDefinition(lpConfig);
LocalizationEntry lEntry = new LocalizationEntry(ld);
lpMap.put(lpName, lEntry);
String destName = lpName.substring(0, lpName.indexOf("@"));
MasterEntry masterEntry = masterMap.get(destName);
if (masterEntry == null) {
masterEntry = new MasterEntry();
}
masterEntry.setDestinationLocalization(ld);
masterMap.put(destName, masterEntry);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, "updateLpMaps", lpMap);
}
return masterEntry;
}
|
java
|
public boolean addLocalizationPoint(LWMConfig lp, DestinationDefinition dd) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, "addLocalizationPoint", lp);
}
boolean valid = false;
LocalizationDefinition ld = ((JsAdminFactoryImpl) jsaf).createLocalizationDefinition(lp);
if (!isInZOSServentRegion()) {
_mpAdmin = ((SIMPAdmin) _me.getMessageProcessor()).getAdministrator();
}
try {
_mpAdmin.createDestinationLocalization(dd, ld);
updatedDestDefList.add(dd);
updatedLocDefList.add(ld);
LocalizationEntry lEntry = new LocalizationEntry(ld);
lpMap.put(ld.getName(), lEntry);
MasterEntry newMasterEntry = new MasterEntry();
newMasterEntry.setDestinationLocalization(ld);
masterMap.put(dd.getName(), newMasterEntry);
valid = true;
} catch (Exception e) {
SibTr.error(tc, "LOCALIZATION_EXCEPTION_SIAS0113", e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, "addLocalizationPoint", Boolean.valueOf(valid));
}
return valid;
}
|
java
|
private boolean isNewDestination(String key) {
Object dd = null;
try {
dd = _me.getSIBDestinationByUuid(_me.getBusName(), key, false);
} catch (Exception e) {
// No FFDC code needed
}
return (dd == null);
}
|
java
|
public void alterLocalizationPoint(BaseDestination destination,LWMConfig lp) throws Exception {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, "alterLocalizationPoint", lp);
}
boolean valid = true;
DestinationDefinition dd = null;
DestinationAliasDefinition dAliasDef=null;
String key = getMasterMapKey(lp);
// Update localization point in master map entry and lpMap
MasterEntry m = updateLpMaps(lp);
if (m == null) {
String reason = CLASS_NAME + ".alterLocalizationPoint(): Entry for name " + key + " not found in cache";
SibTr.error(tc, "INTERNAL_ERROR_SIAS0003", reason);
valid = false;
} else {
try {
// We obtain the DD from the new cache in case it has changed. This is
// lieu of a possible
// design change to allow the independent signalling of a change to the
// DD.
BaseDestinationDefinition bdd = _me.getSIBDestination(_me.getBusName(), key);
if(destination.isAlias())
{
AliasDestination aliasDest=(AliasDestination)destination;
dAliasDef=modifyAliasDestDefinition(aliasDest, (DestinationAliasDefinition) bdd);
}
else
{
dd=(DestinationDefinition)modifyDestDefinition(destination,bdd);
}
} catch (Exception e) {
com.ibm.ws.ffdc.FFDCFilter.processException(e, CLASS_NAME + ".alterLocalizationPoint", "1", this);
SibTr.exception(tc, e);
String reason = m.getDestinationLocalization().getName();
valid = false;
}
}
if (valid == true && !isInZOSServentRegion() && _mpAdmin != null) {
if(destination.isAlias())
{
_mpAdmin.alterDestinationAlias(dAliasDef);
}else
{
LocalizationDefinition ld=m.getDestinationLocalization();
ld.setAlterationTime(dd.getAlterationTime());
ld.setSendAllowed(dd.isSendAllowed());
_mpAdmin.alterDestinationLocalization(dd, ld);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.debug(tc, "alterLocalizationPoint: LP altered on existing destination deferring alter until end, UUID=" + key + " Name=" + dd.getName());
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, "alterLocalizationPoint");
}
}
|
java
|
private String getMasterMapKey(LWMConfig lp) {
String key = null;
String lpIdentifier = ((SIBLocalizationPoint) lp).getIdentifier();
key = lpIdentifier.substring(0, lpIdentifier.indexOf("@"));
return key;
}
|
java
|
private void deleteDestLocalizations(JsBus bus) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, "deleteDestLocalizations", this);
}
Iterator i = alterDestinations.iterator();
while (i.hasNext()) {
String key = (String) i.next();
try {
// Get it from the old cache as it is no longer in the new cache.
DestinationDefinition dd = (DestinationDefinition) _me.getSIBDestination(bus.getName(), key);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
SibTr.debug(tc, "deleteDestLocalizations: deleting DestinationLocalization, name =" + key + " Name=");
}
if (!isInZOSServentRegion() && _mpAdmin != null) {
LocalizationEntry dldEntry = (LocalizationEntry) lpMap.get(dd.getName()+"@"+_me.getName());
LocalizationDefinition dld=(LocalizationDefinition) dldEntry.getLocalizationDefinition();
//Venu Liberty change: passing Destination UUID as String.
//Destination Definition is passed as NULL as entire destination has to be deleted
_mpAdmin.deleteDestinationLocalization(dd.getUUID().toString(), null);
}
} catch (Exception e) {
com.ibm.ws.ffdc.FFDCFilter.processException(e, CLASS_NAME + ".deleteDestLocalizations", "1", this);
SibTr.exception(tc, e);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, "deleteDestLocalizations");
}
}
|
java
|
static File getLogDirectory(Object newValue, File defaultDirectory) {
File newDirectory = defaultDirectory;
// If a value was specified, try creating a file with it
if (newValue != null && newValue instanceof String) {
newDirectory = new File((String) newValue);
}
if (newDirectory == null) {
String value = ".";
try {
value = AccessController.doPrivileged(new java.security.PrivilegedExceptionAction<String>() {
@Override
public String run() throws Exception {
return System.getProperty("user.dir");
}
});
} catch (Exception ex) {
// do nothing
}
newDirectory = new File(value);
}
return LoggingFileUtils.validateDirectory(newDirectory);
}
|
java
|
public static String getStringValue(Object newValue, String defaultValue) {
if (newValue == null)
return defaultValue;
return (String) newValue;
}
|
java
|
public static TraceFormat getFormatValue(Object newValue, TraceFormat defaultValue) {
if (newValue != null && newValue instanceof String) {
String strValue = ((String) newValue).toUpperCase();
try {
return TraceFormat.valueOf(strValue);
} catch (Exception e) {
}
}
return defaultValue;
}
|
java
|
public static String getStringFromCollection(Collection<String> values) {
StringBuilder builder = new StringBuilder();
if (values != null) {
for (String value : values) {
builder.append(value).append(',');
}
if (builder.charAt(builder.length() - 1) == ',')
builder.deleteCharAt(builder.length() - 1);
}
return builder.toString();
}
|
java
|
private Number readNumber() throws IOException {
StringBuffer sb = new StringBuffer();
int l = lineNo;
int c = colNo;
while (isDigitChar(lastChar))
{
sb.append((char)lastChar);
readChar();
}
// convert it!
String string = sb.toString();
try
{
if (-1 != string.indexOf('.'))
{
return Double.valueOf(string);
}
String sign = "";
if (string.startsWith("-"))
{
sign = "-";
string = string.substring(1);
}
if (string.toUpperCase().startsWith("0X"))
{
return Long.valueOf(sign + string.substring(2),16);
}
if (string.equals("0"))
{
return new Long(0);
}
else if (string.startsWith("0") && string.length() > 1)
{
return Long.valueOf(sign + string.substring(1),8);
}
/**
* We have to check for the exponential and treat appropriately
* Exponentials should be treated as Doubles.
*/
if (string.indexOf("e") != -1 || string.indexOf("E") != -1)
{
return Double.valueOf(sign + string);
}
else
{
return Long.valueOf(sign + string,10);
}
}
catch (NumberFormatException e)
{
IOException iox = new IOException("Invalid number literal " + onLineCol(l,c));
iox.initCause(e);
throw iox;
}
}
|
java
|
private String readIdentifier() throws IOException {
StringBuffer sb = new StringBuffer();
while ((-1 != lastChar) && Character.isLetter((char)lastChar))
{
sb.append((char)lastChar);
readChar();
}
return sb.toString();
}
|
java
|
public static AuthenticationData createAuthenticationData(String userName, UserRegistry userRegistry) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "createAuthenticationData", userName);
}
AuthenticationData authData = new WSAuthenticationData();
if (userName == null) {
userName = "";
}
String realm = getDefaultRealm(userRegistry);
authData.set(AuthenticationData.USERNAME, userName);
authData.set(AuthenticationData.REALM, realm);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "createAuthenticationData", authData);
}
return authData;
}
|
java
|
public static AuthenticationData createAuthenticationData(byte[] token) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "createAuthenticationData", token);
}
AuthenticationData authData = new WSAuthenticationData();
authData.set(AuthenticationData.TOKEN, token);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "createAuthenticationData", authData);
}
return authData;
}
|
java
|
public static AuthenticationData createAuthenticationData(String userName, String password) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "createAuthenticationData", new Object[] { userName, "Password Not Traced" });
}
AuthenticationData authData = new WSAuthenticationData();
if (userName == null)
userName = "";
if (password == null)
password = "";
authData.set(AuthenticationData.USERNAME, userName);
authData.set(AuthenticationData.PASSWORD, new ProtectedString(password.toCharArray()));
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "createAuthenticationData", authData);
}
return authData;
}
|
java
|
public static AuthenticationData createAuthenticationData(Certificate[] certs, UserRegistry userRegistry) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "createAuthenticationData", certs);
}
AuthenticationData authData = new WSAuthenticationData();
X509Certificate[] _certs;
_certs = new X509Certificate[certs.length];
for (int i = 0; i < certs.length; i++) {
if (certs[i] instanceof X509Certificate) {
_certs[i] = (X509Certificate) certs[i];
} else {
_certs = null;
break;
}
}
authData.set(AuthenticationData.CERTCHAIN, _certs);
authData.set(AuthenticationData.REALM, getDefaultRealm(userRegistry));
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "createAuthenticationData", authData);
}
return authData;
}
|
java
|
private static String getDefaultRealm(UserRegistry _userRegistry) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "getDefaultRealm");
}
String realm = DEFAULT_REALM;
if (_userRegistry != null) {
realm = _userRegistry.getRealm();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "getDefaultRealm", realm);
}
return realm;
}
|
java
|
public static String getUniqueUserName(Subject subject) throws MessagingSecurityException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "getUniqueUserName", subject);
}
if (subject == null) {
return null;
}
WSCredential cred = subjectHelper.getWSCredential(subject);
String userName = null;
if (cred != null) {
try {
userName = cred.getSecurityName();
} catch (CredentialException ce) {
throw new MessagingSecurityException(ce);
} catch (CredentialDestroyedException e) {
throw new MessagingSecurityException(e);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "getUniqueUserName", userName);
}
return userName;
}
|
java
|
public static boolean isUnauthenticated(Subject subject) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, CLASS_NAME + "isUnauthenticated", subject);
}
boolean result = subjectHelper.isUnauthenticated(subject);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.exit(tc, CLASS_NAME + "isUnauthenticated", result);
}
return result;
}
|
java
|
public E pop() throws EmptyStackException
{
E answer = peek(); // Throws EmptyStackException if there's nothing there
_elements.get().remove(_elements.get().size()-1);
return answer;
}
|
java
|
public ThreadContextDescriptor deserializeThreadContext(Map<String, String> execProps) throws IOException, ClassNotFoundException {
return threadContextBytes == null ? null : ThreadContextDeserializer.deserialize(threadContextBytes, execProps);
}
|
java
|
public static HandlerChainInfo buildHandlerChainInfoFromXML(HandlerChain hChain) {
HandlerChainInfo hcInfo = new HandlerChainInfo();
// set Service QName
if (hChain.getServiceNamePattern() != null) {
hcInfo.setServiceNamePattern(new QName(hChain.getServiceNamePattern().getNamespaceURI(),
hChain.getServiceNamePattern().getLocalPart()));
} else {
hcInfo.setServiceNamePattern(new QName("*"));
}
// set Port QName
if (hChain.getPortNamePattern() != null) {
hcInfo.setPortNamePattern(new QName(hChain.getPortNamePattern().getNamespaceURI(),
hChain.getPortNamePattern().getLocalPart()));
} else {
hcInfo.setPortNamePattern(new QName("*"));
}
// add protocol bindings
hcInfo.addProtocolBindings(hChain.getProtocolBindings());
for (com.ibm.ws.javaee.dd.common.wsclient.Handler handler : hChain.getHandlers()) {
hcInfo.addHandlerInfo(buildHandlerInfoFromXML(handler));
}
return hcInfo;
}
|
java
|
public static HandlerInfo buildHandlerInfoFromXML(com.ibm.ws.javaee.dd.common.wsclient.Handler handler) {
HandlerInfo hInfo = new HandlerInfo();
hInfo.setHandlerClass(handler.getHandlerClassName());
hInfo.setHandlerName(handler.getHandlerName());
for (ParamValue pv : handler.getInitParams()) {
hInfo.addInitParam(new ParamValueInfo(pv.getName(), pv.getValue()));
}
for (String soapRole : handler.getSoapRoles()) {
hInfo.addSoapRole(soapRole);
}
for (com.ibm.ws.javaee.dd.common.QName header : handler.getSoapHeaders()) {
hInfo.addSoapHeader(new XsdQNameInfo(new QName(header.getNamespaceURI(), header.getLocalPart()), ""));
}
return hInfo;
}
|
java
|
protected URL resolveHandlerChainFileName(String clzName, String fileName) {
URL handlerFile = null;
InputStream in = null;
String handlerChainFileName = fileName;
URL baseUrl = classLoader.getResource(getClassResourceName(clzName));
try {
//if the filename start with '/', then find and return the resource under the web application home directory directory.
if (handlerChainFileName.charAt(0) == '/') {
return classLoader.getResource(handlerChainFileName.substring(1));
}
//otherwise, create a new url instance according to the baseurl and the fileName
handlerFile = new URL(baseUrl, handlerChainFileName);
in = handlerFile.openStream();
} catch (Exception e) {
// log the error msg
} finally {
if (in != null) {
try {
in.close();
} catch (Exception e) {
}
}
}
return handlerFile;
}
|
java
|
@SuppressWarnings("rawtypes")
public static List<Handler> sortHandlers(List<Handler> handlers) {
List<LogicalHandler<?>> logicalHandlers = new ArrayList<LogicalHandler<?>>();
List<Handler<?>> protocolHandlers = new ArrayList<Handler<?>>();
for (Handler<?> handler : handlers) {
if (handler instanceof LogicalHandler) {
logicalHandlers.add((LogicalHandler<?>) handler);
} else {
protocolHandlers.add(handler);
}
}
List<Handler> sortedHandlers = new ArrayList<Handler>(logicalHandlers.size() + protocolHandlers.size());
sortedHandlers.addAll(logicalHandlers);
sortedHandlers.addAll(protocolHandlers);
return sortedHandlers;
}
|
java
|
private Dictionary<String, Object> buildServicePropsAndFilterTargets(String pid, Dictionary<String, Object> config) throws IOException, InvalidSyntaxException {
Dictionary<String, Object> result = new Hashtable<String, Object>();
// we will use this later to discover the properties configured in this classloader element in config
result.put("classloader.config.pid", pid);
// Add the application so other DS components can key from this new classloader sevice
String appFilter = "(classloader=" + pid + ")";
Configuration[] appConfigs = configAdmin.listConfigurations(appFilter);
if (appConfigs.length == 1) {
Configuration appConfig = appConfigs[0];
Dictionary<String, Object> properties = appConfig.getProperties();
String appName = (String) properties.get("name");
if (appName != null) {
result.put("application.name", appName);
}
String appConfigPid = (String) properties.get("service.pid");
try {
result.put("application.pid", appConfigPid);
} catch (NullPointerException swallowed) {
/* this will be FFDC'd */
if (tc.isDebugEnabled())
Tr.debug(tc, "service.pid is null", swallowed);
}
if (tc.isDebugEnabled())
Tr.debug(tc, "Creating ApplicationClassloadingService for application" + appName);
}
List<String> allLibraries = new ArrayList<String>();
String[] privateLibraryRefs = (String[]) config.get(LIBRARY_REF_ATT);
if (privateLibraryRefs != null) {
allLibraries.addAll(Arrays.asList(privateLibraryRefs));
}
String[] commonLibraryRefs = (String[]) config.get(COMMON_LIBRARY_REF_ATT);
if (commonLibraryRefs != null) {
allLibraries.addAll(Arrays.asList(commonLibraryRefs));
}
if (allLibraries.size() > 0) {
String filter = buildTargetString(allLibraries);
result.put("libraryStatus.target", filter);
if (tc.isDebugEnabled())
Tr.debug(tc, "This application will wait for the following libraries ", filter);
} else {
// we need to clear the blocking target and make sure we
// do get activated by setting a target we know will happen
result.put("libraryStatus.target", "(id=global)");
}
return result;
}
|
java
|
private String buildTargetString(List<String> privateLibraries) {
StringBuilder filter = new StringBuilder();
filter.append("(&");
for (String lib : privateLibraries)
filter.append(String.format("(|(%s=%s)(%s=%s))", LibraryStatusService.LIBRARY_IDS, lib, LibraryStatusService.LIBRARY_PIDS, lib));
filter.append(")");
return filter.toString();
}
@Override
public String getName() {
return "ApplicationClassloaderConfigurationHelper";
}
|
java
|
@SuppressWarnings("unchecked")
public Class<Object> matchCaller(String className) {
// Walk the stack backwards to find the calling class: don't
// want to use Class.forName, because we want the class as loaded
// by it's original classloader
Class<Object> stack[] = (Class<Object>[]) this.getClassContext();
for (Class<Object> bClass : stack) {
// See if any class in the stack contains the following string
if (bClass.getName().equals(className))
return bClass;
}
return null;
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.