code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public Entry remove(Entry removePointer)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "remove", new Object[] { removePointer });
Entry removedEntry = null;
//check that the entry to be removed is not null and is in this list
if(contains(removePointer))
{
//call the internal unsynchronized remove method on the entry to be removed.
removedEntry = removePointer.remove();
}
else //if the entry is not found in this list, throw a runtime exception
{
SIErrorException e = new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.utils.linkedlist.LinkedList",
"1:291:1.3" },
null));
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.utils.linkedlist.LinkedList.remove",
"1:297:1.3",
this);
SibTr.exception(tc, e);
SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.utils.linkedlist.LinkedList",
"1:304:1.3" });
if (tc.isEntryEnabled())
SibTr.exit(tc, "remove", e);
throw e;
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "remove", removedEntry);
//return the object which was removed
return removedEntry;
} | java |
public Entry getFirst()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getFirst");
if (tc.isEntryEnabled())
SibTr.exit(tc, "getFirst", first);
return first;
} | java |
public Entry getLast()
{
if (tc.isEntryEnabled())
{
SibTr.entry(tc, "getLast");
SibTr.exit(tc, "getLast", last);
}
return last;
} | java |
private void addMemberToList(JSConsumerKey key, boolean specificList)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry( tc, "addMemberToList", new Object[] {key, Boolean.valueOf(specificList)});
if(specificList)
{
if(specificKeyMembers == null)
{
// Our first specific member, create a list for them
specificKeyMembers = new ArrayList<LocalQPConsumerKey>();
}
specificKeyMembers.add((LocalQPConsumerKey)key);
}
else
{
if(generalKeyMembers == null)
{
// Our first specific member, create a list for them
generalKeyMembers = new ArrayList<LocalQPConsumerKey>();
}
generalKeyMembers.add((LocalQPConsumerKey)key);
// As we've modified the list we need to reset the index
generalMemberIndex = 0;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addMemberToList");
} | java |
public void removeMember(JSConsumerKey key)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeMember", key);
LocalQPConsumerKey anyKey = null;
// We lock the CD so other members are not added/removed while
// we do this
synchronized(consumerDispatcher.getDestination().getReadyConsumerPointLock())
{
if(singleMember != null)
{
if(!(key.isSpecific()))
generalMemberCount--;
if(singleMember == key)
singleMember = null;
else
{
// We must be the only member
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "removeMember", "SIErrorException");
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.LocalQPConsumerKeyGroup",
"1:453:1.6.1.14" },
null));
}
}
else
{
if(key.isSpecific())
specificKeyMembers.remove(key);
else
{
generalKeyMembers.remove(key);
generalMemberCount--;
// As we've modified the list we need a new iterator
generalMemberIndex = 0;
}
}
memberCount--;
// If that was the last member, we can remove this group
if(memberCount == 0)
{
consumerDispatcher.removeKeyGroup(this);
// Drive finished against the set of cursors
if(classifyingMessages)
{
// Take the classifications read lock
consumerSet.takeClassificationReadLock();
int numFilters = consumerKeyFilter.length;
for(int i=0;i<numFilters;i++)
consumerKeyFilter[i].detach();
// Free the classifications read lock
consumerSet.freeClassificationReadLock();
}
else
{
consumerKeyFilter[0].detach();
}
}
// If all the remaining members are started we can start receiving
// messages again (we couldn't have been before because the member
// was in stopped state.
else if(memberCount == startedCount)
{
if(generalMemberCount > 0)
anyKey = generalKeyMembers.get(0);
else
anyKey = specificKeyMembers.get(0);
}
} // synchronized
// Start the member up
if(anyKey!=null)
anyKey.getConsumerPoint().checkForMessages();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeMember");
} | java |
public LocalQPConsumerKey resolvedKey()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "resolvedKey");
LocalQPConsumerKey key = null;
if(generalMemberCount > 0)
{
// If we only have one this is easy
if(singleMember != null)
key = singleMember;
// Otherwise, we try to be a little fair and pick the next one in
// the list
else
{
key = generalKeyMembers.get(generalMemberIndex);
// Wrap the index if required
if(++generalMemberIndex == generalMemberCount)
generalMemberIndex = 0;
}
}
else
{
// We should have at least one of these
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "resolvedKey", "SIErrorException");
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.LocalQPConsumerKeyGroup",
"1:688:1.6.1.14" },
null));
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "resolvedKey", key);
return key;
} | java |
public void setConsumerActive(boolean active)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setConsumerActive", active);
if(active)
{
consumerThreadID = Thread.currentThread().getId();
}
else
{
consumerThreadID = 0;
}
consumerThreadActive = active;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "setConsumerActive", consumerThreadID);
} | java |
public boolean filterMatches(AbstractItem item)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "filterMatches", item);
boolean match = false;
LocalQPConsumerKey matchingMember = null;
// Hopefully we have a general consumer so we don't need to parse the message
if(generalMemberCount > 0)
{
// We have a match but we don't care which one out of the general members
// actually takes the message, so if one of the general members is the one
// performing the scan they can take the message.
matchingMember = null;
match = true;
}
// Damn, all we've got are members with selectors, we'll have to parse the message
else
{
// If there is just the single member see if they match the message
if(singleMember != null)
{
if(singleMember.filterMatches(item))
{
match = true;
matchingMember = singleMember;
}
}
// Otherwise we give all the members a chance to match it
else
{
LocalQPConsumerKey keyMember;
int index;
int size = specificKeyMembers.size();
for(index = 0;
(index < size) && !match;
index++)
{
keyMember = specificKeyMembers.get(index);
// Drop out if one of the members matches it
if(keyMember.filterMatches(item))
{
match = true;
matchingMember = keyMember;
}
}
}
}
// we only want to remember this result if get got here as a result of a consumer
//asking for a message.
boolean onConsumerThread = consumerThreadActive &&
(Thread.currentThread().getId() == consumerThreadID);
if(onConsumerThread)
{
currentMatch = match;
currentMatchingMember = matchingMember;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "filterMatches", new Object[] {Boolean.valueOf(match), matchingMember});
return match;
} | java |
public ConsumableKey getMatchingMember(ConsumableKey preferedKey)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getMatchingMember");
ConsumableKey key = null;
// The last move of the getCursor found a match
if(currentMatch)
{
// There was a general waiter so we'll try to use the preferred
// member
if(currentMatchingMember == null)
{
// We can only choose the preferred member if they are not specific
if(!preferedKey.isSpecific())
key = preferedKey;
else if(generalMemberCount > 0)
key = resolvedKey();
}
// The match was to a specific member, we much choose then
else
key = currentMatchingMember;
}
else
{
// There was no match
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getMatchingMember", "SIErrorException");
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.LocalQPConsumerKeyGroup",
"1:982:1.6.1.14" },
null));
}
// We shouldn't be here if we didn't get a match
if(key == null)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getMatchingMember", "SIErrorException");
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.LocalQPConsumerKeyGroup",
"1:995:1.6.1.14" },
null));
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getMatchingMember", key);
return key;
} | java |
public void attachMessage(ConsumableKey consumerKey)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(tc, "attachMessage", msgAttachedMember);
SibTr.exit(tc, "attachMessage", consumerKey);
}
if(msgAttachedMember == null)
msgAttachedMember = consumerKey;
else
{
// We already have a message attached
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "attachMessage", "SIErrorException");
throw new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] {
"com.ibm.ws.sib.processor.impl.LocalQPConsumerKeyGroup",
"1:1027:1.6.1.14" },
null));
}
} | java |
public boolean hasNonSpecificConsumers()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "hasNonSpecificConsumers");
boolean value;
if (generalMemberCount > 0)
value = true;
else
value = false;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "hasNonSpecificConsumers", Boolean.valueOf(value));
return value;
} | java |
@Override
public Object createResource(ResourceInfo info) throws Exception {
ComponentMetaData cData = ComponentMetaDataAccessorImpl.getComponentMetaDataAccessor().getComponentMetaData();
if (cData != null)
applications.add(cData.getJ2EEName().getApplication());
return cloudantSvc.createResource(
(String) props.get("databaseName"),
(Boolean) props.get("create"),
info == null ? ResourceInfo.AUTH_APPLICATION : info.getAuth(),
info == null ? null : info.getLoginPropertyList());
} | java |
public Object getCloudantClient(ResourceInfo info) throws Exception {
return cloudantSvc.getCloudantClient(
info == null ? ResourceInfo.AUTH_APPLICATION : info.getAuth(),
info == null ? null : info.getLoginPropertyList());
} | java |
private URL getRelativePath(FacesContext facesContext, String path) throws IOException
{
URL url = (URL) _relativePaths.get(path);
if (url == null)
{
url = _factory.resolveURL(facesContext, _src, path);
if (url != null)
{
ViewResource viewResource = (ViewResource) facesContext.getAttributes().get(
FaceletFactory.LAST_RESOURCE_RESOLVED);
if (viewResource != null)
{
// If a view resource has been used to resolve a resource, the cache is in
// the ResourceHandler implementation. No need to cache in _relativeLocations.
}
else
{
_relativePaths.put(path, url);
}
}
}
return url;
} | java |
private void include(AbstractFaceletContext ctx, UIComponent parent) throws IOException, FacesException,
FaceletException, ELException
{
ctx.pushPageContext(new PageContextImpl());
try
{
this.refresh(parent);
DefaultFaceletContext ctxWrapper = new DefaultFaceletContext((DefaultFaceletContext)ctx, this, false);
ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctxWrapper);
_root.apply(ctxWrapper, parent);
ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);
this.markApplied(parent);
}
finally
{
ctx.popPageContext();
}
} | java |
public void include(AbstractFaceletContext ctx, UIComponent parent, URL url) throws IOException, FacesException,
FaceletException, ELException
{
DefaultFacelet f = (DefaultFacelet) _factory.getFacelet(ctx, url);
f.include(ctx, parent);
} | java |
@Override
public synchronized void process() throws InjectionException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled())
Tr.entry(tc, "process: " + this);
// -------------------------------------------------------------------
// Determine if it's valid to process the instance or not.
// -------------------------------------------------------------------
if (isAlreadyProcessed) {
if (ivProcessFailure != null) {
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "rethrowing " + ivProcessFailure);
throw new InjectionException(ivProcessFailure.getMessage(), ivProcessFailure);
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "No-opping the .process() method because this ReferenceContext " +
"instance has already been processed.");
return;
}
if (ivProviders.isEmpty()) {
throw new IllegalStateException("Unable to perform reference processing. " +
"The list of input components was empty.");
}
boolean complete = false;
try {
processImpl();
complete = true;
} catch (InjectionException ex) {
ivProcessFailure = ex;
complete = true;
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "process: " + ex);
throw ex;
} finally {
if (complete) {
// Ensure that we only attempt processing once. This will avoid redundant
// work, and will also ensure ComponentNameSpaceConfigurationProvider is
// only called once.
isAlreadyProcessed = true; // F743-17630CodRv
// Remove input objects from memory as they are no longer needed.
// Keep output data structures around, since they need to be retrieved
// by the various containers at unknown point in the future.
ivProviders.clear();
}
}
if (isTraceOn && tc.isEntryEnabled())
Tr.exit(tc, "process");
} | java |
private void createPersistenceMaps(ComponentNameSpaceConfiguration masterCompNSConfig,
List<ComponentNameSpaceConfiguration> compNSConfigs) {
Map<Class<?>, Collection<String>> classesToComponents = new HashMap<Class<?>, Collection<String>>();
Map<String, Collection<String>> persistenceRefsToComponents = new HashMap<String, Collection<String>>();
for (ComponentNameSpaceConfiguration compNSConfig : compNSConfigs) {
ComponentMetaData cmd = compNSConfig.getComponentMetaData();
if (cmd != null) {
String name = cmd.getJ2EEName().getComponent();
if (!compNSConfig.isMetaDataComplete()) {
List<Class<?>> classesToScan = compNSConfig.getInjectionClasses();
if (classesToScan != null) {
for (Class<?> klass : classesToScan) {
for (Class<?> superClass = klass; superClass != null && superClass != Object.class; superClass = superClass.getSuperclass()) {
addComponentToPersistenceMap(classesToComponents, superClass, name);
}
}
}
}
List<? extends PersistenceContextRef> pcRefs = compNSConfig.getPersistenceContextRefs();
if (pcRefs != null) {
for (PersistenceContextRef ref : pcRefs) {
addComponentToPersistenceMap(persistenceRefsToComponents, ref.getName(), name);
}
}
List<? extends PersistenceUnitRef> puRefs = compNSConfig.getPersistenceUnitRefs();
if (puRefs != null) {
for (PersistenceUnitRef ref : puRefs) {
addComponentToPersistenceMap(persistenceRefsToComponents, ref.getName(), name);
}
}
}
}
masterCompNSConfig.setPersistenceMaps(classesToComponents, persistenceRefsToComponents);
} | java |
private String dumpJavaColonCompEnvMap() {
StringBuffer buffer = new StringBuffer("");
buffer.append("EJBContext.lookup data structure contents:\n");
buffer.append(" Contains **" + ivJavaColonCompEnvMap.size() + "** bindings.\n");
if (!ivJavaColonCompEnvMap.isEmpty()) {
Set<Map.Entry<String, InjectionBinding<?>>> entries = ivJavaColonCompEnvMap.entrySet();
Iterator<Map.Entry<String, InjectionBinding<?>>> entryIterator = entries.iterator();
int count = 0;
while (entryIterator.hasNext()) {
Map.Entry<String, InjectionBinding<?>> oneEntry = entryIterator.next();
buffer.append(" Entry " + count + "\n");
buffer.append(" Key: **" + oneEntry.getKey() + "**\n");
buffer.append(" Value: **" + oneEntry.getValue() + "**\n");
buffer.append("\n");
count++;
}
}
return buffer.toString();
} | java |
@Override
public boolean isProcessDynamicNeeded(List<Class<?>> injectionClasses) {
for (Class<?> klass : injectionClasses) {
if (!ivProcessedInjectionClasses.contains(klass)) {
return true;
}
}
return false;
} | java |
public static List<ProvisioningFeatureDefinition> getKernelFeatures(BundleContext ctx, WsLocationAdmin locationService) {
List<ProvisioningFeatureDefinition> result = kernelDefs;
if (result == null) {
result = kernelDefs = getKernelFeatures(ctx, locationService, false);
}
return result;
} | java |
public String download() {
try {
HttpURLConnection conn = getConnection();
return readConnection(conn);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
return null;
} | java |
public OpenAPI downloadModel() throws Exception {
String download = download();
if (download != null) {
try {
SwaggerParseResult parseResult = new OpenAPIParser().readContents(download, null, null, null);
if (parseResult != null) {
return parseResult.getOpenAPI();
}
} catch (Exception e) {
Assert.fail(e.getMessage());
}
return null;
}
return null;
} | java |
public static OpenAPIConnection openAPIDocsConnection(LibertyServer server, boolean secure) {
return new OpenAPIConnection(server, OPEN_API_DOCS).secure(secure);
} | java |
public static OpenAPIConnection openAPIUIConnection(LibertyServer server, boolean secure) {
return new OpenAPIConnection(server, OPEN_API_UI).secure(secure);
} | java |
public void processDrsInbound(long localClock) {
// Is dsrClock timestamp from the remote machine missing
// or was the CE's timestampls already altered?
if (drsClock <= 0) {
return;
}
// Adjust timestamps for this machines clock.
long clockDifference = localClock - drsClock;
if (expirationTime > 0)
expirationTime += clockDifference;
if (timeStamp > 0)
timeStamp += clockDifference;
// Don't allow >1 time alter on this CE.
drsClock = -1;
} | java |
@Override
public synchronized Object getValue() {
if (id != null) {
if (serializedValue != null) {
long oldSize = -1;
if (cacheEntryPool != null) {
if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
oldSize = getObjectSize();
}
}
try {
value = SerializationUtility.deserialize(serializedValue, cacheName);
} catch (Exception ex) {
com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.CacheEntry.getValue", "200", this);
}
if (value != null) {
serializedValue = null;
if (cacheEntryPool != null) {
if (cacheEntryPool.cache.isCacheSizeInMBEnabled()) {
long newSize = getObjectSize();
if (oldSize != -1 && newSize != -1) {
cacheEntryPool.cache.increaseCacheSizeInBytes(newSize - oldSize, "GET_VALUE");
} else {
cacheEntryPool.cache.disableCacheSizeInMB();
}
}
}
}
}
}
return value;
} | java |
protected void setValue(Object value) {
this.value = value;
serializedValue = null;
timeStamp = System.currentTimeMillis();
this.valueHashcode = 0;
} | java |
public void reset() {
if (refCount.get() > 0 && isRefCountingEnabled()) {
Tr.warning(tc, "reset called on " + id + " with a refCount of " + refCount);
Thread.dumpStack();
}
cacheName = null;
drsClock = -1;
timeStamp = -1;
serializedId = null;
id = null;
if (useByteBuffer && this.value != null) {
if (this.value instanceof DistributedNioMapObject) {
((DistributedNioMapObject) this.value).release();
}
}
serializedValue = null;
value = null;
clock = CacheConfig.DEFAULT_PRIORITY;
refCount.set(0);
priority = CacheConfig.DEFAULT_PRIORITY;
timeLimit = -1;
inactivity = -1;
expirationTime = -1;
validatorExpirationTime = -1;
removeWhenUnpinned = false;
_templates = EMPTY_STRING_ARRAY;
_dataIds = EMPTY_OBJECT_ARRAY;
_serializedDataIds = null;
pendingRemoval = false;
sharingPolicy = EntryInfo.NOT_SHARED;
persistToDisk = true;
isOverflowEntry = false;
lruEvicted = false;
lruHead = null;
useByteBuffer = false;
aliasList = EMPTY_OBJECT_ARRAY;
serializedAliasList = null;
userMetaData = null;
serializedUserMetaData = null;
loadedFromDisk = false;
cacheType = CACHE_TYPE_DEFAULT;
skipValueSerialized = false;
skipMemoryAndWriteToDisk = false;
skipMemoryAndWriteToDiskErrorCode = HTODDynacache.NO_EXCEPTION;
valueHashcode = 0;
externalCacheGroupId = null;
} | java |
public void copy(CacheEntry cacheEntry) {
if (cacheEntry == this)
return;
if (useByteBuffer && this.value != null) {
if (this.value instanceof DistributedNioMapObject) {
((DistributedNioMapObject) this.value).release();
}
}
this.value = cacheEntry.value;
this.valueHashcode = cacheEntry.valueHashcode;
this.serializedValue = cacheEntry.serializedValue;
this.serializedId = cacheEntry.serializedId;
timeStamp = cacheEntry.timeStamp;
expirationTime = cacheEntry.expirationTime;
validatorExpirationTime = cacheEntry.validatorExpirationTime;
timeLimit = cacheEntry.timeLimit;
inactivity = cacheEntry.inactivity;
drsClock = cacheEntry.drsClock;
id = cacheEntry.id;
priority = cacheEntry.priority;
if (priority < 0)
priority = 0;
if (priority > CacheConfig.MAX_PRIORITY)
priority = CacheConfig.MAX_PRIORITY;
_templates = cacheEntry._templates;
_dataIds = cacheEntry._dataIds;
_serializedDataIds = cacheEntry._serializedDataIds;
sharingPolicy = cacheEntry.sharingPolicy;
persistToDisk = cacheEntry.persistToDisk;
refCount = new AtomicInteger(cacheEntry.refCount.get());
aliasList = cacheEntry.aliasList;
serializedAliasList = cacheEntry.serializedAliasList;
useByteBuffer = cacheEntry.useByteBuffer;
userMetaData = cacheEntry.userMetaData;
serializedUserMetaData = cacheEntry.serializedUserMetaData;
loadedFromDisk = cacheEntry.loadedFromDisk;
cacheType = cacheEntry.cacheType;
skipValueSerialized = cacheEntry.skipValueSerialized;
skipMemoryAndWriteToDisk = cacheEntry.skipMemoryAndWriteToDisk;
skipMemoryAndWriteToDiskErrorCode = cacheEntry.skipMemoryAndWriteToDiskErrorCode;
vbcSource = cacheEntry.vbcSource;
externalCacheGroupId = cacheEntry.externalCacheGroupId;
//Note: clock is not set here because it's really owned
//by the cache. Only the cache should say when the clock
//changes. It makes the cache code more readable.
} | java |
@Override
public Object getUserMetaData() {
if (serializedUserMetaData != null) {
try {
userMetaData = SerializationUtility.deserialize(serializedUserMetaData, cacheName);
} catch (Exception ex) {
com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.CacheEntry.getUserMetaData", "600", this);
}
serializedUserMetaData = null;
}
return userMetaData;
} | java |
@Override
public long getCacheValueSize() {
long valuesize = -1;
if (this.value != null) {
Object localValue = this.value;
valuesize = ObjectSizer.getSize(localValue);
} else {
if (this.serializedValue != null) {
byte[] localSerializedValue = this.serializedValue;
valuesize = ObjectSizer.getSize(localSerializedValue);
}
}
// System.out.println("Returning cacheValueSize = " + valuesize);
return valuesize;
} | java |
public HttpSession generateNewId(WebApp webapp) {
HttpSession existingSession = (HttpSession) webappToSessionMap.get(webapp);
if (existingSession != null) {
if (!webapp.getSessionContext().isValid(existingSession, request, false)) {
existingSession = null;
}
} else {
// Looks like the session wasn't obtained during the preinvoke
// call. Should only happen if session doesn't exist at preinvoke.
existingSession = webapp.getSessionContext().getIHttpSession(request, (HttpServletResponse) request.getResponse(), false);
}
if ( existingSession == null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isErrorEnabled()) {
Tr.error(tc, "changeSessionId.no.session.associated.with.request", new Object[] {request.getRequestURI()});
}
throw new IllegalStateException(Tr.formatMessage(tc, "changeSessionId.no.session.associated.with.request", request.getRequestURI()));
}
HttpSession session = ((HttpSessionContext31Impl)webapp.getSessionContext()).generateNewId(request, (HttpServletResponse) request.getResponse(), existingSession);
return session;
} | java |
public RecoverableUnitSection lookupSection(int identity)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "lookupSection",new java.lang.Object[]{this,new Integer(identity)});
SQLRecoverableUnitSectionImpl recoverableUnitSection = (SQLRecoverableUnitSectionImpl)_recoverableUnitSections.get(new Integer(identity));
if (tc.isEntryEnabled()) Tr.exit(tc, "lookupSection",recoverableUnitSection);
return recoverableUnitSection;
} | java |
protected synchronized void invoke()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "invoke");
try
{
listener.errorOccurred(exception,
segmentType,
requestNumber,
priority,
conversation);
}
catch(Throwable t)
{
FFDCFilter.processException
(t, "com.ibm.ws.sib.jfapchannel.impl.rldispatcher.ConversationReceiveListenerErrorOccurredInvocation", JFapChannelConstants.CRLERROROCCURREDINVOKE_INVOKE_01);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "exception thrown by conversation receive listener");
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.exception(this, tc, t);
connection.invalidate(true, t, "exception thrown in errorOccurred method - "+t.getMessage()); // D224570
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "invoke");
} | java |
protected synchronized void reset(Connection connection,
ConversationReceiveListener listener,
SIConnectionLostException exception,
int segmentType,
int requestNumber,
int priority,
Conversation conversation)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "reset",
new Object[]
{
connection,
listener,
exception,
""+segmentType,
""+requestNumber,
""+priority,
conversation
});
this.connection = connection;
this.listener = listener;
this.exception = exception;
this.segmentType = segmentType;
this.requestNumber = requestNumber;
this.priority = priority;
this.conversation = conversation;
setDispatchable(null);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "reset");
} | java |
private void _idAdded(String clientId)
{
// An id to visit has been added, update our other
// collections to reflect this.
// Update the ids collection
_ids.add(_getIdFromClientId(clientId));
// Update the unvisited ids collection
_unvisitedClientIds.add(clientId);
// Update the subtree ids collection
_addSubtreeClientId(clientId);
} | java |
private String _getVisitId(UIComponent component)
{
// We first check to see whether the component's id
// is in our id collection. We do this before checking
// for the full client id because getting the full client id
// is more expensive than just getting the local id.
String id = component.getId();
if ((id != null) && !_ids.contains(id))
{
return null;
}
// The id was a match - now check the client id.
// note that client id should never be null (should be
// generated even if id is null, so asserting this.)
String clientId = component.getClientId(getFacesContext());
assert(clientId != null);
return _clientIds.contains(clientId) ? clientId : null;
} | java |
private String _getIdFromClientId(String clientId)
{
final char separator = getFacesContext().getNamingContainerSeparatorChar();
int lastIndex = clientId.lastIndexOf(separator);
String id = null;
if (lastIndex < 0)
{
id = clientId;
}
else if (lastIndex < (clientId.length() - 1))
{
id = clientId.substring(lastIndex + 1);
}
//else
//{
// TODO log warning for trailing colon case
//}
return id;
} | java |
private void _addSubtreeClientId(String clientId)
{
// Loop over the client id and find the substring corresponding to
// each ancestor NamingContainer client id. For each ancestor
// NamingContainer, add an entry into the map for the full client
// id.
final char separator = getFacesContext().getNamingContainerSeparatorChar();
int length = clientId.length();
for (int i = 0; i < length; i++)
{
if (clientId.charAt(i) == separator)
{
// We found an ancestor NamingContainer client id - add
// an entry to the map.
String namingContainerClientId = clientId.substring(0, i);
// Check to see whether we've already ids under this
// NamingContainer client id. If not, create the
// Collection for this NamingContainer client id and
// stash it away in our map
Collection<String> c = _subtreeClientIds.get(namingContainerClientId);
if (c == null)
{
// TODO: smarter initial size?
c = new ArrayList<String>();
_subtreeClientIds.put(namingContainerClientId, c);
}
// Stash away the client id
c.add(clientId);
}
}
} | java |
private void _removeSubtreeClientId(String clientId)
{
// Loop through each entry in the map and check to see whether
// the client id to remove should be contained in the corresponding
// collection - ie. whether the key (the NamingContainer client id)
// is present at the start of the client id to remove.
for (String key : _subtreeClientIds.keySet())
{
if (clientId.startsWith(key))
{
// If the clientId starts with the key, we should
// have an entry for this clientId in the corresponding
// collection. Remove it.
Collection<String> ids = _subtreeClientIds.get(key);
ids.remove(clientId);
}
}
} | java |
@Override
public ORB createServerORB(Map<String, Object> config, Map<String, Object> extraConfig, List<IIOPEndpoint> endpoints, Collection<SubsystemFactory> subsystemFactories) throws ConfigException {
ORB orb = createORB(translateToTargetArgs(config, subsystemFactories), translateToTargetProps(config, extraConfig, endpoints, subsystemFactories));
return orb;
} | java |
@Override
public ORB createClientORB(Map<String, Object> clientProps, Collection<SubsystemFactory> subsystemFactories) throws ConfigException {
return createORB(translateToClientArgs(clientProps, subsystemFactories), translateToClientProps(clientProps, subsystemFactories));
} | java |
private ORB createORB(String[] args, Properties props) {
return ORB.init(args, props);
} | java |
private String[] translateToTargetArgs(Map<String, Object> props, Collection<SubsystemFactory> subsystemFactories) throws ConfigException {
ArrayList<String> list = new ArrayList<String>();
for (SubsystemFactory sf : subsystemFactories) {
sf.addTargetORBInitArgs(props, list);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Configargs: " + list);
}
return list.toArray(new String[list.size()]);
} | java |
private String[] translateToClientArgs(Map<String, Object> clientProps, Collection<SubsystemFactory> subsystemFactories) throws ConfigException {
ArrayList<String> list = new ArrayList<String>();
for (SubsystemFactory sf : subsystemFactories) {
sf.addClientORBInitArgs(clientProps, list);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Configargs: " + list);
}
return list.toArray(new String[list.size()]);
} | java |
private Properties translateToClientProps(Map<String, Object> clientProps, Collection<SubsystemFactory> subsystemFactories) throws ConfigException {
Properties result = createYokoORBProperties();
for (SubsystemFactory sf : subsystemFactories) {
addInitializerPropertyForSubsystem(result, sf, false);
sf.addClientORBInitProperties(result, clientProps);
}
return result;
} | java |
public static String getName() {
String secname = null;
WSCredential credential = getCallerWSCredential();
try {
if (credential != null && !credential.isUnauthenticated()) {
String realmSecname = credential.getRealmSecurityName();
if (realmSecname != null && !realmSecname.isEmpty()) {
secname = realmSecname.substring(realmSecname.lastIndexOf(REALM_SEPARATOR) + 1);
}
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Internal error: " + e);
}
return secname;
} | java |
public static String getUser() {
String accessid = null;
WSCredential credential = getCallerWSCredential();
try {
if (credential != null && !credential.isUnauthenticated())
accessid = credential.getAccessId();
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Internal error: " + e);
}
return accessid;
} | java |
private Boolean compareListValues( // was BooleanValue
Object firstVal,
Object secondVal,
boolean lessThan,
boolean permissive,
boolean overallTrue) // If true we are searching for at least one TRUE result, else at least one FALSE.
{
if (tc.isAnyTracingEnabled() && tc.isEntryEnabled())
tc.entry(cclass,
"compareListValues",
new Object[] { firstVal,
secondVal,
new Boolean(lessThan),
new Boolean(permissive),
new Boolean(overallTrue) });
Boolean finalReturn = null;
// Drive the compare() method
Boolean compReturn = compare(firstVal, secondVal, lessThan, permissive);
if(compReturn != null)
{
if(overallTrue)
{
if (compReturn.equals(Boolean.TRUE))
{
// We've found a pair that meet the criteria
finalReturn = Boolean.TRUE;
}
}
else
{
if (compReturn.equals(Boolean.FALSE))
{
// We've found a pair that meet the criteria
finalReturn = Boolean.TRUE;
}
}
}
if (tc.isAnyTracingEnabled() && tc.isEntryEnabled())
tc.exit(cclass, "compareListValues", finalReturn);
return finalReturn;
} | java |
private URL setURL(URL url) throws RepositoryIllegalArgumentException {
int port = url.getPort();
if (port == -1) {
throw new RepositoryIllegalArgumentException("Bad proxy URL", new IllegalArgumentException("Proxy URL does not contain a port"));
}
String host = url.getHost();
if (host.equals("")) {
throw new RepositoryIllegalArgumentException("Bad proxy URL", new IllegalArgumentException("Proxy URL does not contain a host"));
}
return url;
} | java |
protected void setMBean(ServiceReference<?> ref) {
// Use "jmx.objectname" for determining the ObjectName to be consistent with Apache Aries.
Object jmxObjectName = ref.getProperty("jmx.objectname");
if (jmxObjectName instanceof String) {
try {
// Construct an ObjectName from the "jmx.objectname" property and register the MBean.
ObjectName name = new ObjectName((String) jmxObjectName);
setServiceReferenceInternal(ref, name);
} catch (MalformedObjectNameException e) {
// One of our MBeans had a bad ObjectName.
// TODO: trace, FFDC?
}
} else {
// REVISIT: "jmx.objectname" was not specified or was not in
// the right format. Ignoring this MBean for now since we don't
// have an ObjectName. Possible that this MBean is a
// javax.management.MBeanRegistration, do we want to try to
// register it that way?
}
} | java |
public void printStackToDebug() {
Throwable t = new Throwable();
StackTraceElement[] ste = t.getStackTrace();
int start = (ste.length > 6) ? 6 : ste.length;
for (int i = start; i >= 1; i--) {
Tr.debug(tc, "Calling Stack Element[" + i + "]: " + ste[i]);
}
} | java |
public void setPoolManagerRef(WsByteBufferPoolManagerImpl oManagerRef) {
this.oWsByteBufferPoolManager = oManagerRef;
this.trusted = oManagerRef.isTrustedUsers();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "setPoolManagerRef: trusted=" + this.trusted);
}
} | java |
public void setDirectShadowBuffer(ByteBuffer buffer) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "setDirectShadowBuffer");
}
if (!this.trusted)
checkValidity();
this.oWsBBDirect = buffer;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "setDirectShadowBuffer");
}
} | java |
public void setParmsToDirectBuffer() {
if (oByteBuffer.isDirect()) {
this.oWsBBDirect = this.oByteBuffer;
return;
}
if (oWsBBDirect == null) {
this.oWsBBDirect = ByteBuffer.allocateDirect(oByteBuffer.capacity());
}
// set the position and limit
this.oWsBBDirect.limit(oByteBuffer.limit());
this.oWsBBDirect.position(oByteBuffer.position());
} | java |
private void taskHostStatus(RESTRequest request, RESTResponse response) {
String taskID = RESTHelper.getRequiredParam(request, APIConstants.PARAM_TASK_ID);
String host = RESTHelper.getRequiredParam(request, APIConstants.PARAM_HOST);
String taskHostStatusJson = getMultipleRoutingHelper().getHostDetails(taskID, host);
OutputHelper.writeJsonOutput(response, taskHostStatusJson);
} | java |
protected void prepareExpansion() throws IOException {
WsResource expansionResource = deployedAppServices.getLocationAdmin().resolveResource(AppManagerConstants.EXPANDED_APPS_DIR);
expansionResource.create();
} | java |
@Override
public DeployedAppInfo createDeployedAppInfo(ApplicationInformation<DeployedAppInfo> appInfo)
throws UnableToAdaptException {
String appPid = appInfo.getPid();
String appName = appInfo.getName();
String appPath = appInfo.getLocation();
File appFile = new File(appPath);
Tr.debug(_tc, "Create deployed application:" +
" PID [ " + appPid + " ]" +
" Name [ " + appName + " ]" +
" Location [ " + appPath + " ]");
Container appContainer = appInfo.getContainer();
Container originalAppContainer = null;
// If enabled by an attribute of the application manager configuration,
// expand the application.
//
// Expansion is possible if the application file is not already a directory, and is
// not loosely configuration.
if ( applicationManager.getExpandApps() && isArchive(appFile, appPath) ) {
try {
prepareExpansion();
WsResource expandedResource = resolveExpansion(appName);
File expandedFile = expandedResource.asFile();
expand(appName, appFile, expandedResource, expandedFile);
originalAppContainer = appContainer;
appContainer = deployedAppServices.setupContainer(appPid, expandedFile);
} catch ( IOException e ) {
Tr.error(_tc, "warning.could.not.expand.application", appName, e.getMessage());
}
}
Application applicationDD;
try {
applicationDD = appContainer.adapt(Application.class); // throws UnableToAdaptException
// Null when there is no application descriptor.
} catch ( UnableToAdaptException e ) {
// CWWKZ0113E: Application {0}: Parse error for application descriptor {1}: {2}
Tr.error(_tc, "error.application.parse.descriptor", appName, "META-INF/application.xml", e);
throw e;
}
InterpretedContainer jeeContainer;
if ( appContainer instanceof InterpretedContainer ) {
jeeContainer = (InterpretedContainer) appContainer;
} else {
jeeContainer = appContainer.adapt(InterpretedContainer.class);
}
// Set a structure helper for modules that might be expanded inside
// (e.g., x.ear/y.war or x.ear/y.jar/).
if ( applicationDD == null ) {
jeeContainer.setStructureHelper( EARStructureHelper.getUnknownRootInstance() );
} else {
List<String> modulePaths = new ArrayList<String>();
for ( Module module : applicationDD.getModules() ) {
modulePaths.add( module.getModulePath() );
}
jeeContainer.setStructureHelper( EARStructureHelper.create(modulePaths) );
}
appInfo.setContainer(jeeContainer);
EARDeployedAppInfo deployedApp =
new EARDeployedAppInfo(appInfo, applicationDD, this, deployedAppServices, originalAppContainer);
appInfo.setHandlerInfo(deployedApp);
return deployedApp;
} | java |
protected String createCssContentString() {
StringBuilder css = new StringBuilder();
css.append("<style>");
// body
css.append("body {");
css.append("background-color: #152935;");
css.append("font-family: serif;");
css.append("margin: 0;");
css.append("}\n");
// #top, #bottom
css.append("#top, #bottom {");
css.append("padding: 20px;");
css.append("}\n");
css.append("");
// #top-middle, #bottom-middle
css.append("#top-middle, #bottom-middle {");
css.append("background-color: #001428;");
css.append("padding: 10px;");
css.append("}\n");
css.append("");
// .container
css.append(".container {");
css.append("background-color: white;");
css.append("padding: 20px 50px;");
css.append("}\n");
// .error
css.append(".error {");
css.append("color: red;");
css.append("font-weight: bold;");
css.append("}\n");
css.append("</style>");
return css.toString();
} | java |
public void complete(VirtualConnection vc, TCPReadRequestContext req) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "complete() called: vc=" + vc);
}
HttpOutboundServiceContextImpl mySC = (HttpOutboundServiceContextImpl) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPOSC);
// keep reading and handling new data until either we're done
// parsing headers or until we're waiting on a read to finish
VirtualConnection readVC = null;
try {
do {
if (mySC.parseMessage()) {
// start processing the new parsed message
mySC.handleParsedMessage();
return;
}
// not done parsing, read for more data
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Reading for more data");
}
// configure the buffers for reading
mySC.setupReadBuffers(mySC.getHttpConfig().getIncomingHdrBufferSize(), false);
readVC = req.read(1, this, false, mySC.getReadTimeout());
} while (null != readVC);
} catch (Exception e) {
FFDCFilter.processException(e, getClass().getName() + ".complete", "112", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Caught exception: " + e.getMessage());
}
mySC.setPersistent(false);
mySC.getAppWriteCallback().error(vc, e);
}
} | java |
protected void reConnect(VirtualConnection inVC, IOException ioe) {
if (getLink().isReconnectAllowed()) {
// start the reconnect
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Attempting reconnect: " + getLink().getVirtualConnection());
}
// 359362 - null out the JIT read buffers
getTSC().getReadInterface().setBuffer(null);
getLink().reConnectAsync(ioe);
} else {
callErrorCallback(inVC, ioe);
}
} | java |
void callErrorCallback(VirtualConnection inVC, IOException ioe) {
// otherwise pass the error along to the channel above us, or close
// the connection if nobody is above
setPersistent(false);
if (this.bEarlyReads && null != getAppReadCallback()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Early read failure calling error() on appside");
}
getAppReadCallback().error(inVC, ioe);
} else if (null != getAppWriteCallback()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Calling write.error() on appside");
}
getAppWriteCallback().error(inVC, ioe);
} else {
// nobody above us, just close the connection
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "No appside, closing connection");
}
getLink().getDeviceLink().close(inVC, ioe);
}
} | java |
private boolean resetWriteBuffers() {
int stop = getPendingStop();
WsByteBuffer[] list = getPendingBuffers();
// verify we can actually attempt the re-write
if (null == this.positionList || null == list) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Error in resetBuffers: posList: " + this.positionList + " list: " + list);
}
getTSC().getWriteInterface().setBuffer(null);
return false;
}
// reset positions in each of the buffers
for (int i = 0; i < stop; i++) {
list[i].position(this.positionList[i]);
}
getTSC().getWriteInterface().setBuffers(list);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Reset positions on (" + stop + ") write buffers");
}
return true;
} | java |
protected void nowReconnectedAsync() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Reconnected async for " + this);
}
// reset the data buffers first
if (!resetWriteBuffers()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Resetting buffers (async) failed");
}
// otherwise pass the error along to the channel above us, or close
// the connection if nobody is above
IOException ioe = new IOException("Failed reconnect");
if (null != getAppWriteCallback()) {
getAppWriteCallback().error(getVC(), ioe);
} else {
// nobody above us, just close the connection
getLink().getDeviceLink().close(getVC(), ioe);
}
return;
}
// now that we've reconnected, we should reset the "broken" flag. First
// we set it to the default and then recheck the request msg
setPersistent(true);
updatePersistence(getRequestImpl());
// in case we previously read any partial data, clean out the response
resetRead();
// attempt to write the data
VirtualConnection rc = getTSC().getWriteInterface().write(TCPWriteRequestContext.WRITE_ALL_DATA, HttpOSCWriteCallback.getRef(), isForceAsync(), getWriteTimeout());
if (null != rc) {
// if we've finished writing part of a request, let the channel
// above know that it can write more, otherwise start the read
// for the response
if (!isMessageSent()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Calling callback.complete of app channel.");
}
getAppWriteCallback().complete(getLink().getVirtualConnection());
} else {
if (isReadAheadEnabled()) {
// after a reconnect, there is no more read-ahead active
this.bReadAheadEnabled = false;
}
// force an async read for the response now. Avoid trying to
// re-use any existing read buffer to skip complexity with
// adjusting for partial reads before the reconnect.
setupJITRead(getHttpConfig().getIncomingHdrBufferSize());
getTSC().getReadInterface().read(1, HttpOSCReadCallback.getRef(), true, getReadTimeout());
}
}
} | java |
protected void nowReconnectedSync(IOException originalExcep) throws IOException {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Reconnected sync for " + this);
}
if (!resetWriteBuffers()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Resetting buffers (sync) failed");
}
throw originalExcep;
}
// now that we've reconnected, we should reset the "broken" flag. First
// we set it to the default and then recheck the request msg
setPersistent(true);
updatePersistence(getRequestImpl());
// Note: during a sync path, we don't actually enable reconnects once
// we start reading and parsing the response (only async path)
// in case we read any partial data, we need to clean out the response
// resetRead();
if (isReadAheadEnabled()) {
// after a reconnect, there is no more read-ahead active
this.bReadAheadEnabled = false;
}
try {
getTSC().getWriteInterface().write(TCPWriteRequestContext.WRITE_ALL_DATA, getWriteTimeout());
} catch (IOException ioe) {
// no FFDC required
// just set the "broken" connection flag
setPersistent(false);
throw ioe;
}
} | java |
private VirtualConnection startEarlyRead(InterChannelCallback cb, boolean forceQueue) {
// disallow rewrites once we start mixing the request and temp responses
getLink().disallowRewrites();
setAppReadCallback(cb);
// check for an existing final response
if (headersParsed() && !getResponseImpl().isTemporaryStatusCode()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "earlyRead: Final response already received.");
}
if (forceQueue) {
cb.complete(getVC());
return null;
}
return getVC();
}
// otherwise, if a message is already parsed, then the assumption is
// that the app channel above has already looked at it and is now asking
// for the next, so clear out the previous message and start a read
if (headersParsed()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "earlyRead: Message exists, isOwner: " + isResponseOwner());
}
resetMsgParsedState();
if (!isResponseOwner()) {
// null our reference as not being owner means another SC has this
// message already (i.e. the proxy passed it to the inbound
// side) and then create the new object
setMyResponse(null);
getResponseImpl();
} else {
// otherwise clear the existing response
getResponseImpl().clear();
}
}
// start the read/parse cycle for the next response message
VirtualConnection vc = parseResponseMessageAsync();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "earlyRead: return vc=" + vc);
}
if (null != vc && forceQueue) {
cb.complete(getVC());
return null;
}
return vc;
} | java |
@Override
public void setRequest(HttpRequestMessage msg) throws IllegalRequestObjectException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "setRequest: " + msg);
}
// null message isn't allowed
if (null == msg) {
throw new IllegalRequestObjectException("Illegal null message");
}
HttpRequestMessageImpl temp = null;
try {
temp = (HttpRequestMessageImpl) msg;
} catch (ClassCastException cce) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Non msg impl passed to setRequest");
}
throw new IllegalRequestObjectException("Invalid message provided");
}
// possibly clean up any existing request object
if (null != getMyRequest() && isRequestOwner()) {
if (!getMyRequest().equals(temp)) {
getMyRequest().destroy();
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Caller overlaying same message");
}
}
}
// set the new object in place
setMyRequest(temp);
// 335554 : the message init() will overwrite the version based on config
// and needs to be reset back to whatever we started with here.
VersionValues version = temp.getVersionValue();
getMyRequest().init(this);
getMyRequest().setVersion(version);
updatePersistence(getMyRequest());
getResponseImpl().setHeaderChangeLimit(getMyRequest().getHeaderChangeLimit());
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "setRequest");
}
} | java |
@Override
public void sendRequestHeaders() throws IOException, MessageSentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "sendRequestHeaders(sync)");
}
if (headersSent()) {
throw new MessageSentException("Headers already sent");
}
setPartialBody(true);
getLink().setAllowReconnect(true);
try {
sendHeaders(getRequestImpl());
} catch (IOException e) {
// no FFDC required
reConnect(e);
}
// check to see if we need to read the response now
if (shouldReadResponseImmediately()) {
startResponseReadSync();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "sendRequestHeaders(sync)");
}
} | java |
@Override
public VirtualConnection sendRequestHeaders(InterChannelCallback callback, boolean bForce) throws MessageSentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "sendRequestHeaders(async)");
}
if (headersSent()) {
throw new MessageSentException("Headers already sent");
}
setPartialBody(true);
getLink().setAllowReconnect(true);
setForceAsync(bForce);
setAppWriteCallback(callback);
VirtualConnection vc = sendHeaders(getRequestImpl(), HttpOSCWriteCallback.getRef());
// Note: if forcequeue is true, then we will not get a VC object as
// the lower layer will use the callback and return null
if (null != vc && shouldReadResponseImmediately()) {
// write worked already and we need to read the response headers now
vc = startResponseRead();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "sendRequestHeaders(async): " + vc);
}
return vc;
} | java |
@Override
public void sendRequestBody(WsByteBuffer[] body) throws IOException, MessageSentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "sendRequestBody(sync)");
}
if (isMessageSent()) {
throw new MessageSentException("Message already sent");
}
// if headers haven't been sent, set for partial body transfer
if (!headersSent()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Setting partial body true");
}
setPartialBody(true);
}
getLink().setAllowReconnect(true);
try {
sendOutgoing(body, getRequestImpl());
} catch (IOException e) {
// no FFDC necessary
reConnect(e);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "sendRequestBody(sync)");
}
} | java |
@Override
public VirtualConnection sendRequestBody(WsByteBuffer[] body, InterChannelCallback callback, boolean bForce) throws MessageSentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "sendRequestBody(async)");
}
if (isMessageSent()) {
throw new MessageSentException("Message already sent");
}
// if headers haven't been sent, then set for partial body transfer
if (!headersSent()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Setting partial body true");
}
setPartialBody(true);
}
getLink().setAllowReconnect(true);
setForceAsync(bForce);
setAppWriteCallback(callback);
VirtualConnection vc = sendOutgoing(body, getRequestImpl(), HttpOSCWriteCallback.getRef());
// Note: if forcequeue is true, then we will not get a VC object as
// the lower layer will use the callback and return null
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "sendRequestBody(async): " + vc);
}
return vc;
} | java |
@Override
public void finishRequestMessage(WsByteBuffer[] body) throws IOException, MessageSentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "finishRequestMessage(sync)");
}
if (isMessageSent()) {
throw new MessageSentException("Message already sent");
}
// if headers haven't been sent and chunked encoding is not explicitly
// configured, then set this up for Content-Length
if (!headersSent()) {
if (!getRequestImpl().isChunkedEncodingSet()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Setting partial body false");
}
setPartialBody(false);
}
}
if (getHttpConfig().runningOnZOS()) {
// @LIDB3187-27.1
// add this to notify the xmem channel of our final request write
getVC().getStateMap().put(HttpConstants.FINAL_WRITE_MARK, "true");
}
getLink().setAllowReconnect(true);
try {
sendFullOutgoing(body, getRequestImpl());
} catch (IOException e) {
// no FFDC required
reConnect(e);
}
// LI4335 - if early reads are going, then do not bother with response
// message information here
if (this.bEarlyReads) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "finishRequestMessage(sync): early read is active");
}
return;
}
// if the headers are already parsed, then check to see if we should
// immediately notify the app channel or start a read for the next
// response.
if (headersParsed()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Response headers already parsed");
}
if (this.bTempResponsesUsed || !getResponseImpl().isTemporaryStatusCode()) {
// app channel wants to see all the responses
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "finishRequestMessage(sync): already parsed");
}
return;
}
// the app channel does not want to see the previously parsed msg
resetRead();
readSyncResponse();
} else {
// read for the first response
startResponseReadSync();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "finishRequestMessage(sync)");
}
} | java |
@Override
public VirtualConnection finishRequestMessage(WsByteBuffer[] body, InterChannelCallback callback, boolean bForce) throws MessageSentException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "finishRequestMessage(async)");
}
if (isMessageSent()) {
throw new MessageSentException("Message already sent");
}
// if headers haven't been sent and chunked encoding is not explicitly
// configured, then set this up for Content-Length
if (!headersSent()) {
if (!getRequestImpl().isChunkedEncodingSet()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Setting partial body false");
}
setPartialBody(false);
}
}
if (getHttpConfig().runningOnZOS()) {
// @LIDB3187-27.1
// add this to notify the xmem channel of our final request write
getVC().getStateMap().put(HttpConstants.FINAL_WRITE_MARK, "true");
}
setForceAsync(bForce);
getLink().setAllowReconnect(true);
setAppWriteCallback(callback);
VirtualConnection vc = sendFullOutgoing(body, getRequestImpl(), HttpOSCWriteCallback.getRef());
if (null != vc) {
// Note: if forcequeue is true, then we will not get a VC object as
// the lower layer will use the callback and return null
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Request write completed immediately.");
}
// LI4335 - if early reads are going, then do not bother with response
// message information here
if (this.bEarlyReads) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "finishRequestMessage(async): early read is active");
}
return getVC();
}
// if headers are parsed and this is a final response, exit out.
// if a temp response and using temps, return out. If temp and not
// using temps, keep reading for final
if (headersParsed()) {
if (this.bTempResponsesUsed || !getResponseImpl().isTemporaryStatusCode()) {
// app channel wants to see all the responses
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "finishRequestMessage(async): already parsed");
}
return getVC();
}
// the app channel does not want to see the previously parsed msg
resetRead();
readAsyncResponse();
vc = null;
} else {
// start the read for the first response
vc = startResponseRead();
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "finishRequestMessage(async): " + vc);
}
return vc;
} | java |
private HttpInvalidMessageException checkRequestValidity() {
if (shouldReadResponseImmediately()) {
// ignore body validation as this might happen after sending only
// the headers if 100-continue, Upgrade, immediate-read, etc.
return null;
}
long len = getRequest().getContentLength();
long num = getNumBytesWritten();
if (HeaderStorage.NOTSET != len && num != len) {
// content-length does not match the number of bytes sent, have to
// close the connection since the other end won't be able to read
// the body properly
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Request had content-length of " + len + " but sent " + num);
}
setPersistent(false);
return new HttpInvalidMessageException("Request length " + len + " but sent " + num);
}
return null;
} | java |
VirtualConnection parseResponseMessageAsync() {
VirtualConnection readVC = null;
try {
do {
if (parseMessage()) {
// finished parsing the message
return getVC();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Reading for more data to parse");
}
// configure the buffers for reading
setupReadBuffers(getHttpConfig().getIncomingHdrBufferSize(), false);
readVC = getTSC().getReadInterface().read(1, HttpOSCReadCallback.getRef(), false, getReadTimeout());
} while (null != readVC);
} catch (Exception e) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception while parsing response: " + e);
}
setPersistent(false);
// LI4335 - early reads also use read callback
if (this.bEarlyReads || this.bTempResponsesUsed) {
getAppReadCallback().error(getVC(), e);
} else {
getAppWriteCallback().error(getVC(), e);
}
return null;
}
// getting here means an async read is in-progress
return null;
} | java |
private void parseResponseMessageSync() throws IOException {
// if read buffers are available, then attempt a parse otherwise go
// into the "read data then parse" loop
if (isReadDataAvailable()) {
try {
// if data is already available, don't modify the buffer
if (parseMessage()) {
this.numResponsesReceived++;
return;
}
} catch (IOException ioe) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "IOException while parsing response: " + ioe);
}
throw ioe;
} catch (Exception e) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception while parsing response: " + e);
}
throw new IOException(e.getMessage(), e);
}
}
// keep reading and parsing until we're done
while (true) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Reading for data to parse");
}
try {
// configure the buffers for reading
setupReadBuffers(getHttpConfig().getIncomingHdrBufferSize(), false);
getTSC().getReadInterface().read(1, getReadTimeout());
} catch (IOException ioe) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception while reading response: " + ioe);
}
reConnect(ioe);
}
try {
if (parseMessage()) {
// finished parsing the message
this.numResponsesReceived++;
return;
}
} catch (IOException ioe) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "IOException while parsing response: " + ioe);
}
throw ioe;
} catch (Exception e) {
// no FFDC required
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception while parsing response: " + e);
}
throw new IOException(e.getMessage(), e);
}
}
} | java |
private boolean checkBodyValidity() throws IOException {
// LI4335 - allow response body reading if early reads are in place
if (isImmediateReadEnabled() || this.bEarlyReads) {
if (!headersParsed()) {
// this means they are requesting body buffers prior to sending
// the minimum request headers
IOException ioe = new IOException("Request headers not sent yet");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Attempt to read response prior to sendRequest");
}
throw ioe;
}
// otherwise continue as normal
} else if (!isMessageSent()) {
// request message must be fully sent prior to reading any part of
// the response body
IOException ioe = new IOException("Request not finished yet");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Attempt to read response prior to finishRequest");
}
throw ioe;
}
// check to see if we should be reading for data
return isIncomingBodyValid();
} | java |
protected void wakeupReadAhead() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Received synchronous read-ahead wake-up call.");
}
synchronized (this.readAheadSyncer) {
this.readAheadSyncer.notify();
}
} | java |
private void prepareForCaller(IdentifierType id, String qualifiedEntityType, String uid, String uName,
boolean isIgnoreRepositoryErrors, Set<String> failureRepositoryIds) throws WIMException {
String METHODNAME = "prepareForCaller";
if (id != null) {
String externalId = id.getExternalId();
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " prepare identifier for caller, set [uniqueId="
+ externalId + "]");
}
if (externalId != null) {
id.setUniqueId(externalId);
}
id.setExternalId(null);
}
} | java |
private Entity innerRetrieveEntityFromRepository(Root root, Entity retEntDO, String uniqueId, boolean isAllowOperationIfReposDown,
Set<String> failureRepositoryIds) throws WIMException {
String METHODNAME = "retrieveEntityFromRepository";
List<String> reposIds = getRepositoryManager().getRepoIds();
for (int i = 0; (i < reposIds.size() && retEntDO == null); i++) {
String reposId = reposIds.get(i);
try {
Root retRoot = getRepositoryManager().getRepository(reposId).get(root);
if (retRoot != null) {
List<Entity> entList = retRoot.getEntities();
if (entList.size() >= 1) {
retEntDO = entList.get(0);
}
}
} catch (EntityNotFoundException e) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " EntityNotFoundException[reposId=" + reposId + "] - " + uniqueId);
}
} catch (WIMSystemException wse) {
String message = wse.getMessage();
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " WSE message = " + message);
}
if (message != null && message.contains("CWIML4520E") && message.contains("javax.naming.InvalidNameException")) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, METHODNAME + " WIMSystemException [reposId=" + reposId + "] - " + message);
}
} else
throw wse;
} catch (Exception e) {
if (!isAllowOperationIfReposDown) {
if (e instanceof WIMException) {
throw (WIMException) e;
}
throw new WIMException(e);
} else {
if (tc.isDebugEnabled())
Tr.debug(tc, METHODNAME + " IGNORE: exception [" + e.getMessage()
+ "] when retrieve entity from repository [" + reposId + "]");
failureRepositoryIds.add(reposId);
}
}
}
return retEntDO;
} | java |
private String getRealmNameOrFirstBest(Root root) {
String value = null;
value = getRealmName(root);
if (value == null) {
try {
value = getRealmName();
} catch (Exception e) {
// leave realm at null
}
}
return value;
} | java |
@FFDCIgnore({ EntityNotFoundException.class, Exception.class })
private String getUniqueNameByUniqueId(String uniqueId, boolean isAllowOperationIfReposDown, Set<String> failureRepositoryIds) throws WIMException {
final String METHODNAME = "getUniqueNameByUniqueId";
String uniqueName = null;
boolean found = false;
int i = 0;
Root temp = new Root();
Entity entity = new Entity();
IdentifierType id = new IdentifierType();
id.setExternalId(uniqueId);
entity.setIdentifier(id);
temp.getEntities().add(entity);
List<String> repositoryIds = repositoryManager.getRepoIds();
while (i < repositoryIds.size() && !found) {
try {
Root returnedRoot = repositoryManager.getRepository(repositoryIds.get(i)).get(temp);
if (returnedRoot != null) {
List<Entity> pes = returnedRoot.getEntities();
if (pes != null) {
Entity ent = pes.get(0);
if (ent != null) {
IdentifierType entityId = ent.getIdentifier();
if (entityId != null) {
uniqueName = entityId.getUniqueName();
found = true;
}
}
}
}
} catch (EntityNotFoundException e) {
// Move on to the next repository
i++;
} catch (Exception e) {
if (!isAllowOperationIfReposDown) {
if (e instanceof WIMException) {
throw (WIMException) e;
}
throw new WIMException(e);
} else {
if (tc.isDebugEnabled())
Tr.debug(tc, METHODNAME + " IGNORE: exception [" + e.getMessage()
+ "] on repository [" + repositoryIds.get(i) + "]");
failureRepositoryIds.add(repositoryIds.get(i));
// Move on to the next repository
i++;
}
}
}
return uniqueName;
} | java |
void initResolve() {
featureNamesToResolve = new HashSet<>();
samplesToInstall = new ArrayList<>();
resolvedFeatures = new HashMap<>();
requestedFeatureNames = new HashSet<>();
featuresMissing = new ArrayList<>();
resourcesWrongProduct = new ArrayList<>();
requirementsFoundForOtherProducts = new HashSet<>();
missingTopLevelRequirements = new ArrayList<>();
missingRequirements = new ArrayList<>();
resolverRepository.clearPreferredVersions();
} | java |
List<List<RepositoryResource>> createInstallLists() {
List<List<RepositoryResource>> installLists = new ArrayList<>();
// Create install list for each sample
for (SampleResource sample : samplesToInstall) {
installLists.add(createInstallList(sample));
}
// Create install list for each requested feature
for (String featureName : requestedFeatureNames) {
List<RepositoryResource> installList = createInstallList(featureName);
// May get an empty list if the requested feature is already installed
if (!installList.isEmpty()) {
installLists.add(installList);
}
}
// Create install list for each autofeature which wasn't explicitly requested (otherwise we'd have covered it above) and isn't already installed
for (ProvisioningFeatureDefinition feature : resolvedFeatures.values()) {
if (feature.isAutoFeature() && !requestedFeatureNames.contains(feature.getSymbolicName()) && feature instanceof KernelResolverEsa) {
installLists.add(createInstallList(feature.getSymbolicName()));
}
}
return installLists;
} | java |
public final synchronized long nextId(Object obj)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "nextId", obj);
long id = _idCount++;
// Keep incrementing the id until we
// find one that hasn't been reserved.
while (_idMap.get(id) != null)
{
id = _idCount++;
}
// Add the new id to the map associating
// it with the given object.
_idMap.put(id, obj);
if (tc.isEntryEnabled()) Tr.exit(tc, "nextId", new Long(id));
return id;
} | java |
public final synchronized void removeId(long id)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "removeId", new Long(id));
_idMap.remove(id);
if (tc.isEntryEnabled()) Tr.exit(tc, "removeId");
} | java |
public final synchronized boolean reserveId(long id, Object obj)
{
if (tc.isEntryEnabled()) Tr.entry(tc, "reserveId", new Object[] {new Long(id), obj});
boolean reserved = false;
// The id can only be reserved if it
// isn't already in the map
if (_idMap.get(id) == null)
{
_idMap.put(id, obj);
reserved = true;
}
if (tc.isEntryEnabled()) Tr.exit(tc, "reserveId", new Boolean(reserved));
return reserved;
} | java |
public final synchronized Object[] getAllObjects()
{
if (tc.isEntryEnabled()) Tr.entry(tc, "getAllObjects");
Object[] values = _idMap.values();
if (tc.isEntryEnabled()) Tr.exit(tc, "getAllObjects", values);
return values;
} | java |
public synchronized Object getCacheKey(EvictionTableEntry evt) //3821 NK begin
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
Object key = null;
if (filemgr == null) {
throw new HashtableOnDiskException("No Filemanager");
}
HashtableEntry e = findEntry(evt, RETRIEVE_KEY);
//TODO: Do we need to increment read_hits and read_requests
if (e != null)
key = e.getKey();
return key;
} | java |
public synchronized boolean remove(Object key)
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
if (filemgr == null) {
throw new HashtableOnDiskException("No Filemanager");
}
if (key == null)
return false; // no null keys allowed
HashtableEntry e = findEntry(key, RETRIEVE_KEY, !CHECK_EXPIRED);
if (e == null)
return false; // not found
boolean answer = remove(e);
htoddc.returnToHashtableEntryPool(e);
return answer;
} | java |
public synchronized boolean updateExpirationInHeader(Object key, long expirationTime, long validatorExpirationTime)
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
if (filemgr == null) {
throw new HashtableOnDiskException("No Filemanager");
}
if (key == null)
return false; // no null keys allowed
HashtableEntry entry = findEntry(key, RETRIEVE_KEY, !CHECK_EXPIRED);
if (entry == null)
return false; // not found
//
// Seek to point to validator expiration time field in the header
filemgr.seek(entry.location +
DWORDSIZE + // room for next
SWORDSIZE); // room for hash
filemgr.writeLong(validatorExpirationTime); // update VET
/*
* comment out the code below because the expiration time does not change
* filemgr.writeInt(0);
* filemgr.writeInt(entry.cacheValueHashcode); // update cache value hashcode
* filemgr.writeLong(entry.first_created); // update first created (not neccessary but move to pointer
* filemgr.writeLong(expirationTime); // update RET
*/
htoddc.returnToHashtableEntryPool(entry);
return true;
} | java |
int walkHash(HashtableAction action, int retrieveMode, int index, int length)
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
iterationLock.p();
int tindex = -1;
int tableSize = header.tablesize();
//System.out.println("*** table size= " + tableSize + " index=" + index + " length=" + length);
try {
for (int i = index, j = 0; i < tableSize; i++) {
//
// We want to drop the lock between each iteration so that other
// threads can continue to work
//
boolean result = true;
synchronized (this) {
long location = getHtindex(i, header.currentTableId());
long previous = 0;
long next = 0;
int hash = 0;
initReadBuffer(location);
next = headerin.readLong();
hash = headerin.readInt();
while (location != 0) {
HashtableEntry e = readEntry2(location, next, hash, previous, retrieveMode, !CHECK_EXPIRED, header.currentTableId(), null, null);
if (e != null) {
j++;
try {
Object id = e.getKey();
result = action.execute(e);
// if result is false, do not continue
if (result == false) { // LI4337-17
traceDebug("walkHash()", "cacheName=" + this.htoddc.cacheName + " id=" + id + " action.execute() returns false.");
break;
}
} catch (Exception xcp) {
throw new HashtableOnDiskException("HashtableAction: " + xcp.toString());
}
previous = location;
location = next;
if (location != 0) {
initReadBuffer(location);
next = headerin.readLong();
hash = headerin.readInt();
}
}
}
// if result is false, do not continue
if (result == false) { // LI4337-17
break;
}
if (j >= length) {
tindex = i + 1;
break;
}
}
}
} finally {
iterationLock.v();
}
if (tindex == -1) {
tindex = tableSize;
}
//System.out.println("*** HTOD return index=" + tindex + " tableSize=" + tableSize);
return tindex;
} | java |
public void listfiles(Writer o)
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
ListAction act = new ListAction(o);
walkHash(act, RETRIEVE_KEY, 0, -1);
} | java |
private void countAndVerifyObjects()
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
println("countAndVerifyObjects(): Hashtable " + filename + " was not closed properly. Validating ");
header.set_num_objects(0);
HashtableAction act = new HashtableAction() {
public boolean execute(HashtableEntry e)
throws IOException
{
if ((header.num_objects() % 100) == 0) {
print(".");
}
header.incrementObjectCount();
if (item_initialize != null) {
item_initialize.initialize(e.getKey(), e.getValue());
}
return true;
}
};
walkHash(act, RETRIEVE_ALL, 0, -1);
header.write();
println("countAndVerifyObjects(): done");
} | java |
private void countObjects()
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
println("countObjects(): Hashtable " + filename + " was not closed properly. Validating ");
iterationLock.p();
int count = 0;
try {
for (int i = 0; i < header.tablesize(); i++) {
//
// We want to drop the lock between each iteration so that other
// threads can continue to work
//
long next = getHtindex(i, header.currentTableId());// jrc 04/30/02 use cached entry
while (next != 0) {
count++;
if ((count % 100) == 0) {
if (debug)
print(".");
}
filemgr.seek(next);
next = filemgr.readLong();
}
}
header.set_num_objects(count);
header.write();
} finally {
iterationLock.v();
}
println("countObjects(): done[" + count + "]");
} | java |
private void rehash()
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
int size = (header.tablesize() * 2) + 1;
if (this.tempTableSize > size) {
doRehash(this.tempTableSize);
this.tempTableSize = 0;
} else {
doRehash(size);
}
} | java |
private void doRehash(int new_table_size)
throws IOException,
EOFException,
FileManagerException,
ClassNotFoundException,
HashtableOnDiskException {
//
// Acquire the lock to prevent iteration while doubling
//
iterationLock.p();
//
// Step 0:
// This should be our only exposure = for a short time we
// will have allocated the new table but not stored its location
// anywhere. If we crash here we leak that storage permanently.
//
long new_table = 0;
header.setRehashFlag(1);
new_table = filemgr.allocateAndClear(new_table_size * DWORDSIZE);
header.initNewTable(new_table_size, new_table);
PrimitiveArrayPool.PoolEntry longPoolEntry = this.htoddc.longArrayPool.allocate(new_table_size);
new_htindex = (long[]) longPoolEntry.getArray();
//new_htindex = new long[new_table_size];
Rehash rehash = new Rehash(this, new_table, new_table_size);
Thread t = new Thread(rehash);
t.start();
} | java |
void setRehashFlag(long location)
throws IOException,
EOFException {
rehashInProgress = location;
filemgr.seek(rehashOffset);
filemgr.writeLong(location);
} | java |
public synchronized boolean contains(int id)
{
if (tc.isEntryEnabled()) SibTr.entry(this, tc, "contains", ""+id);
mutableKey.setValue(id);
boolean returnValue = idToConvTable.containsKey(mutableKey);
if (tc.isEntryEnabled()) SibTr.exit(this, tc, "contains", ""+returnValue);
return returnValue;
} | java |