void parseSocketBindingGroup_1_0( final XMLExtendedStreamReader reader, final Set<String> interfaces, final ModelNode address, final Namespace expectedNs, final List<ModelNode> updates) throws XMLStreamException { final Set<String> includedGroups = new HashSet<String>(); // unique socket-binding names final Set<String> uniqueBindingNames = new HashSet<String>(); // Handle attributes final String[] attrValues = requireAttributes( reader, Attribute.NAME.getLocalName(), Attribute.DEFAULT_INTERFACE.getLocalName()); final String socketBindingGroupName = attrValues[0]; final String defaultInterface = attrValues[1]; final ModelNode groupAddress = new ModelNode().set(address); groupAddress.add(SOCKET_BINDING_GROUP, socketBindingGroupName); final ModelNode bindingGroupUpdate = new ModelNode(); bindingGroupUpdate.get(OP_ADDR).set(groupAddress); bindingGroupUpdate.get(OP).set(ADD); SocketBindingGroupResourceDefinition.DEFAULT_INTERFACE.parseAndSetParameter( defaultInterface, bindingGroupUpdate, reader); if (bindingGroupUpdate .get(SocketBindingGroupResourceDefinition.DEFAULT_INTERFACE.getName()) .getType() != ModelType.EXPRESSION && !interfaces.contains(defaultInterface)) { throw MESSAGES.unknownInterface( defaultInterface, Attribute.DEFAULT_INTERFACE.getLocalName(), Element.INTERFACES.getLocalName(), reader.getLocation()); } final ModelNode includes = bindingGroupUpdate.get(INCLUDES); includes.setEmptyList(); updates.add(bindingGroupUpdate); // Handle elements while (reader.nextTag() != END_ELEMENT) { requireNamespace(reader, expectedNs); final Element element = Element.forName(reader.getLocalName()); switch (element) { case INCLUDE: { HOST_CONTROLLER_LOGGER.warnIgnoringSocketBindingGroupInclude(reader.getLocation()); /* This will be reintroduced for 7.2.0, leave commented out final String includedGroup = readStringAttributeElement(reader, Attribute.SOCKET_BINDING_GROUP.getLocalName()); if (!includedGroups.add(includedGroup)) { throw MESSAGES.alreadyDeclared(Attribute.SOCKET_BINDING_GROUP.getLocalName(), includedGroup, reader.getLocation()); } SocketBindingGroupResourceDefinition.INCLUDES.parseAndAddParameterElement(includedGroup, bindingGroupUpdate, reader.getLocation()); */ break; } case SOCKET_BINDING: { final String bindingName = parseSocketBinding(reader, interfaces, groupAddress, updates); if (!uniqueBindingNames.add(bindingName)) { throw MESSAGES.alreadyDeclared( Element.SOCKET_BINDING.getLocalName(), bindingName, Element.SOCKET_BINDING_GROUP.getLocalName(), socketBindingGroupName, reader.getLocation()); } break; } default: throw unexpectedElement(reader); } } }
void parseProfiles( final XMLExtendedStreamReader reader, final ModelNode address, final Namespace expectedNs, final List<ModelNode> list) throws XMLStreamException { requireNoAttributes(reader); final Set<String> names = new HashSet<String>(); while (reader.nextTag() != END_ELEMENT) { requireNamespace(reader, expectedNs); Element element = Element.forName(reader.getLocalName()); if (Element.PROFILE != element) { throw unexpectedElement(reader); } // Attributes requireSingleAttribute(reader, Attribute.NAME.getLocalName()); final String name = reader.getAttributeValue(0); if (!names.add(name)) { throw MESSAGES.duplicateDeclaration("profile", name, reader.getLocation()); } // final Set<String> includes = new HashSet<String>(); // See commented out section below. // final ModelNode profileIncludes = new ModelNode(); // Content // Sequence final Map<String, List<ModelNode>> profileOps = new LinkedHashMap<String, List<ModelNode>>(); while (reader.nextTag() != END_ELEMENT) { Namespace ns = Namespace.forUri(reader.getNamespaceURI()); switch (ns) { case UNKNOWN: { if (Element.forName(reader.getLocalName()) != Element.SUBSYSTEM) { throw unexpectedElement(reader); } String namespace = reader.getNamespaceURI(); if (profileOps.containsKey(namespace)) { throw MESSAGES.duplicateDeclaration("subsystem", name, reader.getLocation()); } // parse content final List<ModelNode> subsystems = new ArrayList<ModelNode>(); reader.handleAny(subsystems); profileOps.put(namespace, subsystems); break; } case DOMAIN_1_0: case DOMAIN_1_1: case DOMAIN_1_2: case DOMAIN_1_3: { requireNamespace(reader, expectedNs); // include should come first if (profileOps.size() > 0) { throw unexpectedElement(reader); } if (Element.forName(reader.getLocalName()) != Element.INCLUDE) { throw unexpectedElement(reader); } // Remove support for profile includes until 7.2.0 if (ns == Namespace.DOMAIN_1_0) { HOST_CONTROLLER_LOGGER.warnIgnoringProfileInclude(reader.getLocation()); } throw unexpectedElement(reader); /* This will be reintroduced for 7.2.0, leave commented out final String includedName = readStringAttributeElement(reader, Attribute.PROFILE.getLocalName()); if (! names.contains(includedName)) { throw MESSAGES.profileNotFound(reader.getLocation()); } if (! includes.add(includedName)) { throw MESSAGES.duplicateProfile(reader.getLocation()); } profileIncludes.add(includedName); break; */ } default: { throw unexpectedElement(reader); } } } // Let extensions modify the profile Set<ProfileParsingCompletionHandler> completionHandlers = extensionRegistry.getProfileParsingCompletionHandlers(); for (ProfileParsingCompletionHandler completionHandler : completionHandlers) { completionHandler.handleProfileParsingCompletion(profileOps, list); } final ModelNode profile = new ModelNode(); profile.get(OP).set(ADD); profile.get(OP_ADDR).set(address).add(ModelDescriptionConstants.PROFILE, name); /* This will be reintroduced for 7.2.0, leave commented out profile.get(INCLUDES).set(profileIncludes); */ list.add(profile); // Process subsystems for (List<ModelNode> subsystems : profileOps.values()) { for (final ModelNode update : subsystems) { // Process relative subsystem path address final ModelNode subsystemAddress = address.clone().set(address).add(ModelDescriptionConstants.PROFILE, name); 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); } } if (profileOps.size() == 0) { throw MESSAGES.profileHasNoSubsystems(reader.getLocation()); } } }
@Override public void execute(final OperationContext context, final ModelNode operation) throws OperationFailedException { if (context.hasFailureDescription()) { // abort context.setRollbackOnly(); context.completeStep(); return; } final Set<String> outstanding = new HashSet<String>(hostProxies.keySet()); final List< TransactionalProtocolClient.PreparedOperation<HostControllerUpdateTask.ProxyOperation>> results = new ArrayList< TransactionalProtocolClient.PreparedOperation< HostControllerUpdateTask.ProxyOperation>>(); final Map<String, HostControllerUpdateTask.ExecutedHostRequest> finalResults = new HashMap<String, HostControllerUpdateTask.ExecutedHostRequest>(); final HostControllerUpdateTask.ProxyOperationListener listener = new HostControllerUpdateTask.ProxyOperationListener(); for (Map.Entry<String, ProxyController> entry : hostProxies.entrySet()) { // Create the proxy task final String host = entry.getKey(); final TransformingProxyController proxyController = (TransformingProxyController) entry.getValue(); List<DomainOperationTransformer> transformers = context.getAttachment(OperationAttachments.SLAVE_SERVER_OPERATION_TRANSFORMERS); ModelNode op = operation; if (transformers != null) { for (final DomainOperationTransformer transformer : transformers) { op = transformer.transform(context, op); } } final HostControllerUpdateTask task = new HostControllerUpdateTask(host, op.clone(), context, proxyController); // Execute the operation on the remote host final HostControllerUpdateTask.ExecutedHostRequest finalResult = task.execute(listener); finalResults.put(host, finalResult); } // Wait for all hosts to reach the prepared state boolean interrupted = false; try { try { while (outstanding.size() > 0) { final TransactionalProtocolClient.PreparedOperation< HostControllerUpdateTask.ProxyOperation> prepared = listener.retrievePreparedOperation(); final String hostName = prepared.getOperation().getName(); if (!outstanding.remove(hostName)) { continue; } final ModelNode preparedResult = prepared.getPreparedResult(); if (HOST_CONTROLLER_LOGGER.isTraceEnabled()) { HOST_CONTROLLER_LOGGER.tracef( "Preliminary result for remote host %s is %s", hostName, preparedResult); } domainOperationContext.addHostControllerResult(hostName, preparedResult); results.add(prepared); } } catch (InterruptedException ie) { interrupted = true; // Set rollback only domainOperationContext.setFailureReported(true); // Rollback all HCs for (final HostControllerUpdateTask.ExecutedHostRequest finalResult : finalResults.values()) { finalResult.asyncCancel(); } // Wait that all hosts are rolled back!? for (final Map.Entry<String, HostControllerUpdateTask.ExecutedHostRequest> entry : finalResults.entrySet()) { final String hostName = entry.getKey(); try { final HostControllerUpdateTask.ExecutedHostRequest request = entry.getValue(); final ModelNode result = request.getFinalResult().get(); final ModelNode transformedResult = request.transformResult(result); domainOperationContext.addHostControllerResult(hostName, transformedResult); } catch (Exception e) { final ModelNode result = new ModelNode(); result.get(OUTCOME).set(FAILED); if (e instanceof InterruptedException) { result .get(FAILURE_DESCRIPTION) .set(MESSAGES.interruptedAwaitingResultFromHost(entry.getKey())); interrupted = true; } else { result .get(FAILURE_DESCRIPTION) .set(MESSAGES.exceptionAwaitingResultFromHost(entry.getKey(), e.getMessage())); } domainOperationContext.addHostControllerResult(hostName, result); } } } context.completeStep(); } finally { try { // Inform the remote hosts whether to commit or roll back their updates // Do this in parallel boolean rollback = domainOperationContext.isCompleteRollback(); for (final TransactionalProtocolClient.PreparedOperation< HostControllerUpdateTask.ProxyOperation> prepared : results) { if (prepared.isDone()) { continue; } if (!rollback) { prepared.commit(); } else { prepared.rollback(); } } // Now get the final results from the hosts for (final TransactionalProtocolClient.PreparedOperation< HostControllerUpdateTask.ProxyOperation> prepared : results) { final String hostName = prepared.getOperation().getName(); try { final ModelNode finalResult = prepared.getFinalResult().get(); domainOperationContext.addHostControllerResult(hostName, finalResult); if (HOST_CONTROLLER_LOGGER.isTraceEnabled()) { HOST_CONTROLLER_LOGGER.tracef( "Final result for remote host %s is %s", hostName, finalResult); } } catch (InterruptedException e) { interrupted = true; CONTROLLER_LOGGER.interruptedAwaitingFinalResponse(hostName); } catch (ExecutionException e) { CONTROLLER_LOGGER.caughtExceptionAwaitingFinalResponse(e.getCause(), hostName); } } } finally { if (interrupted) { Thread.currentThread().interrupt(); } } } }