Refine search
static ModelNode transformModel(final ModelNode legacyModel) { final ModelNode model = new ModelNode(); for (Property property : legacyModel.asPropertyList()) { String name = property.getName(); ModelNode legacyValue = property.getValue(); if (legacyValue.isDefined()) { if(name.equals(JacORBSubsystemConstants.IOR_SETTINGS)){ transformIorSettings(model, legacyValue); if(legacyValue.getType()==ModelType.EXPRESSION){ expression = true; final Matcher matcher = Pattern.compile("\\A\\$\\{(.*):(.*)\\}\\Z").matcher(legacyValue.asExpression().getExpressionString()); if(matcher.find()){ expressionVariable = matcher.group(1); value = new ModelNode(new ValueExpression(newExpression)); model.get(name).set(value);
if (!node.isDefined()) { return node; ModelType type = node.getType(); ModelNode resolved; if (type == ModelType.EXPRESSION) { resolved = resolveExpressionStringRecursively(node.asExpression().getExpressionString(), lenient, true); } else if (type == ModelType.OBJECT) { resolved = node.clone();
protected ModelNode correctValue(ModelNode toResolve, boolean isGeneratedWriteAttribute) { if (toResolve.getType() == ModelType.STRING) { toResolve = new ModelNode().set(new ValueExpression(toResolve.asString())); } try { return ExpressionResolver.TEST_RESOLVER.resolveExpressions(toResolve); } catch (OperationFailedException e) { throw new IllegalArgumentException(e); } }
public static ModelNode parsePossibleExpression(String value) { ModelNode result = new ModelNode(); if (isExpression(value)) { result.set(new ValueExpression(value)); } else { result.set(value); } return result; }
protected SetUnsecureInterfaceInetAddress() { name(SUBTASK_NAME); skipPolicy(skipIfDefaultTaskSkipPropertyIsSet()); final ManageableResourceTaskRunnableBuilder<S, InterfaceResource> runnableBuilder = params -> context -> { final InterfaceResource resource = params.getResource(); final ModelNode resourceConfig = params.getResource().getResourceConfiguration(); if (resourceConfig == null) { context.getLogger().debugf("Interface %s does not exists.", INTERFACE_NAME); return ServerMigrationTaskResult.SKIPPED; } // check if attribute is defined if (resourceConfig.hasDefined(INET_ADDRESS)) { context.getLogger().debugf("Interface %s inet address already defined.", INTERFACE_NAME); return ServerMigrationTaskResult.SKIPPED; } // set attribute value final ValueExpression valueExpression = new ValueExpression("${jboss.bind.address.unsecure:127.0.0.1}"); final PathAddress pathAddress = resource.getResourcePathAddress(); final ModelNode writeAttrOp = Util.createEmptyOperation(WRITE_ATTRIBUTE_OPERATION, pathAddress); writeAttrOp.get(NAME).set(INET_ADDRESS); writeAttrOp.get(VALUE).set(valueExpression); resource.getServerConfiguration().executeManagementOperation(writeAttrOp); context.getLogger().debugf("Interface %s inet address value set as %s.", INTERFACE_NAME, valueExpression.getExpressionString()); return ServerMigrationTaskResult.SUCCESS; }; runBuilder(runnableBuilder); } }
/** * This sets the given node's named attribute to the given value. If the value * appears to be an expression (that is, contains "${" somewhere in it), this will * set the value as an expression on the node. * * @param node the node whose attribute is to be set * @param name the name of the attribute whose value is to be set * @param value the value, possibly an expression * * @return returns the node */ public static ModelNode setPossibleExpression(ModelNode node, String name, String value) { if (value != null) { if (value.contains("${")) { return node.get(name).set(new ValueExpression(value)); } else { return node.get(name).set(value); } } else { return node.get(name).clear(); } }
String resolved = line; if (ExpressionResolver.EXPRESSION_PATTERN.matcher(line).matches()) { ModelNode input = new ModelNode(new ValueExpression(line)); try { resolved = replacer.resolveExpressions(input).asString(); } catch (OperationFailedException e) {
protected AddInterface() { name(TASK_NAME+".add-config"); skipPolicy(TaskSkipPolicy.skipIfDefaultTaskSkipPropertyIsSet()); runBuilder(params -> context -> { final ManageableServerConfiguration serverConfiguration = params.getServerConfiguration(); if (serverConfiguration.getInterfaceResourceNames().contains(INTERFACE_NAME)) { context.getLogger().debugf("Skipping task to add interface private, the configuration already has it."); return ServerMigrationTaskResult.SKIPPED; } final ModelNode addInterfaceOp = Util.createAddOperation(serverConfiguration.getInterfaceResourcePathAddress(INTERFACE_NAME)); addInterfaceOp.get(INET_ADDRESS).set(new ValueExpression("${jboss.bind.address.private:127.0.0.1}")); serverConfiguration.executeManagementOperation(addInterfaceOp); context.getLogger().debugf("Interface %s added.", INTERFACE_NAME); return ServerMigrationTaskResult.SUCCESS; }); } }
if (ModelType.OBJECT.equals(modelNode.getType())) { actualPayload = modelNode; throw new IllegalArgumentException("Unsupported ModelType " + modelNode.getType() + ": " + modelNode); String detypedName = binding.detypedName(); ModelNode dmrPayload = actualPayload.get(detypedName); ValueExpression expression = dmrPayload.asExpression(); ((Map)entity).put(method.name(), expression.getExpressionString());
if (value.startsWith("${") && value.endsWith("}")) value = new ValueExpression(value).resolveString(); target.set(value); target.set((Integer) propValue); target.set((Double) propValue);
} else if (resolved.modified) { return new ModelNode(resolved.result); } else if (initial && EXPRESSION_PATTERN.matcher(expressionString).matches()) { return new ModelNode(new ValueExpression(expressionString)); } else { return new ModelNode(expressionString);
public static StringResolver createStringResolver(Properties properties) { final ValueExpressionResolver resolver = createValueExpressionResolver(properties); return value -> new ValueExpression(value).resolveString(resolver); }
private void addPossibleExpression(ModelNode node, String name, String value) { if (value != null && value.contains("${")) { node.add(name, new ModelNode(ModelType.EXPRESSION).set(new ValueExpression(value))); } else { node.add(name, value); } }
if (!node.isDefined()) { return node; ModelType type = node.getType(); ModelNode resolved; if (type == ModelType.EXPRESSION) { resolved = resolveExpressionStringRecursively(node.asExpression().getExpressionString(), lenient, true); } else if (type == ModelType.OBJECT) { resolved = node.clone();
/** Resolve the given string using any plugin and the DMR resolve method */ private String resolveExpressionString(final String unresolvedString) throws OperationFailedException { // parseAndResolve should only be providing expressions with no leading or trailing chars assert unresolvedString.startsWith("${") && unresolvedString.endsWith("}"); // Default result is no change from input String result = unresolvedString; ModelNode resolveNode = new ModelNode(new ValueExpression(unresolvedString)); // Try plug-in resolution; i.e. vault resolvePluggableExpression(resolveNode); if (resolveNode.getType() == ModelType.EXPRESSION ) { // resolvePluggableExpression did nothing. Try standard resolution String resolvedString = resolveStandardExpression(resolveNode); if (!unresolvedString.equals(resolvedString)) { // resolveStandardExpression made progress result = resolvedString; } // else there is nothing more we can do with this string } else { // resolvePluggableExpression made progress result = resolveNode.asString(); } return result; }
public static ModelNode parsePossibleExpression(String value) { ModelNode result = new ModelNode(); if (isExpression(value)) { result.set(new ValueExpression(value)); } else { result.set(value); } return result; }
String resolved = line; if (ExpressionResolver.EXPRESSION_PATTERN.matcher(line).matches()) { ModelNode input = new ModelNode(new ValueExpression(line)); try { resolved = replacer.resolveExpressions(input).asString(); } catch (OperationFailedException e) {