code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public Class<E> getEventClass() {
if (cachedClazz != null) {
return cachedClazz;
}
Class<?> clazz = this.getClass();
while (clazz != Object.class) {
try {
Type mySuperclass = clazz.getGenericSuperclass();
Type tType = ((ParameterizedType) mySuperclass).getActualTypeArguments()[0];
cachedClazz = (Class<E>) Class.forName(tType.getTypeName());
return cachedClazz;
} catch (Exception e) {
}
clazz = clazz.getSuperclass();
}
throw new IllegalStateException("Failed to load event class - " + this.getClass().getCanonicalName());
} | java |
protected final String computeId(
final ITemplateContext context,
final IProcessableElementTag tag,
final String name, final boolean sequence) {
String id = tag.getAttributeValue(this.idAttributeDefinition.getAttributeName());
if (!org.thymeleaf.util.StringUtils.isEmptyOrWhitespace(id)) {
return (StringUtils.hasText(id) ? id : null);
}
id = FieldUtils.idFromName(name);
if (sequence) {
final Integer count = context.getIdentifierSequences().getAndIncrementIDSeq(id);
return id + count.toString();
}
return id;
} | java |
public String code(final String code) {
if (this.theme == null) {
throw new TemplateProcessingException("Theme cannot be resolved because RequestContext was not found. "
+ "Are you using a Context object without a RequestContext variable?");
}
return this.theme.getMessageSource().getMessage(code, null, "", this.locale);
} | java |
private static DirectoryGrouping resolveDirectoryGrouping(final ModelNode model, final ExpressionResolver expressionResolver) {
try {
return DirectoryGrouping.forName(HostResourceDefinition.DIRECTORY_GROUPING.resolveModelAttribute(expressionResolver, model).asString());
} catch (OperationFailedException e) {
throw new IllegalStateException(e);
}
} | java |
private String addPathProperty(final List<String> command, final String typeName, final String propertyName, final Map<String, String> properties, final DirectoryGrouping directoryGrouping,
final File typeDir, File serverDir) {
final String result;
final String value = properties.get(propertyName);
if (value == null) {
switch (directoryGrouping) {
case BY_TYPE:
result = getAbsolutePath(typeDir, "servers", serverName);
break;
case BY_SERVER:
default:
result = getAbsolutePath(serverDir, typeName);
break;
}
properties.put(propertyName, result);
} else {
final File dir = new File(value);
switch (directoryGrouping) {
case BY_TYPE:
result = getAbsolutePath(dir, "servers", serverName);
break;
case BY_SERVER:
default:
result = getAbsolutePath(dir, serverName);
break;
}
}
command.add(String.format("-D%s=%s", propertyName, result));
return result;
} | java |
private String findLoggingProfile(final ResourceRoot resourceRoot) {
final Manifest manifest = resourceRoot.getAttachment(Attachments.MANIFEST);
if (manifest != null) {
final String loggingProfile = manifest.getMainAttributes().getValue(LOGGING_PROFILE);
if (loggingProfile != null) {
LoggingLogger.ROOT_LOGGER.debugf("Logging profile '%s' found in '%s'.", loggingProfile, resourceRoot);
return loggingProfile;
}
}
return null;
} | java |
public static int getBytesToken(ParsingContext ctx) {
String input = ctx.getInput().substring(ctx.getLocation());
int tokenOffset = 0;
int i = 0;
char[] inputChars = input.toCharArray();
for (; i < input.length(); i += 1) {
char c = inputChars[i];
if (c == ' ') {
continue;
}
if (c != BYTES_TOKEN_CHARS[tokenOffset]) {
return -1;
} else {
tokenOffset += 1;
if (tokenOffset == BYTES_TOKEN_CHARS.length) {
// Found the token.
return i;
}
}
}
return -1;
} | java |
public static void addOperation(final OperationContext context) {
RbacSanityCheckOperation added = context.getAttachment(KEY);
if (added == null) {
// TODO support managed domain
if (!context.isNormalServer()) return;
context.addStep(createOperation(), INSTANCE, Stage.MODEL);
context.attach(KEY, INSTANCE);
}
} | java |
public static ModelNode getFailureDescription(final ModelNode result) {
if (isSuccessfulOutcome(result)) {
throw ControllerClientLogger.ROOT_LOGGER.noFailureDescription();
}
if (result.hasDefined(FAILURE_DESCRIPTION)) {
return result.get(FAILURE_DESCRIPTION);
}
return new ModelNode();
} | java |
public static ModelNode getOperationAddress(final ModelNode op) {
return op.hasDefined(OP_ADDR) ? op.get(OP_ADDR) : new ModelNode();
} | java |
public static String getOperationName(final ModelNode op) {
if (op.hasDefined(OP)) {
return op.get(OP).asString();
}
throw ControllerClientLogger.ROOT_LOGGER.operationNameNotFound();
} | java |
public static ModelNode createReadResourceOperation(final ModelNode address, final boolean recursive) {
final ModelNode op = createOperation(READ_RESOURCE_OPERATION, address);
op.get(RECURSIVE).set(recursive);
return op;
} | java |
public ModelNode buildRequest() throws OperationFormatException {
ModelNode address = request.get(Util.ADDRESS);
if(prefix.isEmpty()) {
address.setEmptyList();
} else {
Iterator<Node> iterator = prefix.iterator();
while (iterator.hasNext()) {
OperationRequestAddress.Node node = iterator.next();
if (node.getName() != null) {
address.add(node.getType(), node.getName());
} else if (iterator.hasNext()) {
throw new OperationFormatException(
"The node name is not specified for type '"
+ node.getType() + "'");
}
}
}
if(!request.hasDefined(Util.OPERATION)) {
throw new OperationFormatException("The operation name is missing or the format of the operation request is wrong.");
}
return request;
} | java |
private void parseUsersAuthentication(final XMLExtendedStreamReader reader,
final ModelNode realmAddress, final List<ModelNode> list)
throws XMLStreamException {
final ModelNode usersAddress = realmAddress.clone().add(AUTHENTICATION, USERS);
list.add(Util.getEmptyOperation(ADD, usersAddress));
while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
requireNamespace(reader, namespace);
final Element element = Element.forName(reader.getLocalName());
switch (element) {
case USER: {
parseUser(reader, usersAddress, list);
break;
}
default: {
throw unexpectedElement(reader);
}
}
}
} | java |
public Set<Action.ActionEffect> getActionEffects() {
switch(getImpact()) {
case CLASSLOADING:
case WRITE:
return WRITES;
case READ_ONLY:
return READS;
default:
throw new IllegalStateException();
}
} | java |
private ModelNode addLocalHost(final ModelNode address, final List<ModelNode> operationList, final String hostName) {
String resolvedHost = hostName != null ? hostName : defaultHostControllerName;
// All further operations should modify the newly added host so the address passed in is updated.
address.add(HOST, resolvedHost);
// Add a step to setup the ManagementResourceRegistrations for the root host resource
final ModelNode hostAddOp = new ModelNode();
hostAddOp.get(OP).set(HostAddHandler.OPERATION_NAME);
hostAddOp.get(OP_ADDR).set(address);
operationList.add(hostAddOp);
// Add a step to store the HC name
ModelNode nameValue = hostName == null ? new ModelNode() : new ModelNode(hostName);
final ModelNode writeName = Util.getWriteAttributeOperation(address, NAME, nameValue);
operationList.add(writeName);
return hostAddOp;
} | java |
public static byte[] hashPath(MessageDigest messageDigest, Path path) throws IOException {
try (InputStream in = getRecursiveContentStream(path)) {
return hashContent(messageDigest, in);
}
} | java |
public synchronized ModelNode doCommand(String command) throws CommandFormatException, IOException {
ModelNode request = cmdCtx.buildRequest(command);
return execute(request, isSlowCommand(command)).getResponseNode();
} | java |
public synchronized Response doCommandFullResponse(String command) throws CommandFormatException, IOException {
ModelNode request = cmdCtx.buildRequest(command);
boolean replacedBytes = replaceFilePathsWithBytes(request);
OperationResponse response = execute(request, isSlowCommand(command) || replacedBytes);
return new Response(command, request, response);
} | java |
private File[] getFilesFromProperty(final String name, final Properties props) {
String sep = WildFlySecurityManager.getPropertyPrivileged("path.separator", null);
String value = props.getProperty(name, null);
if (value != null) {
final String[] paths = value.split(Pattern.quote(sep));
final int len = paths.length;
final File[] files = new File[len];
for (int i = 0; i < len; i++) {
files[i] = new File(paths[i]);
}
return files;
}
return NO_FILES;
} | java |
public boolean putAtomic(C instance, K key, V value, Map<K, V> snapshot) {
Assert.checkNotNullParam("key", key);
final Map<K, V> newMap;
final int oldSize = snapshot.size();
if (oldSize == 0) {
newMap = Collections.singletonMap(key, value);
} else if (oldSize == 1) {
final Map.Entry<K, V> entry = snapshot.entrySet().iterator().next();
final K oldKey = entry.getKey();
if (oldKey.equals(key)) {
return false;
} else {
newMap = new FastCopyHashMap<K, V>(snapshot);
newMap.put(key, value);
}
} else {
newMap = new FastCopyHashMap<K, V>(snapshot);
newMap.put(key, value);
}
return updater.compareAndSet(instance, snapshot, newMap);
} | java |
@Deprecated
public void parseAndSetParameter(String value, ModelNode operation, XMLStreamReader reader) throws XMLStreamException {
//we use manual parsing here, and not #getParser().. to preserve backward compatibility.
if (value != null) {
for (String element : value.split(",")) {
parseAndAddParameterElement(element.trim(), operation, reader);
}
}
} | java |
boolean lock(final Integer permit, final long timeout, final TimeUnit unit) {
boolean result = false;
try {
result = lockInterruptibly(permit, timeout, unit);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return result;
} | java |
boolean lockShared(final Integer permit, final long timeout, final TimeUnit unit) {
boolean result = false;
try {
result = lockSharedInterruptibly(permit, timeout, unit);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return result;
} | java |
void lockInterruptibly(final Integer permit) throws InterruptedException {
if (permit == null) {
throw new IllegalArgumentException();
}
sync.acquireInterruptibly(permit);
} | java |
void lockSharedInterruptibly(final Integer permit) throws InterruptedException {
if (permit == null) {
throw new IllegalArgumentException();
}
sync.acquireSharedInterruptibly(permit);
} | java |
boolean lockInterruptibly(final Integer permit, final long timeout, final TimeUnit unit) throws InterruptedException {
if (permit == null) {
throw new IllegalArgumentException();
}
return sync.tryAcquireNanos(permit, unit.toNanos(timeout));
} | java |
boolean lockSharedInterruptibly(final Integer permit, final long timeout, final TimeUnit unit) throws InterruptedException {
if (permit == null) {
throw new IllegalArgumentException();
}
return sync.tryAcquireSharedNanos(permit, unit.toNanos(timeout));
} | java |
CapabilityRegistry createShadowCopy() {
CapabilityRegistry result = new CapabilityRegistry(forServer, this);
readLock.lock();
try {
try {
result.writeLock.lock();
copy(this, result);
} finally {
result.writeLock.unlock();
}
} finally {
readLock.unlock();
}
return result;
} | java |
private void registerRequirement(RuntimeRequirementRegistration requirement) {
assert writeLock.isHeldByCurrentThread();
CapabilityId dependentId = requirement.getDependentId();
if (!capabilities.containsKey(dependentId)) {
throw ControllerLogger.MGMT_OP_LOGGER.unknownCapabilityInContext(dependentId.getName(),
dependentId.getScope().getName());
}
Map<CapabilityId, Map<String, RuntimeRequirementRegistration>> requirementMap =
requirement.isRuntimeOnly() ? runtimeOnlyRequirements : requirements;
Map<String, RuntimeRequirementRegistration> dependents = requirementMap.get(dependentId);
if (dependents == null) {
dependents = new HashMap<>();
requirementMap.put(dependentId, dependents);
}
RuntimeRequirementRegistration existing = dependents.get(requirement.getRequiredName());
if (existing == null) {
dependents.put(requirement.getRequiredName(), requirement);
} else {
existing.addRegistrationPoint(requirement.getOldestRegistrationPoint());
}
modified = true;
} | java |
@Override
public void removeCapabilityRequirement(RuntimeRequirementRegistration requirementRegistration) {
// We don't know if this got registered as an runtime-only requirement or a hard one
// so clean it from both maps
writeLock.lock();
try {
removeRequirement(requirementRegistration, false);
removeRequirement(requirementRegistration, true);
} finally {
writeLock.unlock();
}
} | java |
void publish() {
assert publishedFullRegistry != null : "Cannot write directly to main registry";
writeLock.lock();
try {
if (!modified) {
return;
}
publishedFullRegistry.writeLock.lock();
try {
publishedFullRegistry.clear(true);
copy(this, publishedFullRegistry);
pendingRemoveCapabilities.clear();
pendingRemoveRequirements.clear();
modified = false;
} finally {
publishedFullRegistry.writeLock.unlock();
}
} finally {
writeLock.unlock();
}
} | java |
void rollback() {
if (publishedFullRegistry == null) {
return;
}
writeLock.lock();
try {
publishedFullRegistry.readLock.lock();
try {
clear(true);
copy(publishedFullRegistry, this);
modified = false;
} finally {
publishedFullRegistry.readLock.unlock();
}
} finally {
writeLock.unlock();
}
} | java |
static void addOperationAddress(final ModelNode operation, final PathAddress base, final String key, final String value) {
operation.get(OP_ADDR).set(base.append(key, value).toModelNode());
} | java |
static String findNonProgressingOp(Resource resource, boolean forServer, long timeout) throws OperationFailedException {
Resource.ResourceEntry nonProgressing = null;
for (Resource.ResourceEntry child : resource.getChildren(ACTIVE_OPERATION)) {
ModelNode model = child.getModel();
if (model.get(EXCLUSIVE_RUNNING_TIME).asLong() > timeout) {
nonProgressing = child;
ControllerLogger.MGMT_OP_LOGGER.tracef("non-progressing op: %s", nonProgressing.getModel());
break;
}
}
if (nonProgressing != null && !forServer) {
// WFCORE-263
// See if the op is non-progressing because it's the HC op waiting for commit
// from the DC while other ops (i.e. ops proxied to our servers) associated
// with the same domain-uuid are not completing
ModelNode model = nonProgressing.getModel();
if (model.get(DOMAIN_ROLLOUT).asBoolean()
&& OperationContext.ExecutionStatus.COMPLETING.toString().equals(model.get(EXECUTION_STATUS).asString())
&& model.hasDefined(DOMAIN_UUID)) {
ControllerLogger.MGMT_OP_LOGGER.trace("Potential domain rollout issue");
String domainUUID = model.get(DOMAIN_UUID).asString();
Set<String> relatedIds = null;
List<Resource.ResourceEntry> relatedExecutingOps = null;
for (Resource.ResourceEntry activeOp : resource.getChildren(ACTIVE_OPERATION)) {
if (nonProgressing.getName().equals(activeOp.getName())) {
continue; // ignore self
}
ModelNode opModel = activeOp.getModel();
if (opModel.hasDefined(DOMAIN_UUID) && domainUUID.equals(opModel.get(DOMAIN_UUID).asString())
&& opModel.get(RUNNING_TIME).asLong() > timeout) {
if (relatedIds == null) {
relatedIds = new TreeSet<String>(); // order these as an aid to unit testing
}
relatedIds.add(activeOp.getName());
// If the op is ExecutionStatus.EXECUTING that means it's still EXECUTING on the
// server or a prepare message got lost. It would be COMPLETING if the server
// had sent a prepare message, as that would result in ProxyStepHandler calling completeStep
if (OperationContext.ExecutionStatus.EXECUTING.toString().equals(opModel.get(EXECUTION_STATUS).asString())) {
if (relatedExecutingOps == null) {
relatedExecutingOps = new ArrayList<Resource.ResourceEntry>();
}
relatedExecutingOps.add(activeOp);
ControllerLogger.MGMT_OP_LOGGER.tracef("Related executing: %s", opModel);
} else ControllerLogger.MGMT_OP_LOGGER.tracef("Related non-executing: %s", opModel);
} else ControllerLogger.MGMT_OP_LOGGER.tracef("unrelated: %s", opModel);
}
if (relatedIds != null) {
// There are other ops associated with this domain-uuid that are also not completing
// in the desired time, so we can't treat the one holding the lock as the problem.
if (relatedExecutingOps != null && relatedExecutingOps.size() == 1) {
// There's a single related op that's executing for too long. So we can report that one.
// Note that it's possible that the same problem exists on other hosts as well
// and that this cancellation will not resolve the overall problem. But, we only
// get here on a slave HC and if the user is invoking this on a slave and not the
// master, we'll assume they have a reason for doing that and want us to treat this
// as a problem on this particular host.
nonProgressing = relatedExecutingOps.get(0);
} else {
// Fail and provide a useful failure message.
throw DomainManagementLogger.ROOT_LOGGER.domainRolloutNotProgressing(nonProgressing.getName(),
timeout, domainUUID, relatedIds);
}
}
}
}
return nonProgressing == null ? null : nonProgressing.getName();
} | java |
void bootTimeScan(final DeploymentOperations deploymentOperations) {
// WFCORE-1579: skip the scan if deployment dir is not available
if (!checkDeploymentDir(this.deploymentDir)) {
DeploymentScannerLogger.ROOT_LOGGER.bootTimeScanFailed(deploymentDir.getAbsolutePath());
return;
}
this.establishDeployedContentList(this.deploymentDir, deploymentOperations);
deployedContentEstablished = true;
if (acquireScanLock()) {
try {
scan(true, deploymentOperations);
} finally {
releaseScanLock();
}
}
} | java |
void scan() {
if (acquireScanLock()) {
boolean scheduleRescan = false;
try {
scheduleRescan = scan(false, deploymentOperations);
} finally {
try {
if (scheduleRescan) {
synchronized (this) {
if (scanEnabled) {
rescanIncompleteTask = scheduledExecutor.schedule(scanRunnable, 200, TimeUnit.MILLISECONDS);
}
}
}
} finally {
releaseScanLock();
}
}
}
} | java |
void forcedUndeployScan() {
if (acquireScanLock()) {
try {
ROOT_LOGGER.tracef("Performing a post-boot forced undeploy scan for scan directory %s", deploymentDir.getAbsolutePath());
ScanContext scanContext = new ScanContext(deploymentOperations);
// Add remove actions to the plan for anything we count as
// deployed that we didn't find on the scan
for (Map.Entry<String, DeploymentMarker> missing : scanContext.toRemove.entrySet()) {
// remove successful deployment and left will be removed
if (scanContext.registeredDeployments.containsKey(missing.getKey())) {
scanContext.registeredDeployments.remove(missing.getKey());
}
}
Set<String> scannedDeployments = new HashSet<String>(scanContext.registeredDeployments.keySet());
scannedDeployments.removeAll(scanContext.persistentDeployments);
List<ScannerTask> scannerTasks = scanContext.scannerTasks;
for (String toUndeploy : scannedDeployments) {
scannerTasks.add(new UndeployTask(toUndeploy, deploymentDir, scanContext.scanStartTime, true));
}
try {
executeScannerTasks(scannerTasks, deploymentOperations, true);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
ROOT_LOGGER.tracef("Forced undeploy scan complete");
} catch (Exception e) {
ROOT_LOGGER.scanException(e, deploymentDir.getAbsolutePath());
} finally {
releaseScanLock();
}
}
} | java |
private boolean checkDeploymentDir(File directory) {
if (!directory.exists()) {
if (deploymentDirAccessible) {
deploymentDirAccessible = false;
ROOT_LOGGER.directoryIsNonexistent(deploymentDir.getAbsolutePath());
}
}
else if (!directory.isDirectory()) {
if (deploymentDirAccessible) {
deploymentDirAccessible = false;
ROOT_LOGGER.isNotADirectory(deploymentDir.getAbsolutePath());
}
}
else if (!directory.canRead()) {
if (deploymentDirAccessible) {
deploymentDirAccessible = false;
ROOT_LOGGER.directoryIsNotReadable(deploymentDir.getAbsolutePath());
}
}
else if (!directory.canWrite()) {
if (deploymentDirAccessible) {
deploymentDirAccessible = false;
ROOT_LOGGER.directoryIsNotWritable(deploymentDir.getAbsolutePath());
}
} else {
deploymentDirAccessible = true;
}
return deploymentDirAccessible;
} | java |
private static ModelNode createOperation(final ModelNode operationToValidate) {
PathAddress pa = PathAddress.pathAddress(operationToValidate.require(OP_ADDR));
PathAddress validationAddress = pa.subAddress(0, pa.size() - 1);
return Util.getEmptyOperation("validate-cache", validationAddress.toModelNode());
} | java |
public synchronized RegistrationPoint getOldestRegistrationPoint() {
return registrationPoints.size() == 0 ? null : registrationPoints.values().iterator().next().get(0);
} | java |
public synchronized Set<RegistrationPoint> getRegistrationPoints() {
Set<RegistrationPoint> result = new HashSet<>();
for (List<RegistrationPoint> registrationPoints : registrationPoints.values()) {
result.addAll(registrationPoints);
}
return Collections.unmodifiableSet(result);
} | java |
public static boolean hasValidContentAdditionParameterDefined(ModelNode operation) {
for (String s : DeploymentAttributes.MANAGED_CONTENT_ATTRIBUTES.keySet()) {
if (operation.hasDefined(s)) {
return true;
}
}
return false;
} | java |
static InstalledIdentity load(final InstalledImage image, final ProductConfig productConfig, final List<File> moduleRoots, final List<File> bundleRoots) throws IOException {
// build the identity information
final String productVersion = productConfig.resolveVersion();
final String productName = productConfig.resolveName();
final Identity identity = new AbstractLazyIdentity() {
@Override
public String getName() {
return productName;
}
@Override
public String getVersion() {
return productVersion;
}
@Override
public InstalledImage getInstalledImage() {
return image;
}
};
final Properties properties = PatchUtils.loadProperties(identity.getDirectoryStructure().getInstallationInfo());
final List<String> allPatches = PatchUtils.readRefs(properties, Constants.ALL_PATCHES);
// Step 1 - gather the installed layers data
final InstalledConfiguration conf = createInstalledConfig(image);
// Step 2 - process the actual module and bundle roots
final ProcessedLayers processedLayers = process(conf, moduleRoots, bundleRoots);
final InstalledConfiguration config = processedLayers.getConf();
// Step 3 - create the actual config objects
// Process layers
final InstalledIdentityImpl installedIdentity = new InstalledIdentityImpl(identity, allPatches, image);
for (final LayerPathConfig layer : processedLayers.getLayers().values()) {
final String name = layer.name;
installedIdentity.putLayer(name, createPatchableTarget(name, layer, config.getLayerMetadataDir(name), image));
}
// Process add-ons
for (final LayerPathConfig addOn : processedLayers.getAddOns().values()) {
final String name = addOn.name;
installedIdentity.putAddOn(name, createPatchableTarget(name, addOn, config.getAddOnMetadataDir(name), image));
}
return installedIdentity;
} | java |
static ProcessedLayers process(final InstalledConfiguration conf, final List<File> moduleRoots, final List<File> bundleRoots) throws IOException {
final ProcessedLayers layers = new ProcessedLayers(conf);
// Process module roots
final LayerPathSetter moduleSetter = new LayerPathSetter() {
@Override
public boolean setPath(final LayerPathConfig pending, final File root) {
if (pending.modulePath == null) {
pending.modulePath = root;
return true;
}
return false;
}
};
for (final File moduleRoot : moduleRoots) {
processRoot(moduleRoot, layers, moduleSetter);
}
// Process bundle root
final LayerPathSetter bundleSetter = new LayerPathSetter() {
@Override
public boolean setPath(LayerPathConfig pending, File root) {
if (pending.bundlePath == null) {
pending.bundlePath = root;
return true;
}
return false;
}
};
for (final File bundleRoot : bundleRoots) {
processRoot(bundleRoot, layers, bundleSetter);
}
// if (conf.getInstalledLayers().size() != layers.getLayers().size()) {
// throw processingError("processed layers don't match expected %s, but was %s", conf.getInstalledLayers(), layers.getLayers().keySet());
// }
// if (conf.getInstalledAddOns().size() != layers.getAddOns().size()) {
// throw processingError("processed add-ons don't match expected %s, but was %s", conf.getInstalledAddOns(), layers.getAddOns().keySet());
// }
return layers;
} | java |
static void processRoot(final File root, final ProcessedLayers layers, final LayerPathSetter setter) throws IOException {
final LayersConfig layersConfig = LayersConfig.getLayersConfig(root);
// Process layers
final File layersDir = new File(root, layersConfig.getLayersPath());
if (!layersDir.exists()) {
if (layersConfig.isConfigured()) {
// Bad config from user
throw PatchLogger.ROOT_LOGGER.installationNoLayersConfigFound(layersDir.getAbsolutePath());
}
// else this isn't a root that has layers and add-ons
} else {
// check for a valid layer configuration
for (final String layer : layersConfig.getLayers()) {
File layerDir = new File(layersDir, layer);
if (!layerDir.exists()) {
if (layersConfig.isConfigured()) {
// Bad config from user
throw PatchLogger.ROOT_LOGGER.installationMissingLayer(layer, layersDir.getAbsolutePath());
}
// else this isn't a standard layers and add-ons structure
return;
}
layers.addLayer(layer, layerDir, setter);
}
}
// Finally process the add-ons
final File addOnsDir = new File(root, layersConfig.getAddOnsPath());
final File[] addOnsList = addOnsDir.listFiles();
if (addOnsList != null) {
for (final File addOn : addOnsList) {
layers.addAddOn(addOn.getName(), addOn, setter);
}
}
} | java |
static AbstractLazyPatchableTarget createPatchableTarget(final String name, final LayerPathConfig layer, final File metadata, final InstalledImage image) throws IOException {
// patchable target
return new AbstractLazyPatchableTarget() {
@Override
public InstalledImage getInstalledImage() {
return image;
}
@Override
public File getModuleRoot() {
return layer.modulePath;
}
@Override
public File getBundleRepositoryRoot() {
return layer.bundlePath;
}
public File getPatchesMetadata() {
return metadata;
}
@Override
public String getName() {
return name;
}
};
} | java |
public List<ModelNode> getAllowedValues() {
if (allowedValues == null) {
return Collections.emptyList();
}
return Arrays.asList(this.allowedValues);
} | java |
protected void addAllowedValuesToDescription(ModelNode result, ParameterValidator validator) {
if (allowedValues != null) {
for (ModelNode allowedValue : allowedValues) {
result.get(ModelDescriptionConstants.ALLOWED).add(allowedValue);
}
} else if (validator instanceof AllowedValuesValidator) {
AllowedValuesValidator avv = (AllowedValuesValidator) validator;
List<ModelNode> allowed = avv.getAllowedValues();
if (allowed != null) {
for (ModelNode ok : allowed) {
result.get(ModelDescriptionConstants.ALLOWED).add(ok);
}
}
}
} | java |
public static ModelNode validateRequest(CommandContext ctx, ModelNode request) throws CommandFormatException {
final Set<String> keys = request.keys();
if (keys.size() == 2) { // no props
return null;
}
ModelNode outcome = (ModelNode) ctx.get(Scope.REQUEST, DESCRIPTION_RESPONSE);
if (outcome == null) {
outcome = retrieveDescription(ctx, request, true);
if (outcome == null) {
return null;
} else {
ctx.set(Scope.REQUEST, DESCRIPTION_RESPONSE, outcome);
}
}
if(!outcome.has(Util.RESULT)) {
throw new CommandFormatException("Failed to perform " + Util.READ_OPERATION_DESCRIPTION + " to validate the request: result is not available.");
}
final String operationName = request.get(Util.OPERATION).asString();
final ModelNode result = outcome.get(Util.RESULT);
final Set<String> definedProps = result.hasDefined(Util.REQUEST_PROPERTIES) ? result.get(Util.REQUEST_PROPERTIES).keys() : Collections.emptySet();
if(definedProps.isEmpty()) {
if(!(keys.size() == 3 && keys.contains(Util.OPERATION_HEADERS))) {
throw new CommandFormatException("Operation '" + operationName + "' does not expect any property.");
}
} else {
int skipped = 0;
for(String prop : keys) {
if(skipped < 2 && (prop.equals(Util.ADDRESS) || prop.equals(Util.OPERATION))) {
++skipped;
continue;
}
if(!definedProps.contains(prop)) {
if(!Util.OPERATION_HEADERS.equals(prop)) {
throw new CommandFormatException("'" + prop + "' is not found among the supported properties: " + definedProps);
}
}
}
}
return outcome;
} | java |
public static boolean reconnectContext(RedirectException re, CommandContext ctx) {
boolean reconnected = false;
try {
ConnectionInfo info = ctx.getConnectionInfo();
ControllerAddress address = null;
if (info != null) {
address = info.getControllerAddress();
}
if (address != null && isHttpsRedirect(re, address.getProtocol())) {
LOG.debug("Trying to reconnect an http to http upgrade");
try {
ctx.connectController();
reconnected = true;
} catch (Exception ex) {
LOG.warn("Exception reconnecting", ex);
// Proper https redirect but error.
// Ignoring it.
}
}
} catch (URISyntaxException ex) {
LOG.warn("Invalid URI: ", ex);
// OK, invalid redirect.
}
return reconnected;
} | java |
public static String compactToString(ModelNode node) {
Objects.requireNonNull(node);
final StringWriter stringWriter = new StringWriter();
final PrintWriter writer = new PrintWriter(stringWriter, true);
node.writeString(writer, true);
return stringWriter.toString();
} | java |
private void init() {
validatePreSignedUrls();
try {
conn = new AWSAuthConnection(access_key, secret_access_key);
// Determine the bucket name if prefix is set or if pre-signed URLs are being used
if (prefix != null && prefix.length() > 0) {
ListAllMyBucketsResponse bucket_list = conn.listAllMyBuckets(null);
List buckets = bucket_list.entries;
if (buckets != null) {
boolean found = false;
for (Object tmp : buckets) {
if (tmp instanceof Bucket) {
Bucket bucket = (Bucket) tmp;
if (bucket.name.startsWith(prefix)) {
location = bucket.name;
found = true;
}
}
}
if (!found) {
location = prefix + "-" + java.util.UUID.randomUUID().toString();
}
}
}
if (usingPreSignedUrls()) {
PreSignedUrlParser parsedPut = new PreSignedUrlParser(pre_signed_put_url);
location = parsedPut.getBucket();
}
if (!conn.checkBucketExists(location)) {
conn.createBucket(location, AWSAuthConnection.LOCATION_DEFAULT, null).connection.getResponseMessage();
}
} catch (Exception e) {
throw HostControllerLogger.ROOT_LOGGER.cannotAccessS3Bucket(location, e.getLocalizedMessage());
}
} | java |
private List<DomainControllerData> readFromFile(String directoryName) {
List<DomainControllerData> data = new ArrayList<DomainControllerData>();
if (directoryName == null) {
return data;
}
if (conn == null) {
init();
}
try {
if (usingPreSignedUrls()) {
PreSignedUrlParser parsedPut = new PreSignedUrlParser(pre_signed_put_url);
directoryName = parsedPut.getPrefix();
}
String key = S3Util.sanitize(directoryName) + "/" + S3Util.sanitize(DC_FILE_NAME);
GetResponse val = conn.get(location, key, null);
if (val.object != null) {
byte[] buf = val.object.data;
if (buf != null && buf.length > 0) {
try {
data = S3Util.domainControllerDataFromByteBuffer(buf);
} catch (Exception e) {
throw HostControllerLogger.ROOT_LOGGER.failedMarshallingDomainControllerData();
}
}
}
return data;
} catch (IOException e) {
throw HostControllerLogger.ROOT_LOGGER.cannotAccessS3File(e.getLocalizedMessage());
}
} | java |
private void writeToFile(List<DomainControllerData> data, String domainName) throws IOException {
if(domainName == null || data == null) {
return;
}
if (conn == null) {
init();
}
try {
String key = S3Util.sanitize(domainName) + "/" + S3Util.sanitize(DC_FILE_NAME);
byte[] buf = S3Util.domainControllerDataToByteBuffer(data);
S3Object val = new S3Object(buf, null);
if (usingPreSignedUrls()) {
Map headers = new TreeMap();
headers.put("x-amz-acl", Arrays.asList("public-read"));
conn.put(pre_signed_put_url, val, headers).connection.getResponseMessage();
} else {
Map headers = new TreeMap();
headers.put("Content-Type", Arrays.asList("text/plain"));
conn.put(location, key, val, headers).connection.getResponseMessage();
}
}
catch(Exception e) {
throw HostControllerLogger.ROOT_LOGGER.cannotWriteToS3File(e.getLocalizedMessage());
}
} | java |
private void remove(String directoryName) {
if ((directoryName == null) || (conn == null))
return;
String key = S3Util.sanitize(directoryName) + "/" + S3Util.sanitize(DC_FILE_NAME);
try {
Map headers = new TreeMap();
headers.put("Content-Type", Arrays.asList("text/plain"));
if (usingPreSignedUrls()) {
conn.delete(pre_signed_delete_url).connection.getResponseMessage();
} else {
conn.delete(location, key, headers).connection.getResponseMessage();
}
}
catch(Exception e) {
ROOT_LOGGER.cannotRemoveS3File(e);
}
} | java |
public void mergeSubtree(final OperationTransformerRegistry targetRegistry, final Map<PathAddress, ModelVersion> subTree) {
for(Map.Entry<PathAddress, ModelVersion> entry: subTree.entrySet()) {
mergeSubtree(targetRegistry, entry.getKey(), entry.getValue());
}
} | java |
private static boolean isDisabledHandler(final LogContext logContext, final String handlerName) {
final Map<String, String> disableHandlers = logContext.getAttachment(CommonAttributes.ROOT_LOGGER_NAME, DISABLED_HANDLERS_KEY);
return disableHandlers != null && disableHandlers.containsKey(handlerName);
} | java |
static PathAddress toPathAddress(String domain, ImmutableManagementResourceRegistration registry, ObjectName name) {
if (!name.getDomain().equals(domain)) {
return PathAddress.EMPTY_ADDRESS;
}
if (name.equals(ModelControllerMBeanHelper.createRootObjectName(domain))) {
return PathAddress.EMPTY_ADDRESS;
}
final Hashtable<String, String> properties = name.getKeyPropertyList();
return searchPathAddress(PathAddress.EMPTY_ADDRESS, registry, properties);
} | java |
private void stopDone() {
synchronized (stopLock) {
final StopContext stopContext = this.stopContext;
this.stopContext = null;
if (stopContext != null) {
stopContext.complete();
}
stopLock.notifyAll();
}
} | java |
public String getRejectionLogMessageId() {
String id = logMessageId;
if (id == null) {
id = getRejectionLogMessage(Collections.<String, ModelNode>emptyMap());
}
logMessageId = id;
return logMessageId;
} | java |
@Override
public synchronized void stop(final StopContext context) {
final boolean shutdownServers = runningModeControl.getRestartMode() == RestartMode.SERVERS;
if (shutdownServers) {
Runnable task = new Runnable() {
@Override
public void run() {
try {
serverInventory.shutdown(true, -1, true); // TODO graceful shutdown
serverInventory = null;
// client.getValue().setServerInventory(null);
} finally {
serverCallback.getValue().setCallbackHandler(null);
context.complete();
}
}
};
try {
executorService.getValue().execute(task);
} catch (RejectedExecutionException e) {
task.run();
} finally {
context.asynchronous();
}
} else {
// We have to set the shutdown flag in any case
serverInventory.shutdown(false, -1, true);
serverInventory = null;
}
} | java |
public boolean isResourceExcluded(final PathAddress address) {
if (!localHostControllerInfo.isMasterDomainController() && address.size() > 0) {
IgnoredDomainResourceRoot root = this.rootResource;
PathElement firstElement = address.getElement(0);
IgnoreDomainResourceTypeResource typeResource = root == null ? null : root.getChildInternal(firstElement.getKey());
if (typeResource != null) {
if (typeResource.hasName(firstElement.getValue())) {
return true;
}
}
}
return false;
} | java |
VersionExcludeData getVersionIgnoreData(int major, int minor, int micro) {
VersionExcludeData result = registry.get(new VersionKey(major, minor, micro));
if (result == null) {
result = registry.get(new VersionKey(major, minor, null));
}
return result;
} | java |
public static void copyRecursively(final Path source, final Path target, boolean overwrite) throws IOException {
final CopyOption[] options;
if (overwrite) {
options = new CopyOption[]{StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING};
} else {
options = new CopyOption[]{StandardCopyOption.COPY_ATTRIBUTES};
}
Files.walkFileTree(source, new FileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
Files.copy(dir, target.resolve(source.relativize(dir)), options);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.copy(file, target.resolve(source.relativize(file)), options);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
DeploymentRepositoryLogger.ROOT_LOGGER.cannotCopyFile(exc, file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
return FileVisitResult.CONTINUE;
}
});
} | java |
public static void deleteSilentlyRecursively(final Path path) {
if (path != null) {
try {
deleteRecursively(path);
} catch (IOException ioex) {
DeploymentRepositoryLogger.ROOT_LOGGER.cannotDeleteFile(ioex, path);
}
}
} | java |
public static void deleteRecursively(final Path path) throws IOException {
DeploymentRepositoryLogger.ROOT_LOGGER.debugf("Deleting %s recursively", path);
if (Files.exists(path)) {
Files.walkFileTree(path, new FileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
DeploymentRepositoryLogger.ROOT_LOGGER.cannotDeleteFile(exc, path);
throw exc;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
}
} | java |
public static final Path resolveSecurely(Path rootPath, String path) {
Path resolvedPath;
if(path == null || path.isEmpty()) {
resolvedPath = rootPath.normalize();
} else {
String relativePath = removeSuperflousSlashes(path);
resolvedPath = rootPath.resolve(relativePath).normalize();
}
if(!resolvedPath.startsWith(rootPath)) {
throw DeploymentRepositoryLogger.ROOT_LOGGER.forbiddenPath(path);
}
return resolvedPath;
} | java |
public static List<ContentRepositoryElement> listFiles(final Path rootPath, Path tempDir, final ContentFilter filter) throws IOException {
List<ContentRepositoryElement> result = new ArrayList<>();
if (Files.exists(rootPath)) {
if(isArchive(rootPath)) {
return listZipContent(rootPath, filter);
}
Files.walkFileTree(rootPath, new FileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
if (filter.acceptFile(rootPath, file)) {
result.add(ContentRepositoryElement.createFile(formatPath(rootPath.relativize(file)), Files.size(file)));
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
if (filter.acceptDirectory(rootPath, dir)) {
String directoryPath = formatDirectoryPath(rootPath.relativize(dir));
if(! "/".equals(directoryPath)) {
result.add(ContentRepositoryElement.createFolder(directoryPath));
}
}
return FileVisitResult.CONTINUE;
}
private String formatDirectoryPath(Path path) {
return formatPath(path) + '/';
}
private String formatPath(Path path) {
return path.toString().replace(File.separatorChar, '/');
}
});
} else {
Path file = getFile(rootPath);
if(isArchive(file)) {
Path relativePath = file.relativize(rootPath);
Path target = createTempDirectory(tempDir, "unarchive");
unzip(file, target);
return listFiles(target.resolve(relativePath), tempDir, filter);
} else {
throw new FileNotFoundException(rootPath.toString());
}
}
return result;
} | java |
public static Path createTempDirectory(Path dir, String prefix) throws IOException {
try {
return Files.createTempDirectory(dir, prefix);
} catch (UnsupportedOperationException ex) {
}
return Files.createTempDirectory(dir, prefix);
} | java |
public static void unzip(Path zip, Path target) throws IOException {
try (final ZipFile zipFile = new ZipFile(zip.toFile())){
unzip(zipFile, target);
}
} | java |
public static ServiceController<String> addService(final ServiceName name, final String path,
boolean possiblyAbsolute, final String relativeTo, final ServiceTarget serviceTarget) {
if (possiblyAbsolute && isAbsoluteUnixOrWindowsPath(path)) {
return AbsolutePathService.addService(name, path, serviceTarget);
}
RelativePathService service = new RelativePathService(path);
ServiceBuilder<String> builder = serviceTarget.addService(name, service)
.addDependency(pathNameOf(relativeTo), String.class, service.injectedPath);
ServiceController<String> svc = builder.install();
return svc;
} | java |
public List<File> getInactiveHistory() throws PatchingException {
if (validHistory == null) {
walk();
}
final File[] inactiveDirs = installedIdentity.getInstalledImage().getPatchesDir().listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.isDirectory() && !validHistory.contains(pathname.getName());
}
});
return inactiveDirs == null ? Collections.<File>emptyList() : Arrays.asList(inactiveDirs);
} | java |
public List<File> getInactiveOverlays() throws PatchingException {
if (referencedOverlayDirectories == null) {
walk();
}
List<File> inactiveDirs = null;
for (Layer layer : installedIdentity.getLayers()) {
final File overlaysDir = new File(layer.getDirectoryStructure().getModuleRoot(), Constants.OVERLAYS);
final File[] inactiveLayerDirs = overlaysDir.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.isDirectory() && !referencedOverlayDirectories.contains(pathname);
}
});
if (inactiveLayerDirs != null && inactiveLayerDirs.length > 0) {
if (inactiveDirs == null) {
inactiveDirs = new ArrayList<File>();
}
inactiveDirs.addAll(Arrays.asList(inactiveLayerDirs));
}
}
return inactiveDirs == null ? Collections.<File>emptyList() : inactiveDirs;
} | java |
public void deleteInactiveContent() throws PatchingException {
List<File> dirs = getInactiveHistory();
if (!dirs.isEmpty()) {
for (File dir : dirs) {
deleteDir(dir, ALL);
}
}
dirs = getInactiveOverlays();
if (!dirs.isEmpty()) {
for (File dir : dirs) {
deleteDir(dir, ALL);
}
}
} | java |
public void bootstrap() throws Exception {
final HostRunningModeControl runningModeControl = environment.getRunningModeControl();
final ControlledProcessState processState = new ControlledProcessState(true);
shutdownHook.setControlledProcessState(processState);
ServiceTarget target = serviceContainer.subTarget();
ControlledProcessStateService controlledProcessStateService = ControlledProcessStateService.addService(target, processState).getValue();
RunningStateJmx.registerMBean(controlledProcessStateService, null, runningModeControl, false);
final HostControllerService hcs = new HostControllerService(environment, runningModeControl, authCode, processState);
target.addService(HostControllerService.HC_SERVICE_NAME, hcs).install();
} | java |
private void persistDecorator(XMLExtendedStreamWriter writer, ModelNode model) throws XMLStreamException {
if (shouldWriteDecoratorAndElements(model)) {
writer.writeStartElement(decoratorElement);
persistChildren(writer, model);
writer.writeEndElement();
}
} | java |
@Deprecated
public static PersistentResourceXMLBuilder decorator(final String elementName) {
return new PersistentResourceXMLBuilder(PathElement.pathElement(elementName), null).setDecoratorGroup(elementName);
} | java |
void rejectAttributes(RejectedAttributesLogContext rejectedAttributes, ModelNode attributeValue) {
for (RejectAttributeChecker checker : checks) {
rejectedAttributes.checkAttribute(checker, name, attributeValue);
}
} | java |
private OperationEntry getInheritableOperationEntryLocked(final String operationName) {
final OperationEntry entry = operations == null ? null : operations.get(operationName);
if (entry != null && entry.isInherited()) {
return entry;
}
return null;
} | java |
private void registerChildInternal(IgnoreDomainResourceTypeResource child) {
child.setParent(this);
children.put(child.getName(), child);
} | java |
protected Channel awaitChannel() throws IOException {
Channel channel = this.channel;
if(channel != null) {
return channel;
}
synchronized (lock) {
for(;;) {
if(state == State.CLOSED) {
throw ProtocolLogger.ROOT_LOGGER.channelClosed();
}
channel = this.channel;
if(channel != null) {
return channel;
}
if(state == State.CLOSING) {
throw ProtocolLogger.ROOT_LOGGER.channelClosed();
}
try {
lock.wait();
} catch (InterruptedException e) {
throw new IOException(e);
}
}
}
} | java |
protected boolean prepareClose() {
synchronized (lock) {
final State state = this.state;
if (state == State.OPEN) {
this.state = State.CLOSING;
lock.notifyAll();
return true;
}
}
return false;
} | java |
protected boolean setChannel(final Channel newChannel) {
if(newChannel == null) {
return false;
}
synchronized (lock) {
if(state != State.OPEN || channel != null) {
return false;
}
this.channel = newChannel;
this.channel.addCloseHandler(new CloseHandler<Channel>() {
@Override
public void handleClose(final Channel closed, final IOException exception) {
synchronized (lock) {
if(FutureManagementChannel.this.channel == closed) {
FutureManagementChannel.this.channel = null;
}
lock.notifyAll();
}
}
});
lock.notifyAll();
return true;
}
} | java |
private boolean isRedeployAfterRemoval(ModelNode operation) {
return operation.hasDefined(DEPLOYMENT_OVERLAY_LINK_REMOVAL) &&
operation.get(DEPLOYMENT_OVERLAY_LINK_REMOVAL).asBoolean();
} | java |
protected void createNewFile(final File file) {
try {
file.createNewFile();
setFileNotWorldReadablePermissions(file);
} catch (IOException e){
throw new RuntimeException(e);
}
} | java |
private void setFileNotWorldReadablePermissions(File file) {
file.setReadable(false, false);
file.setWritable(false, false);
file.setExecutable(false, false);
file.setReadable(true, true);
file.setWritable(true, true);
} | java |
protected synchronized ResourceRoot getSeamIntResourceRoot() throws DeploymentUnitProcessingException {
try {
if (seamIntResourceRoot == null) {
final ModuleLoader moduleLoader = Module.getBootModuleLoader();
Module extModule = moduleLoader.loadModule(EXT_CONTENT_MODULE);
URL url = extModule.getExportedResource(SEAM_INT_JAR);
if (url == null)
throw ServerLogger.ROOT_LOGGER.noSeamIntegrationJarPresent(extModule);
File file = new File(url.toURI());
VirtualFile vf = VFS.getChild(file.toURI());
final Closeable mountHandle = VFS.mountZip(file, vf, TempFileProviderService.provider());
Service<Closeable> mountHandleService = new Service<Closeable>() {
public void start(StartContext startContext) throws StartException {
}
public void stop(StopContext stopContext) {
VFSUtils.safeClose(mountHandle);
}
public Closeable getValue() throws IllegalStateException, IllegalArgumentException {
return mountHandle;
}
};
ServiceBuilder<Closeable> builder = serviceTarget.addService(ServiceName.JBOSS.append(SEAM_INT_JAR),
mountHandleService);
builder.setInitialMode(ServiceController.Mode.ACTIVE).install();
serviceTarget = null; // our cleanup service install work is done
MountHandle dummy = MountHandle.create(null); // actual close is done by the MSC service above
seamIntResourceRoot = new ResourceRoot(vf, dummy);
}
return seamIntResourceRoot;
} catch (Exception e) {
throw new DeploymentUnitProcessingException(e);
}
} | java |
public static PathAddress pathAddress(final ModelNode node) {
if (node.isDefined()) {
// final List<Property> props = node.asPropertyList();
// Following bit is crap TODO; uncomment above and delete below
// when bug is fixed
final List<Property> props = new ArrayList<Property>();
String key = null;
for (ModelNode element : node.asList()) {
Property prop = null;
if (element.getType() == ModelType.PROPERTY || element.getType() == ModelType.OBJECT) {
prop = element.asProperty();
} else if (key == null) {
key = element.asString();
} else {
prop = new Property(key, element);
}
if (prop != null) {
props.add(prop);
key = null;
}
}
if (props.size() == 0) {
return EMPTY_ADDRESS;
} else {
final Set<String> seen = new HashSet<String>();
final List<PathElement> values = new ArrayList<PathElement>();
int index = 0;
for (final Property prop : props) {
final String name = prop.getName();
if (seen.add(name)) {
values.add(new PathElement(name, prop.getValue().asString()));
} else {
throw duplicateElement(name);
}
if (index == 1 && name.equals(SERVER) && seen.contains(HOST)) {
seen.clear();
}
index++;
}
return new PathAddress(Collections.unmodifiableList(values));
}
} else {
return EMPTY_ADDRESS;
}
} | java |
public PathElement getElement(int index) {
final List<PathElement> list = pathAddressList;
return list.get(index);
} | java |
public PathElement getLastElement() {
final List<PathElement> list = pathAddressList;
return list.size() == 0 ? null : list.get(list.size() - 1);
} | java |
public PathAddress append(List<PathElement> additionalElements) {
final ArrayList<PathElement> newList = new ArrayList<PathElement>(pathAddressList.size() + additionalElements.size());
newList.addAll(pathAddressList);
newList.addAll(additionalElements);
return pathAddress(newList);
} | java |
@Deprecated
public ModelNode navigate(ModelNode model, boolean create) throws NoSuchElementException {
final Iterator<PathElement> i = pathAddressList.iterator();
while (i.hasNext()) {
final PathElement element = i.next();
if (create && !i.hasNext()) {
if (element.isMultiTarget()) {
throw new IllegalStateException();
}
model = model.require(element.getKey()).get(element.getValue());
} else {
model = model.require(element.getKey()).require(element.getValue());
}
}
return model;
} | java |
@Deprecated
public ModelNode remove(ModelNode model) throws NoSuchElementException {
final Iterator<PathElement> i = pathAddressList.iterator();
while (i.hasNext()) {
final PathElement element = i.next();
if (i.hasNext()) {
model = model.require(element.getKey()).require(element.getValue());
} else {
final ModelNode parent = model.require(element.getKey());
model = parent.remove(element.getValue()).clone();
}
}
return model;
} | java |
public ModelNode toModelNode() {
final ModelNode node = new ModelNode().setEmptyList();
for (PathElement element : pathAddressList) {
final String value;
if (element.isMultiTarget() && !element.isWildcard()) {
value = '[' + element.getValue() + ']';
} else {
value = element.getValue();
}
node.add(element.getKey(), value);
}
return node;
} | java |
public boolean matches(PathAddress address) {
if (address == null) {
return false;
}
if (equals(address)) {
return true;
}
if (size() != address.size()) {
return false;
}
for (int i = 0; i < size(); i++) {
PathElement pe = getElement(i);
PathElement other = address.getElement(i);
if (!pe.matches(other)) {
// Could be a multiTarget with segments
if (pe.isMultiTarget() && !pe.isWildcard()) {
boolean matched = false;
for (String segment : pe.getSegments()) {
if (segment.equals(other.getValue())) {
matched = true;
break;
}
}
if (!matched) {
return false;
}
} else {
return false;
}
}
}
return true;
} | java |
public static void indexResourceRoot(final ResourceRoot resourceRoot) throws DeploymentUnitProcessingException {
if (resourceRoot.getAttachment(Attachments.ANNOTATION_INDEX) != null) {
return;
}
VirtualFile indexFile = resourceRoot.getRoot().getChild(ModuleIndexBuilder.INDEX_LOCATION);
if (indexFile.exists()) {
try {
IndexReader reader = new IndexReader(indexFile.openStream());
resourceRoot.putAttachment(Attachments.ANNOTATION_INDEX, reader.read());
ServerLogger.DEPLOYMENT_LOGGER.tracef("Found and read index at: %s", indexFile);
return;
} catch (Exception e) {
ServerLogger.DEPLOYMENT_LOGGER.cannotLoadAnnotationIndex(indexFile.getPathName());
}
}
// if this flag is present and set to false then do not index the resource
Boolean shouldIndexResource = resourceRoot.getAttachment(Attachments.INDEX_RESOURCE_ROOT);
if (shouldIndexResource != null && !shouldIndexResource) {
return;
}
final List<String> indexIgnorePathList = resourceRoot.getAttachment(Attachments.INDEX_IGNORE_PATHS);
final Set<String> indexIgnorePaths;
if (indexIgnorePathList != null && !indexIgnorePathList.isEmpty()) {
indexIgnorePaths = new HashSet<String>(indexIgnorePathList);
} else {
indexIgnorePaths = null;
}
final VirtualFile virtualFile = resourceRoot.getRoot();
final Indexer indexer = new Indexer();
try {
final VisitorAttributes visitorAttributes = new VisitorAttributes();
visitorAttributes.setLeavesOnly(true);
visitorAttributes.setRecurseFilter(new VirtualFileFilter() {
public boolean accepts(VirtualFile file) {
return indexIgnorePaths == null || !indexIgnorePaths.contains(file.getPathNameRelativeTo(virtualFile));
}
});
final List<VirtualFile> classChildren = virtualFile.getChildren(new SuffixMatchFilter(".class", visitorAttributes));
for (VirtualFile classFile : classChildren) {
InputStream inputStream = null;
try {
inputStream = classFile.openStream();
indexer.index(inputStream);
} catch (Exception e) {
ServerLogger.DEPLOYMENT_LOGGER.cannotIndexClass(classFile.getPathNameRelativeTo(virtualFile), virtualFile.getPathName(), e);
} finally {
VFSUtils.safeClose(inputStream);
}
}
final Index index = indexer.complete();
resourceRoot.putAttachment(Attachments.ANNOTATION_INDEX, index);
ServerLogger.DEPLOYMENT_LOGGER.tracef("Generated index for archive %s", virtualFile);
} catch (Throwable t) {
throw ServerLogger.ROOT_LOGGER.deploymentIndexingFailed(t);
}
} | java |
public static void validateRollbackState(final String patchID, final InstalledIdentity identity) throws PatchingException {
final Set<String> validHistory = processRollbackState(patchID, identity);
if (patchID != null && !validHistory.contains(patchID)) {
throw PatchLogger.ROOT_LOGGER.patchNotFoundInHistory(patchID);
}
} | java |
public static void mark(DeploymentUnit unit) {
unit = DeploymentUtils.getTopDeploymentUnit(unit);
unit.putAttachment(MARKER, Boolean.TRUE);
} | java |
@Override
public Map<String, Set<String>> cleanObsoleteContent() {
if(!readWrite) {
return Collections.emptyMap();
}
Map<String, Set<String>> cleanedContents = new HashMap<>(2);
cleanedContents.put(MARKED_CONTENT, new HashSet<>());
cleanedContents.put(DELETED_CONTENT, new HashSet<>());
synchronized (contentHashReferences) {
for (ContentReference fsContent : listLocalContents()) {
if (!readWrite) {
return Collections.emptyMap();
}
if (!contentHashReferences.containsKey(fsContent.getHexHash())) { //We have no reference to this content
if (markAsObsolete(fsContent)) {
cleanedContents.get(DELETED_CONTENT).add(fsContent.getContentIdentifier());
} else {
cleanedContents.get(MARKED_CONTENT).add(fsContent.getContentIdentifier());
}
} else {
obsoleteContents.remove(fsContent.getHexHash()); //Remove existing references from obsoleteContents
}
}
}
return cleanedContents;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.