@Test
public void testTransformers() throws Exception {
ModelVersion oldVersion = ModelVersion.create(1, 0, 0);
KernelServicesBuilder builder =
createKernelServicesBuilder(null).setSubsystemXml(getSubsystemXml());
builder
.createLegacyKernelServicesBuilder(null, oldVersion)
.setExtensionClassName(VersionedExtension1.class.getName())
.addSimpleResourceURL("target/legacy-archive.jar");
KernelServices mainServices = builder.build();
KernelServices legacyServices = mainServices.getLegacyServices(oldVersion);
Assert.assertNotNull(legacyServices);
ModelNode mainModel = mainServices.readWholeModel();
ModelNode mainSubsystem = mainModel.get(SUBSYSTEM, "test-subsystem");
Assert.assertEquals(3, mainSubsystem.keys().size());
Assert.assertEquals("This is only a test", mainSubsystem.get("test-attribute").asString());
Assert.assertTrue(mainSubsystem.hasDefined("new-element"));
Assert.assertTrue(mainSubsystem.get("new-element").hasDefined("test"));
Assert.assertTrue(mainSubsystem.hasDefined("renamed"));
Assert.assertTrue(mainSubsystem.get("renamed").hasDefined("element"));
ModelNode legacyModel = legacyServices.readWholeModel();
ModelNode legacySubsystem = legacyModel.get(SUBSYSTEM, "test-subsystem");
Assert.assertEquals(2, legacySubsystem.keys().size());
Assert.assertEquals("This is only a test", legacySubsystem.get("test-attribute").asString());
Assert.assertTrue(legacySubsystem.hasDefined("element"));
Assert.assertTrue(legacySubsystem.get("element").hasDefined("renamed"));
generateLegacySubsystemResourceRegistrationDmr(mainServices, oldVersion);
checkSubsystemTransformer(mainServices, oldVersion);
}
@Override
public void writeContent(XMLExtendedStreamWriter writer, SubsystemMarshallingContext context)
throws XMLStreamException {
context.startSubsystemElement(Namespace.CURRENT.getUriString(), false);
ModelNode node = context.getModelNode();
if (has(node, ACTIVATION)) {
writeAttribute(writer, Attribute.ACTIVATION, node.get(ACTIVATION));
}
if (has(node, CONFIGURATION)) {
ModelNode configuration = node.get(CONFIGURATION);
writer.writeStartElement(Element.CONFIGURATION.getLocalName());
writeAttribute(writer, Attribute.PID, configuration.require(PID));
if (has(configuration, CONFIGURATION_PROPERTIES)) {
ModelNode configurationProperties = configuration.get(CONFIGURATION_PROPERTIES);
Set<String> keys = configurationProperties.keys();
for (String current : keys) {
String value = configurationProperties.get(current).asString();
writer.writeStartElement(Element.PROPERTY.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), current);
writer.writeCharacters(value);
writer.writeEndElement();
}
}
writer.writeEndElement();
}
if (has(node, PROPERTIES)) {
ModelNode properties = node.get(PROPERTIES);
writer.writeStartElement(Element.PROPERTIES.getLocalName());
Set<String> keys = properties.keys();
for (String current : keys) {
String value = properties.get(current).asString();
writer.writeStartElement(Element.PROPERTY.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), current);
writer.writeCharacters(value);
writer.writeEndElement();
}
writer.writeEndElement();
}
if (has(node, MODULES)) {
ModelNode modules = node.get(MODULES);
writer.writeStartElement(Element.MODULES.getLocalName());
Set<String> keys = modules.keys();
for (String current : keys) {
ModelNode currentModule = modules.get(current);
writer.writeEmptyElement(Element.MODULE.getLocalName());
writer.writeAttribute(Attribute.IDENTIFIER.getLocalName(), current);
if (has(currentModule, START)) {
writeAttribute(writer, Attribute.START, currentModule.require(START));
}
}
writer.writeEndElement();
}
writer.writeEndElement();
}
/**
* Compares two models to make sure that they are the same
*
* @param node1 the first model
* @param node2 the second model
* @throws AssertionFailedError if the models were not the same
*/
protected void compare(ModelNode node1, ModelNode node2) {
Assert.assertEquals(getCompareStackAsString() + " types", node1.getType(), node2.getType());
if (node1.getType() == ModelType.OBJECT) {
final Set<String> keys1 = node1.keys();
final Set<String> keys2 = node2.keys();
Assert.assertEquals(node1 + "\n" + node2, keys1.size(), keys2.size());
for (String key : keys1) {
final ModelNode child1 = node1.get(key);
Assert.assertTrue("Missing: " + key + "\n" + node1 + "\n" + node2, node2.has(key));
final ModelNode child2 = node2.get(key);
if (child1.isDefined()) {
Assert.assertTrue(child1.toString(), child2.isDefined());
stack.get().push(key + "/");
compare(child1, child2);
stack.get().pop();
} else {
Assert.assertFalse(child2.asString(), child2.isDefined());
}
}
} else if (node1.getType() == ModelType.LIST) {
List<ModelNode> list1 = node1.asList();
List<ModelNode> list2 = node2.asList();
Assert.assertEquals(list1 + "\n" + list2, list1.size(), list2.size());
for (int i = 0; i < list1.size(); i++) {
stack.get().push(i + "/");
compare(list1.get(i), list2.get(i));
stack.get().pop();
}
} else if (node1.getType() == ModelType.PROPERTY) {
Property prop1 = node1.asProperty();
Property prop2 = node2.asProperty();
Assert.assertEquals(prop1 + "\n" + prop2, prop1.getName(), prop2.getName());
stack.get().push(prop1.getName() + "/");
compare(prop1.getValue(), prop2.getValue());
stack.get().pop();
} else {
try {
Assert.assertEquals(
getCompareStackAsString()
+ "\n\""
+ node1.asString()
+ "\"\n\""
+ node2.asString()
+ "\"\n-----",
node2.asString().trim(),
node1.asString().trim());
} catch (AssertionFailedError error) {
throw error;
}
}
}
private void addManagementSecurityRealms(List<ModelNode> updates) {
if (hostModel.get(CORE_SERVICE, MANAGEMENT, SECURITY_REALM).isDefined()) {
ModelNode securityRealms = hostModel.get(CORE_SERVICE, MANAGEMENT, SECURITY_REALM);
Set<String> keys = securityRealms.keys();
for (String current : keys) {
ModelNode addOp = new ModelNode();
ModelNode realmAddress = new ModelNode();
realmAddress.add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, current);
addOp.get(OP).set(ADD);
addOp.get(OP_ADDR).set(realmAddress);
updates.add(addOp);
ModelNode currentRealm = securityRealms.get(current);
if (currentRealm.hasDefined(SERVER_IDENTITY)) {
addManagementComponentComponent(currentRealm, realmAddress, SERVER_IDENTITY, updates);
}
if (currentRealm.hasDefined(AUTHENTICATION)) {
addManagementComponentComponent(currentRealm, realmAddress, AUTHENTICATION, updates);
}
if (currentRealm.hasDefined(AUTHORIZATION)) {
addManagementComponentComponent(currentRealm, realmAddress, AUTHORIZATION, updates);
}
}
}
}
protected StringBuilder formatResponse(
CommandContext ctx, ModelNode opResponse, boolean composite, StringBuilder buf) {
if (!opResponse.hasDefined(Util.RESULT)) {
return null;
}
final ModelNode result = opResponse.get(Util.RESULT);
if (composite) {
final Set<String> keys;
try {
keys = result.keys();
} catch (Exception e) {
ctx.printLine(
"Failed to get step results from a composite operation response " + opResponse);
e.printStackTrace();
return null;
}
for (String key : keys) {
final ModelNode stepResponse = result.get(key);
buf =
formatResponse(
ctx, stepResponse, false, buf); // TODO nested composite ops aren't expected for now
}
} else {
final ModelNodeFormatter formatter = ModelNodeFormatter.Factory.forType(result.getType());
if (buf == null) {
buf = new StringBuilder();
}
formatter.format(buf, 0, result);
}
return buf;
}
/** {@inheritDoc} */
@Override
public void writeContent(XMLExtendedStreamWriter writer, SubsystemMarshallingContext context)
throws XMLStreamException {
context.startSubsystemElement(Namespace.CURRENT.getUriString(), false);
final ModelNode model = context.getModelNode();
writeWorkerThreadPoolIfAttributesSet(writer, model);
if (model.hasDefined(CONNECTOR)) {
final ModelNode connector = model.get(CONNECTOR);
for (String name : connector.keys()) {
writeConnector(writer, connector.require(name), name);
}
}
if (model.hasDefined(OUTBOUND_CONNECTION)
|| model.hasDefined(REMOTE_OUTBOUND_CONNECTION)
|| model.hasDefined(LOCAL_OUTBOUND_CONNECTION)) {
// write <outbound-connections> element
writer.writeStartElement(Element.OUTBOUND_CONNECTIONS.getLocalName());
if (model.hasDefined(OUTBOUND_CONNECTION)) {
final List<Property> outboundConnections = model.get(OUTBOUND_CONNECTION).asPropertyList();
for (Property property : outboundConnections) {
final String connectionName = property.getName();
// get the specific outbound-connection
final ModelNode genericOutboundConnectionModel = property.getValue();
// process and write outbound connection
this.writeOutboundConnection(writer, connectionName, genericOutboundConnectionModel);
}
}
if (model.hasDefined(REMOTE_OUTBOUND_CONNECTION)) {
final List<Property> remoteOutboundConnections =
model.get(REMOTE_OUTBOUND_CONNECTION).asPropertyList();
for (Property property : remoteOutboundConnections) {
final String connectionName = property.getName();
// get the specific remote outbound connection
final ModelNode remoteOutboundConnectionModel = property.getValue();
// process and write remote outbound connection
this.writeRemoteOutboundConnection(writer, connectionName, remoteOutboundConnectionModel);
}
}
if (model.hasDefined(LOCAL_OUTBOUND_CONNECTION)) {
final List<Property> localOutboundConnections =
model.get(LOCAL_OUTBOUND_CONNECTION).asPropertyList();
for (Property property : localOutboundConnections) {
final String connectionName = property.getName();
// get the specific local outbound connection
final ModelNode localOutboundConnectionModel = property.getValue();
// process and write local outbound connection
this.writeLocalOutboundConnection(writer, connectionName, localOutboundConnectionModel);
}
}
// </outbound-connections>
writer.writeEndElement();
}
writer.writeEndElement();
}
private void writeBinaryStorage(XMLExtendedStreamWriter writer, ModelNode repository)
throws XMLStreamException {
if (has(repository, ModelKeys.CONFIGURATION, ModelKeys.BINARY_STORAGE)) {
ModelNode configuration = repository.get(ModelKeys.CONFIGURATION);
ModelNode binaryStorage = configuration.get(ModelKeys.BINARY_STORAGE);
ModelNode binaryStorageType = binaryStorage.get(ModelKeys.STORAGE_TYPE);
String storageType =
binaryStorageType.isDefined() && binaryStorageType.keys().size() == 1
? (String) binaryStorageType.keys().toArray()[0]
: null;
ModelNode storage =
storageType != null
? binaryStorageType.get((String) binaryStorageType.keys().toArray()[0])
: new ModelNode();
writeBinaryStorageModel(writer, storageType, storage);
}
}
private void extractEnterpriseArchiveContexts(HTTPContext context, ModelNode deploymentNode) {
if (deploymentNode.hasDefined(SUBDEPLOYMENT)) {
for (ModelNode subdeployment : deploymentNode.get(SUBDEPLOYMENT).asList()) {
String deploymentName = subdeployment.keys().iterator().next();
if (isWebArchive(deploymentName)) {
extractWebArchiveContexts(context, deploymentName, subdeployment.get(deploymentName));
}
}
}
}
/**
* @deprecated Horrible idea, as it promotes copying random stuff from an operation into the
* model.
*/
@Deprecated
public static void copyParamsToModel(final ModelNode operation, final ModelNode model) {
Set<String> keys = new HashSet<String>(operation.keys());
// Remove general operation params
keys.remove(OP);
keys.remove(OP_ADDR);
keys.remove(OPERATION_HEADERS);
for (String key : keys) {
model.get(key).set(operation.get(key));
}
}
public static ModelNode getOperation(
final String operationName, final PathAddress address, final ModelNode params) {
ModelNode op = createEmptyOperation(operationName, address);
Set<String> keys = params.keys();
keys.remove(OP);
keys.remove(OP_ADDR);
for (String key : keys) {
op.get(key).set(params.get(key));
}
return op;
}
private String findAttributeName(ModelNode attributes, String attributeName)
throws AttributeNotFoundException {
if (attributes.hasDefined(attributeName)) {
return attributeName;
}
for (String key : attributes.keys()) {
if (NameConverter.convertToCamelCase(key).equals(attributeName)) {
return key;
}
}
throw MESSAGES.attributeNotFound(attributeName);
}
private void writeNestedStoresOfType(
ModelNode storage, String nestedStorageType, String storeType, XMLExtendedStreamWriter writer)
throws XMLStreamException {
if (has(storage, nestedStorageType)) {
List<ModelNode> nestedCacheStores = storage.get(nestedStorageType).asList();
for (ModelNode nestedStore : nestedCacheStores) {
String storeName = (String) nestedStore.keys().toArray()[0];
writeBinaryStorageModel(writer, storeType, nestedStore.get(storeName));
}
}
}
protected void displayResponseHeaders(CommandContext ctx, ModelNode response) {
if (response.has(Util.RESPONSE_HEADERS)) {
final ModelNode headers = response.get(Util.RESPONSE_HEADERS);
final Set<String> keys = headers.keys();
final SimpleTable table = new SimpleTable(2);
for (String key : keys) {
table.addLine(new String[] {key + ':', headers.get(key).asString()});
}
final StringBuilder buf = new StringBuilder();
table.append(buf, true);
ctx.printLine(buf.toString());
}
}
public static void validateInSeriesServerGroup(ModelNode serverGroup)
throws OperationFailedException {
if (serverGroup.isDefined()) {
try {
final Set<String> specKeys = serverGroup.keys();
if (!ALLOWED_SERVER_GROUP_CHILDREN.containsAll(specKeys)) {
throw new OperationFailedException(
MESSAGES.unrecognizedChildren(
SERVER_GROUP, ALLOWED_SERVER_GROUP_CHILDREN.toString(), specKeys.toString()));
}
} catch (IllegalArgumentException e) { // ignore?
}
}
}
public static Map<String, String> readConfiguration(ModelControllerClient client, String pid)
throws IOException, MgmtOperationException {
ModelNode op =
ModelUtil.createOpNode(
"subsystem=configadmin/configuration=" + pid,
ModelDescriptionConstants.READ_RESOURCE_OPERATION);
ModelNode result = executeOperation(client, op, true);
ModelNode entries = result.get("entries");
Map<String, String> map = new HashMap<String, String>();
for (String key : entries.keys()) {
map.put(key, entries.get(key).asString());
}
return map;
}
@Override
protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model)
throws OperationFailedException {
ServiceTarget serviceTarget = context.getServiceTarget();
RuntimeCapability<Void> runtimeCapability =
REALM_MAPPER_RUNTIME_CAPABILITY.fromBaseCapability(context.getCurrentAddressValue());
ServiceName realmMapperName = runtimeCapability.getCapabilityServiceName(RealmMapper.class);
final String pattern = PATTERN.resolveModelAttribute(context, model).asString();
ModelNode realmMapList = REALM_REALM_MAP.resolveModelAttribute(context, model);
Set<String> names = realmMapList.keys();
final Map<String, String> realmRealmMap = new HashMap<String, String>(names.size());
names.forEach((String s) -> realmRealmMap.put(s, realmMapList.require(s).asString()));
String delegateRealmMapper = asStringIfDefined(context, DELEGATE_REALM_MAPPER, model);
final InjectedValue<RealmMapper> delegateRealmMapperInjector =
new InjectedValue<RealmMapper>();
TrivialService<RealmMapper> realmMapperService =
new TrivialService<RealmMapper>(
() -> {
RealmMapper delegate = delegateRealmMapperInjector.getOptionalValue();
Pattern compiledPattern = Pattern.compile(pattern);
if (delegate == null) {
return new MappedRegexRealmMapper(compiledPattern, realmRealmMap);
} else {
return new MappedRegexRealmMapper(compiledPattern, delegate, realmRealmMap);
}
});
ServiceBuilder<RealmMapper> realmMapperBuilder =
serviceTarget.addService(realmMapperName, realmMapperService);
if (delegateRealmMapper != null) {
String delegateCapabilityName =
RuntimeCapability.buildDynamicCapabilityName(
REALM_MAPPER_CAPABILITY, delegateRealmMapper);
ServiceName delegateServiceName =
context.getCapabilityServiceName(delegateCapabilityName, RealmMapper.class);
realmMapperBuilder.addDependency(
delegateServiceName, RealmMapper.class, delegateRealmMapperInjector);
}
commonDependencies(realmMapperBuilder).setInitialMode(Mode.LAZY).install();
}
private void removeSubsystems(ModelNode description) {
// TODO should remove all subsystems since they are tested in unit tests
// but for now leave threads and remoting in since unit tests could not be created
// for them due to circular maven dependencies
ModelNode subsystemDescriptions = description.get(CHILDREN, SUBSYSTEM, MODEL_DESCRIPTION);
Set<String> removes = new HashSet<String>();
for (String key : subsystemDescriptions.keys()) {
if (!key.equals(RemotingExtension.SUBSYSTEM_NAME)
&& !key.equals(ThreadsExtension.SUBSYSTEM_NAME)) {
removes.add(key);
}
}
for (String remove : removes) {
subsystemDescriptions.remove(remove);
}
}
@Override
protected void populateModel(final ModelNode operation, final Resource resource)
throws OperationFailedException {
if (operation.hasDefined(CommonAttributes.MOD_CLUSTER_CONFIG)) {
ModelNode configuration;
if (operation
.get(CommonAttributes.MOD_CLUSTER_CONFIG)
.hasDefined(CommonAttributes.CONFIGURATION)) {
configuration =
operation.get(CommonAttributes.MOD_CLUSTER_CONFIG).get(CommonAttributes.CONFIGURATION);
} else {
configuration = operation.get(CommonAttributes.MOD_CLUSTER_CONFIG);
}
resource.registerChild(ModClusterExtension.configurationPath, Resource.Factory.create());
final Resource conf = resource.getChild(ModClusterExtension.configurationPath);
final ModelNode confModel = conf.getModel();
for (final String attribute : configuration.keys()) {
if (attribute.equals(CommonAttributes.SSL)) {
conf.registerChild(ModClusterExtension.sslConfigurationPath, Resource.Factory.create());
final Resource ssl = conf.getChild(ModClusterExtension.sslConfigurationPath);
ModelNode sslnode;
if (configuration.get(attribute).hasDefined(CommonAttributes.CONFIGURATION)) {
sslnode = configuration.get(attribute).get(CommonAttributes.CONFIGURATION);
} else {
sslnode = configuration.get(attribute);
}
final ModelNode sslModel = ssl.getModel();
for (AttributeDefinition sslAttr : ModClusterSSLResourceDefinition.ATTRIBUTES) {
sslAttr.validateAndSet(sslnode, sslModel);
}
} else if (attribute.equals(CommonAttributes.DYNAMIC_LOAD_PROVIDER)
|| attribute.equals(CommonAttributes.SIMPLE_LOAD_PROVIDER)) {
// TODO AS7-4050 properly handle these
confModel.get(attribute).set(configuration.get(attribute));
} else {
AttributeDefinition ad =
ModClusterConfigResourceDefinition.ATTRIBUTES_BY_NAME.get(attribute);
if (ad != null) {
ad.validateAndSet(configuration, confModel);
} // else ignore unknown params
}
}
}
}
private void addManagementConnections(List<ModelNode> updates) {
if (hostModel.get(CORE_SERVICE, MANAGEMENT, LDAP_CONNECTION).isDefined()) {
ModelNode baseAddress = new ModelNode();
baseAddress.add(CORE_SERVICE, MANAGEMENT);
ModelNode connections = hostModel.get(CORE_SERVICE, MANAGEMENT, LDAP_CONNECTION);
for (String connectionName : connections.keys()) {
ModelNode addConnection = new ModelNode();
// First take the properties to pass over.
addConnection.set(connections.get(connectionName));
// Now convert it to an operation by adding a name and address.
ModelNode identityAddress = baseAddress.clone().add(LDAP_CONNECTION, connectionName);
addConnection.get(OP).set(ADD);
addConnection.get(OP_ADDR).set(identityAddress);
updates.add(addConnection);
}
}
}
private void writeDomainDeployments(
final XMLExtendedStreamWriter writer, final ModelNode modelNode) throws XMLStreamException {
final Set<String> deploymentNames = modelNode.keys();
if (deploymentNames.size() > 0) {
writer.writeStartElement(Element.DEPLOYMENTS.getLocalName());
for (String uniqueName : deploymentNames) {
final ModelNode deployment = modelNode.get(uniqueName);
final String runtimeName = deployment.get(RUNTIME_NAME).asString();
writer.writeStartElement(Element.DEPLOYMENT.getLocalName());
writeAttribute(writer, Attribute.NAME, uniqueName);
writeAttribute(writer, Attribute.RUNTIME_NAME, runtimeName);
final List<ModelNode> contentItems = deployment.require(CONTENT).asList();
for (ModelNode contentItem : contentItems) {
writeContentItem(writer, contentItem);
}
writer.writeEndElement();
}
writer.writeEndElement();
}
}
private static void writePooledConnectionFactories(
final XMLExtendedStreamWriter writer, final ModelNode node) throws XMLStreamException {
if (!node.isDefined() || node.keys().size() == 0) {
return;
}
List<Property> properties = node.asPropertyList();
if (!properties.isEmpty()) {
for (Property prop : properties) {
final String name = prop.getName();
final ModelNode factory = prop.getValue();
if (factory.isDefined()) {
writer.writeStartElement(Element.POOLED_CONNECTION_FACTORY.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), name);
// write inbound config attributes first...
if (hasDefinedInboundConfigAttributes(factory)) {
writer.writeStartElement(Element.INBOUND_CONFIG.getLocalName());
for (ConnectionFactoryAttribute attribute :
PooledConnectionFactoryDefinition.ATTRIBUTES) {
if (attribute.isInboundConfig()) {
attribute.getDefinition().marshallAsElement(factory, writer);
}
}
writer.writeEndElement();
}
// ... then the attributes that are not part of the inbound config
for (ConnectionFactoryAttribute attribute :
PooledConnectionFactoryDefinition.ATTRIBUTES) {
if (!attribute.isInboundConfig()) {
attribute.getDefinition().marshallAsElement(factory, writer);
}
}
writer.writeEndElement();
}
}
}
}
private void writeServerGroupDeployments(
final XMLExtendedStreamWriter writer, final ModelNode modelNode) throws XMLStreamException {
final Set<String> deploymentNames = modelNode.keys();
if (deploymentNames.size() > 0) {
writer.writeStartElement(Element.DEPLOYMENTS.getLocalName());
for (String uniqueName : deploymentNames) {
final ModelNode deployment = modelNode.get(uniqueName);
final String runtimeName = deployment.get(RUNTIME_NAME).asString();
final boolean enabled =
!deployment.hasDefined(ENABLED) || deployment.get(ENABLED).asBoolean();
writer.writeStartElement(Element.DEPLOYMENT.getLocalName());
writeAttribute(writer, Attribute.NAME, uniqueName);
writeAttribute(writer, Attribute.RUNTIME_NAME, runtimeName);
if (!enabled) {
writeAttribute(writer, Attribute.ENABLED, Boolean.FALSE.toString());
}
writer.writeEndElement();
}
writer.writeEndElement();
}
}
private static void writeConnectionFactories(
final XMLExtendedStreamWriter writer, final ModelNode node) throws XMLStreamException {
if (!node.isDefined() || node.keys().size() == 0) {
return;
}
List<Property> properties = node.asPropertyList();
if (!properties.isEmpty()) {
for (Property prop : properties) {
final String name = prop.getName();
final ModelNode factory = prop.getValue();
if (factory.isDefined()) {
writer.writeStartElement(Element.CONNECTION_FACTORY.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), name);
for (AttributeDefinition attribute : ConnectionFactoryDefinition.ATTRIBUTES) {
attribute.marshallAsElement(factory, writer);
}
writer.writeEndElement();
}
}
}
}
private static void writeTopics(final XMLExtendedStreamWriter writer, final ModelNode node)
throws XMLStreamException {
if (!node.isDefined() || node.keys().size() == 0) {
return;
}
List<Property> properties = node.asPropertyList();
if (!properties.isEmpty()) {
for (Property prop : properties) {
final String name = prop.getName();
final ModelNode topic = prop.getValue();
if (topic.isDefined()) {
writer.writeStartElement(Element.JMS_TOPIC.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), name);
for (AttributeDefinition attribute : JMSTopicDefinition.ATTRIBUTES) {
attribute.marshallAsElement(topic, writer);
}
writer.writeEndElement();
}
}
}
}
private void extractWebArchiveContexts(
HTTPContext context, String deploymentName, ModelNode deploymentNode) {
if (deploymentNode.hasDefined(SUBSYSTEM)) {
ModelNode subsystem = deploymentNode.get(SUBSYSTEM);
if (subsystem.hasDefined(UNDERTOW)) {
ModelNode webSubSystem = subsystem.get(UNDERTOW);
if (webSubSystem.isDefined() && webSubSystem.hasDefined("context-root")) {
final String contextName = webSubSystem.get("context-root").asString();
if (webSubSystem.hasDefined(SERVLET)) {
for (final ModelNode servletNode : webSubSystem.get(SERVLET).asList()) {
for (final String servletName : servletNode.keys()) {
context.add(new Servlet(servletName, toContextName(contextName)));
}
}
}
/*
* This is a WebApp, it has some form of webcontext whether it has a
* Servlet or not. AS7 does not expose jsp / default servlet in mgm api
*/
context.add(new Servlet("default", toContextName(contextName)));
}
}
}
}
private String getAddedRule(ModelNode rewritenode) {
for (final String attribute : rewritenode.keys()) {
if (attribute.startsWith("rule-")) return attribute;
}
return "rule-0";
}
private String getAddedConditionName(ModelNode conditionnode) {
for (final String attribute : conditionnode.keys()) {
if (attribute.startsWith("condition-")) return attribute;
}
return "condition-0";
}
private Object invoke(
final OperationEntry entry, final String operationName, PathAddress address, Object[] params)
throws InstanceNotFoundException, MBeanException, ReflectionException {
if (!standalone && !entry.getFlags().contains(OperationEntry.Flag.READ_ONLY)) {
throw MESSAGES.noOperationCalled(operationName);
}
ResourceAccessControl accessControl;
if (operationName.equals("add")) {
accessControl = accessControlUtil.getResourceAccess(address, true);
} else {
ObjectName objectName = ObjectNameAddressUtil.createObjectName(operationName, address);
accessControl =
accessControlUtil.getResourceAccessWithInstanceNotFoundExceptionIfNotAccessible(
objectName, address, true);
}
if (!accessControl.isExecutableOperation(operationName)) {
throw MESSAGES.notAuthorizedToExecuteOperation(operationName);
}
final ModelNode description = entry.getDescriptionProvider().getModelDescription(null);
ModelNode op = new ModelNode();
op.get(OP).set(operationName);
op.get(OP_ADDR).set(address.toModelNode());
if (params.length > 0) {
ModelNode requestProperties = description.require(REQUEST_PROPERTIES);
Set<String> keys = requestProperties.keys();
if (keys.size() != params.length) {
throw MESSAGES.differentLengths("params", "description");
}
Iterator<String> it = requestProperties.keys().iterator();
for (int i = 0; i < params.length; i++) {
String attributeName = it.next();
ModelNode paramDescription = requestProperties.get(attributeName);
op.get(attributeName).set(converters.toModelNode(paramDescription, params[i]));
}
}
ModelNode result = execute(op);
String error = getFailureDescription(result);
if (error != null) {
if (error.contains(AUTHORIZED_ERROR)) {
for (Object param : params) {
// Since read-resource-description does not know the parameters of the operation, i.e. if
// a vault expression is used or not,
// check the error code
// TODO add a separate authorize step where we check ourselves that the operation will
// pass authorization?
if (isVaultExpression(param)) {
throw MESSAGES.notAuthorizedToExecuteOperation(operationName);
}
}
}
throw new ReflectionException(null, error);
}
if (!description.hasDefined(REPLY_PROPERTIES)) {
return null;
}
// TODO we could have more than one reply property
return converters.fromModelNode(description.get(REPLY_PROPERTIES), result.get(RESULT));
}
@Override
public void validateParameter(String parameterName, ModelNode plan)
throws OperationFailedException {
if (plan == null) {
throw new OperationFailedException(MESSAGES.nullVar("plan").getLocalizedMessage());
}
if (!plan.hasDefined(ROLLOUT_PLAN)) {
throw new OperationFailedException(
MESSAGES.requiredChildIsMissing(ROLLOUT_PLAN, ROLLOUT_PLAN, plan.toString()));
}
ModelNode rolloutPlan1 = plan.get(ROLLOUT_PLAN);
final Set<String> keys;
try {
keys = rolloutPlan1.keys();
} catch (IllegalArgumentException e) {
throw new OperationFailedException(
MESSAGES.requiredChildIsMissing(ROLLOUT_PLAN, IN_SERIES, plan.toString()));
}
if (!keys.contains(IN_SERIES)) {
throw new OperationFailedException(
MESSAGES.requiredChildIsMissing(ROLLOUT_PLAN, IN_SERIES, plan.toString()));
}
if (keys.size() > 2 || keys.size() == 2 && !keys.contains(ROLLBACK_ACROSS_GROUPS)) {
throw new OperationFailedException(
MESSAGES.unrecognizedChildren(
ROLLOUT_PLAN, IN_SERIES + ", " + ROLLBACK_ACROSS_GROUPS, plan.toString()));
}
final ModelNode inSeries = rolloutPlan1.get(IN_SERIES);
if (!inSeries.isDefined()) {
throw new OperationFailedException(
MESSAGES.requiredChildIsMissing(ROLLOUT_PLAN, IN_SERIES, plan.toString()));
}
final List<ModelNode> groups = inSeries.asList();
if (groups.isEmpty()) {
throw new OperationFailedException(MESSAGES.inSeriesIsMissingGroups(plan.toString()));
}
for (ModelNode group : groups) {
if (group.hasDefined(SERVER_GROUP)) {
final ModelNode serverGroup = group.get(SERVER_GROUP);
final Set<String> groupKeys;
try {
groupKeys = serverGroup.keys();
} catch (IllegalArgumentException e) {
throw new OperationFailedException(
MESSAGES.serverGroupExpectsSingleChild(plan.toString()));
}
if (groupKeys.size() != 1) {
throw new OperationFailedException(
MESSAGES.serverGroupExpectsSingleChild(plan.toString()));
}
validateInSeriesServerGroup(serverGroup.asProperty().getValue());
} else if (group.hasDefined(CONCURRENT_GROUPS)) {
final ModelNode concurrent = group.get(CONCURRENT_GROUPS);
for (ModelNode child : concurrent.asList()) {
validateInSeriesServerGroup(child.asProperty().getValue());
}
} else {
throw new OperationFailedException(MESSAGES.unexpectedInSeriesGroup(plan.toString()));
}
}
}
private void addExtensions(Set<String> extensionNames, ModelNode extensions) {
if (extensions.isDefined()) {
extensionNames.addAll(extensions.keys());
}
}