private void parseServerProfile(
final XMLExtendedStreamReader reader, final ModelNode address, final List<ModelNode> list)
throws XMLStreamException {
// Attributes
requireNoAttributes(reader);
// Content
final Set<String> configuredSubsystemTypes = new HashSet<String>();
while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
if (Element.forName(reader.getLocalName()) != Element.SUBSYSTEM) {
throw unexpectedElement(reader);
}
if (!configuredSubsystemTypes.add(reader.getNamespaceURI())) {
throw AppClientLogger.ROOT_LOGGER.duplicateSubsystemDeclaration(reader.getLocation());
}
// parse subsystem
final List<ModelNode> subsystems = new ArrayList<ModelNode>();
reader.handleAny(subsystems);
// Process subsystems
for (final ModelNode update : subsystems) {
// Process relative subsystem path address
final ModelNode subsystemAddress = address.clone();
for (final Property path : update.get(OP_ADDR).asPropertyList()) {
subsystemAddress.add(path.getName(), path.getValue().asString());
}
update.get(OP_ADDR).set(subsystemAddress);
list.add(update);
}
}
}
private void setProps(ModelNode requestProperties) throws Exception {
props = new TreeSet<RequestProp>();
if (opName.equals("add")) {
UserObject usrObj = (UserObject) node.getUserObject();
props.add(
new RequestProp(
"/" + usrObj.getName() + "=<name>/",
"Resource name for the new " + usrObj.getName(),
true,
ModelType.STRING));
}
if (opName.equals("write-attribute") && node.isLeaf()) {
ModelNode nameNode = requestProperties.get("name");
nameNode
.get("type")
.set(ModelType.UNDEFINED); // undefined type will display as uneditable String
UserObject usrObj = (UserObject) node.getUserObject();
ModelNode nameNodeValue = new ModelNode();
nameNodeValue.set(usrObj.getName());
props.add(new RequestProp("name", requestProperties.get("name"), nameNodeValue));
ModelNode rscDesc =
cliGuiCtx.getExecutor().doCommand(node.addressPath() + ":read-resource-description");
ModelNode valueNode = rscDesc.get("result", "attributes", usrObj.getName());
valueNode.get("required").set(false); // value is never required for write-attribute
ModelNode valueNodeValue = usrObj.getBackingNode().get(usrObj.getName());
props.add(new RequestProp("value", valueNode, valueNodeValue));
return;
}
for (Property prop : requestProperties.asPropertyList()) {
props.add(new RequestProp(prop.getName(), prop.getValue(), null));
}
}
/*
* Tests access to local cache attributes
*/
@SuppressWarnings("deprecation")
@Test
public void testDistributedCacheMixedJDBCStoreReadWriteOperation() throws Exception {
ModelNode stringKeyedTable = createStringKeyedTable();
// Parse and install the XML into the controller
String subsystemXml = getSubsystemXml();
KernelServices servicesA =
this.createKernelServicesBuilder().setSubsystemXml(subsystemXml).build();
// read the distributed cache mixed-keyed-jdbc-store datasource attribute
ModelNode result =
servicesA.executeOperation(
getMixedKeyedJDBCCacheStoreReadOperation(
"maximal",
DistributedCacheResourceDefinition.WILDCARD_PATH.getKey(),
"dist",
JDBCStoreResourceDefinition.Attribute.DATA_SOURCE));
Assert.assertEquals(result.toString(), SUCCESS, result.get(OUTCOME).asString());
Assert.assertEquals("ExampleDS", result.get(RESULT).asString());
// write the batching attribute
result =
servicesA.executeOperation(
getMixedKeyedJDBCCacheStoreWriteOperation(
"maximal",
DistributedCacheResourceDefinition.WILDCARD_PATH.getKey(),
"dist",
JDBCStoreResourceDefinition.Attribute.DATA_SOURCE,
"new-datasource"));
Assert.assertEquals(result.toString(), SUCCESS, result.get(OUTCOME).asString());
// re-read the batching attribute
result =
servicesA.executeOperation(
getMixedKeyedJDBCCacheStoreReadOperation(
"maximal",
DistributedCacheResourceDefinition.WILDCARD_PATH.getKey(),
"dist",
JDBCStoreResourceDefinition.Attribute.DATA_SOURCE));
Assert.assertEquals(result.toString(), SUCCESS, result.get(OUTCOME).asString());
Assert.assertEquals("new-datasource", result.get(RESULT).asString());
// read the string-keyed-table attribute
result =
servicesA.executeOperation(
getMixedKeyedJDBCCacheStoreReadOperation(
"maximal",
DistributedCacheResourceDefinition.WILDCARD_PATH.getKey(),
"dist",
MixedKeyedJDBCStoreResourceDefinition.DeprecatedAttribute.STRING_TABLE));
Assert.assertEquals(result.toString(), SUCCESS, result.get(OUTCOME).asString());
Assert.assertEquals(
stringKeyedTable.asPropertyList().size(), result.get(RESULT).asPropertyList().size());
for (Property property : stringKeyedTable.asPropertyList()) {
Assert.assertTrue(result.get(RESULT).hasDefined(property.getName()));
Assert.assertEquals(property.getValue(), result.get(RESULT).get(property.getName()));
}
}
// For any request params that are of type BYTES, replace the file path with the bytes from the
// file
private boolean replaceFilePathsWithBytes(ModelNode request)
throws CommandFormatException, IOException {
boolean didReplacement = false;
ModelNode opDesc = new ModelNode();
opDesc.get("address").set(request.get("address"));
opDesc.get("operation").set("read-operation-description");
final String opName = request.get("operation").asString();
opDesc.get("name").set(opName);
ModelNode response = execute(opDesc, false).getResponseNode();
if (response.hasDefined("result", "request-properties")) {
final ModelNode requestProps = response.get("result", "request-properties");
for (Property prop : requestProps.asPropertyList()) {
ModelNode typeDesc = prop.getValue().get("type");
if (typeDesc.getType() == ModelType.TYPE
&& typeDesc.asType() == ModelType.BYTES
&& request.hasDefined(prop.getName())) {
String filePath = request.get(prop.getName()).asString();
File localFile = new File(filePath);
if (!localFile.exists()) continue;
try {
request.get(prop.getName()).set(Util.readBytes(localFile));
didReplacement = true;
} catch (OperationFormatException e) {
throw new CommandFormatException(e);
}
}
}
}
return didReplacement;
}
void launchServices(
final OperationContext context,
final PathAddress pathAddress,
final ModelNode model,
final ServiceVerificationHandler verificationHandler,
final List<ServiceController<?>> newControllers)
throws OperationFailedException {
Handler newHandler = new Handler();
newHandler.setClazz(
HandlerResourceDefinition.CLASS.resolveModelAttribute(context, model).asString());
ModelNode handler = Resource.Tools.readModel(context.readResourceFromRoot(pathAddress));
if (handler.hasDefined(COMMON_HANDLER_PARAMETER.getName())) {
for (ModelNode handlerParameter : handler.get(COMMON_HANDLER_PARAMETER.getName()).asList()) {
Property property = handlerParameter.asProperty();
String paramName = property.getName();
String paramValue =
HandlerParameterResourceDefinition.VALUE
.resolveModelAttribute(context, property.getValue())
.asString();
KeyValueType kv = new KeyValueType();
kv.setKey(paramName);
kv.setValue(paramValue);
newHandler.add(kv);
}
}
SAMLHandlerService service = new SAMLHandlerService(newHandler);
PathElement providerAlias = pathAddress.subAddress(0, pathAddress.size() - 1).getLastElement();
ServiceTarget serviceTarget = context.getServiceTarget();
ServiceBuilder<SAMLHandlerService> serviceBuilder =
serviceTarget.addService(
createServiceName(providerAlias.getValue(), newHandler.getClazz()), service);
ServiceName serviceName;
if (providerAlias.getKey().equals(IDENTITY_PROVIDER.getName())) {
serviceName = IdentityProviderService.createServiceName(providerAlias.getValue());
} else {
serviceName = ServiceProviderService.createServiceName(providerAlias.getValue());
}
serviceBuilder.addDependency(
serviceName, EntityProviderService.class, service.getEntityProviderService());
ServiceController<SAMLHandlerService> controller =
serviceBuilder
.addListener(verificationHandler)
.setInitialMode(ServiceController.Mode.PASSIVE)
.install();
if (newControllers != null) {
newControllers.add(controller);
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
private void configureCredentialHandlers(
OperationContext context,
ModelNode identityStore,
IdentityStoreConfigurationBuilder<?, ?> storeConfig)
throws OperationFailedException {
if (identityStore.hasDefined(IDENTITY_STORE_CREDENTIAL_HANDLER.getName())) {
for (Property credentialHandler :
identityStore.get(IDENTITY_STORE_CREDENTIAL_HANDLER.getName()).asPropertyList()) {
ModelNode classNameNode =
CredentialHandlerResourceDefinition.CLASS_NAME.resolveModelAttribute(
context, credentialHandler.getValue());
ModelNode codeNode =
CredentialHandlerResourceDefinition.CODE.resolveModelAttribute(
context, credentialHandler.getValue());
ModelNode moduleNode =
CredentialHandlerResourceDefinition.MODULE.resolveModelAttribute(
context, credentialHandler.getValue());
String typeName;
if (classNameNode.isDefined()) {
typeName = classNameNode.asString();
} else if (codeNode.isDefined()) {
typeName = CredentialTypeEnum.forType(codeNode.asString());
} else {
throw ROOT_LOGGER.typeNotProvided(IDENTITY_STORE_CREDENTIAL_HANDLER.getName());
}
storeConfig.addCredentialHandler(this.<CredentialHandler>loadClass(moduleNode, typeName));
}
}
}
private void addThreadFactories(final ModelNode result, final ModelNode model) {
if (model.hasDefined(THREAD_FACTORY)) {
ModelNode pools = model.get(THREAD_FACTORY);
for (Property poolProp : pools.asPropertyList()) {
final ModelNode operation =
Util.getEmptyOperation(
ADD,
pathAddress(
PathElement.pathElement(SUBSYSTEM, SUBSYSTEM_NAME),
PathElement.pathElement(THREAD_FACTORY, poolProp.getName())));
final ModelNode pool = poolProp.getValue();
operation.get(NAME).set(pool.require(NAME));
if (pool.hasDefined(GROUP_NAME)) {
operation.get(GROUP_NAME).set(pool.get(GROUP_NAME));
}
if (pool.hasDefined(THREAD_NAME_PATTERN)) {
operation.get(THREAD_NAME_PATTERN).set(pool.get(THREAD_NAME_PATTERN));
}
if (pool.hasDefined(PRIORITY)) {
operation.get(PRIORITY).set(pool.get(PRIORITY));
}
if (pool.hasDefined(PROPERTIES)) {
operation.get(PROPERTIES).set(pool.get(PROPERTIES));
}
result.add(operation);
}
}
}
private void addUnboundedQueueThreadPools(final ModelNode result, final ModelNode model) {
if (model.hasDefined(UNBOUNDED_QUEUE_THREAD_POOL)) {
ModelNode pools = model.get(UNBOUNDED_QUEUE_THREAD_POOL);
for (Property poolProp : pools.asPropertyList()) {
final ModelNode operation =
Util.getEmptyOperation(
ADD,
pathAddress(
PathElement.pathElement(SUBSYSTEM, SUBSYSTEM_NAME),
PathElement.pathElement(UNBOUNDED_QUEUE_THREAD_POOL, poolProp.getName())));
final ModelNode pool = poolProp.getValue();
operation.get(NAME).set(pool.require(NAME));
if (pool.hasDefined(THREAD_FACTORY)) {
operation.get(THREAD_FACTORY).set(pool.get(THREAD_FACTORY));
}
if (pool.hasDefined(PROPERTIES)) {
operation.get(PROPERTIES).set(pool.get(PROPERTIES));
}
if (pool.hasDefined(MAX_THREADS)) {
operation.get(MAX_THREADS).set(pool.get(MAX_THREADS));
}
if (pool.hasDefined(KEEPALIVE_TIME)) {
operation.get(KEEPALIVE_TIME).set(pool.get(KEEPALIVE_TIME));
}
result.add(operation);
}
}
}
private void addInterfaces(Map<String, ModelNode> map, ModelNode iface) {
if (iface.isDefined()) {
for (Property prop : iface.asPropertyList()) {
map.put(prop.getName(), prop.getValue());
}
}
}
static MailSessionConfig from(final OperationContext operationContext, final ModelNode model)
throws OperationFailedException {
MailSessionConfig cfg = new MailSessionConfig();
cfg.setJndiName(
MailSessionDefinition.JNDI_NAME.resolveModelAttribute(operationContext, model).asString());
cfg.setDebug(
MailSessionDefinition.DEBUG.resolveModelAttribute(operationContext, model).asBoolean());
if (MailSessionDefinition.FROM.resolveModelAttribute(operationContext, model).isDefined()) {
cfg.setFrom(
MailSessionDefinition.FROM.resolveModelAttribute(operationContext, model).asString());
}
if (model.hasDefined(SERVER_TYPE)) {
ModelNode server = model.get(SERVER_TYPE);
if (server.hasDefined(SMTP)) {
cfg.setSmtpServer(readServerConfig(operationContext, server.get(SMTP)));
}
if (server.hasDefined(POP3)) {
cfg.setPop3Server(readServerConfig(operationContext, server.get(POP3)));
}
if (server.hasDefined(IMAP)) {
cfg.setImapServer(readServerConfig(operationContext, server.get(IMAP)));
}
}
if (model.hasDefined(CUSTOM)) {
for (Property server : model.get(CUSTOM).asPropertyList()) {
cfg.addCustomServer(
readCustomServerConfig(server.getName(), operationContext, server.getValue()));
}
}
return cfg;
}
static ModelNode parseCustomLoadMetric(XMLExtendedStreamReader reader) throws XMLStreamException {
final ModelNode load = new ModelNode();
final int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
requireNoNamespaceAttribute(reader, i);
final String value = reader.getAttributeValue(i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case CAPACITY:
load.get(CAPACITY).set(value);
break;
case WEIGHT:
load.get(WEIGHT).set(value);
break;
case CLASS:
load.get(CLASS).set(value);
break;
default:
unexpectedAttribute(reader, i);
}
}
while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
final Element element = Element.forName(reader.getLocalName());
switch (element) {
case PROPERTY:
final Property property = parseProperty(reader);
load.get("property").add(property.getName(), property.getValue());
break;
default:
unexpectedElement(reader);
}
}
return load;
}
private static ModelFixer createModelFixer(ModelVersion version) {
return (ModelNode model) -> {
if (InfinispanModel.VERSION_4_1_0.requiresTransformation(version)) {
final ModelNode maximal = model.get("cache-container", "maximal");
maximal
.asPropertyList()
.stream()
.filter(
caches ->
caches.getName().equals("distributed-cache")
|| caches.getName().equals("replicated-cache"))
.forEach(
p -> {
ModelNode caches = maximal.get(p.getName());
final List<Property> cachesModel = caches.asPropertyList();
for (Property cacheName : cachesModel) {
final ModelNode cache = caches.get(cacheName.getName());
if (cache.hasDefined("component")) {
cache.get("component", "backups").set(new ModelNode());
}
}
});
}
if (InfinispanModel.VERSION_4_0_0.requiresTransformation(version)) {
// Fix the legacy model to expect new default values applied in
// StateTransferResourceDefinition#buildTransformation
Arrays.asList("cache-with-string-keyed-store", "cache-with-binary-keyed-store")
.forEach(
cacheName -> {
ModelNode cache =
model.get("cache-container", "maximal", "replicated-cache", cacheName);
assertFalse(
cache.hasDefined(
StateTransferResourceDefinition.LEGACY_PATH.getKeyValuePair()));
ModelNode stateTransfer =
cache.get(StateTransferResourceDefinition.LEGACY_PATH.getKeyValuePair());
stateTransfer
.get(
StateTransferResourceDefinition.Attribute.CHUNK_SIZE
.getDefinition()
.getName())
.set(
StateTransferResourceDefinition.Attribute.CHUNK_SIZE
.getDefinition()
.getDefaultValue());
stateTransfer
.get(
StateTransferResourceDefinition.Attribute.TIMEOUT
.getDefinition()
.getName())
.set(
StateTransferResourceDefinition.Attribute.TIMEOUT
.getDefinition()
.getDefaultValue());
});
}
return model;
};
}
/* Property logic */
static void writeProperty(final XMLExtendedStreamWriter writer, Property property)
throws XMLStreamException {
writer.writeStartElement(Element.PROPERTY.getLocalName());
writer.writeAttribute(NAME, property.getName());
writer.writeAttribute(VALUE, property.getValue().asString());
writer.writeEndElement();
}
@Override
public void persist(XMLExtendedStreamWriter writer, ModelNode model) throws XMLStreamException {
boolean wildcard = getPathElement().isWildcard();
model =
wildcard
? model.get(getPathElement().getKey())
: model.get(getPathElement().getKeyValuePair());
if (!model.isDefined()) {
return;
}
boolean writeWrapper = getXmlWrapperElement() != null;
if (writeWrapper) {
writer.writeStartElement(getXmlWrapperElement());
}
writer.writeStartElement(getXmlElementName());
if (wildcard) {
for (Property p : model.asPropertyList()) {
writer.writeAttribute(NAME, p.getName());
for (AttributeDefinition def : getAttributes()) {
def.getAttributeMarshaller().marshallAsAttribute(def, p.getValue(), false, writer);
}
persistChildren(writer, p.getValue());
}
} else {
for (AttributeDefinition def : getAttributes()) {
def.getAttributeMarshaller().marshallAsAttribute(def, model, false, writer);
}
persistChildren(writer, model);
}
writer.writeEndElement();
if (writeWrapper) {
writer.writeEndElement();
}
}
private void configureSupportedTypes(
OperationContext context,
ModelNode identityStore,
IdentityStoreConfigurationBuilder storeConfig)
throws OperationFailedException {
boolean hasSupportedType = identityStore.hasDefined(SUPPORTED_TYPES.getName());
if (hasSupportedType) {
ModelNode featuresSetNode =
identityStore.get(SUPPORTED_TYPES.getName()).asProperty().getValue();
ModelNode supportsAllNode =
SupportedTypesResourceDefinition.SUPPORTS_ALL.resolveModelAttribute(
context, featuresSetNode);
if (supportsAllNode.asBoolean()) {
storeConfig.supportAllFeatures();
}
hasSupportedType = supportsAllNode.asBoolean();
if (featuresSetNode.hasDefined(SUPPORTED_TYPE.getName())) {
for (Property supportedTypeNode :
featuresSetNode.get(SUPPORTED_TYPE.getName()).asPropertyList()) {
ModelNode supportedType = supportedTypeNode.getValue();
ModelNode classNameNode =
SupportedTypeResourceDefinition.CLASS_NAME.resolveModelAttribute(
context, supportedType);
ModelNode codeNode =
SupportedTypeResourceDefinition.CODE.resolveModelAttribute(context, supportedType);
String typeName;
if (classNameNode.isDefined()) {
typeName = classNameNode.asString();
} else if (codeNode.isDefined()) {
typeName = AttributedTypeEnum.forType(codeNode.asString());
} else {
throw ROOT_LOGGER.typeNotProvided(SUPPORTED_TYPE.getName());
}
ModelNode moduleNode =
SupportedTypeResourceDefinition.MODULE.resolveModelAttribute(context, supportedType);
Class<? extends AttributedType> attributedTypeClass = loadClass(moduleNode, typeName);
if (Relationship.class.isAssignableFrom(attributedTypeClass)) {
storeConfig.supportGlobalRelationship(
(Class<? extends Relationship>) attributedTypeClass);
} else {
storeConfig.supportType(attributedTypeClass);
}
hasSupportedType = true;
}
}
}
if (!hasSupportedType) {
throw ROOT_LOGGER.idmNoSupportedTypesDefined();
}
}
private void addPaths(Map<String, ModelNode> map, ModelNode path) {
if (path.isDefined()) {
for (Property prop : path.asPropertyList()) {
// TODO merge rather than replace existing?
map.put(prop.getName(), prop.getValue());
}
}
}
private Map<String, ModelNode> getSortedEntryMap(ModelNode parent, String name) {
if (!parent.hasDefined(name)) {
return Collections.emptyMap();
}
Map<String, ModelNode> sorted = new TreeMap<String, ModelNode>();
for (Property prop : parent.get(name).asPropertyList()) {
sorted.put(prop.getName(), prop.getValue());
}
return sorted;
}
private void addSchemaLocations(Map<String, ModelNode> map, ModelNode namespaces) {
if (namespaces.isDefined()) {
for (Property prop : namespaces.asPropertyList()) {
map.put(
prop.getName(),
SchemaLocationAddHandler.getAddSchemaLocationOperation(
EMPTY, prop.getName(), prop.getValue().asString()));
}
}
}
static void addConnectorServiceConfigs(final Configuration configuration, final ModelNode model)
throws OperationFailedException {
if (model.hasDefined(CommonAttributes.CONNECTOR_SERVICE)) {
final List<ConnectorServiceConfiguration> configs =
configuration.getConnectorServiceConfigurations();
for (Property prop : model.get(CommonAttributes.CONNECTOR_SERVICE).asPropertyList()) {
configs.add(createConnectorServiceConfiguration(prop.getName(), prop.getValue()));
}
}
}
private Map<String, ModelNode> createMapIndexedByKey(ModelNode node) {
Map<String, ModelNode> map = new HashMap<String, ModelNode>();
if (!node.isDefined()) {
return map;
}
for (Property prop : node.asPropertyList()) {
map.put(prop.getName(), prop.getValue());
}
return map;
}
private void configureIdentityStore(
OperationContext context,
ServiceBuilder<PartitionManager> serviceBuilder,
ServiceVerificationHandler verificationHandler,
List<ServiceController<?>> newControllers,
PartitionManagerService partitionManagerService,
String configurationName,
NamedIdentityConfigurationBuilder namedIdentityConfigurationBuilder,
ModelNode modelNode)
throws OperationFailedException {
Property prop = modelNode.asProperty();
String storeType = prop.getName();
ModelNode identityStore = prop.getValue().asProperty().getValue();
IdentityStoreConfigurationBuilder<?, ?> storeConfig = null;
if (storeType.equals(JPA_STORE.getName())) {
storeConfig =
configureJPAIdentityStore(
context,
serviceBuilder,
verificationHandler,
newControllers,
partitionManagerService,
identityStore,
configurationName,
namedIdentityConfigurationBuilder);
} else if (storeType.equals(FILE_STORE.getName())) {
storeConfig =
configureFileIdentityStore(
context,
serviceBuilder,
verificationHandler,
newControllers,
partitionManagerService,
identityStore,
configurationName,
namedIdentityConfigurationBuilder);
} else if (storeType.equals(LDAP_STORE.getName())) {
storeConfig =
configureLDAPIdentityStore(context, identityStore, namedIdentityConfigurationBuilder);
}
ModelNode supportAttributeNode =
JPAStoreResourceDefinition.SUPPORT_ATTRIBUTE.resolveModelAttribute(context, identityStore);
storeConfig.supportAttributes(supportAttributeNode.asBoolean());
ModelNode supportCredentialNode =
JPAStoreResourceDefinition.SUPPORT_CREDENTIAL.resolveModelAttribute(context, identityStore);
storeConfig.supportCredentials(supportCredentialNode.asBoolean());
configureSupportedTypes(context, identityStore, storeConfig);
configureCredentialHandlers(context, identityStore, storeConfig);
}
private void writeWorkspaces(XMLExtendedStreamWriter writer, ModelNode repository)
throws XMLStreamException {
boolean started = false;
// Write these model attributes of 'repository' onto the 'workspaces' XML element ...
if (ModelAttributes.DEFAULT_WORKSPACE.isMarshallable(repository, false)) {
started = startIfNeeded(writer, Element.WORKSPACES, started);
ModelAttributes.DEFAULT_WORKSPACE.marshallAsAttribute(repository, writer);
}
if (ModelAttributes.ALLOW_WORKSPACE_CREATION.isMarshallable(repository, false)) {
started = startIfNeeded(writer, Element.WORKSPACES, started);
ModelAttributes.ALLOW_WORKSPACE_CREATION.marshallAsAttribute(repository, writer);
}
if (ModelAttributes.WORKSPACES_CACHE_CONTAINER.isMarshallable(repository, false)) {
started = startIfNeeded(writer, Element.WORKSPACES, started);
ModelAttributes.WORKSPACES_CACHE_CONTAINER.marshallAsAttribute(repository, writer);
}
if (has(repository, ModelKeys.PREDEFINED_WORKSPACE_NAMES)) {
started = startIfNeeded(writer, Element.WORKSPACES, started);
ModelNode names = repository.get(ModelKeys.PREDEFINED_WORKSPACE_NAMES);
if (names.isDefined()) {
Map<String, String> workspacesInitialContent = new HashMap<String, String>();
if (has(repository, ModelKeys.WORKSPACES_INITIAL_CONTENT)) {
List<ModelNode> initialContentNodes =
repository.get(ModelKeys.WORKSPACES_INITIAL_CONTENT).asList();
for (ModelNode modelNode : initialContentNodes) {
Property property = modelNode.asProperty();
workspacesInitialContent.put(property.getName(), property.getValue().asString());
}
}
for (ModelNode workspace : repository.get(ModelKeys.PREDEFINED_WORKSPACE_NAMES).asList()) {
writer.writeStartElement(Element.WORKSPACE.getLocalName());
String name = workspace.asString();
writer.writeAttribute(Attribute.NAME.getLocalName(), name);
if (workspacesInitialContent.containsKey(name)) {
writer.writeStartElement(Element.INITIAL_CONTENT.getLocalName());
writer.writeCharacters(workspacesInitialContent.get(name));
writer.writeEndElement();
}
writer.writeEndElement();
}
}
}
if (has(repository, ModelKeys.DEFAULT_INITIAL_CONTENT)) {
started = startIfNeeded(writer, Element.WORKSPACES, started);
writer.writeStartElement(Element.INITIAL_CONTENT.getLocalName());
writer.writeCharacters(repository.get(ModelKeys.DEFAULT_INITIAL_CONTENT).asString());
writer.writeEndElement();
}
if (started) {
writer.writeEndElement();
}
}
private void writeProperties(final XMLExtendedStreamWriter writer, final ModelNode node)
throws XMLStreamException {
writer.writeStartElement(Element.PROPERTIES.getLocalName());
for (Property prop : node.asPropertyList()) {
writer.writeStartElement(Element.PROPERTY.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), prop.getName());
PropertyResource.VALUE.marshallAsAttribute(prop.getValue(), writer);
writer.writeEndElement();
}
writer.writeEndElement();
}
private static void writeAcceptorContent(
final XMLExtendedStreamWriter writer, final Property property) throws XMLStreamException {
writer.writeAttribute(Attribute.NAME.getLocalName(), property.getName());
final ModelNode value = property.getValue();
RemoteTransportDefinition.SOCKET_BINDING.marshallAsAttribute(value, writer);
InVMTransportDefinition.SERVER_ID.marshallAsAttribute(value, writer);
CommonAttributes.FACTORY_CLASS.marshallAsElement(value, writer);
writeTransportParam(writer, value.get(PARAM));
}
public void addDeploymentOverlays(final List<ModelNode> updates) {
if (domainModel.hasDefined(DEPLOYMENT_OVERLAY)) {
HostFileRepository remoteRepository = null;
if (!domainController.getLocalHostInfo().isMasterDomainController()) {
remoteRepository = domainController.getRemoteFileRepository();
}
for (Property deploymentOverlay : domainModel.get(DEPLOYMENT_OVERLAY).asPropertyList()) {
String name = deploymentOverlay.getName();
ModelNode details = deploymentOverlay.getValue();
PathAddress addr =
PathAddress.pathAddress(PathElement.pathElement(DEPLOYMENT_OVERLAY, name));
ModelNode addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
updates.add(addOp);
if (details.hasDefined(CONTENT)) {
for (Property content : details.get(CONTENT).asPropertyList()) {
final String contentName = content.getName();
final ModelNode contentDetails = content.getValue();
byte[] hash = contentDetails.require(CONTENT).asBytes();
File[] files = domainController.getLocalFileRepository().getDeploymentFiles(hash);
if (files == null || files.length == 0) {
if (remoteRepository != null) {
remoteRepository.getDeploymentFiles(hash);
}
}
addr =
PathAddress.pathAddress(
PathElement.pathElement(DEPLOYMENT_OVERLAY, name),
PathElement.pathElement(CONTENT, contentName));
addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
addOp.get(CONTENT).get(HASH).set(contentDetails.get(CONTENT));
updates.add(addOp);
}
}
if (serverGroup.hasDefined(DEPLOYMENT_OVERLAY)) {
final ModelNode groupOverlay = serverGroup.get(DEPLOYMENT_OVERLAY).asObject();
if (groupOverlay.has(name)) {
ModelNode deploymentsNode = groupOverlay.get(name);
if (deploymentsNode.has(DEPLOYMENT)) {
for (Property content : deploymentsNode.get(DEPLOYMENT).asPropertyList()) {
final String deploymentName = content.getName();
final ModelNode deploymentDetails = content.getValue();
addr =
PathAddress.pathAddress(
PathElement.pathElement(DEPLOYMENT_OVERLAY, name),
PathElement.pathElement(DEPLOYMENT, deploymentName));
addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
updates.add(addOp);
}
}
}
}
}
}
}
private void writeStoreProperties(XMLExtendedStreamWriter writer, ModelNode store)
throws XMLStreamException {
if (store.hasDefined(ModelKeys.PROPERTY)) {
for (Property property : store.get(ModelKeys.PROPERTY).asPropertyList()) {
writer.writeStartElement(Element.PROPERTY.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), property.getName());
writer.writeCharacters(property.getValue().asString());
writer.writeEndElement();
}
}
}
/** {@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();
}
/** {@inheritDoc} */
@Override
public void writeContent(XMLExtendedStreamWriter writer, SubsystemMarshallingContext context)
throws XMLStreamException {
context.startSubsystemElement(Namespace.CURRENT.getUriString(), false);
ModelNode scanners = context.getModelNode();
for (final Property list : scanners.asPropertyList()) {
final ModelNode node = list.getValue();
for (final Property scanner : node.asPropertyList()) {
writer.writeEmptyElement(Element.DEPLOYMENT_SCANNER.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), scanner.getName());
ModelNode configuration = scanner.getValue();
if (configuration.hasDefined(CommonAttributes.PATH)) {
writer.writeAttribute(
Attribute.PATH.getLocalName(), configuration.get(CommonAttributes.PATH).asString());
}
if (configuration.hasDefined(CommonAttributes.SCAN_ENABLED)) {
writer.writeAttribute(
Attribute.SCAN_ENABLED.getLocalName(),
configuration.get(CommonAttributes.SCAN_ENABLED).asString());
}
if (configuration.hasDefined(CommonAttributes.SCAN_INTERVAL)) {
writer.writeAttribute(
Attribute.SCAN_INTERVAL.getLocalName(),
configuration.get(CommonAttributes.SCAN_INTERVAL).asString());
}
if (configuration.hasDefined(CommonAttributes.RELATIVE_TO)) {
writer.writeAttribute(
Attribute.RELATIVE_TO.getLocalName(),
configuration.get(CommonAttributes.RELATIVE_TO).asString());
}
if (configuration.hasDefined(CommonAttributes.AUTO_DEPLOY_ZIPPED)) {
if (!configuration.get(CommonAttributes.AUTO_DEPLOY_ZIPPED).asBoolean()) {
writer.writeAttribute(
Attribute.AUTO_DEPLOY_ZIPPED.getLocalName(), Boolean.FALSE.toString());
}
}
if (configuration.hasDefined(CommonAttributes.AUTO_DEPLOY_EXPLODED)) {
if (configuration.get(CommonAttributes.AUTO_DEPLOY_EXPLODED).asBoolean()) {
writer.writeAttribute(
Attribute.AUTO_DEPLOY_EXPLODED.getLocalName(), Boolean.TRUE.toString());
}
}
if (configuration.hasDefined(CommonAttributes.DEPLOYMENT_TIMEOUT)) {
writer.writeAttribute(
Attribute.DEPLOYMENT_TIMEOUT.getLocalName(),
configuration.get(CommonAttributes.DEPLOYMENT_TIMEOUT).asString());
}
}
writer.writeEndElement();
}
}
public Map<String, String> unwrap(final OperationContext context, final ModelNode model)
throws OperationFailedException {
if (!model.hasDefined(getName())) {
return new HashMap<String, String>();
}
ModelNode modelProps = model.get(getName());
Map<String, String> props = new HashMap<String, String>();
for (Property p : modelProps.asPropertyList()) {
props.put(p.getName(), context.resolveExpressions(p.getValue()).asString());
}
return props;
}
private void writeServerGroup(
final XMLExtendedStreamWriter writer, final String groupName, final ModelNode group)
throws XMLStreamException {
writer.writeStartElement(Element.SERVER_GROUP.getLocalName());
writer.writeAttribute(Attribute.NAME.getLocalName(), groupName);
writer.writeAttribute(Attribute.PROFILE.getLocalName(), group.get(PROFILE).asString());
// JVM
if (group.hasDefined(JVM)) {
for (final Property jvm : group.get(JVM).asPropertyList()) {
JvmXml.writeJVMElement(writer, jvm.getName(), jvm.getValue());
break; // TODO just write the first !?
}
}
// Socket binding ref
String bindingGroupRef =
group.hasDefined(SOCKET_BINDING_GROUP) ? group.get(SOCKET_BINDING_GROUP).asString() : null;
String portOffset =
group.hasDefined(SOCKET_BINDING_PORT_OFFSET)
? group.get(SOCKET_BINDING_PORT_OFFSET).asString()
: null;
Boolean managementSubsystemEndpoint =
group.hasDefined(MANAGEMENT_SUBSYSTEM_ENDPOINT)
? group.get(MANAGEMENT_SUBSYSTEM_ENDPOINT).asBoolean()
: null;
if (bindingGroupRef != null || portOffset != null) {
writer.writeStartElement(Element.SOCKET_BINDING_GROUP.getLocalName());
if (bindingGroupRef != null) {
writeAttribute(writer, Attribute.REF, bindingGroupRef);
}
if (portOffset != null) {
writeAttribute(writer, Attribute.PORT_OFFSET, portOffset);
}
if (managementSubsystemEndpoint != null) {
writeAttribute(
writer,
Attribute.MANAGEMENT_SUBSYSTEM_ENDPOINT,
managementSubsystemEndpoint.toString());
}
writer.writeEndElement();
}
if (group.hasDefined(DEPLOYMENT)) {
writeServerGroupDeployments(writer, group.get(DEPLOYMENT));
}
// System properties
if (group.hasDefined(SYSTEM_PROPERTY)) {
writeProperties(writer, group.get(SYSTEM_PROPERTY), Element.SYSTEM_PROPERTIES, false);
}
writer.writeEndElement();
}
