code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
void remove(PatternWrapper pattern, Conjunction selector, MatchTarget object,
InternTable subExpr, OrdinalPosition parentId) throws MatchingException {
if (tc.isEntryEnabled())
tc.entry(this,cclass, "remove", new Object[]{pattern,selector,object,subExpr});
switch (pattern.getState()) {
case PatternWrapper.FINAL_EXACT:
exactChild = exactChild.remove(selector, object, subExpr, parentId);
break;
case PatternWrapper.FINAL_MANY:
if(hasMidClauses(pattern))
{
// We have multiple multi-level wildcarding and need to work with the
// matchManyChildren list
MatchManyWrapper wrapper = findMatchManyWrapper(pattern);
// if we couldn't find the wrapper, throw an exception
if (wrapper == null)
throw new MatchingException();
ContentMatcher next = wrapper.matcher;
ContentMatcher newNext =
(ContentMatcher) next.remove(selector, object, subExpr, parentId);
if (newNext == null)
matchManyChildren.remove(wrapper);
else if (newNext != next)
{
MatchManyWrapper newWrapper = new MatchManyWrapper(pattern, newNext);
matchManyChildren.add(newWrapper);
}
}
else
{
// Simpler case where there is a single multi-level wildcard
singleMatchManyChild =
singleMatchManyChild.remove(selector, object, subExpr, parentId);
}
break;
case PatternWrapper.PREFIX_CHARS:
case PatternWrapper.SUFFIX_CHARS:
char[] chars = pattern.getChars();
for (PartialMatch pm = this ;; pm = pm.next) {
if (pm == null)
throw new MatchingException();
if (Arrays.equals(chars, pm.key)) {
pm.remove(pattern, selector, object, subExpr, parentId);
break;
}
}
break;
case PatternWrapper.SKIP_ONE_PREFIX:
case PatternWrapper.SKIP_ONE_SUFFIX:
pattern.advance();
matchOneChild.remove(pattern, selector, object, subExpr, parentId);
if (matchOneChild.isEmptyChain())
matchOneChild = null;
break;
case PatternWrapper.SWITCH_TO_SUFFIX:
pattern.advance();
suffix.remove(pattern, selector, object, subExpr, parentId);
if (suffix.isEmptyChain())
suffix = null;
break;
}
if (key.length == 0)
cleanChain();
if (tc.isEntryEnabled())
tc.exit(this,cclass, "remove");
} | java |
void get(char[] chars, int start, int length, boolean invert, MatchSpaceKey msg,
EvalCache cache, Object contextValue, SearchResults result)
throws MatchingException, BadMessageFormatMatchingException {
if (tc.isEntryEnabled())
tc.entry(this,cclass, "get", new Object[]{chars,new Integer(start),new Integer(length),
new Boolean(invert),msg,cache,result});
examineMatches:
for (PartialMatch pm = this; pm != null && length >= pm.key.length; pm = pm.next) {
int origin = invert ? (start + length - pm.key.length) : start;
for (int i = 0; i < pm.key.length; i++)
if (pm.key[i] != chars[origin + i])
continue examineMatches;
// A match on pm; either it exhausts chars (exact) or only part thereof
if (length == pm.key.length) {
// An exact match fires both exactChild and matchManyChild
if (pm.exactChild != null)
pm.exactChild.get(null, msg, cache, contextValue, result);
// Process just the default MatchManyChild
if (pm.singleMatchManyChild != null)
pm.singleMatchManyChild.get(null, msg, cache, contextValue, result);
}
else
if (!invert)
pm.doPartialGet(chars, start + pm.key.length, length-pm.key.length, false,
msg, cache, contextValue, result);
else
pm.doPartialGet(chars, start, length-pm.key.length, true, msg, cache, contextValue, result);
}
if (tc.isEntryEnabled())
tc.exit(this,cclass, "get");
} | java |
void doPartialGet(char[] chars, int start, int length, boolean invert, MatchSpaceKey msg,
EvalCache cache, Object contextValue, SearchResults result)
throws MatchingException, BadMessageFormatMatchingException {
if (tc.isEntryEnabled())
tc.entry(this,cclass, "doPartialGet", new Object[] {chars,new Integer(start),
new Integer(length),new Boolean(invert),msg,cache,result});
if (matchOneChild != null)
if (!invert)
matchOneChild.get(chars, start+1, length-1, false, msg, cache, contextValue, result);
else
matchOneChild.get(chars, start, length-1, true, msg, cache, contextValue, result);
if (suffix != null)
suffix.get(chars, start, length, true, msg, cache, contextValue, result);
getFromManyChildMatchers(chars, start, length, msg, cache, contextValue, result);
if (tc.isEntryEnabled())
tc.exit(this,cclass, "doPartialGet");
} | java |
private MatchManyWrapper findMatchManyWrapper(PatternWrapper pattern)
{
MatchManyWrapper wrapper = null;
if (matchManyChildren != null)
{
// Iterate over the matchManyChildren
Iterator iter = matchManyChildren.iterator();
while(iter.hasNext())
{
MatchManyWrapper nextElement = (MatchManyWrapper) iter.next();
PatternWrapper nextPattern = nextElement.pattern;
if(nextPattern.equals(pattern))
{
// We're done, we've found the matching pattern
wrapper = nextElement;
break;
}
} // eof while more children in the list
}
return wrapper;
} | java |
@Override
public Principal getCallerPrincipal() {
synchronized (this) {
if ((state == PRE_CREATE) || (state == CREATING) || (!allowRollbackOnly))
throw new IllegalStateException();
}
return super.getCallerPrincipal();
} | java |
public MQLinkHandler getMQLinkHandler()
{
if (tc.isEntryEnabled())
{
SibTr.entry(tc, "getMQLinkHandler");
SibTr.exit(tc, "getMQLinkHandler", _mqLinkHandler);
}
return _mqLinkHandler;
} | java |
public void markAsToBeDeleted(Transaction transaction) throws SIResourceException
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "markAsToBeDeleted", transaction);
toBeDeleted = Boolean.TRUE;
try
{
requestUpdate(transaction);
}
catch (MessageStoreException e)
{
// MessageStoreException shouldn't occur so FFDC.
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.store.itemstreams.MQLinkPubSubBridgeItemStream.markAsToBeDeleted",
"1:151:1.16",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "markAsToBeDeleted", e);
throw new SIResourceException(e);
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "markAsToBeDeleted");
return;
} | java |
public NavigationCase getNavigationCase(FacesContext facesContext, String fromAction, String outcome)
{
NavigationContext navigationContext = new NavigationContext();
try
{
return getNavigationCommand(facesContext, navigationContext, fromAction, outcome, null);
}
finally
{
navigationContext.finish(facesContext);
}
} | java |
private NavigationCase createNavigationCase(String fromViewId, String outcome, String toViewId)
{
return new NavigationCase(fromViewId, null, outcome, null, toViewId, null, false, false);
} | java |
public String getViewId(FacesContext context, String fromAction, String outcome)
{
return this.getNavigationCase(context, fromAction, outcome).getToViewId(context);
} | java |
@FFDCIgnore({NumberFormatException.class, IllegalArgumentException.class, ParseException.class})
private long handleRetry(String retryValue) {
// RETRY_AFTER is a String that can either correspond to seconds (long)
// or a HTTP-Date (which can be one of 7 variations)"
if (!(retryValue.contains(":"))) {
// Must be a long since all dates include ":"
try {
Long retryLong = Long.valueOf(retryValue);
//The RETRY_AFTER value is in seconds so change units
return TimeUnit.MILLISECONDS.convert(retryLong.longValue(), TimeUnit.SECONDS);
} catch (NumberFormatException e) {
LOG.fine("SSE RETRY_AFTER Incorrect time value: " + e);
}
} else {
char[] retryValueArray = retryValue.toCharArray();
//handle date
try {
SimpleDateFormat sdf = null;
// Determine the appropriate HTTP-Date pattern
if (retryValueArray[3] == ',') {
sdf = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z"); // RTC 822, updated by RFC 1123
} else if (retryValueArray[6] == ',') {
sdf = new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss z"); // RFC 850, obsoleted by RFC 1036
} else if (retryValueArray[7] == ',') {
sdf = new SimpleDateFormat("EEEEEEE, dd-MMM-yy HH:mm:ss z"); // RFC 850, obsoleted by RFC 1036
} else if (retryValueArray[8] == ',') {
sdf = new SimpleDateFormat("EEEEEEEE, dd-MMM-yy HH:mm:ss z"); // RFC 850, obsoleted by RFC 1036
} else if (retryValueArray[9] == ',') {
sdf = new SimpleDateFormat("EEEEEEEEE, dd-MMM-yy HH:mm:ss z"); // RFC 850, obsoleted by RFC 1036
} else if (retryValueArray[8] == ',') {
sdf = new SimpleDateFormat("EEEEEEEE, dd-MMM-yy HH:mm:ss z"); // RFC 850, obsoleted by RFC 1036
} else if (retryValueArray[8] == ' ') {
sdf = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy"); // ANSI C's asctime() format
} else {
sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy"); // ANSI C's asctime() format
}
Date retryDate = sdf.parse(retryValue);
long retryTime = retryDate.getTime();
long now = System.currentTimeMillis();
long delayTime = retryTime - now;
if (delayTime > 0) {
return delayTime;//HTTP Date is in milliseconds
}
LOG.fine("SSE RETRY_AFTER Date value represents a time already past");
} catch (IllegalArgumentException ex) {
LOG.fine("SSE RETRY_AFTER Date value format incorrect: " + ex);
} catch (ParseException e2) {
LOG.fine("SSE RETRY_AFTER Date value cannot be parsed: " + e2);
}
}
return -1L;
} | java |
public static final void WASInstallDirectory(String WASInstallDirectory)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "WASInstallDirectory", WASInstallDirectory);
_WASInstallDirectory = WASInstallDirectory;
if (tc.isEntryEnabled())
Tr.exit(tc, "WASInstallDirectory");
} | java |
public static final void cellName(String name)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "cellName", name);
_cellName = name;
if (tc.isEntryEnabled())
Tr.exit(tc, "cellName");
} | java |
public static final void clusterName(String name)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "clusterName", name);
_clusterName = name;
if (tc.isEntryEnabled())
Tr.exit(tc, "clusterName");
} | java |
public static final void nodeName(String name)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "nodeName", name);
_nodeName = name;
if (tc.isEntryEnabled())
Tr.exit(tc, "nodeName");
} | java |
public static final void serverName(String name)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "serverName", name);
_serverName = name;
if (tc.isEntryEnabled())
Tr.exit(tc, "serverName");
} | java |
public static final void serverShortName(String name)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "serverShortName", name);
_serverShortName = name;
if (tc.isEntryEnabled())
Tr.exit(tc, "serverShortName");
} | java |
public static final void uuid(String uuid)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "uuid", uuid);
_uuid = uuid;
if (tc.isEntryEnabled())
Tr.exit(tc, "uuid");
} | java |
public static final String fqServerName()
{
if (tc.isEntryEnabled())
Tr.entry(tc, "fqServerName");
String fqServerName = _serverName; // RLSUtils.FQHAMCompatibleServerName(_cellName,_nodeName,_serverName); tWAS
if (tc.isEntryEnabled())
Tr.exit(tc, "fqServerName", fqServerName);
return fqServerName;
} | java |
public static final void HAEnabled(boolean HAEnabled)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "HAEnabled", new Boolean(HAEnabled));
_HAEnabled = HAEnabled;
if (tc.isEntryEnabled())
Tr.exit(tc, "HAEnabled");
} | java |
public static final void localFailureScope(FailureScope localFailureScope)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "localFailureScope", localFailureScope);
_localFailureScope = localFailureScope;
if (tc.isEntryEnabled())
Tr.exit(tc, "localFailureScope");
} | java |
public static final boolean isZOS()
{
if (tc.isEntryEnabled())
Tr.entry(tc, "isZOS");
if (tc.isEntryEnabled())
Tr.exit(tc, "isZOS", new Boolean(_isZOS));
return _isZOS;
} | java |
public static final void useFileLocking(boolean useFileLocking)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "useFileLocking", new Boolean(useFileLocking));
_useFileLocking = useFileLocking;
if (tc.isEntryEnabled())
Tr.exit(tc, "useFileLocking");
} | java |
private void registerDefaultDelegationProvider(ComponentContext cc) {
defaultDelegationProvider = new DefaultDelegationProvider();
defaultDelegationProvider.setSecurityService(securityServiceRef.getService());
defaultDelegationProvider.setIdentityStoreHandlerService(identityStoreHandlerServiceRef);
BundleContext bc = cc.getBundleContext();
Dictionary<String, Object> props = new Hashtable<String, Object>();
props.put("type", "defaultProvider");
defaultDelegationProviderReg = bc.registerService(DelegationProvider.class,
defaultDelegationProvider,
props);
} | java |
private Map<String, RoleSet> updateMapForSpecialSubject(String appName,
Map<String, RoleSet> specialSubjectToRolesMap,
String specialSubjectName) {
RoleSet computedRoles = RoleSet.EMPTY_ROLESET;
Set<String> rolesForSubject = new HashSet<String>();
//TODO what if the appName is not present in the map?
for (SecurityRole role : resourceToAuthzInfoMap.get(appName).securityRoles) {
String roleName = role.getName();
for (SpecialSubject specialSubject : role.getSpecialSubjects()) {
String specialSubjectNameFromRole = specialSubject.getType().toString();
if (specialSubjectName.equals(specialSubjectNameFromRole)) {
rolesForSubject.add(roleName);
}
}
}
if (!rolesForSubject.isEmpty()) {
computedRoles = new RoleSet(rolesForSubject);
}
specialSubjectToRolesMap.put(specialSubjectName, computedRoles);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Added the following subject to role mapping for application: " + appName + ".",
specialSubjectName, computedRoles);
}
return specialSubjectToRolesMap;
} | java |
@FFDCIgnore(EntryNotFoundException.class)
private String getMissingAccessId(com.ibm.ws.javaee.dd.appbnd.Subject subjectFromArchive) {
String subjectType = null;
try {
SecurityService securityService = securityServiceRef.getService();
UserRegistryService userRegistryService = securityService.getUserRegistryService();
if (!userRegistryService.isUserRegistryConfigured())
return null;
UserRegistry userRegistry = userRegistryService.getUserRegistry();
String realm = userRegistry.getRealm();
if (subjectFromArchive instanceof Group) {
subjectType = "group";
String groupUniqueId = userRegistry.getUniqueGroupId(subjectFromArchive.getName());
return AccessIdUtil.createAccessId(AccessIdUtil.TYPE_GROUP, realm, groupUniqueId);
} else if (subjectFromArchive instanceof User) {
subjectType = "user";
String uniqueId = userRegistry.getUniqueUserId(subjectFromArchive.getName());
return AccessIdUtil.createAccessId(AccessIdUtil.TYPE_USER, realm, uniqueId);
}
} catch (EntryNotFoundException e) {
if (TraceComponent.isAnyTracingEnabled()) {
if (tc.isEventEnabled()) {
Tr.event(tc, "No entry found for " + subjectType + " "
+ subjectFromArchive.getName() + " found in user registry. Unable to create access ID.");
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "EntryNotFoundException details:", e);
}
}
} catch (RegistryException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Unexpected exception getting the accessId for "
+ subjectFromArchive.getName() + ": " + e);
}
}
return null;
} | java |
private String updateMissingUserAccessId(AuthzTableContainer maps, User user, String userNameFromRole) {
String accessIdFromRole;
accessIdFromRole = getMissingAccessId(user);
if (accessIdFromRole != null) {
maps.userToAccessIdMap.put(userNameFromRole, accessIdFromRole);
} else {
// Unable to compute the accessId, store an invalid access ID indicate this
maps.userToAccessIdMap.put(userNameFromRole, INVALID_ACCESS_ID);
}
return accessIdFromRole;
} | java |
private String updateMissingGroupAccessId(AuthzTableContainer maps, Group group, String groupNameFromRole) {
String accessIdFromRole;
accessIdFromRole = getMissingAccessId(group);
if (accessIdFromRole != null) {
maps.groupToAccessIdMap.put(groupNameFromRole, accessIdFromRole);
} else {
// Unable to compute the accessId, store an invalid access ID indicate this
// and avoid future attempts
maps.groupToAccessIdMap.put(groupNameFromRole, INVALID_ACCESS_ID);
}
return accessIdFromRole;
} | java |
private void fireProgressEvent(int state, int progress, String messageKey, RepositoryResource installResource) throws InstallException {
String resourceName = null;
if (installResource instanceof EsaResource) {
EsaResource esar = ((EsaResource) installResource);
if (esar.getVisibility().equals(Visibility.PUBLIC) || esar.getVisibility().equals(Visibility.INSTALL)) {
resourceName = (esar.getShortName() == null) ? installResource.getName() : esar.getShortName();
} else if (!firePublicAssetOnly && messageKey.equals("STATE_DOWNLOADING")) {
messageKey = "STATE_DOWNLOADING_DEPENDENCY";
resourceName = "";
} else {
return;
}
}
if (installResource instanceof SampleResource) {
SampleResource sr = ((SampleResource) installResource);
resourceName = sr.getShortName() == null ? installResource.getName() : sr.getShortName();
} else {
resourceName = installResource.getName();
}
fireProgressEvent(state, progress,
Messages.INSTALL_KERNEL_MESSAGES.getLogMessage(messageKey, resourceName));
} | java |
public void fireInstallProgressEvent(int progress, InstallAsset installAsset) throws InstallException {
if (installAsset.isServerPackage())
fireProgressEvent(InstallProgressEvent.DEPLOY, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_DEPLOYING", installAsset.toString()), true);
else if (installAsset.isFeature()) {
ESAAsset esaa = ((ESAAsset) installAsset);
if (esaa.isPublic()) {
String resourceName = (esaa.getShortName() == null) ? esaa.getDisplayName() : esaa.getShortName();
fireProgressEvent(InstallProgressEvent.INSTALL, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_INSTALLING", resourceName), true);
} else if (!firePublicAssetOnly) {
fireProgressEvent(InstallProgressEvent.INSTALL, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_INSTALLING_DEPENDENCY"), true);
}
} else {
fireProgressEvent(InstallProgressEvent.INSTALL, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_INSTALLING", installAsset.toString()), true);
}
} | java |
public void fireDownloadProgressEvent(int progress, RepositoryResource installResource) throws InstallException {
if (installResource.getType().equals(ResourceType.FEATURE)) {
Visibility v = ((EsaResource) installResource).getVisibility();
if (v.equals(Visibility.PUBLIC) || v.equals(Visibility.INSTALL)) {
EsaResource esar = (EsaResource) installResource;
String resourceName = (esar.getShortName() == null) ? installResource.getName() : esar.getShortName();
fireProgressEvent(InstallProgressEvent.DOWNLOAD, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_DOWNLOADING", resourceName), true);
} else if (!firePublicAssetOnly) {
fireProgressEvent(InstallProgressEvent.DOWNLOAD, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_DOWNLOADING_DEPENDENCY"), true);
}
} else if (installResource.getType().equals(ResourceType.PRODUCTSAMPLE) ||
installResource.getType().equals(ResourceType.OPENSOURCE)) {
fireProgressEvent(InstallProgressEvent.DOWNLOAD, progress, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_DOWNLOADING", installResource.getName()), true);
}
} | java |
public void installFeatures(Collection<String> featureNames, String toExtension, boolean acceptLicense, String userId, String password) throws InstallException {
installFeatures(featureNames, toExtension, acceptLicense, userId, password, 1);
} | java |
public void installFeature(String esaLocation, String toExtension, boolean acceptLicense) throws InstallException {
fireProgressEvent(InstallProgressEvent.CHECK, 1, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CHECKING"));
ArrayList<InstallAsset> installAssets = new ArrayList<InstallAsset>();
String feature = getResolveDirector().resolve(esaLocation, toExtension, product.getInstalledFeatures(), installAssets, 10, 40);
if (installAssets.isEmpty()) {
throw ExceptionUtils.create(Messages.PROVISIONER_MESSAGES.getLogMessage("tool.feature.exists", feature), InstallException.ALREADY_EXISTS);
}
this.installAssets = new ArrayList<List<InstallAsset>>(1);
this.installAssets.add(installAssets);
} | java |
public void installFeatureNoResolve(String esaLocation, String toExtension, boolean acceptLicense) throws InstallException {
fireProgressEvent(InstallProgressEvent.CHECK, 1, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CHECKING"));
ArrayList<InstallAsset> singleFeatureInstall = new ArrayList<InstallAsset>();
InstallAsset esa = null;
try {
esa = new ESAAsset(new File(esaLocation), toExtension, false);
} catch (ZipException e) {
throw ExceptionUtils.create(Messages.PROVISIONER_MESSAGES.getLogMessage("tool.install.download.esa", esaLocation, e.getMessage()),
InstallException.BAD_ARGUMENT);
} catch (IOException e) {
throw ExceptionUtils.create(Messages.PROVISIONER_MESSAGES.getLogMessage("tool.install.download.esa", esaLocation, e.getMessage()),
InstallException.BAD_ARGUMENT);
}
singleFeatureInstall.add(esa);
this.installAssets = new ArrayList<List<InstallAsset>>(1);
this.installAssets.add(singleFeatureInstall);
} | java |
public void installFeature(Collection<String> featureIds, File fromDir, String toExtension, boolean acceptLicense, boolean offlineOnly) throws InstallException {
//fireProgressEvent(InstallProgressEvent.CHECK, 1, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CHECKING"));
this.installAssets = new ArrayList<List<InstallAsset>>();
ArrayList<InstallAsset> installAssets = new ArrayList<InstallAsset>();
ArrayList<String> unresolvedFeatures = new ArrayList<String>();
Collection<ESAAsset> autoFeatures = getResolveDirector().getAutoFeature(fromDir, toExtension);
getResolveDirector().resolve(featureIds, fromDir, toExtension, offlineOnly, installAssets, unresolvedFeatures);
if (!offlineOnly && !unresolvedFeatures.isEmpty()) {
log(Level.FINEST, "installFeature() determined unresolved features: " + unresolvedFeatures.toString() + " from " + fromDir.getAbsolutePath());
installFeatures(unresolvedFeatures, toExtension, acceptLicense, null, null, 5);
}
if (!installAssets.isEmpty()) {
getResolveDirector().resolveAutoFeatures(autoFeatures, installAssets);
this.installAssets.add(installAssets);
}
if (this.installAssets.isEmpty()) {
throw ExceptionUtils.createByKey(InstallException.ALREADY_EXISTS, "ALREADY_INSTALLED", featureIds.toString());
}
} | java |
public ServerPackageAsset resolveServerPackage(File archiveFile) throws InstallException {
ServerPackageAsset spa = (ServerPackageJarAsset.validType(archiveFile.getAbsolutePath().toLowerCase())) ? new ServerPackageJarAsset(archiveFile, false) : new ServerPackageZipAsset(archiveFile, false);
this.installAssets = new ArrayList<List<InstallAsset>>();
this.installAssets.add(Arrays.asList((InstallAsset) spa));
return spa;
} | java |
public Collection<String> getServerFeaturesToInstall(Set<ServerAsset> servers, boolean offlineOnly) throws InstallException, IOException {
Set<String> features = new TreeSet<String>();
Set<String> serverNames = new HashSet<String>(servers.size());
Set<String> allServerNames = new HashSet<String>(servers.size());
for (ServerAsset sa : servers) {
Collection<String> requiredFeatures = sa.getRequiredFeatures();
if (!requiredFeatures.isEmpty()) {
logger.log(Level.FINEST, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("LOG_DEPLOY_SERVER_FEATURES",
sa.getServerName(),
InstallUtils.getFeatureListOutput(requiredFeatures)));
features.addAll(requiredFeatures);
serverNames.add(sa.getServerName());
}
allServerNames.add(sa.getServerName());
}
Collection<String> featuresToInstall = getFeaturesToInstall(features, offlineOnly);
if (!featuresToInstall.isEmpty()) {
logger.log(Level.FINE, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("LOG_DEPLOY_ADDITIONAL_FEATURES_REQUIRED",
serverNames, featuresToInstall));
} else {
logger.log(Level.FINE, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("LOG_DEPLOY_NO_ADDITIONAL_FEATURES_REQUIRED",
allServerNames));
}
return featuresToInstall;
} | java |
public void installFixes(Collection<String> fixes, String userId, String password) throws InstallException {
fireProgressEvent(InstallProgressEvent.CHECK, 1, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CHECKING"));
List<String> fixesToInstall = new ArrayList<String>(fixes.size());
for (String fix : fixes) {
fixesToInstall.add(fix);
}
RepositoryConnectionList loginInfo = getResolveDirector().getRepositoryConnectionList(null, userId, password, this.getClass().getCanonicalName() + ".installFixes");
Resolver resolver = new Resolver(loginInfo);
List<IfixResource> ifixResources = resolver.resolveFixResources(fixesToInstall);
if (ifixResources.isEmpty())
throw ExceptionUtils.createByKey("ERROR_FAILED_TO_RESOLVE_IFIX", InstallUtils.getFeatureListOutput(fixes));
ArrayList<InstallAsset> installAssets = new ArrayList<InstallAsset>();
int progress = 10;
int interval = 40 / ifixResources.size();
for (IfixResource fix : ifixResources) {
fireProgressEvent(InstallProgressEvent.DOWNLOAD, progress, "STATE_DOWNLOADING", fix);
progress += interval;
File d;
try {
d = InstallUtils.download(this.product.getInstallTempDir(), fix);
} catch (InstallException e) {
throw e;
} catch (Exception e) {
throw ExceptionUtils.createByKey(e, "ERROR_FAILED_TO_DOWNLOAD_IFIX", fix.getName(), this.product.getInstallTempDir().getAbsolutePath());
}
try {
installAssets.add(new FixAsset(fix.getName(), d, true));
} catch (Exception e) {
throw ExceptionUtils.createByKey(e, "ERROR_INVALID_IFIX", fix.getName());
}
}
this.installAssets = new ArrayList<List<InstallAsset>>(1);
this.installAssets.add(installAssets);
} | java |
public Set<InstallLicense> getFeatureLicense(Collection<String> featureIds, File fromDir, String toExtension, boolean offlineOnly, Locale locale) throws InstallException {
Set<InstallLicense> licenses = new HashSet<InstallLicense>();
ArrayList<InstallAsset> installAssets = new ArrayList<InstallAsset>();
ArrayList<String> unresolvedFeatures = new ArrayList<String>();
Collection<ESAAsset> autoFeatures = getResolveDirector().getAutoFeature(fromDir, toExtension);
getResolveDirector().resolve(featureIds, fromDir, toExtension, offlineOnly, installAssets, unresolvedFeatures);
if (!offlineOnly && !unresolvedFeatures.isEmpty()) {
log(Level.FINEST, "getFeatureLicense() determined unresolved features: " + unresolvedFeatures.toString() + " from " + fromDir.getAbsolutePath());
licenses = getFeatureLicense(unresolvedFeatures, locale, null, null);
}
if (installAssets.isEmpty()) {
return licenses;
}
getResolveDirector().resolveAutoFeatures(autoFeatures, installAssets);
Map<String, InstallLicenseImpl> licenseIds = new HashMap<String, InstallLicenseImpl>();
for (InstallAsset installAsset : installAssets) {
if (installAsset.isFeature()) {
ESAAsset esa = (ESAAsset) installAsset;
if (esa.isPublic()) {
ExeInstallAction.incrementNumOfLocalFeatures();
}
LicenseProvider lp = esa.getLicenseProvider(locale);
String licenseId = esa.getLicenseId();
if (licenseId != null && !licenseId.isEmpty()) {
InstallLicenseImpl ili = licenseIds.get(licenseId);
if (ili == null) {
ili = new InstallLicenseImpl(licenseId, null, lp);
licenseIds.put(licenseId, ili);
}
ili.addFeature(esa.getProvideFeature());
}
}
}
licenses.addAll(licenseIds.values());
return licenses;
} | java |
public Set<InstallLicense> getFeatureLicense(String esaLocation, Locale locale) throws InstallException {
Set<InstallLicense> licenses = new HashSet<InstallLicense>();
ArrayList<InstallAsset> installAssets = new ArrayList<InstallAsset>();
getResolveDirector().resolve(esaLocation, "", product.getInstalledFeatures(), installAssets, 10, 40);
if (installAssets.isEmpty()) {
return licenses;
}
Map<String, InstallLicenseImpl> licenseIds = new HashMap<String, InstallLicenseImpl>();
for (InstallAsset installAsset : installAssets) {
if (installAsset.isFeature()) {
ESAAsset esa = (ESAAsset) installAsset;
LicenseProvider lp = esa.getLicenseProvider(locale);
String licenseId = esa.getLicenseId();
if (licenseId != null && !licenseId.isEmpty()) {
InstallLicenseImpl ili = licenseIds.get(licenseId);
if (ili == null) {
ili = new InstallLicenseImpl(licenseId, null, lp);
licenseIds.put(licenseId, ili);
}
ili.addFeature(esa.getProvideFeature());
}
}
}
licenses.addAll(licenseIds.values());
return licenses;
} | java |
public Set<InstallLicense> getFeatureLicense(Collection<String> featureNames, Locale locale, String userId, String password) throws InstallException {
Set<InstallLicense> licenses = new HashSet<InstallLicense>();
if (featureNames == null || featureNames.isEmpty())
return licenses;
Map<String, List<List<RepositoryResource>>> installResources = getResolveDirector().resolveMap(featureNames, DownloadOption.required, userId, password);
if (isEmpty(installResources)) {
this.installAssets = new ArrayList<List<InstallAsset>>(0);
return licenses;
}
return getFeatureLicense(locale, installResources);
} | java |
public Set<InstallLicense> getServerPackageFeatureLicense(File archive, boolean offlineOnly, Locale locale) throws InstallException {
String aName = archive.getAbsolutePath().toLowerCase();
ServerPackageAsset spa = null;
if (ServerPackageZipAsset.validType(aName)) {
spa = new ServerPackageZipAsset(archive, false);
} else if (ServerPackageJarAsset.validType(aName)) {
spa = new ServerPackageJarAsset(archive, false);
} else {
return new HashSet<InstallLicense>();
}
return getFeatureLicense(spa.getRequiredFeatures(), locale, null, null);
} | java |
public Set<InstallLicense> getServerFeatureLicense(File serverXML, boolean offlineOnly, Locale locale) throws InstallException, IOException {
if (null != serverXML) {
return getFeatureLicense(new ServerAsset(serverXML).getRequiredFeatures(), locale, null, null);
}
return new HashSet<InstallLicense>();
} | java |
public void cleanUp() {
fireProgressEvent(InstallProgressEvent.CLEAN_UP, 98, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CLEANING"));
if (installAssets != null) {
for (List<InstallAsset> iaList : installAssets) {
for (InstallAsset asset : iaList) {
asset.delete();
}
}
}
boolean del = InstallUtils.deleteDirectory(this.product.getInstallTempDir());
if (!del)
this.product.getInstallTempDir().deleteOnExit();
installAssets = null;
setScriptsPermission = false;
if (resolveDirector != null)
resolveDirector.cleanUp();
if (uninstallDirector != null)
uninstallDirector.cleanUp();
log(Level.FINE, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("MSG_CLEANUP_SUCCESS"));
} | java |
public Collection<String> getInstalledFeatureNames() {
if (installAssets == null)
return null;
Collection<String> installed = new ArrayList<String>();
for (List<InstallAsset> iaList : installAssets) {
for (InstallAsset asset : iaList) {
if (asset.isFeature()) {
ESAAsset esa = (ESAAsset) asset;
if (esa.isPublic()) {
String esaName = esa.getShortName();
if (esaName == null || esaName.isEmpty())
esaName = esa.getFeatureName();
installed.add(esaName);
}
}
}
}
return installed;
} | java |
public void enableConsoleLog(Level level, boolean verbose) {
InstallLogUtils.enableConsoleLogging(level, verbose);
InstallLogUtils.enableConsoleErrorLogging(verbose);
} | java |
public void reapplyFixIfNeeded() throws ReapplyFixException {
BundleRepositoryRegistry.initializeDefaults(null, false);
Set<String> fixesToReapply = ValidateCommandTask.getFixesToReapply(product.getManifestFileProcessor(), new InstallUtils.InstallCommandConsole());
try {
fireProgressEvent(InstallProgressEvent.CHECK, 90, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_VALIDATING_FIXES", fixesToReapply.toString()));
this.enableEvent = false;
if (fixesToReapply.isEmpty()) {
log(Level.FINEST, "No fix is required to be reapplied.");
} else {
installFixes(fixesToReapply, null, null);
install(ExistsAction.replace, false, false);
log(Level.FINEST, "Successfully reapplied the following fixes: " + fixesToReapply.toString());
}
} catch (InstallException e) {
log(Level.FINEST, "Failed to reapply the following fixes: " + fixesToReapply.toString());
throw new ReapplyFixException(Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("LOG_REINSTALL_FIXES_WARNING",
fixesToReapply.toString()).trim(), e, InstallException.RUNTIME_EXCEPTION);
} finally {
this.enableEvent = true;
}
} | java |
public void setScriptsPermission(int event) {
if (event == InstallProgressEvent.POST_INSTALL ? setScriptsPermission : getUninstallDirector().needToSetScriptsPermission()) {
fireProgressEvent(event, 95, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_SET_SCRIPTS_PERMISSION"));
try {
SelfExtractUtils.fixScriptPermissions(new SelfExtractor.NullExtractProgress(), product.getInstallDir(), null);
} catch (Exception e) {
}
}
} | java |
public List<EsaResource> queryFeatures(String searchStr) throws InstallException {
List<EsaResource> features = new ArrayList<EsaResource>();
RepositoryConnectionList loginInfo = getResolveDirector().getRepositoryConnectionList(null, null, null, this.getClass().getCanonicalName() + ".queryFeatures");
try {
for (ProductInfo productInfo : ProductInfo.getAllProductInfo().values()) {
log(Level.FINE, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("MSG_SEARCHING_FEATURES"));
features.addAll(loginInfo.findMatchingEsas(searchStr, new ProductInfoProductDefinition(productInfo), Visibility.PUBLIC));
log(Level.FINE, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("MSG_SEARCHING_ADDONS"));
features.addAll(loginInfo.findMatchingEsas(searchStr, new ProductInfoProductDefinition(productInfo), Visibility.INSTALL));
}
log(Level.FINE, " ");
} catch (ProductInfoParseException pipe) {
throw ExceptionUtils.create(pipe);
} catch (DuplicateProductInfoException dpie) {
throw ExceptionUtils.create(dpie);
} catch (ProductInfoReplaceException pire) {
throw ExceptionUtils.create(pire);
} catch (RepositoryException re) {
throw ExceptionUtils.create(re, re.getCause(), getResolveDirector().getProxy(), getResolveDirector().defaultRepo());
}
return features;
} | java |
public Map<String, Collection<String>> downloadAssetsInstallUtility(Set<String> assetsNames, File toDir, DownloadOption downloadOption, String user, String password,
boolean isOverride) throws InstallException {
fireProgressEvent(InstallProgressEvent.CHECK, 1, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CHECKING"));
createRepoConfig(toDir, assetsNames);
if (assetsNames == null || assetsNames.isEmpty()) {
throw ExceptionUtils.createByKey("ERROR_ASSETS_LIST_INVALID");
}
Map<String, Collection<String>> downloaded = new HashMap<String, Collection<String>>();
RepositoryDownloadUtil.writeResourcesToDiskRepo(downloaded, toDir, getResolveDirector().getInstallResources(), this.product.getProductVersion(),
eventManager, getResolveDirector().defaultRepo());
return downloaded;
} | java |
public Map<String, InstalledFeature> getInstalledCoreFeatures() {
try {
Map<String, InstalledFeature> installedFeatures = new TreeMap<String, InstalledFeature>();
Map<String, ProvisioningFeatureDefinition> fdMap = product.getCoreFeatureDefinitions();
for (Entry<String, ProvisioningFeatureDefinition> entry : fdMap.entrySet()) {
installedFeatures.put(entry.getKey(), new InstalledAssetImpl(entry.getValue()));
}
return installedFeatures;
} catch (FeatureToolException rte) {
log(Level.FINEST, "Director.getInstalledCoreFeatures() got exception.", rte);
return null;
}
} | java |
public Map<String, InstalledFeatureCollection> getInstalledFeatureCollections() {
try {
Map<String, InstalledFeatureCollection> installedFeatureCollections = new TreeMap<String, InstalledFeatureCollection>();
Map<String, ProvisioningFeatureDefinition> fdMap = product.getFeatureCollectionDefinitions();
for (Entry<String, ProvisioningFeatureDefinition> entry : fdMap.entrySet()) {
installedFeatureCollections.put(entry.getKey(), new InstalledAssetImpl(entry.getValue()));
}
return installedFeatureCollections;
} catch (FeatureToolException rte) {
log(Level.FINEST, "Director.getInstalledFeatureCollections() got exception.", rte);
return null;
}
} | java |
public void installAssets(Collection<String> assetIds, File fromDir, RepositoryConnectionList loginInfo) throws InstallException {
this.installAssets = new ArrayList<List<InstallAsset>>();
ArrayList<InstallAsset> installAssets = new ArrayList<InstallAsset>();
ArrayList<String> unresolvedFeatures = new ArrayList<String>();
Collection<ESAAsset> autoFeatures = getResolveDirector().getAutoFeature(fromDir, InstallConstants.TO_USER);
getResolveDirector().resolve(assetIds, fromDir, InstallConstants.TO_USER, false, installAssets, unresolvedFeatures);
if (!unresolvedFeatures.isEmpty()) {
log(Level.FINEST, "installAssets() determined unresolved features: " + unresolvedFeatures.toString() + " from " + fromDir.getAbsolutePath());
installAssets(unresolvedFeatures, loginInfo);
}
if (!installAssets.isEmpty()) {
getResolveDirector().resolveAutoFeatures(autoFeatures, installAssets);
this.installAssets.add(installAssets);
}
if (this.installAssets.isEmpty()) {
throw ExceptionUtils.createByKey(InstallException.ALREADY_EXISTS, "ASSETS_ALREADY_INSTALLED", assetIds.toString());
}
} | java |
public void installAssets(Collection<String> assetIds, RepositoryConnectionList loginInfo) throws InstallException {
fireProgressEvent(InstallProgressEvent.CHECK, 1, Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("STATE_CHECKING_ASSETS"));
if (assetIds == null || assetIds.isEmpty()) {
throw ExceptionUtils.createByKey("ERROR_ASSETS_LIST_INVALID");
}
RepositoryConnectionList li = loginInfo == null ? getResolveDirector().getRepositoryConnectionList(null, null, null,
this.getClass().getCanonicalName() + ".installAssets") : loginInfo;
Map<String, List<List<RepositoryResource>>> installResources = getResolveDirector().resolveMap(assetIds, li, false);
if (isEmpty(installResources)) {
throw ExceptionUtils.createByKey(InstallException.ALREADY_EXISTS, "ASSETS_ALREADY_INSTALLED",
InstallUtils.getShortNames(product.getFeatureDefinitions(), assetIds).toString());
}
downloadAssets(installResources, InstallConstants.TO_USER);
} | java |
public void checkResources() throws InstallException {
getResolveDirector().checkResources();
if (installAssets != null) {
for (List<InstallAsset> iaList : installAssets) {
for (InstallAsset ia : iaList) {
checkResource(ia);
}
}
}
long required = getResolveDirector().getInstallResourcesMainAttachmentSize();
String requiredSpace = castToPrintableMessage(required);
logger.log(Level.FINEST, "Total required space for installation is " + requiredSpace + " including temporary files.");
File wlpDir = product.getInstallDir();
long free = wlpDir.getFreeSpace();
String wlpDirSpace = castToPrintableMessage(wlpDir.getFreeSpace());
logger.log(Level.FINEST, "Total available space is " + wlpDirSpace + ".");
if (free < required) {
try {
throw ExceptionUtils.createByKey("ERROR_WLP_DIR_NO_SPACE", wlpDir.getCanonicalPath(), wlpDirSpace, requiredSpace);
} catch (IOException e) {
throw ExceptionUtils.create(e);
}
}
} | java |
public String castToPrintableMessage(long number) {
long i = number / 1048576;
if (i > 0)
return String.valueOf(i) + " MB";
else {
long l = number / 1024;
return String.valueOf(l) + " KB";
}
} | java |
public Map<String, Collection<String>> getInstalledAssetNames() {
if (installAssets == null)
return null;
Map<String, Collection<String>> installed = new HashMap<String, Collection<String>>();
Collection<String> installedAddons = new ArrayList<String>();
Collection<String> installedFeatures = new ArrayList<String>();
Collection<String> installedFixes = new ArrayList<String>();
Collection<String> installedSamples = new ArrayList<String>();
Collection<String> installedOpenSources = new ArrayList<String>();
for (List<InstallAsset> iaList : installAssets) {
for (InstallAsset asset : iaList) {
if (asset.isFeature()) {
ESAAsset esa = (ESAAsset) asset;
if (esa.isPublic()) {
String esaName = esa.getShortName();
if (esaName == null || esaName.isEmpty())
esaName = esa.getFeatureName();
if (esa.isAddon())
installedAddons.add(esaName);
else
installedFeatures.add(esaName);
}
} else if (asset.isFix()) {
installedFixes.add(asset.toString());
} else if (asset.isSample()) {
installedSamples.add(asset.toString());
} else if (asset.isOpenSource()) {
installedOpenSources.add(asset.toString());
}
}
}
installed.put(InstallConstants.ADDON, installedAddons);
installed.put(InstallConstants.FEATURE, installedFeatures);
installed.put(InstallConstants.IFIX, installedFixes);
installed.put(InstallConstants.SAMPLE, installedSamples);
installed.put(InstallConstants.OPENSOURCE, installedOpenSources);
return installed;
} | java |
public Set<InstallLicense> getFeatureLicense(Locale locale) throws InstallException {
Map<String, InstallLicenseImpl> licenseIds = new HashMap<String, InstallLicenseImpl>();
getFeatureLicenseFromInstallAssets(locale, licenseIds, getResolveDirector().getLocalInstallAssets());
getFeatureLicenseFromInstallResources(locale, licenseIds, getResolveDirector().getInstallResources());
Set<InstallLicense> licenses = new HashSet<InstallLicense>();
licenses.addAll(licenseIds.values());
return licenses;
} | java |
public Collection<String> getSampleLicense(Locale locale) throws InstallException {
Collection<String> licenses = new ArrayList<String>();
for (List<List<RepositoryResource>> targetList : getResolveDirector().getInstallResources().values()) {
for (List<RepositoryResource> mrList : targetList) {
for (RepositoryResource mr : mrList) {
ResourceType type = mr.getType();
if (type.equals(ResourceType.PRODUCTSAMPLE) ||
type.equals(ResourceType.OPENSOURCE)) {
try {
AttachmentResource lar = mr.getLicenseAgreement(locale);
if (lar != null)
licenses.add(InstallLicenseImpl.getLicense(lar));
} catch (RepositoryException e) {
throw ExceptionUtils.createByKey(e, "ERROR_FAILED_TO_GET_ASSET_LICENSE", mr.getName());
}
}
}
}
}
return licenses;
} | java |
public Collection<String> getSamplesOrOpenSources() {
Collection<String> samplesOrOpenSources = new ArrayList<String>();
Map<String, List<List<RepositoryResource>>> installResources = getResolveDirector().getInstallResources();
if (installResources != null) {
for (List<List<RepositoryResource>> targetList : installResources.values()) {
for (List<RepositoryResource> mrList : targetList) {
for (RepositoryResource mr : mrList) {
ResourceType type = mr.getType();
if (type.equals(ResourceType.PRODUCTSAMPLE) ||
type.equals(ResourceType.OPENSOURCE)) {
samplesOrOpenSources.add(InstallUtils.getResourceId(mr));
}
}
}
}
}
return samplesOrOpenSources;
} | java |
public void downloadAssets(String toExtension) throws InstallException {
downloadAssets(getResolveDirector().getInstallResources(), toExtension);
if (getResolveDirector().getLocalInstallAssetsSize() > 0)
this.installAssets.add(getResolveDirector().getLocalInstallAssets());
} | java |
public void resolve(String feature, File esaFile, String toExtension) throws InstallException {
getResolveDirector().resolve(feature, esaFile, toExtension);
} | java |
public boolean resolveExistingAssetsFromDirectoryRepo(Collection<String> featureNames, File repoDir, boolean isOverwrite) throws InstallException {
return getResolveDirector().resolveExistingAssetsFromDirectoryRepo(featureNames, repoDir, isOverwrite);
} | java |
public void uninstall(Collection<String> ids, boolean force) throws InstallException {
getUninstallDirector().uninstall(ids, force);
} | java |
public void uninstall(boolean checkDependency, String[] productIds, Collection<File> toBeDeleted) throws InstallException {
getUninstallDirector().uninstall(checkDependency, productIds, toBeDeleted);
} | java |
public void uninstallFeaturesByProductId(String productId, boolean exceptPlatformFeatures) throws InstallException {
String[] productIds = new String[1];
productIds[0] = productId;
uninstallFeaturesByProductId(productIds, exceptPlatformFeatures);
} | java |
public synchronized final void append(Link link)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "append");
Link prev = _dummyTail._getPreviousLink();
link._link(prev, _dummyTail, _nextPositionToIssue++, this);
prev._setNextLink(link);
_dummyTail._setPreviousLink(link);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "append", _debugString());
} | java |
public final AbstractItem findFirstMatching(final Filter filter) throws MessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "findFirstMatching", filter);
AbstractItem found = null;
Link link = getHead();
while (link != null && found == null)
{
found = ((AbstractItemLink)link).matches(filter);
if (found == null)
{
// Defect 493652/PK59872
// We need to lock on the list at this point as our current link
// may have been unlinked by another thread during the matches()
// call. In that case we need to start at the head of the list again
// as the next/previous pointers for the unlinked link will not be
// set.
synchronized(this)
{
if (link.isPhysicallyUnlinked())
{
// We have been unlinked while we were doing the match.
// Start again at the beginning of the list.
link = getHead();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Current link is PhysicallyUnlinked so returning to beginning of list.");
}
else
{
link = link.getNextLogicalLink();
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "findFirstMatching", found);
return found;
} | java |
public final AbstractItem removeFirstMatching(final Filter filter, PersistentTransaction transaction) throws MessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "removeFirstMatching", new Object[] { filter, transaction});
AbstractItem found = null;
Link link = getHead();
while (link != null && found == null)
{
found = ((AbstractItemLink)link).removeIfMatches(filter, transaction);
if (found == null)
{
// Defect 493652/PK59872
// We need to lock on the list at this point as our current link
// may have been unlinked by another thread during the matches()
// call. In that case we need to start at the head of the list again
// as the next/previous pointers for the unlinked link will not be
// set.
synchronized(this)
{
if (link.isPhysicallyUnlinked())
{
// We have been unlinked while we were doing the match.
// Start again at the beginning of the list.
link = getHead();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Current link is PhysicallyUnlinked so returning to beginning of list.");
}
else
{
link = link.getNextLogicalLink();
}
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "removeFirstMatching", found);
return found;
} | java |
public final void xmlWriteOn(FormattedWriter writer, String tagName) throws IOException
{
Link link = getHead();
if (link != null)
{
writer.newLine();
writer.startTag(tagName);
writer.indent();
while (link != null)
{
writer.newLine();
link.xmlWriteOn(writer);
link = link.getNextPhysicalLink();
}
writer.outdent();
writer.newLine();
writer.endTag(tagName);
}
} | java |
public int countLinks()
{
int count = 0;
Link look = _dummyHead.getNextLogicalLink();
while (look != null && _dummyTail != look)
{
count++;
look = look._getNextLink();
}
return count;
} | java |
private void purge()
{
if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.entry(this, _tc, "purge");
Iterator<Map.Entry<K,TimedValue<V>>> it = _realMap.entrySet().iterator();
while (it.hasNext())
{
Map.Entry<K,TimedValue<V>> entry = it.next();
TimedValue<V> value = entry.getValue();
if (value.hasExipred())
{
it.remove();
if (TraceComponent.isAnyTracingEnabled() && _tc.isDebugEnabled())
{
SibTr.debug(_tc, "The value with the key " + entry.getKey() + " has expired");
}
}
}
if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.exit(this, _tc, "purge");
} | java |
private static StringBuilder toBase64(long value) {
StringBuilder result = new StringBuilder(23); // Initialize with the size of ID if using Base64
for(int shift=60; shift>=0; shift-=6) {
result.append(Base64[(int)((value >> shift) & 0x3F)]);
}
return result;
} | java |
private void nextQueue()
{
if(super.hasNext())
{
do
{
if(_currentSubIterator != null) _currentSubIterator.finished();
_currentSubIterator = null;
_currentQueue = (SIMPQueueControllable) super.next();
try
{
_currentSubIterator = _currentQueue.getRemoteQueuePointIterator();
}
catch (SIMPException e)
{
// No FFDC code needed
if (tc.isDebugEnabled())
SibTr.exception(tc, e);
}
}
// Retry if we failed to get an iterator, that iterator does not
// have any remote queue points in it and we have more queues available.
while((_currentSubIterator == null || !_currentSubIterator.hasNext())
&& super.hasNext());
}
else
{
_currentQueue = null;
if(_currentSubIterator != null) _currentSubIterator.finished();
_currentSubIterator = null;
}
} | java |
@SuppressWarnings("unchecked")
public static <T> T getContextData(String name) {
EventImpl event = (EventImpl) CurrentEvent.get();
if (null != event) {
return (T) event.getContextData(name);
}
return null;
} | java |
public static <T> EventLocal<T> getLocal(String name) {
return (EventLocal<T>) eventLocalNames.get(name);
} | java |
public T get() {
EventImpl event = (EventImpl) CurrentEvent.get();
if (null == event) {
return null;
}
return event.get(this);
} | java |
public void set(T value) {
EventImpl event = (EventImpl) CurrentEvent.get();
if (null != event) {
event.set(this, value);
}
} | java |
public T remove() {
EventImpl event = (EventImpl) CurrentEvent.get();
if (null != event) {
// Also need to remove name, if specified, from the Event's Set.
if (name != null) {
event.removeEventLocalName(name);
}
return event.remove(this);
}
return null;
} | java |
protected void validate() throws IOException {
if (null != this.error) {
throw this.error;
}
if (isClosed()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "validate - is closed: hc: " + this.hashCode() + " details: " + this);
}
throw new IOException("Stream is closed");
}
if (null == this.output) {
setBufferSize(32768);
}
} | java |
@FFDCIgnore({ IOException.class })
private void convertFile(FileChannel fc) throws IOException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Converting FileChannel to buffers");
}
final WsByteBuffer[] body = new WsByteBuffer[1];
final WsByteBufferPoolManager mgr = HttpDispatcher.getBufferManager();
final long max = fc.size();
final long blocksize = (1048576L < max) ? 1048576L : max;
long offset = 0;
while (offset < max) {
ByteBuffer bb = fc.map(MapMode.READ_ONLY, offset, blocksize);
offset += blocksize;
WsByteBuffer wsbb = mgr.wrap(bb);
body[0] = wsbb;
try {
this.isc.sendResponseBody(body);
} catch (MessageSentException mse) {
FFDCFilter.processException(mse, getClass().getName(),
"convertFile", new Object[] { this, this.isc });
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(tc, "Invalid state, message-sent-exception received; " + this.isc);
}
this.error = new IOException("Invalid state");
throw this.error;
} catch (IOException ioe) {
// no FFDC required
this.error = ioe;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Received exception during write: " + ioe);
}
throw ioe;
} finally {
wsbb.release();
}
} // end-while
} | java |
private List<InMemoryMappingFile> copyInMemoryMappingFiles(List<InMemoryMappingFile> copyIMMF) {
List<InMemoryMappingFile> immf = new ArrayList<InMemoryMappingFile>();
for (InMemoryMappingFile file : copyIMMF) {
immf.add(new InMemoryMappingFile(file.getMappingFile()));
}
return immf;
} | java |
protected Channel createChannel(ChannelData channelData) throws ChannelException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "createChannel");
}
TCPChannelConfiguration newCC = new TCPChannelConfiguration(channelData);
TCPChannel channel = null;
boolean isOverrideClassUsed = false;
if ((!newCC.isNIOOnly())
&& (commClass != null)
&& (ChannelFrameworkImpl.getRef().getAsyncIOEnabled())) {
try {
channel = (TCPChannel) commClass.newInstance();
ChannelTermination ct = channel.setup(channelData, newCC, this);
if (ct != null) {
this.terminationList.put(commClassName, ct);
}
isOverrideClassUsed = true;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "using CommClass: " + commClass);
}
} catch (Exception e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception trying to instantiate CommClass: " + e);
}
}
}
if (!isOverrideClassUsed) {
channel = new NioTCPChannel();
ChannelTermination ct = channel.setup(channelData, newCC, this);
if (ct != null) {
this.terminationList.put("NioTCPChannel", ct);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "createChannel");
}
return channel;
} | java |
public void processException(HttpServletRequest req, HttpServletResponse res) throws IOException
{
if (redirectURL != null)
{
res.sendRedirect(redirectURL);
return;
}
if (message == null)
{
res.sendError(statusCode);
}
else
{
res.sendError(statusCode, message);
}
} | java |
public static String getMD5String(String str) {
MessageDigest messageDigest = getMessageDigest(MD5);
return getHashString(str, messageDigest);
} | java |
public static String getFileMD5String(File file) throws IOException {
MessageDigest messageDigest = getMessageDigest(MD5);
return getFileHashString(file, messageDigest);
} | java |
public static String getSHA256String(String str) {
MessageDigest messageDigest = getMessageDigest(SHA256);
return getHashString(str, messageDigest);
} | java |
public static String getFileSHA256String(File file) throws IOException {
MessageDigest messageDigest = getMessageDigest(SHA256);
return getFileHashString(file, messageDigest);
} | java |
private static MessageDigest getMessageDigest(String digestType) {
MessageDigest messageDigest;
try {
messageDigest = MessageDigest.getInstance(digestType);
} catch (NoSuchAlgorithmException e) {
//should not happen
throw new RuntimeException(e);
}
return messageDigest;
} | java |
public void install(InstallAsset installAsset, List<File> filesInstalled, Collection<String> featuresToBeInstalled, ExistsAction existsAction,
Set<String> executableFiles, Map<String, Set<String>> extattrFiles, boolean downloadDependencies,
RestRepositoryConnectionProxy proxy, ChecksumsManager checksumsManager) throws IOException, InstallException {
if (installAsset.isFeature())
ESAAdaptor.install(product, (ESAAsset) installAsset, filesInstalled, featuresToBeInstalled, existsAction, executableFiles, extattrFiles, checksumsManager);
else if (installAsset.isFix())
FixAdaptor.install(product, (FixAsset) installAsset);
else if (installAsset.isServerPackage())
if (installAsset instanceof JarAsset) {
ServerPackageJarAdaptor.install(product, (JarAsset) installAsset, filesInstalled, downloadDependencies, proxy);
} else {
ServicePackageAdaptor.install(product, (ServerPackageAsset) installAsset, filesInstalled, existsAction);
}
else if (installAsset.isSample())
ServerPackageJarAdaptor.install(product, (JarAsset) installAsset, filesInstalled, downloadDependencies, proxy);
else if (installAsset.isOpenSource())
ServerPackageJarAdaptor.install(product, (JarAsset) installAsset, filesInstalled, downloadDependencies, proxy);
} | java |
public void installFeatureNoDependencyCheck(InstallAsset installAsset, List<File> filesInstalled, Collection<String> featuresToBeInstalled, ExistsAction existsAction,
Set<String> executableFiles, Map<String, Set<String>> extattrFiles, boolean downloadDependencies,
RestRepositoryConnectionProxy proxy, ChecksumsManager checksumsManager) throws IOException, InstallException {
ESAAdaptor.install(product, (ESAAsset) installAsset, filesInstalled, featuresToBeInstalled, existsAction, executableFiles, extattrFiles, checksumsManager, true);
} | java |
public void uninstall(UninstallAsset uninstallAsset, boolean checkDependency,
List<File> filesRestored) throws IOException, ParserConfigurationException, SAXException, InstallException {
if (uninstallAsset.getType().equals(UninstallAssetType.feature)) {
// Remove the feature contents and metadata
ESAAdaptor.uninstallFeature(uninstallAsset, uninstallAsset.getProvisioningFeatureDefinition(),
getBaseDir(uninstallAsset.getProvisioningFeatureDefinition()), filesRestored);
} else if (uninstallAsset.getType().equals(UninstallAssetType.fix)) {
FixAdaptor.uninstallFix(uninstallAsset.getIFixInfo(), product.getInstallDir(), filesRestored);
}
InstallUtils.updateFingerprint(product.getInstallDir());
} | java |
public void preCheck(UninstallAsset uninstallAsset) throws InstallException {
if (uninstallAsset.getType().equals(UninstallAssetType.feature)) {
ESAAdaptor.preCheck(uninstallAsset, uninstallAsset.getProvisioningFeatureDefinition(),
getBaseDir(uninstallAsset.getProvisioningFeatureDefinition()));
} else if (uninstallAsset.getType().equals(UninstallAssetType.fix)) {
FixAdaptor.preCheck(uninstallAsset.getIFixInfo(), product.getInstallDir());
}
} | java |
public final FFDCLogger append(String description, Object value) {
lines.add(description);
lines.add(new StringBuffer().append(TAB).append(value).append(AdapterUtil.EOLN).toString());
return this;
} | java |
public final FFDCLogger append(String info) {
lines.add(new StringBuffer().append(info).append(AdapterUtil.EOLN).toString());
return this;
} | java |
public final FFDCLogger append(String[] moreLines) {
int numLines = moreLines.length;
for (int i = 0; i < numLines; i++)
lines.add(moreLines[i]);
return this;
} | java |
public final FFDCLogger indent(Object value) {
lines.add(new StringBuffer().append(TAB).append(value).toString());
return this;
} | java |
public final FFDCLogger introspect(String description, Object value)
{
if (value instanceof FFDCSelfIntrospectable)
append(((FFDCSelfIntrospectable) value).introspectSelf());
else
append(description, value);
return this;
} | java |
private ProvisioningFeatureDefinition getCachedFeature(String featureName) {
List<ProvisioningFeatureDefinition> featureList = symbolicNameToFeature.get(featureName);
if (featureList == null) {
featureName = publicNameToSymbolicName.get(featureName.toLowerCase());
if (featureName != null) {
featureList = symbolicNameToFeature.get(featureName);
}
}
if (featureList == null || featureList.isEmpty()) {
return null;
}
return getPreferredVersion(featureName, featureList);
} | java |
private List<RepositoryResource> getResourcesForName(String resourceName) {
List<RepositoryResource> results = new ArrayList<>();
try {
results.addAll(repositoryConnection.getMatchingEsas(FilterableAttribute.SYMBOLIC_NAME, resourceName));
results.addAll(repositoryConnection.getMatchingEsas(FilterableAttribute.LOWER_CASE_SHORT_NAME, resourceName.toLowerCase()));
results.addAll(repositoryConnection.getMatchingSamples(FilterableAttribute.LOWER_CASE_SHORT_NAME, resourceName.toLowerCase()));
} catch (RepositoryBackendException e) {
// Don't worry if we fail to contact the repository
// worst case is we report a resource as missing rather than available on another version/edition
}
return results;
} | java |