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(); }