code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
private Object ownership(Object val, boolean forceShared) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.entry(this, tc, "ownership", new Object[] { val, Boolean.valueOf(forceShared) });
if (val instanceof JSMessageData) {
((JSMessageData) val).setParent(compatibilityWrapperOrSelf);
if (forceShared) {
((JSMessageData) val).sharedContents = true;
}
}
else if (val instanceof JMFEncapsulation) {
((JMFEncapsulation) val).setContainingMessageData(compatibilityWrapperOrSelf);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "ownership", val);
return val;
}
|
java
|
private void checkPrimitiveType(int accessor, int typeCode) throws JMFUninitializedAccessException, JMFSchemaViolationException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.entry(this, tc, "checkPrimitiveType", new Object[] { Integer.valueOf(accessor), Integer.valueOf(typeCode) });
JSField field = getFieldDef(accessor, true);
if (field == null) {
JMFUninitializedAccessException e = new JMFUninitializedAccessException("Value at accessor " + accessor + " should not be present");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "checkPrimitiveType", e);
throw e;
}
if (field instanceof JSPrimitive) {
if (((JSPrimitive) field).getTypeCode() != typeCode) {
JMFSchemaViolationException e = new JMFSchemaViolationException("Value at accessor " + accessor + " is incorrect type");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "checkPrimitiveType", e);
throw e;
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "checkPrimitiveType");
return;
}
}
else if (field instanceof JSEnum && (typeCode == JMFPrimitiveType.INT)) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "checkPrimitiveType");
return;
}
else {
JMFSchemaViolationException e = new JMFSchemaViolationException("Value at accessor " + accessor + " is incorrect");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "checkPrimitiveType", e);
throw e;
}
}
|
java
|
void lazyCopy(JSMessageData original) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.entry(this, tc, "lazyCopy", new Object[] { original });
synchronized (getMessageLockArtefact()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
JmfTr.debug(this, tc, "lazyCopy locked dest ", new Object[] { getMessageLockArtefact() });
// This is the only occasion that we reach out and lock another message instance
// but we work on the assumption that lazy copying is happening as part of
// instantiation of a new message instance, so the potential for deadlocking
// is nil, since no other thread knows about this instance and can not therefore
// be concurrently supplying 'this' as the 'original' argument in another thread.
synchronized (original.getMessageLockArtefact()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
JmfTr.debug(this, tc, "lazyCopy locked source ", new Object[] { original.getMessageLockArtefact() });
// Copy common fields
indirect = original.indirect;
// If the message is assembled (i.e. we have a contents buffer) we share both the
// buffer and the cache between original and copy.
// If the message is unassembled (no contents buffer) we just share the cache.
// In either case if a change later needs to be made to the shared portion we
// will need to copy it before changing, so the shared flags is set to
// indicate sharing exists between unrelated parts.
if (original.contents == null) {
contents = null;
original.sharedCache = true;
sharedCache = true;
cache = original.cache;
}
else {
original.sharedContents = true;
sharedContents = true;
contents = original.contents;
original.sharedCache = true;
sharedCache = true;
cache = original.cache;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
JmfTr.debug(this, tc, "lazyCopy unlocking source ", new Object[] { original.getMessageLockArtefact() });
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
JmfTr.debug(this, tc, "lazyCopy unlocking dest ", new Object[] { getMessageLockArtefact() });
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
JmfTr.exit(this, tc, "lazyCopy");
}
|
java
|
public Set<String> getKeySet() {
HashSet<String> result = new HashSet<>();
for (PollingDynamicConfig config : children) {
Iterator<String> iter = config.getKeys();
while (iter.hasNext()) {
String key = iter.next();
result.add(key);
}
}
return result;
}
|
java
|
public final boolean isAutoCommit()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isAutoCommit");
SibTr.exit(this, tc, "isAutoCommit", "return=false");
}
return false;
}
|
java
|
public void incrementCurrentSize() throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "incrementCurrentSize");
if (_currentTran != null)
{
_currentTran.incrementCurrentSize();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementCurrentSize");
}
|
java
|
public boolean isAlive()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isAlive");
boolean retval = false;
if (_currentTran != null)
{
retval = _currentTran.isAlive();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isAlive", "return="+retval);
return retval;
}
|
java
|
public void end(Xid xid, int flags) throws XAException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "end", new Object[]{"XID="+xid, _manager.xaFlagsToString(flags)});
try
{
_manager.end(new PersistentTranId(xid), flags);
// Reset our instance variables.
_currentTran = null;
_currentPtid = null;
}
catch (XidUnknownException xue)
{
com.ibm.ws.ffdc.FFDCFilter.processException(xue, "com.ibm.ws.sib.msgstore.transactions.MSDelegatingXAResource.end", "1:375:1.51.1.7", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot dis-associate from this Xid. It is unknown!", xue);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "end");
XAException xaException = new XAException(XAException.XAER_NOTA);
xaException.initCause(xue);
throw xaException;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "end");
}
|
java
|
public Xid[] recover(int recoveryId) throws XAException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "recover", "Recovery ID="+recoveryId);
Xid[] list = _manager.recover();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "recover", "return="+Arrays.toString(list));
return list;
}
|
java
|
public static String dumpAsString(
Object obj)
{
if (obj instanceof DERObject)
{
return _dumpAsString("", (DERObject) obj);
}
else if (obj instanceof DEREncodable)
{
return _dumpAsString("", ((DEREncodable) obj).getDERObject());
}
return "unknown object type " + obj.toString();
}
|
java
|
public void deployMicroProfileLoginConfigFormLoginInWebXmlBasicInApp(LibertyServer server) throws Exception {
List<String> classList = createAppClassListBuildAppNames("CommonMicroProfileMarker_FormLoginInWeb_BasicInApp", "MicroProfileLoginConfigFormLoginInWebXmlBasicInApp");
ShrinkHelper.exportAppToServer(server, genericCreateArchiveWithJsps(MpJwtFatConstants.LOGINCONFIG_FORM_LOGIN_IN_WEB_XML_SERVLET_BASIC_IN_APP_ROOT_CONTEXT, classList));
server.addInstalledAppForValidation(MpJwtFatConstants.LOGINCONFIG_FORM_LOGIN_IN_WEB_XML_SERVLET_BASIC_IN_APP_ROOT_CONTEXT);
}
|
java
|
protected WebArchive genericCreateArchiveWithPems(String sourceWarName, String baseWarName, List<String> classList) throws Exception {
try {
String warName = baseWarName + ".war";
WebArchive newWar = ShrinkWrap.create(WebArchive.class, warName);
addDefaultFileAssetsForAppsToWar(sourceWarName, newWar);
addPemFilesForAppsToWar(warName, newWar);
for (String theClass : classList) {
newWar.addClass(theClass);
}
return newWar;
} catch (Exception e) {
Log.error(thisClass, "genericCreateArchive", e);
throw e;
}
}
|
java
|
protected WebArchive genericCreateArchiveWithPemsAndMPConfig(String sourceWarName, String baseWarName, List<String> classList, String mpConfig,
String fileContent) throws Exception {
try {
WebArchive newWar = genericCreateArchiveWithPems(sourceWarName, baseWarName, classList);
newWar.add(new StringAsset(fileContent), mpConfig);
return newWar;
} catch (Exception e) {
Log.error(thisClass, "genericCreateArchive", e);
throw e;
}
}
|
java
|
public List<String> createAppClassListBuildAppNames(String app1, String app2, String app3) throws Exception {
List<String> classList = createAppClassListBuildAppNames(app1, app2);
classList.add("com.ibm.ws.jaxrs.fat.microProfileApp." + app2 + ".MicroProfileApp" + app3);
return classList;
}
|
java
|
public String getOutputBufferAsString() throws IOException
{
byte[] buffer = getOutputBuffer();
if (buffer != null)
return new String(buffer, this.getCharacterEncoding());
else
return null;
}
|
java
|
public void transferResponse(HttpServletResponse target) throws IOException // never
// called
// for
// ARD.
// would
// be
// in
// trouble
// with
// a
// bunch
// of
// include
// warnings
{
_finish();
if (containsError())
{
// transfer error
String message = getErrorMessage();
int sc = getErrorStatusCode();
if (message == null)
{
target.sendError(sc);
}
else
{
target.sendError(sc, message);
}
}
else if (isRedirected())
{
// transfer cookies
Cookie[] cookies = getCookies();
for (int i = 0; i < cookies.length; i++)
{
target.addCookie(cookies[i]);
}
// transfer redirect
target.sendRedirect(getRedirectURI());
}
else
{
// transfer status code
if (getStatusMessage() == null)
{
target.setStatus(getStatusCode());
}
else
{
target.setStatus(getStatusCode(), getStatusMessage());
}
// transfer headers
_header.transferHeader(target);
// transfer cookies
Cookie[] cookies = getCookies();
for (int i = 0; i < cookies.length; i++)
{
target.addCookie(cookies[i]);
}
if (this.getOutputBuffer() != null)
{ // PM17019
// transfer data
ServletOutputStream out;
try
{
out = target.getOutputStream();
}
catch (IllegalStateException i)
{
while (!(target instanceof StoredResponse))
{
while (target instanceof HttpServletResponseWrapper)
{
target = ((HttpServletResponse) ((HttpServletResponseWrapper) target).getResponse());
}
while (target instanceof HttpServletResponseProxy)
{
target = ((HttpServletResponse) ((HttpServletResponseProxy) target).getProxiedHttpServletResponse());
}
while (target instanceof IncludedResponse)
{
target = ((IncludedResponse) target).getProxiedHttpServletResponse();
}
// PQ88880 begin
if (target instanceof SRTServletResponse)
{
target.getWriter().write(this.getOutputBufferAsString().toCharArray());
return;
}
// PQ88880 end
}
StoredResponse s = (StoredResponse) target;
out = s._outInternal;
}
out.write(this.getOutputBuffer());
}
}
}
|
java
|
public final static Reliability getReliabilityByName(String name)
throws NullPointerException, IllegalArgumentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.info(tc, "Name = " + name);
if (name == null) {
throw new NullPointerException();
}
/* Look for the name in the nameSet, and return the corresponding */
/* Reliability from the indexSet. */
for (int i = 0; i <= MAX_INDEX + 1; i++) {
if (name.equals(nameSet[i])) {
return indexSet[i];
}
}
/* If the name didn't match, throw IllegalArgumentException */
throw new IllegalArgumentException();
}
|
java
|
public final static Reliability getReliabilityByIndex(int mpIndex) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.info(tc, "Index = " + mpIndex);
return indexSet[mpIndex + 1];
}
|
java
|
public final static Reliability getReliability(Byte aValue) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
SibTr.info(tc, "Value = " + aValue);
return set[aValue.intValue()];
}
|
java
|
@Override
public String[] getHeader() {
ArrayList<String> result = new ArrayList<String>();
if (customHeader.length > 0) {
for (CustomHeaderLine line: customHeader) {
String formattedLine = line.formatLine(headerProps);
if (formattedLine != null) {
result.add(formattedLine);
}
}
} else {
for (String prop: headerProps.stringPropertyNames()) {
result.add(prop + " = " + headerProps.getProperty(prop));
}
}
return result.toArray(new String[result.size()]);
}
|
java
|
protected void createEventTimeStamp(RepositoryLogRecord record, StringBuilder buffer) {
if (null == record) {
throw new IllegalArgumentException("Record cannot be null");
}
if (null == buffer) {
throw new IllegalArgumentException("Buffer cannot be null");
}
// Create the time stamp
buffer.append('[');
Date eventDate = new Date(record.getMillis());
// set the dateFormat object to the desired timeZone. Allows log output
// to be presented in different time zones.
dateFormat.setTimeZone(timeZone); // set the format to
// the desired
// time zone.
buffer.append(dateFormat.format(eventDate));
buffer.append("] ");
}
|
java
|
protected static String mapLevelToType(RepositoryLogRecord logRecord) {
if (null == logRecord) {
return " Z ";
}
Level l = logRecord.getLevel();
if (null == l) {
return " Z ";
}
// In HPEL SystemOut and SystemErr are recorded in custom level but since we want
// them to be handled specially do it now before checking for custom levels
String s = logRecord.getLoggerName();
if (s != null) {
if (s.equals("SystemOut")) {
return " O ";
} else if (s.equals("SystemErr")) {
return " R ";
}
}
String id = customLevels.get(l);
if (id != null) {
return (" " + id + " ");
}
// Since we have used the static Level object throughout the logging framework
// object reference comparisons should work.
if (l == Level.SEVERE) {
return " E ";
}
if (l == Level.WARNING) {
return " W ";
}
if (l == Level.INFO) {
return " I ";
}
if (l == Level.CONFIG) {
return " C ";
}
if (l == Level.FINE) {
return " 1 ";
}
if (l == Level.FINER) {
// D198403 Start
// added check for Entry and Exit messages to return < or >
String message = logRecord.getRawMessage();
if (message != null) {
if (message.indexOf("Entry") != -1 || message.indexOf("ENTRY") != -1) {
return " > ";
}
if (message.indexOf("Exit") != -1 || message.indexOf("RETURN") != -1) {
return " < ";
}
}
return " 2 ";
// D198403 End
}
if (l == Level.FINEST) {
return " 3 ";
}
return " Z ";
}
|
java
|
protected void setCookies(HttpServletRequest request, HttpServletResponse response, String requestToken, String stateValue) {
ReferrerURLCookieHandler referrerURLCookieHandler = WebAppSecurityCollaboratorImpl.getGlobalWebAppSecurityConfig().createReferrerURLCookieHandler();
// Create cookie for request token
Cookie requestTokenCookie = referrerURLCookieHandler.createCookie(TwitterConstants.COOKIE_NAME_REQUEST_TOKEN, requestToken, request);
response.addCookie(requestTokenCookie);
// Set original request URL in cookie
String cookieName = ClientConstants.COOKIE_NAME_REQ_URL_PREFIX + stateValue.hashCode();
Cookie c = referrerURLCookieHandler.createCookie(cookieName, webUtils.getRequestUrlWithEncodedQueryString(request), request);
response.addCookie(c);
}
|
java
|
private void setUnauthenticatedSubjectIfNeeded() {
if (LocationUtils.isServer()) {
com.ibm.ws.security.context.SubjectManager sm = new com.ibm.ws.security.context.SubjectManager();
Subject invokedSubject = sm.getInvocationSubject();
if (invokedSubject == null) {
Subject callerSubject = sm.getCallerSubject();
if (callerSubject == null) {
// create the unauthenticated subject and set as the invocation subject
UnauthenticatedSubjectService unAuthenticationService = SecurityServices.getUnauthenticatedSubjectService();
if (unAuthenticationService != null) {
sm.setInvocationSubject(unAuthenticationService.getUnauthenticatedSubject());
}
}
}
}
}
|
java
|
private void updateClientPolicy(Message m) {
if (!clientSidePolicyCalced) {
PolicyDataEngine policyEngine = bus.getExtension(PolicyDataEngine.class);
if (policyEngine != null && endpointInfo.getService() != null) {
clientSidePolicy = policyEngine.getClientEndpointPolicy(m,
endpointInfo,
this,
new ClientPolicyCalculator());
if (clientSidePolicy != null) {
clientSidePolicy.removePropertyChangeListener(this); //make sure we aren't added twice
clientSidePolicy.addPropertyChangeListener(this);
}
}
}
clientSidePolicyCalced = true;
}
|
java
|
public void finalizeConfig() {
// See if not set by configuration, if there are defaults
// in order from the Endpoint, Service, or Bus.
configureConduitFromEndpointInfo(this, endpointInfo);
logConfig();
if (getClient().getDecoupledEndpoint() != null) {
this.endpointInfo.setProperty("org.apache.cxf.ws.addressing.replyto",
getClient().getDecoupledEndpoint());
}
}
|
java
|
public AuthorizationPolicy getEffectiveAuthPolicy(Message message) {
AuthorizationPolicy authPolicy = getAuthorization();
AuthorizationPolicy newPolicy = message.get(AuthorizationPolicy.class);
AuthorizationPolicy effectivePolicy = newPolicy;
if (effectivePolicy == null) {
effectivePolicy = authPolicy;
}
if (effectivePolicy == null) {
effectivePolicy = new AuthorizationPolicy();
}
return effectivePolicy;
}
|
java
|
public void setClient(HTTPClientPolicy client) {
if (this.clientSidePolicy != null) {
this.clientSidePolicy.removePropertyChangeListener(this);
}
this.clientSidePolicyCalced = true;
this.clientSidePolicy = client;
clientSidePolicy.removePropertyChangeListener(this); //make sure we aren't added twice
clientSidePolicy.addPropertyChangeListener(this);
endpointInfo.setProperty("org.apache.cxf.ws.addressing.replyto", client.getDecoupledEndpoint());
}
|
java
|
public void setTlsClientParameters(TLSClientParameters params) {
this.tlsClientParameters = params;
if (this.tlsClientParameters != null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.log(Level.FINE, "Conduit '" + getConduitName()
+ "' has been (re) configured for TLS "
+ "keyManagers " + Arrays.toString(tlsClientParameters.getKeyManagers())
+ "trustManagers " + Arrays.toString(tlsClientParameters.getTrustManagers())
+ "secureRandom " + tlsClientParameters.getSecureRandom());
}
CertificateConstraintsType constraints = params.getCertConstraints();
if (constraints != null) {
certConstraints = CertConstraintsJaxBUtils.createCertConstraints(constraints);
}
} else {
if (LOG.isLoggable(Level.FINE)) {
LOG.log(Level.FINE, "Conduit '" + getConduitName()
+ "' has been (re)configured for plain http.");
}
}
}
|
java
|
protected String extractLocation(Map<String, List<String>> headers) throws MalformedURLException {
for (Map.Entry<String, List<String>> head : headers.entrySet()) {
if ("Location".equalsIgnoreCase(head.getKey())) {
List<String> locs = head.getValue();
if (locs != null && locs.size() > 0) {
String location = locs.get(0);
if (location != null) {
return location;
} else {
return null;
}
}
}
}
return null;
}
|
java
|
private static String convertToAbsoluteUrlIfNeeded(String conduitName,
String lastURL,
String newURL,
Message message) throws IOException {
if (newURL != null && !newURL.startsWith("http")) {
if (MessageUtils.isTrue(message.getContextualProperty(AUTO_REDIRECT_ALLOW_REL_URI))) {
return URI.create(lastURL).resolve(newURL).toString();
} else {
String msg = "Relative Redirect detected on Conduit '"
+ conduitName + "' on '" + newURL + "'";
LOG.log(Level.INFO, msg);
throw new IOException(msg);
}
} else {
return newURL;
}
}
|
java
|
private void resumeTran(Transaction tran) {
if (tran != null) {
try {
tranMgr.resume(tran);
} catch (Exception e) {
throw new BatchRuntimeException("Failed to resume transaction after JobOperator method", e);
}
}
}
|
java
|
private void addAndSortReaders(List<ProviderInfo<MessageBodyReader<?>>> newReaders, boolean forceSort) {
Comparator<ProviderInfo<MessageBodyReader<?>>> comparator = null;
if (!customComparatorAvailable(MessageBodyReader.class)) {
comparator = new MessageBodyReaderComparator(readerMediaTypesMap);
}
messageReaders.addAndSortProviders(newReaders, comparator, forceSort);
}
|
java
|
private static Type[] getGenericInterfaces(Class<?> cls, Class<?> expectedClass,
Class<?> commonBaseCls) {
if (Object.class == cls) {
return emptyType;
}
Type[] cachedTypes = getTypes(cls, expectedClass, commonBaseCls);
if (cachedTypes != null)
return cachedTypes;
if (expectedClass != null) {
Type genericSuperType = cls.getGenericSuperclass();
if (genericSuperType instanceof ParameterizedType) {
Class<?> actualType = InjectionUtils.getActualType(genericSuperType);
if (actualType != null && actualType.isAssignableFrom(expectedClass)) {
Type[] tempTypes = new Type[] { genericSuperType };
putTypes(cls, expectedClass, commonBaseCls, tempTypes);
return tempTypes;
} else if (commonBaseCls != null && commonBaseCls != Object.class
&& commonBaseCls.isAssignableFrom(expectedClass)
&& commonBaseCls.isAssignableFrom(actualType)
|| expectedClass.isAssignableFrom(actualType)) {
putTypes(cls, expectedClass, commonBaseCls, emptyType);
return emptyType;
}
}
}
Type[] types = cls.getGenericInterfaces();
if (types.length > 0) {
putTypes(cls, expectedClass, commonBaseCls, types);
return types;
}
Type[] superGenericTypes = getGenericInterfaces(cls.getSuperclass(), expectedClass, commonBaseCls);
putTypes(cls, expectedClass, commonBaseCls, superGenericTypes);
return superGenericTypes;
}
|
java
|
void onCompletion(Collection<ApplicationDependency> dependencies) {
if (!dependencies.isEmpty()) {
for (ApplicationDependency dependency : dependencies) {
dependency.onCompletion(this);
}
}
}
|
java
|
@Override
public boolean hasObjectWithPrefix(JavaColonNamespace namespace, String name) throws NamingException {
JavaColonNamespaceBindings<EJBBinding> bindings;
boolean result = false;
Lock readLock = null;
ComponentMetaData cmd = null;
try {
// This helper only provides support for java:global, java:app, and java:module
if (namespace == JavaColonNamespace.GLOBAL) {
// Called to ensure that the java:global code path
// is coming from a Java EE thread. If not this will reject this
// method call with the correct Java EE error message.
cmd = getComponentMetaData(namespace, name);
bindings = javaColonGlobalBindings;
readLock = javaColonLock.readLock();
readLock.lock();
} else if (namespace == JavaColonNamespace.APP) {
// Get the ComponentMetaData for the currently active component.
// There is no component name space if there is no active component.
cmd = getComponentMetaData(namespace, name);
bindings = getAppBindingMap(cmd.getModuleMetaData().getApplicationMetaData());
readLock = javaColonLock.readLock();
readLock.lock();
} else if (namespace == JavaColonNamespace.MODULE) {
cmd = getComponentMetaData(namespace, name);
bindings = getModuleBindingMap(cmd.getModuleMetaData());
} else {
bindings = null;
}
result = bindings != null && bindings.hasObjectWithPrefix(name);
} finally {
if (readLock != null) {
readLock.unlock();
}
}
return result;
}
|
java
|
public void removeGlobalBindings(List<String> names) {
Lock writeLock = javaColonLock.writeLock();
writeLock.lock();
try {
for (String name : names) {
javaColonGlobalBindings.unbind(name);
}
} finally {
writeLock.unlock();
}
}
|
java
|
private JavaColonNamespaceBindings<EJBBinding> getAppBindingMap(ApplicationMetaData amd) {
@SuppressWarnings("unchecked")
JavaColonNamespaceBindings<EJBBinding> bindingMap = (JavaColonNamespaceBindings<EJBBinding>) amd.getMetaData(amdSlot);
if (bindingMap == null) {
bindingMap = new JavaColonNamespaceBindings<EJBBinding>(NamingConstants.JavaColonNamespace.APP, this);
amd.setMetaData(amdSlot, bindingMap);
}
return bindingMap;
}
|
java
|
private JavaColonNamespaceBindings<EJBBinding> getModuleBindingMap(ModuleMetaData mmd) {
@SuppressWarnings("unchecked")
JavaColonNamespaceBindings<EJBBinding> bindingMap = (JavaColonNamespaceBindings<EJBBinding>) mmd.getMetaData(mmdSlot);
if (bindingMap == null) {
bindingMap = new JavaColonNamespaceBindings<EJBBinding>(NamingConstants.JavaColonNamespace.MODULE, this);
mmd.setMetaData(mmdSlot, bindingMap);
}
return bindingMap;
}
|
java
|
public void removeAppBindings(ModuleMetaData mmd, List<String> names) {
ApplicationMetaData amd = mmd.getApplicationMetaData();
Lock writeLock = javaColonLock.writeLock();
writeLock.lock();
try {
JavaColonNamespaceBindings<EJBBinding> bindings = getAppBindingMap(amd);
// getAppBindings returns a non-null value
for (String name : names) {
bindings.unbind(name);
}
} finally {
writeLock.unlock();
}
}
|
java
|
private void throwCannotInstanciateUnsupported(EJBBinding binding,
JavaColonNamespace jndiType,
String lookupName,
String messageId) throws NameNotFoundException {
J2EEName j2eeName = getJ2EEName(binding);
String jndiName = jndiType.toString() + "/" + lookupName;
String msgTxt = Tr.formatMessage(tc, messageId,
binding.interfaceName,
j2eeName.getComponent(),
j2eeName.getModule(),
j2eeName.getApplication(),
jndiName);
throw (new NameNotFoundException(msgTxt));
}
|
java
|
protected void unsetVirtualHost(VirtualHost vhost) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Unset vhost: ", vhost);
}
secureVirtualHost = null;
}
|
java
|
private synchronized void createJMXWorkAreaResourceIfChanged(VirtualHost vhost) {
// Make sure our context root has been registered...
String contextRoot = registeredContextRoot;
if (contextRoot != null) {
// Make sure that we are dealing with the secure port before writing the file...
String newAppURLString = vhost.getUrlString(contextRoot, true);
if (newAppURLString.startsWith("https")) {
// If we are dealing with the secure port, woohoo!
String oldAppURL = appURL;
String newAppURL = processContextRootURL(newAppURLString);
if (oldAppURL == null || !oldAppURL.equals(newAppURL)) {
this.appURL = newAppURL;
if (restJMXAddressWorkareaFile == null) {
restJMXAddressWorkareaFile = createJMXWorkAreaResource(locationService);
} else {
createJmxAddressResource(restJMXAddressWorkareaFile);
}
if (restJMXAddressStateFile == null) {
restJMXAddressStateFile = createJMXStateResource(locationService);
} else {
createJmxAddressResource(restJMXAddressStateFile);
}
// Register or update a marker service with JMX host/port
Hashtable<String, Object> props = new Hashtable<String, Object>();
props.put("name", "JMXConnectorEndpoint");
props.put("jmxHost", vhost.getHostName(secureAlias));
props.put("jmxPort", vhost.getSecureHttpPort(secureAlias));
props.put("jmxAlias", secureAlias);
if (jmxEndpointRegistration == null)
jmxEndpointRegistration = bContext.registerService(Object.class, this, props);
else
jmxEndpointRegistration.setProperties(props);
}
}
}
}
|
java
|
@Reference(service = WsLocationAdmin.class,
policy = ReferencePolicy.DYNAMIC,
cardinality = ReferenceCardinality.MANDATORY)
protected void setLocationService(WsLocationAdmin locationService) {
this.locationService = locationService;
if (restJMXAddressWorkareaFile == null) {
restJMXAddressWorkareaFile = createJMXWorkAreaResource(locationService);
}
if (restJMXAddressStateFile == null) {
restJMXAddressStateFile = createJMXStateResource(locationService);
}
}
|
java
|
public final List<String> getConnectionFactoryInterfaceNames() {
return cfInterfaceNames instanceof String ? Collections.singletonList((String) cfInterfaceNames) //
: cfInterfaceNames instanceof String[] ? Arrays.asList((String[]) cfInterfaceNames) //
: Collections.<String> emptyList();
}
|
java
|
private void destroyConnectionFactories(boolean destroyImmediately) {
lock.writeLock().lock();
try {
if (isInitialized.get()) {
// Mark all connection factories as disabled
isInitialized.set(false);
// Destroy the connection factories
conMgrSvc.deleteObserver(this);
conMgrSvc.destroyConnectionFactories();
conMgrSvc = null;
}
} finally {
lock.writeLock().unlock();
}
}
|
java
|
@Override
@Trivial
public boolean getReauthenticationSupport() {
return Boolean.TRUE.equals(bootstrapContextRef.getReference().getProperty(REAUTHENTICATION_SUPPORT));
}
|
java
|
@Override
public TransactionSupportLevel getTransactionSupport() {
// If ManagedConnectionFactory implements TransactionSupport, that takes priority
TransactionSupportLevel transactionSupport = mcf instanceof TransactionSupport ? ((TransactionSupport) mcf).getTransactionSupport() : null;
// Otherwise get the value from the deployment descriptor
String prop = (String) bootstrapContextRef.getReference().getProperty(TRANSACTION_SUPPORT);
if (prop != null) {
TransactionSupportLevel ddTransactionSupport = TransactionSupportLevel.valueOf(prop);
if (transactionSupport == null)
transactionSupport = ddTransactionSupport;
else if (transactionSupport.ordinal() > ddTransactionSupport.ordinal())
throw new IllegalArgumentException(ManagedConnectionFactory.class.getName() + ':' + transactionSupport
+ ", " + Connector.class.getName() + ':' + ddTransactionSupport);
}
if (connectionFactoryTransactionSupport != null) {
if (connectionFactoryTransactionSupport.ordinal() > transactionSupport.ordinal())
throw new IllegalArgumentException(ManagedConnectionFactory.class.getName() + ':' + transactionSupport
+ ", " + Connector.class.getName() + ':' + connectionFactoryTransactionSupport);
else
transactionSupport = connectionFactoryTransactionSupport;
}
// Otherwise choose NoTransaction
return transactionSupport == null ? TransactionSupportLevel.NoTransaction : transactionSupport;
}
|
java
|
public StackNode<E> clean() {
do {
final StackNode<E> oldTop = top.get();
if (top.compareAndSet(oldTop, null))
return oldTop;
} while (true);
}
|
java
|
public E pop() {
StackNode<E> oldTop, newTop;
while (true) {
oldTop = top.get();
if (oldTop == null)
return null;
newTop = oldTop.next;
if (top.compareAndSet(oldTop, newTop))
break;
}
return oldTop.data;
}
|
java
|
public void push(E d) {
StackNode<E> oldTop, newTop;
newTop = new StackNode<E>(d);
while (true) {
oldTop = top.get();
newTop.next = oldTop;
if (oldTop != null)
newTop.index = oldTop.index + 1;
else
newTop.index = 0;
if (top.compareAndSet(oldTop, newTop))
return;
}
}
|
java
|
public E peek() {
final StackNode<E> oldTop = top.get();
if (oldTop == null) {
return null;
} else {
return oldTop.data;
}
}
|
java
|
public void setSizeRefsByMsgSize(boolean sizeByMsgSize)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setSizeRefsByMsgSize", Boolean.valueOf(sizeByMsgSize));
this._sizeRefsByMsgSize = sizeByMsgSize;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setSizeRefsByMsgSize");
}
|
java
|
public int getInMemoryDataSize()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getInMemoryDataSize");
int dataSize;
// If tuning has requested return the size of the message we reference,
// then delegate to the message. Otherwise call our parent to get a
// (small) default size.
if (_sizeRefsByMsgSize)
{
try
{
dataSize = getReferredItem().getInMemoryDataSize();
}
catch (SevereMessageStoreException e)
{
com.ibm.ws.ffdc.FFDCFilter.processException(e,"com.ibm.ws.sib.msgstore.ItemReference.getInMemoryDataSize","244",this);
// After FFDCing anything nasty, fall back to the standard answer
dataSize = super.getInMemoryDataSize();
}
}
else
{
dataSize = super.getInMemoryDataSize();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getInMemoryDataSize", dataSize);
return dataSize;
}
|
java
|
public void begin() throws SIIncorrectCallException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "begin");
// Are we currently in use? do we have work
// we still need to commit?
if (_state == TransactionState.STATE_ACTIVE && _workList != null)
{
SIIncorrectCallException ice = new SIIncorrectCallException(nls.getFormattedMessage("TRAN_PROTOCOL_ERROR_SIMS1001", null, "TRAN_PROTOCOL_ERROR_SIMS1001"));
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot begin new LocalTran. Existing work needs completing first!", ice);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "begin");
throw ice;
}
synchronized(this)
{
_ptid = null;
}
_workList = null;
_size = 0;
_callbacks.clear();
_state = TransactionState.STATE_ACTIVE;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "begin");
}
|
java
|
public void rollback() throws SIIncorrectCallException, SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "rollback");
if (_state != TransactionState.STATE_ACTIVE)
{
SIIncorrectCallException sie = new SIIncorrectCallException(nls.getFormattedMessage("CANNOT_ROLLBACK_COMPLETE_SIMS1005", new Object[]{}, null));
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot rollback Transaction. Transaction is complete or completing!", sie);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
throw sie;
}
_state = TransactionState.STATE_ROLLINGBACK;
try
{
// We are rolling back all changes so we don't need
// to tell the persistence layer to do anything we
// just need to get the in memory model to back out
// its changes.
if (_workList != null)
{
_workList.rollback(this);
}
_state = TransactionState.STATE_ROLLEDBACK;
}
catch (Throwable t)
{
com.ibm.ws.ffdc.FFDCFilter.processException(t, "com.ibm.ws.sib.msgstore.transactions.MSDelegatingLocalTransaction.rollback", "1:539:1.51.1.14", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Exception caught during rollback phase of transaction!", t);
throw new SIResourceException(nls.getFormattedMessage("COMPLETION_EXCEPTION_SIMS1002", new Object[] {t}, null), t);
}
finally
{
// We always ensure that all afterCompletion
// callbacks are called even in the case of
// rollback.
// Defect 316887
try
{
if (_workList != null)
{
_workList.postComplete(this, false);
}
for (int i = 0; i < _callbacks.size(); i++)
{
TransactionCallback callback = (TransactionCallback) _callbacks.get(i);
callback.afterCompletion(this, false);
}
}
catch (Throwable t)
{
com.ibm.ws.ffdc.FFDCFilter.processException(t, "com.ibm.ws.sib.msgstore.transactions.MSDelegatingLocalTransaction.rollback", "1:565:1.51.1.14", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Exception caught during post rollback phase of transaction!", t);
// We aren't going to rethrow this exception as if
// a previous exception has been thrown outside the
// finally block it is likely to have more
// information about the root problem.
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
}
}
|
java
|
static void setInjectionEngine(InternalInjectionEngine ie)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setInjectionEngine : " + ie);
svInstance = ie;
}
|
java
|
public static boolean isRemoteable(Class<?> valueClass, int rmicCompatible) {
// NOTE: This logic must be kept in sync with write_value.
return valueClass.isInterface() &&
valueClass != Serializable.class &&
valueClass != Externalizable.class &&
(isCORBAObject(valueClass, rmicCompatible) ||
Remote.class.isAssignableFrom(valueClass) ||
isAbstractInterface(valueClass, rmicCompatible));
}
|
java
|
public static boolean hasJNDIScheme(String jndiName) {
int colonIndex = jndiName.indexOf(':');
int slashIndex = jndiName.indexOf('/');
return colonIndex != -1 && (slashIndex == -1 || colonIndex < slashIndex);
}
|
java
|
private List<WsByteBuffer> writeHeader(List<WsByteBuffer> list) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Writing gzip header information");
}
WsByteBuffer hdr = HttpDispatcher.getBufferManager().allocateDirect(GZIP_Header.length);
hdr.put(GZIP_Header);
hdr.flip();
list.add(hdr);
this.haveWrittenHeader = true;
return list;
}
|
java
|
private WsByteBuffer makeBuffer(int len) {
WsByteBuffer buffer = HttpDispatcher.getBufferManager().allocateDirect(len);
buffer.put(this.buf, 0, len);
buffer.flip();
return buffer;
}
|
java
|
private void writeInt(int value, byte[] data, int offset) {
int index = offset;
data[index++] = (byte) (value & 0xff);
data[index++] = (byte) ((value >> 8) & 0xff);
data[index++] = (byte) ((value >> 16) & 0xff);
data[index++] = (byte) ((value >> 24) & 0xff);
}
|
java
|
protected Object getInjectedObjectFromCXF(Class<?> classType,
Type genericType,
Annotation[] memberAnnotations,
ParamInjectionMetadata paramInjectionMetadata) {
Parameter p = ResourceUtils.getParameter(0, memberAnnotations, classType);
Object injectedObject = null;
Message message = paramInjectionMetadata.getInMessage();
OperationResourceInfo ori = paramInjectionMetadata.getOperationResourceInfo();
BeanResourceInfo cri = ori.getClassResourceInfo();
MultivaluedMap<String, String> values = (MultivaluedMap<String, String>) message.get(URITemplate.TEMPLATE_PARAMETERS);
if (p.getType() == ParameterType.BEAN && cri instanceof ClassResourceInfo) {
injectedObject = JAXRSUtils.createBeanParamValue(message, classType, ori);
} else {
injectedObject = JAXRSUtils.createHttpParameterValue(p,
classType,
genericType,
memberAnnotations,
message,
values,
ori);
}
return injectedObject;
}
|
java
|
private void setBufferSize(int size) {
this.amountToBuffer = size;
this.bbSize = (49152 < size) ? 32768 : 8192;
int numBuffers = (size / this.bbSize);
if (0 == size || 0 != (size % this.bbSize)) {
numBuffers++;
}
this._output = new WsByteBuffer[numBuffers];
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "setBufferSize=[" + size + "]; " + this);
}
}
|
java
|
private void clear() {
if (null != this._output) {
for (int i = 0; i < this._output.length; i++) {
if (null != this._output[i]) {
this._output[i].release();
this._output[i] = null;
}
}
}
this.outputIndex = 0;
this.bufferedCount = 0;
this.bytesWritten = 0L;
this.setWriteListenerCallBack(null);
}
|
java
|
@Reference(service = Application.class,
cardinality = ReferenceCardinality.MULTIPLE,
policy = ReferencePolicy.DYNAMIC,
target = "(application.state=STARTED)")
protected void addStartedApplication(ServiceReference<Application> ref) {
ExecutorService executor;
String appName = (String) ref.getProperty(NAME);
Set<Runnable> tasks;
lock.writeLock().lock();
try {
executor = this.executor;
appStates.put(appName, ApplicationState.STARTED);
tasks = deferredTasks.remove(appName);
} finally {
lock.writeLock().unlock();
}
if (tasks != null)
for (Runnable task : tasks)
executor.submit(task);
}
|
java
|
@Reference(service = Application.class,
cardinality = ReferenceCardinality.MULTIPLE,
policy = ReferencePolicy.DYNAMIC,
target = "(application.state=STARTING)")
protected void addStartingApplication(ServiceReference<Application> ref) {
String appName = (String) ref.getProperty(NAME);
lock.writeLock().lock();
try {
if (!appStates.containsKey(appName))
appStates.put(appName, ApplicationState.STARTING);
} finally {
lock.writeLock().unlock();
}
}
|
java
|
boolean isStarted(String appName) {
lock.readLock().lock();
try {
return appStates.get(appName) == ApplicationState.STARTED;
} finally {
lock.readLock().unlock();
}
}
|
java
|
protected void removeStartedApplication(ServiceReference<Application> ref) {
String appName = (String) ref.getProperty(NAME);
lock.writeLock().lock();
try {
appStates.remove(appName);
} finally {
lock.writeLock().unlock();
}
}
|
java
|
String objectsToString(String key, Object objects) {
java.io.StringWriter stringWriter = new java.io.StringWriter();
stringWriter.write(key);
stringWriter.write(":");
if (objects == null) {
stringWriter.write("\n");
} else if (objects instanceof Object[]) {
for (int i = 0; i < ((Object[]) objects).length; i++) {
Object object = ((Object[]) objects)[i];
if (object == null)
stringWriter.write("null\n");
else {
stringWriter.write(((Object[]) objects)[i].toString());
stringWriter.write("\n");
}
}
} else {
stringWriter.write(objects.toString());
stringWriter.write("\n");
}
return stringWriter.toString();
}
|
java
|
private static String getPID() {
String name = ManagementFactory.getRuntimeMXBean().getName();
int index = name.indexOf('@');
if (index == -1) {
return null;
}
String pid = name.substring(0, index);
if (!pid.matches("[0-9]+")) {
return null;
}
return pid;
}
|
java
|
private File createNewFile(File outputDir, String prefix, String extension) throws IOException {
String dateTime = new SimpleDateFormat("yyyyMMdd.HHmmss").format(new Date());
File outputFile;
do {
String pid = PID == null ? "" : PID + '.';
int sequenceNumber = nextSequenceNumber.getAndIncrement();
outputFile = new File(outputDir, String.format("%s.%s.%s%04d.%s", prefix, dateTime, pid, sequenceNumber, extension));
} while (outputFile.exists());
return outputFile;
}
|
java
|
private File createThreadDump(File outputDir) {
// Determine if we're using Java Attach (VirtualMachine.remoteDataDump)
// or the DiagnosticCommand MBean. Java Attach is only available on
// JREs (not JDKs) and sometimes fails to connect, but we prefer it when
// available because DiagnosticCommand returns the entire thread dump as
// a single String, which risks OutOfMemoryError.
VirtualMachine vm = null;
try {
vm = getAttachedVirtualMachine();
if (vm == null && diagnosticCommandName == null) {
// Neither Java Attach nor DiagnosticCommand are available, so
// it's not possible to create a thread dump.
return null;
}
} catch (VirtualMachineException e) {
// Sometimes Java Attach fails spuriously. If DiagnosticCommand is
// available, try that. Otherwise, propagate the failure.
if (diagnosticCommandName == null) {
Throwable cause = e.getCause();
throw cause instanceof RuntimeException ? (RuntimeException) cause : new RuntimeException(cause);
}
}
File outputFile = null;
InputStream input = null;
OutputStream output = null;
boolean success = false;
try {
// Use a filename that resembles an IBM javacore.
outputFile = createNewFile(outputDir, "javadump", "txt");
if (vm != null) {
input = vm.remoteDataDump();
input = new BufferedInputStream(input);
output = new FileOutputStream(outputFile);
output = new BufferedOutputStream(output);
byte[] buf = new byte[8192];
for (int read; (read = input.read(buf)) != -1;) {
output.write(buf, 0, read);
}
} else {
String outputString;
try {
outputString = (String) platformMBeanServer.invoke(diagnosticCommandName,
"threadPrint",
new Object[] { new String[] { "-l" } },
new String[] { String[].class.getName() });
} catch (Exception e) {
throw new RuntimeException(e);
}
output = new FileOutputStream(outputFile);
Writer writer = new OutputStreamWriter(output, "UTF-8");
writer.write(outputString);
writer.close();
}
success = true;
} catch (IOException ex) {
throw new RuntimeException(ex);
} finally {
Utils.tryToClose(input);
Utils.tryToClose(output);
if (!success && outputFile != null && !outputFile.delete()) {
// Avoid FindBugs warning. We .delete() as a best effort.
outputFile = null;
}
}
return outputFile;
}
|
java
|
private synchronized VirtualMachine getAttachedVirtualMachine() throws VirtualMachineException {
if (PID == null) {
// Java Attach requires a PID.
return null;
}
if (vm == null) {
vm = createVirtualMachine();
}
return vm.isAttached() ? vm : null;
}
|
java
|
private VirtualMachine createVirtualMachine() throws VirtualMachineException {
ClassLoader toolsClassLoader;
File toolsJar = getToolsJar();
if (toolsJar == null) {
// The attach classes are on the boot classpath on Mac.
toolsClassLoader = HotSpotJavaDumperImpl.class.getClassLoader();
} else {
try {
toolsClassLoader = new URLClassLoader(new URL[] { toolsJar.getAbsoluteFile().toURI().toURL() });
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
}
try {
Class<?> vmClass = toolsClassLoader.loadClass("com.sun.tools.attach.VirtualMachine");
Method attachMethod = vmClass.getMethod("attach", new Class<?>[] { String.class });
Object toolsVM = attachMethod.invoke(null, new Object[] { PID });
Method remoteDataDumpMethod = toolsVM.getClass().getMethod("remoteDataDump", new Class<?>[] { Object[].class });
return new VirtualMachine(toolsVM, remoteDataDumpMethod);
} catch (ClassNotFoundException e) {
// The class isn't found, so we won't be able to create dumps.
} catch (InvocationTargetException e) {
throw new VirtualMachineException(e);
} catch (Exception e) {
throw new RuntimeException(e);
}
return new VirtualMachine(null, null);
}
|
java
|
public List<com.ibm.wsspi.security.wim.model.IdentifierType> getManager() {
if (manager == null) {
manager = new ArrayList<com.ibm.wsspi.security.wim.model.IdentifierType>();
}
return this.manager;
}
|
java
|
public List<com.ibm.wsspi.security.wim.model.IdentifierType> getSecretary() {
if (secretary == null) {
secretary = new ArrayList<com.ibm.wsspi.security.wim.model.IdentifierType>();
}
return this.secretary;
}
|
java
|
public List<com.ibm.wsspi.security.wim.model.AddressType> getHomeAddress() {
if (homeAddress == null) {
homeAddress = new ArrayList<com.ibm.wsspi.security.wim.model.AddressType>();
}
return this.homeAddress;
}
|
java
|
public List<com.ibm.wsspi.security.wim.model.AddressType> getBusinessAddress() {
if (businessAddress == null) {
businessAddress = new ArrayList<com.ibm.wsspi.security.wim.model.AddressType>();
}
return this.businessAddress;
}
|
java
|
public static ModuleMetaData getModuleMetaData() {
ComponentMetaData cmd = getComponentMetaData();
ModuleMetaData mmd = null;
if (cmd != null) {
mmd = cmd.getModuleMetaData();
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "ModuleMetaData object is " + (mmd != null ? mmd.toString() : "null!"));
}
return mmd;
}
|
java
|
void setDelete(
GBSNode deleteNode,
int deleteIndex)
{
_deleteNode = deleteNode;
_deleteIndex = deleteIndex;
_notFound = false;
}
|
java
|
void setTarget(
GBSNode targetNode,
int targetIndex,
int type)
{
_targetNode = targetNode;
_targetIndex = targetIndex;
_type = type;
}
|
java
|
void reset()
{
_deleteNode = null;
_deleteIndex = 0;
_targetNode = null;
_targetIndex = 0;
_type = NONE;
_notFound = true;
}
|
java
|
private String getPID(String dir, String serverName) {
String pid = null;
if (platformType == SelfExtractUtils.PlatformType_CYGWIN) {
String pidFile = dir + File.separator + "wlp" + File.separator + "usr" + File.separator + "servers" + File.separator + ".pid" + File.separator
+ serverName + ".pid";
try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(pidFile), "UTF-8"));
try {
return br.readLine();
} finally {
br.close();
}
} catch (IOException e) {
pid = null;
}
if (pid == null) {
Object[] substitution = { dir };
System.out.println(MessageFormat.format(resourceBundle.getString("UNABLE_TO_FIND_PID"), substitution));
}
}
return pid;
}
|
java
|
private void stopServer() throws IOException {
// build stop command for Unix platforms
String cmd = dir + File.separator + "wlp" + File.separator + "bin" + File.separator + "server stop " + serverName;
if (platformType == SelfExtractUtils.PlatformType_UNIX) {
// use command as-is
} else if (platformType == SelfExtractUtils.PlatformType_WINDOWS) {
cmd = "cmd /k " + cmd;
} else if (platformType == SelfExtractUtils.PlatformType_CYGWIN) {
cmd = "bash -c " + '"' + cmd.replace('\\', '/') + '"';
}
Runtime.getRuntime().exec(cmd, SelfExtractUtils.runEnv(dir), null); // stop server
}
|
java
|
private void startAsyncDelete() throws IOException {
Runtime rt = Runtime.getRuntime();
File scriptFile = null;
if (platformType == SelfExtractUtils.PlatformType_UNIX) {
scriptFile = writeCleanupFile(SelfExtractUtils.PlatformType_UNIX);
rt.exec("chmod 750 " + scriptFile.getAbsolutePath());
rt.exec("sh -c " + scriptFile.getAbsolutePath() + " &");
} else if (platformType == SelfExtractUtils.PlatformType_WINDOWS) {
scriptFile = writeCleanupFile(SelfExtractUtils.PlatformType_WINDOWS);
// Note: must redirect output in order for script to run on windows.
// This is a quirk validated by testing. Redirect to NUL is fine since we're
// not trying to trap this output anyway.
rt.exec("cmd /k start /B " + scriptFile.getAbsolutePath() + " >/NUL 2>/NUL");
} else if (platformType == SelfExtractUtils.PlatformType_CYGWIN) {
scriptFile = writeCleanupFile(SelfExtractUtils.PlatformType_CYGWIN);
// convert to Unix type path and run under bash
rt.exec("bash -c " + scriptFile.getAbsolutePath().replace('\\', '/') + " &");
}
}
|
java
|
private void writeWindowsCleanup(File file, BufferedWriter bw) throws IOException {
bw.write("set max=30\n");
bw.write("set cnt=0\n");
bw.write("set dir=" + dir + "\n");
bw.write("echo delete %dir%\n");
bw.write(":while\n");
bw.write(" if exist %dir% (\n");
bw.write(" rmdir /s /q %dir%\n");
bw.write(" timeout 1\n");
bw.write(" set /a cnt+=1\n");
bw.write(" if %cnt% leq %max% (\n");
bw.write(" goto :while \n");
bw.write(" )\n");
bw.write(" )\n");
bw.write("erase " + file.getAbsoluteFile() + "\n");
}
|
java
|
private void writeUnixCleanup(File file, BufferedWriter bw) throws IOException {
bw.write("echo begin delete" + "\n");
bw.write("n=0" + "\n");
bw.write("while [ $n -ne 1 ]; do" + "\n");
bw.write(" sleep 3" + "\n");
bw.write(" if [ -e " + dir.replace('\\', '/') + " ]; then" + "\n");
bw.write(" rm -rf " + dir.replace('\\', '/') + "\n");
bw.write(" else" + "\n");
bw.write(" echo file not found - n=$n" + "\n");
bw.write(" n=1" + "\n");
bw.write(" fi" + "\n");
bw.write("done" + "\n");
bw.write("echo end delete" + "\n");
bw.write("rm " + file.getAbsolutePath().replace('\\', '/') + "\n");
}
|
java
|
private void writeCygwinCleanup(File file, BufferedWriter bw) throws IOException {
// Under cygwin, must explicitly kill the process that runs
// the server. It simply does not die on its own. And it's
// JVM holds file locks which will prevent cleanup of extraction
// directory. So kill it.
String pid = getPID(dir, serverName);
if (pid != null)
bw.write("kill " + pid + "\n");
writeUnixCleanup(file, bw);
}
|
java
|
public void run() {
try {
stopServer(); // first, stop server
// wait on error/output stream threads to complete
// note on Windows the streams never close, so wait with brief timeout
if (!System.getProperty("os.name").startsWith("Win")) {
out.join();
err.join();
} else { // windows, so use timeout
out.join(500);
err.join(500);
}
startAsyncDelete(); // now launch async process to cleanup extraction directory
} catch (Exception e) {
throw new RuntimeException("Shutdown hook failed with exception " + e.getMessage());
}
}
|
java
|
protected int position()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "position", this);
int position = _absolutePosition + _buffer.position();
if (tc.isEntryEnabled()) Tr.exit(tc, "position", new Integer(position));
return position;
}
|
java
|
protected void position(int newPosition)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "position", new Object[]{this,new Integer(newPosition)});
newPosition -= _absolutePosition;
_buffer.position(newPosition);
if (tc.isEntryEnabled()) Tr.exit(tc, "position");
}
|
java
|
protected void advancePosition(int bytes)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "advancePosition", new Object[] {this, new Integer(bytes)});
final int newPosition = _buffer.position() + bytes;
_buffer.position(newPosition);
if (tc.isDebugEnabled()) Tr.debug(tc, "Buffer's position now " + newPosition);
if (tc.isEntryEnabled()) Tr.exit(tc, "advancePosition");
}
|
java
|
protected void get(byte[] bytes)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "get",new Object[] {this,new Integer(bytes.length)});
_buffer.get(bytes);
if (tc.isDebugEnabled()) Tr.debug(tc, RLSUtils.toHexString(bytes, RLSUtils.MAX_DISPLAY_BYTES));
if (tc.isEntryEnabled()) Tr.exit(tc, "get");
}
|
java
|
protected int getInt()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getInt",this);
int data = _buffer.getInt();
if (tc.isEntryEnabled()) Tr.exit(tc, "getInt",new Integer(data));
return data;
}
|
java
|
protected long getLong()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getLong",this);
long data = _buffer.getLong();
if (tc.isEntryEnabled()) Tr.exit(tc, "getLong", new Long(data));
return data;
}
|
java
|
protected short getShort()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getShort",this);
short data = _buffer.getShort();
if (tc.isEntryEnabled()) Tr.exit(tc, "getShort", new Short(data));
return data;
}
|
java
|
protected boolean getBoolean()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getBoolean", this);
byte dataByte = _buffer.get();
boolean data = (dataByte == TRUE);
if (tc.isEntryEnabled()) Tr.exit(tc, "getBoolean", new Boolean(data));
return data;
}
|
java
|
private Object readItem() {
Object itemRead = null;
try {
currentChunkStatus.incrementItemsTouchedInCurrentChunk();
// call read listeners before and after the actual read
for (ItemReadListenerProxy readListenerProxy : itemReadListeners) {
readListenerProxy.beforeRead();
}
itemRead = readerProxy.readItem();
for (ItemReadListenerProxy readListenerProxy : itemReadListeners) {
readListenerProxy.afterRead(itemRead);
}
// itemRead == null means we reached the end of
// the readerProxy "resultset"
if (itemRead == null) {
currentChunkStatus.markReadNull();
currentChunkStatus.decrementItemsTouchedInCurrentChunk();
}
} catch (Exception e) {
runtimeStepExecution.setException(e);
for (ItemReadListenerProxy readListenerProxy : itemReadListeners) {
readListenerProxy.onReadError(e);
}
if (!currentChunkStatus.isRetryingAfterRollback()) {
if (retryReadException(e)) {
if (!retryHandler.isRollbackException(e)) {
// retry without rollback
itemRead = readItem();
} else {
// retry with rollback
currentChunkStatus.markForRollbackWithRetry(e);
}
} else if (skipReadException(e)) {
currentItemStatus.setSkipped(true);
runtimeStepExecution.getMetric(MetricImpl.MetricType.READ_SKIP_COUNT).incValue();
} else {
throw new BatchContainerRuntimeException(e);
}
} else {
// coming from a rollback retry
if (skipReadException(e)) {
currentItemStatus.setSkipped(true);
runtimeStepExecution.getMetric(MetricImpl.MetricType.READ_SKIP_COUNT).incValue();
} else if (retryReadException(e)) {
if (!retryHandler.isRollbackException(e)) {
// retry without rollback
itemRead = readItem();
} else {
// retry with rollback
currentChunkStatus.markForRollbackWithRetry(e);
}
} else {
throw new BatchContainerRuntimeException(e);
}
}
} catch (Throwable e) {
throw new BatchContainerRuntimeException(e);
}
logger.exiting(sourceClass, "readItem", itemRead == null ? "<null>" : itemRead);
return itemRead;
}
|
java
|
private void publishCheckpointEvent(String stepName, long jobInstanceId, long jobExecutionId, long stepExecutionId) {
BatchEventsPublisher publisher = getBatchEventsPublisher();
if (publisher != null) {
String correlationId = runtimeWorkUnitExecution.getCorrelationId();
publisher.publishCheckpointEvent(stepName, jobInstanceId, jobExecutionId, stepExecutionId, correlationId);
}
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.