private boolean checkHostServersStarted(DomainClient masterClient, String host) {
   try {
     ModelNode op =
         Util.createEmptyOperation(
             READ_CHILDREN_NAMES_OPERATION, PathAddress.pathAddress(HOST, host));
     op.get(CHILD_TYPE).set(SERVER);
     ModelNode ret = DomainTestUtils.executeForResult(op, masterClient);
     List<ModelNode> list = ret.asList();
     for (ModelNode entry : list) {
       String server = entry.asString();
       op =
           Util.createEmptyOperation(
               READ_ATTRIBUTE_OPERATION,
               PathAddress.pathAddress(HOST, host).append(SERVER, server));
       op.get(NAME).set("server-state");
       ModelNode state = DomainTestUtils.executeForResult(op, masterClient);
       if (SUCCESS.equals(state.get(OUTCOME).asString())) {
         return "running".equals(state.get(RESULT).asString());
       }
     }
     return false;
   } catch (Exception e) {
     return false;
   }
 }
Example #2
0
  @Override
  protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model)
      throws OperationFailedException {
    final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
    final String name = address.getLastElement().getValue();
    final ServiceTarget serviceTarget = context.getServiceTarget();
    final ServiceName serviceName =
        MessagingServices.getActiveMQServiceName(
            PathAddress.pathAddress(operation.get(ModelDescriptionConstants.OP_ADDR)));

    final ModelNode selectorNode = SELECTOR.resolveModelAttribute(context, model);
    final boolean durable = DURABLE.resolveModelAttribute(context, model).asBoolean();

    final String selector = selectorNode.isDefined() ? selectorNode.asString() : null;

    // Do not pass the JNDI bindings to ActiveMQ but install them directly instead so that the
    // dependencies from the BinderServices to the JMSQueueService are not broken
    Service<Queue> queueService =
        JMSQueueService.installService(
            name, serviceTarget, serviceName, selector, durable, new String[0]);

    final ModelNode entries =
        CommonAttributes.DESTINATION_ENTRIES.resolveModelAttribute(context, model);
    final ServiceName jmsQueueServiceName =
        JMSServices.getJmsQueueBaseServiceName(serviceName).append(name);
    final String[] jndiBindings = JMSServices.getJndiBindings(entries);
    for (String jndiBinding : jndiBindings) {
      // install a binder service which depends on the JMS queue service
      BinderServiceUtil.installBinderService(
          serviceTarget, jndiBinding, queueService, jmsQueueServiceName);
    }
  }
  @After
  public void after() throws IOException, MgmtOperationException {

    shutdownHttpClient();

    try {
      ModelNode op =
          Util.createEmptyOperation(
              REMOVE,
              PathAddress.pathAddress(SYSTEM_PROPERTY, LogStreamExtension.LOG_MESSAGE_PROP));
      executeOperation(op);
    } finally {
      try {
        ModelNode op =
            Util.createEmptyOperation(
                REMOVE, PathAddress.pathAddress(SUBSYSTEM, LogStreamExtension.SUBSYSTEM_NAME));
        executeOperation(op);
      } finally {
        ModelNode op =
            Util.createEmptyOperation(
                REMOVE, PathAddress.pathAddress(EXTENSION, LogStreamExtension.MODULE_NAME));
        executeOperation(op);
      }
    }
  }
Example #4
0
    @Override
    public OperationResult execute(
        OperationContext context, ModelNode operation, ResultHandler resultHandler) {
      final ModelNode model = context.getSubModel();

      PathAddress rootAddress =
          PathAddress.pathAddress(
              PathAddress.pathAddress(operation.require(OP_ADDR)).getLastElement());
      final ModelNode result = new ModelNode();

      final ModelNode subsystem = new ModelNode();
      subsystem.get(OP).set(ADD);
      subsystem.get(OP_ADDR).set(rootAddress.toModelNode());
      if (model.has(ACTIVATION)) {
        subsystem.get(ACTIVATION).set(model.get(ACTIVATION));
      }
      if (model.has(CONFIGURATION)) {
        subsystem.get(CONFIGURATION).set(model.get(CONFIGURATION));
      }
      if (model.has(PROPERTIES)) {
        subsystem.get(PROPERTIES).set(model.get(PROPERTIES));
      }
      if (model.has(MODULES)) {
        subsystem.get(MODULES).set(model.get(MODULES));
      }
      result.add(subsystem);

      resultHandler.handleResultFragment(Util.NO_LOCATION, result);
      resultHandler.handleResultComplete();
      return new BasicOperationResult();
    }
Example #5
0
  protected void performRuntime(
      OperationContext context,
      ModelNode operation,
      ModelNode model,
      ServiceVerificationHandler verificationHandler,
      List<ServiceController<?>> newControllers)
      throws OperationFailedException {
    final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
    final String name = address.getLastElement().getValue();
    final ServiceTarget serviceTarget = context.getServiceTarget();
    final ServiceName hqServiceName =
        MessagingServices.getHornetQServiceName(
            PathAddress.pathAddress(operation.get(ModelDescriptionConstants.OP_ADDR)));

    final ModelNode selectorNode = SELECTOR.resolveModelAttribute(context, model);
    final boolean durable = DURABLE.resolveModelAttribute(context, model).asBoolean();

    final String selector = selectorNode.isDefined() ? selectorNode.asString() : null;
    final ModelNode entries =
        CommonAttributes.DESTINATION_ENTRIES.resolveModelAttribute(context, model);
    final String[] jndiBindings = JMSServices.getJndiBindings(entries);
    installServices(
        verificationHandler,
        newControllers,
        name,
        serviceTarget,
        hqServiceName,
        selector,
        durable,
        jndiBindings);
  }
  @Override
  protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model)
      throws OperationFailedException {

    ServiceRegistry registry = context.getServiceRegistry(false);
    final ServiceName serviceName =
        MessagingServices.getActiveMQServiceName(
            PathAddress.pathAddress(operation.get(ModelDescriptionConstants.OP_ADDR)));
    ServiceController<?> service = registry.getService(serviceName);
    if (service != null) {
      context.reloadRequired();
    } else {
      final PathAddress address = PathAddress.pathAddress(operation.require(OP_ADDR));
      final String name = address.getLastElement().getValue();

      final ServiceTarget target = context.getServiceTarget();
      if (model.hasDefined(JGROUPS_CHANNEL.getName())) {
        // nothing to do, in that case, the clustering.jgroups subsystem will have setup the stack
      } else if (model.hasDefined(RemoteTransportDefinition.SOCKET_BINDING.getName())) {
        final GroupBindingService bindingService = new GroupBindingService();
        target
            .addService(
                GroupBindingService.getBroadcastBaseServiceName(serviceName).append(name),
                bindingService)
            .addDependency(
                SocketBinding.JBOSS_BINDING_NAME.append(model.get(SOCKET_BINDING).asString()),
                SocketBinding.class,
                bindingService.getBindingRef())
            .install();
      }
    }
  }
  public static void excludeBadOps_7_1_x(LegacyKernelServicesInitializer initializer) {
    // deployment overlays don't exist in 7.1.x
    initializer.addOperationValidationExclude(
        ADD, PathAddress.pathAddress(PathElement.pathElement(DEPLOYMENT_OVERLAY)));

    initializer.addOperationValidationExclude(
        ADD,
        PathAddress.pathAddress(
            PathElement.pathElement(DEPLOYMENT_OVERLAY), PathElement.pathElement(CONTENT)));
    initializer.addOperationValidationExclude(
        ADD,
        PathAddress.pathAddress(
            PathElement.pathElement(SERVER_GROUP), PathElement.pathElement(DEPLOYMENT_OVERLAY)));

    // Socket binding group/socket-binding has problems if there are expressions in the
    // multicast-port
    initializer.addOperationValidationResolve(
        ADD,
        PathAddress.pathAddress(
            PathElement.pathElement(SOCKET_BINDING_GROUP),
            PathElement.pathElement(SOCKET_BINDING)));

    // Deployment operation validator thinks that content is required
    initializer.addOperationValidationExclude(
        ADD,
        PathAddress.pathAddress(
            PathElement.pathElement(SERVER_GROUP), PathElement.pathElement(DEPLOYMENT)));
  }
Example #8
0
  private ModelNode removeServerGroups(final DomainClient client) throws Exception {
    final ModelNode op =
        Util.createEmptyOperation(
            READ_RESOURCE_OPERATION,
            PathAddress.pathAddress(PathElement.pathElement(SERVER_GROUP)));
    final ModelNode results = executeForResult(op, client);
    ModelNode group = null;
    for (ModelNode result : results.asList()) {
      String groupName = PathAddress.pathAddress(result.get(ADDRESS)).getLastElement().getValue();
      if (groupName.equals(OTHER_SERVER_GROUP)) {
        group = result.get(RESULT);
      } else {
        ModelNode remove = Util.createRemoveOperation(PathAddress.pathAddress(result.get(ADDRESS)));
        executeForResult(remove, client);
      }
    }
    Assert.assertNotNull(group);

    // Add main-server-group as a copy of other-server-group (cuts down on the amount of profiles
    // needed)
    final ModelNode addMain = group.clone();
    final PathAddress mainServerGroupAddress =
        PathAddress.pathAddress(SERVER_GROUP, MAIN_SERVER_GROUP);
    addMain.get(OP).set(ADD);
    addMain.get(OP_ADDR).set(mainServerGroupAddress.toModelNode());
    executeForResult(addMain, client);

    return group;
  }
 protected void describe(
     final Resource resource,
     final ModelNode address,
     ModelNode result,
     final ImmutableManagementResourceRegistration registration) {
   if (registration.isRemote()
       || registration.isRuntimeOnly()
       || resource.isProxy()
       || resource.isRuntime()) {
     return;
   }
   final Set<PathElement> children = registration.getChildAddresses(PathAddress.EMPTY_ADDRESS);
   result.add(createAddOperation(address, resource.getModel(), children));
   for (final PathElement element : children) {
     if (element.isMultiTarget()) {
       final String childType = element.getKey();
       for (final Resource.ResourceEntry entry : resource.getChildren(childType)) {
         final ImmutableManagementResourceRegistration childRegistration =
             registration.getSubModel(
                 PathAddress.pathAddress(PathElement.pathElement(childType, entry.getName())));
         final ModelNode childAddress = address.clone();
         childAddress.add(childType, entry.getName());
         describe(entry, childAddress, result, childRegistration);
       }
     } else {
       final Resource child = resource.getChild(element);
       final ImmutableManagementResourceRegistration childRegistration =
           registration.getSubModel(PathAddress.pathAddress(element));
       final ModelNode childAddress = address.clone();
       childAddress.add(element.getKey(), element.getValue());
       describe(child, childAddress, result, childRegistration);
     }
   }
 }
  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 setupNestingProperties() throws IOException, MgmtOperationException {
   ModelNode opA = Util.createAddOperation(PathAddress.pathAddress("system-property", "A"));
   opA.get("value").set("a");
   executeOperation(opA);
   ModelNode opB = Util.createAddOperation(PathAddress.pathAddress("system-property", "B"));
   opA.get("value").set("b");
   executeOperation(opB);
   ModelNode opab = Util.createAddOperation(PathAddress.pathAddress("system-property", "ab"));
   opA.get("value").set("asd");
   executeOperation(opab);
 }
 @Override
 public void execute(final OperationContext context, final ModelNode operation)
     throws OperationFailedException {
   final ModelNode address =
       PathAddress.pathAddress(
               PathAddress.pathAddress(operation.require(OP_ADDR)).getLastElement())
           .toModelNode();
   final Resource resource = context.readResource(PathAddress.EMPTY_ADDRESS);
   final ModelNode result = context.getResult();
   describe(resource, address, result, context.getResourceRegistration());
   context.completeStep();
 }
 private AddressControl getAddressControl(
     final OperationContext context, final ModelNode operation) {
   final String addressName =
       PathAddress.pathAddress(operation.require(OP_ADDR)).getLastElement().getValue();
   final ServiceName hqServiceName =
       MessagingServices.getHornetQServiceName(
           PathAddress.pathAddress(operation.get(ModelDescriptionConstants.OP_ADDR)));
   ServiceController<?> hqService = context.getServiceRegistry(false).getService(hqServiceName);
   HornetQServer hqServer = HornetQServer.class.cast(hqService.getValue());
   return AddressControl.class.cast(
       hqServer.getManagementService().getResource(ResourceNames.CORE_ADDRESS + addressName));
 }
Example #14
0
 private void removeUnusedSocketBindingGroups(final DomainClient client, final String keepGroup)
     throws Exception {
   final List<String> allGroups =
       getAllChildrenOfType(client, PathAddress.EMPTY_ADDRESS, SOCKET_BINDING_GROUP);
   for (String groupName : allGroups) {
     if (!keepGroup.equals(groupName)) {
       ModelNode remove =
           Util.createRemoveOperation(
               PathAddress.pathAddress(PathAddress.pathAddress(SOCKET_BINDING_GROUP, groupName)));
       executeForResult(remove, client);
     }
   }
 }
  @Test
  public void testNativeInterface() throws Exception {
    ModelNode opNode =
        Util.getReadAttributeOperation(
            PathAddress.pathAddress(SUBSYSTEM, LogStreamExtension.SUBSYSTEM_NAME), "log-file");
    readLogFile(opNode);

    opNode =
        Util.createEmptyOperation(
            LogStreamExtension.STREAM_LOG_FILE,
            PathAddress.pathAddress(SUBSYSTEM, LogStreamExtension.SUBSYSTEM_NAME));
    readLogFile(opNode);
  }
 @Test
 public void testExcludeLegacy() throws Exception {
   ModelControllerClient client = getModelControllerClient();
   final ModelNode add =
       Util.createAddOperation(
           PathAddress.pathAddress(
               PathAddress.pathAddress()
                   .append(PathElement.pathElement(CORE_SERVICE, MANAGEMENT))
                   .append(LegacyConfigurationChangeResourceDefinition.PATH)));
   add.get("max-history").set(MAX_HISTORY_SIZE);
   ModelNode response = client.execute(add);
   Assert.assertFalse(Operations.isSuccessfulOutcome(response));
   assertThat(
       Operations.getFailureDescription(response).asString(), containsString("WFLYCTL0158"));
 }
  @Override
  protected void addBootOperations(List<ModelNode> bootOperations) {
    if (enableRbac) {
      for (StandardRole standardRole : EnumSet.allOf(StandardRole.class)) {
        ModelNode addRoleMappingOp =
            Util.createAddOperation(
                PathAddress.pathAddress(
                    CoreManagementResourceDefinition.PATH_ELEMENT,
                    AccessAuthorizationResourceDefinition.PATH_ELEMENT,
                    PathElement.pathElement(
                        RoleMappingResourceDefinition.PATH_KEY, standardRole.getFormalName())));
        bootOperations.add(addRoleMappingOp);

        ModelNode addIncludeUserOp =
            Util.createAddOperation(
                PathAddress.pathAddress(
                    CoreManagementResourceDefinition.PATH_ELEMENT,
                    AccessAuthorizationResourceDefinition.PATH_ELEMENT,
                    PathElement.pathElement(
                        RoleMappingResourceDefinition.PATH_KEY, standardRole.getFormalName()),
                    PathElement.pathElement(
                        ModelDescriptionConstants.INCLUDE,
                        "user-" + roleToUserName(standardRole))));
        addIncludeUserOp
            .get(PrincipalResourceDefinition.NAME.getName())
            .set(roleToUserName(standardRole));
        addIncludeUserOp
            .get(PrincipalResourceDefinition.TYPE.getName())
            .set(PrincipalResourceDefinition.Type.USER.toString());
        bootOperations.add(addIncludeUserOp);
      }

      ModelNode enableRbacOp =
          Util.getWriteAttributeOperation(
              PathAddress.pathAddress(
                  CoreManagementResourceDefinition.PATH_ELEMENT,
                  AccessAuthorizationResourceDefinition.PATH_ELEMENT),
              AccessAuthorizationResourceDefinition.PROVIDER.getName(),
              new ModelNode(AccessAuthorizationResourceDefinition.Provider.RBAC.toString()));
      bootOperations.add(enableRbacOp);
    }

    ModelNode addOp =
        Util.createAddOperation(
            PathAddress.pathAddress(
                ModelDescriptionConstants.SUBSYSTEM, JMXExtension.SUBSYSTEM_NAME));
    bootOperations.add(addOp);
  }
 String getServerGroupName(final ModelNode operation) {
   final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
   if (address.size() == 0) {
     return null;
   }
   return address.getLastElement().getValue();
 }
    /** {@inheritDoc} */
    @Override
    public void execute(OperationContext context, ModelNode operation)
        throws OperationFailedException {
      final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
      final PathElement element = address.getLastElement();

      context.addStep(
          new OperationStepHandler() {
            @Override
            public void execute(final OperationContext context, final ModelNode operation)
                throws OperationFailedException {
              final ModelNode result = context.getResult();
              final ServiceController<?> controller =
                  context
                      .getServiceRegistry(false)
                      .getRequiredService(SOCKET_BINDING.append(element.getValue()));
              if (controller != null && controller.getState() == ServiceController.State.UP) {
                final SocketBinding binding = SocketBinding.class.cast(controller.getValue());
                AbstractBindingMetricsHandler.this.execute(operation, binding, result);
              } else {
                result.set(getNoMetrics());
              }

              context.stepCompleted();
            }
          },
          OperationContext.Stage.RUNTIME);

      context.stepCompleted();
    }
Example #20
0
  /**
   * [AS7-5850] Core queues created with ActiveMQ API does not create WildFly resources
   *
   * <p>For backwards compatibility if an operation is invoked on a queue that has no corresponding
   * resources, we forward the operation to the corresponding runtime-queue resource (which *does*
   * exist).
   *
   * @return true if the operation is forwarded to the corresponding runtime-queue resource, false
   *     else.
   */
  static boolean forwardToRuntimeQueue(
      OperationContext context, ModelNode operation, OperationStepHandler handler) {
    PathAddress address =
        PathAddress.pathAddress(operation.require(ModelDescriptionConstants.OP_ADDR));

    // do not forward if the current operation is for a runtime-queue already:
    if (RUNTIME_QUEUE.equals(address.getLastElement().getKey())) {
      return false;
    }

    String queueName = address.getLastElement().getValue();

    PathAddress activeMQPathAddress = MessagingServices.getActiveMQServerPathAddress(address);
    Resource serverResource = context.readResourceFromRoot(activeMQPathAddress);
    boolean hasChild = serverResource.hasChild(address.getLastElement());
    if (hasChild) {
      return false;
    } else {
      // there is no registered queue resource, forward to the runtime-queue address instead
      ModelNode forwardOperation = operation.clone();
      forwardOperation
          .get(ModelDescriptionConstants.OP_ADDR)
          .set(activeMQPathAddress.append(RUNTIME_QUEUE, queueName).toModelNode());
      context.addStep(forwardOperation, handler, OperationContext.Stage.RUNTIME, true);
      return true;
    }
  }
Example #21
0
 @Override
 protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model)
     throws OperationFailedException {
   final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
   final String name = address.getLastElement().getValue();
   ModClusterService.install(name, context.getServiceTarget(), model, context);
 }
  @Override
  public void execute(OperationContext context, ModelNode operation)
      throws OperationFailedException {

    final PathAddress address = PathAddress.pathAddress(operation.require(OP_ADDR));
    final PathElement element = address.getLastElement();
    final String serverName = element.getValue();

    final ModelNode subModel = context.readModel(PathAddress.EMPTY_ADDRESS);
    final boolean isStart;
    if (subModel.hasDefined(AUTO_START)) {
      isStart = subModel.get(AUTO_START).asBoolean();
    } else {
      isStart = true;
    }

    ServerStatus status = serverInventory.determineServerStatus(serverName);

    if (status == ServerStatus.STOPPED) {
      status = isStart ? status : ServerStatus.DISABLED;
    }

    if (status != null) {
      context.getResult().set(status.toString());
      context.completeStep();
    } else {
      throw new OperationFailedException(new ModelNode().set("Failed to get server status"));
    }
  }
  @Test
  public void testParseSubsystem_1_0() throws Exception {
    String subsystemXml =
        "<subsystem xmlns=\"urn:jboss:domain:jacorb:1.0\">"
            + "    <orb name=\"JBoss\" print-version=\"off\">"
            + "        <connection retries=\"5\" retry-interval=\"500\" client-timeout=\"0\" server-timeout=\"0\"/>"
            + "        <naming root-context=\"JBoss/Naming/root\" export-corbaloc=\"on\"/>"
            + "    </orb>"
            + "    <poa monitoring=\"off\" queue-wait=\"on\" queue-min=\"10\" queue-max=\"100\">"
            + "        <request-processors pool-size=\"10\" max-threads=\"32\"/>"
            + "    </poa>"
            + "    <interop sun=\"on\" comet=\"off\" chunk-custom-rmi-valuetypes=\"on\"/>"
            + "    <security support-ssl=\"off\" use-domain-socket-factory=\"off\" use-domain-server-socket-factory=\"off\"/>"
            + "    <property key=\"a\" value=\"va\"/>"
            + "    <property key=\"b\" value=\"vb\"/>"
            + "    <initializers>security,transactions</initializers>"
            + "</subsystem>";

    List<ModelNode> operations = super.parse(subsystemXml);

    // check that we have the expected number of operations.
    Assert.assertEquals(1, operations.size());
    // check that each operation has the correct content.
    ModelNode addSubsystem = operations.get(0);
    Assert.assertEquals(ADD, addSubsystem.get(OP).asString());
    PathAddress addr = PathAddress.pathAddress(addSubsystem.get(OP_ADDR));
    Assert.assertEquals(1, addr.size());
    PathElement element = addr.getElement(0);
    Assert.assertEquals(SUBSYSTEM, element.getKey());
    Assert.assertEquals(JacORBExtension.SUBSYSTEM_NAME, element.getValue());
  }
  private void parseFileStore(
      XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
      throws XMLStreamException {

    PathAddress storeAddress =
        PathAddress.pathAddress(cache.get(OP_ADDR))
            .append(ModelKeys.FILE_STORE, ModelKeys.FILE_STORE_NAME);
    ModelNode store = Util.createAddOperation(storeAddress);

    for (int i = 0; i < reader.getAttributeCount(); i++) {
      String value = reader.getAttributeValue(i);
      Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
      switch (attribute) {
        case RELATIVE_TO:
          {
            FileStoreResource.RELATIVE_TO.parseAndSetParameter(value, store, reader);
            break;
          }
        case PATH:
          {
            FileStoreResource.PATH.parseAndSetParameter(value, store, reader);
            break;
          }
        default:
          {
            this.parseStoreAttribute(reader, i, attribute, value, store);
          }
      }
    }

    List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
    this.parseStoreElements(reader, store, additionalConfigurationOperations);
    operations.add(store);
    operations.addAll(additionalConfigurationOperations);
  }
  private void parseCustomStore(
      XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
      throws XMLStreamException {

    PathAddress storeAddress =
        PathAddress.pathAddress(cache.get(OP_ADDR)).append(ModelKeys.STORE, ModelKeys.STORE_NAME);
    ModelNode store = Util.createAddOperation(storeAddress);

    for (int i = 0; i < reader.getAttributeCount(); i++) {
      String value = reader.getAttributeValue(i);
      Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
      switch (attribute) {
        case CLASS:
          {
            StoreResource.CLASS.parseAndSetParameter(value, store, reader);
            break;
          }
        default:
          {
            this.parseStoreAttribute(reader, i, attribute, value, store);
          }
      }
    }

    if (!store.hasDefined(ModelKeys.CLASS)) {
      throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.CLASS));
    }

    List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
    this.parseStoreElements(reader, store, additionalConfigurationOperations);
    operations.add(store);
    operations.addAll(additionalConfigurationOperations);
  }
  private void parseEviction(
      XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
      throws XMLStreamException {

    PathAddress evictionAddress =
        PathAddress.pathAddress(cache.get(OP_ADDR))
            .append(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME);
    ModelNode eviction = Util.createAddOperation(evictionAddress);

    for (int i = 0; i < reader.getAttributeCount(); i++) {
      String value = reader.getAttributeValue(i);
      Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
      switch (attribute) {
        case STRATEGY:
          {
            EvictionResource.EVICTION_STRATEGY.parseAndSetParameter(value, eviction, reader);
            break;
          }
        case MAX_ENTRIES:
          {
            EvictionResource.MAX_ENTRIES.parseAndSetParameter(value, eviction, reader);
            break;
          }
        default:
          {
            throw ParseUtils.unexpectedAttribute(reader, i);
          }
      }
    }
    ParseUtils.requireNoContent(reader);
    operations.add(eviction);
  }
  /**
   * {@inheritDoc}
   *
   * @see
   *     org.jboss.staxmapper.XMLElementReader#readElement(org.jboss.staxmapper.XMLExtendedStreamReader,
   *     Object)
   */
  @Override
  public void readElement(XMLExtendedStreamReader reader, List<ModelNode> operations)
      throws XMLStreamException {

    PathAddress subsystemAddress = PathAddress.pathAddress(InfinispanExtension.SUBSYSTEM_PATH);
    ModelNode subsystem = Util.createAddOperation(subsystemAddress);

    // command to add the subsystem
    operations.add(subsystem);

    while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
      Element element = Element.forName(reader.getLocalName());
      switch (element) {
        case CACHE_CONTAINER:
          {
            parseContainer(reader, subsystemAddress, operations);
            break;
          }
        default:
          {
            throw ParseUtils.unexpectedElement(reader);
          }
      }
    }
  }
  /** Tests that the xml is parsed into the correct operations */
  @Test
  public void testParseSubsystem() throws Exception {
    // Parse the subsystem xml into operations
    List<ModelNode> operations = super.parse(getSubsystemXml());

    /*
    // print the operations
    System.out.println("List of operations");
    for (ModelNode op : operations) {
        System.out.println("operation = " + op.toString());
    }
    */

    // Check that we have the expected number of operations
    // one for each resource instance
    Assert.assertEquals(this.operations, operations.size());

    // Check that each operation has the correct content
    ModelNode addSubsystem = operations.get(0);
    Assert.assertEquals(ADD, addSubsystem.get(OP).asString());
    PathAddress addr = PathAddress.pathAddress(addSubsystem.get(OP_ADDR));
    Assert.assertEquals(1, addr.size());
    PathElement element = addr.getElement(0);
    Assert.assertEquals(SUBSYSTEM, element.getKey());
    Assert.assertEquals(getMainSubsystemName(), element.getValue());
  }
  private void compareSubsystemModels() {
    System.out.println("====== Comparing subsystem models ======");
    ResourceDefinition rootCurrentDefinition =
        new ResourceDefinition(trimNonSubsystem(currentResourceDefinitions), currentModelVersions);
    ResourceDefinition rootLegacyDefinition =
        new ResourceDefinition(trimNonSubsystem(legacyResourceDefinitions), legacyModelVersions);
    Map<String, ModelNode> currentSubsystems = rootCurrentDefinition.getChildren(SUBSYSTEM);
    Map<String, ModelNode> legacySubsystems = rootLegacyDefinition.getChildren(SUBSYSTEM);

    CompareContext context =
        new CompareContext(
            PathAddress.EMPTY_ADDRESS,
            PathAddress.EMPTY_ADDRESS,
            true,
            rootCurrentDefinition,
            rootLegacyDefinition);
    compareKeySetsAndRemoveMissing(context, "subsystems", currentSubsystems, legacySubsystems);

    for (Map.Entry<String, ModelNode> legacyEntry : legacySubsystems.entrySet()) {
      PathAddress subsystemAddress =
          PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, legacyEntry.getKey()));
      ResourceDefinition currentDefinition =
          new ResourceDefinition(currentSubsystems.get(legacyEntry.getKey()), currentModelVersions);
      ResourceDefinition legacyDefinition =
          new ResourceDefinition(legacyEntry.getValue(), legacyModelVersions);
      context =
          new CompareContext(
              subsystemAddress, subsystemAddress, false, currentDefinition, legacyDefinition);
      if (!context.continuteWithCheck()) {
        continue;
      }
      compareModel(context);
    }
  }
  private void parseStoreProperty(
      XMLExtendedStreamReader reader, ModelNode node, final List<ModelNode> operations)
      throws XMLStreamException {

    int attributes = reader.getAttributeCount();
    String propertyName = null;
    for (int i = 0; i < attributes; i++) {
      String value = reader.getAttributeValue(i);
      Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
      switch (attribute) {
        case NAME:
          {
            propertyName = value;
            break;
          }
        default:
          {
            throw ParseUtils.unexpectedAttribute(reader, i);
          }
      }
    }
    if (propertyName == null) {
      throw ParseUtils.missingRequired(reader, Collections.singleton(Attribute.NAME));
    }
    String propertyValue = reader.getElementText();

    PathAddress propertyAddress =
        PathAddress.pathAddress(node.get(OP_ADDR)).append(ModelKeys.PROPERTY, propertyName);
    ModelNode property = Util.createAddOperation(propertyAddress);

    // represent the value as a ModelNode to cater for expressions
    StorePropertyResource.VALUE.parseAndSetParameter(propertyValue, property, reader);

    operations.add(property);
  }