/**
   * Test the deployment operation. This will add and remove a given set of deployment using a
   * composite operation and attaching the streams necessary to the http post message.
   *
   * @param quantity the amount of deployments
   * @param encoded whether to send the operation in the dmr encoded format or not
   * @throws IOException
   */
  private void testDeploymentOperations(final int quantity, final boolean encoded)
      throws IOException {

    // Create the deployment
    final File temp = createTempDeploymentZip();
    try {
      final ModelNode deployment = createCompositeDeploymentOperation(quantity);
      final ContentBody operation = getOperationBody(deployment, encoded);
      final List<ContentBody> streams = new ArrayList<ContentBody>();
      for (int i = 0; i < quantity; i++) {
        streams.add(new FileBody(temp));
      }

      final ModelNode response = executePost(operation, encoded, streams);
      Assert.assertEquals(response.toString(), SUCCESS, response.get(OUTCOME).asString());

    } finally {
      temp.delete();
    }

    // And remove the deployments again
    final ModelNode remove = removeDeploymentsOperation(quantity);
    final ContentBody operation = getOperationBody(remove, encoded);
    final ModelNode response = executePost(operation, encoded);
    Assert.assertEquals(response.toString(), SUCCESS, response.get(OUTCOME).asString());
  }
  @Override
  public void marshallAsElement(ModelNode resourceModel, XMLStreamWriter writer)
      throws XMLStreamException {
    if (resourceModel.hasDefined(getName()) && resourceModel.asInt() > 0) {
      final ModelNode modules = resourceModel.get(getName());
      for (ModelNode module : modules.asList()) {
        writer.writeStartElement(getXmlName());
        writer.writeAttribute(Attribute.CODE.getLocalName(), module.get(CODE).asString());
        if (module.hasDefined(Constants.LOGIN_MODULE_STACK_REF)) {
          writer.writeAttribute(
              Attribute.LOGIN_MODULE_STACK_REF.getLocalName(),
              module.get(Constants.LOGIN_MODULE_STACK_REF).asString());
        }

        if (module.hasDefined(Constants.MODULE_OPTIONS)) {
          for (ModelNode option : module.get(Constants.MODULE_OPTIONS).asList()) {
            writer.writeEmptyElement(Element.MODULE_OPTION.getLocalName());
            writer.writeAttribute(Attribute.NAME.getLocalName(), option.asProperty().getName());
            writer.writeAttribute(
                Attribute.VALUE.getLocalName(), option.asProperty().getValue().asString());
          }
        }
        writer.writeEndElement();
      }
    }
  }
  private void compareValueType(
      CompareContext context, String id, ModelNode current, ModelNode legacy) {
    ModelNode currentValueType = current.get(VALUE_TYPE);
    ModelNode legacyValueType = legacy.get(VALUE_TYPE);
    if (!currentValueType.isDefined() && !legacyValueType.isDefined()) {
      return;
    }
    if (isType(legacyValueType) || isType(currentValueType)) {
      if (!currentValueType.equals(legacyValueType)) {
        context.println(
            "Different 'value-type' for "
                + id
                + ". Current: "
                + current.get(VALUE_TYPE)
                + "; legacy: "
                + legacy.get(VALUE_TYPE));
      }
    } else {
      Map<String, ModelNode> legacyValueTypes = createMapIndexedByKey(legacyValueType);
      Map<String, ModelNode> currentValueTypes = createMapIndexedByKey(currentValueType);

      compareKeySetsAndRemoveMissing(
          context, "value-type for " + id, currentValueTypes, legacyValueTypes);
      for (Map.Entry<String, ModelNode> entry : currentValueTypes.entrySet()) {
        ModelNode currentEntry = entry.getValue();
        ModelNode legacyEntry = legacyValueTypes.get(entry.getKey());
        compareAttributeOrOperationParameter(
            context,
            "value-type key '" + entry.getKey() + "' for " + id,
            currentEntry,
            legacyEntry);
      }
    }
  }
 static ModelNode parseModClusterConfig(XMLExtendedStreamReader reader) throws XMLStreamException {
   final ModelNode config = new ModelNode();
   // Parse the attributes.
   parsePropConf(reader, config);
   // Parse the elements
   while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
     final Element element = Element.forName(reader.getLocalName());
     switch (element) {
       case SIMPLE_LOAD_PROVIDER:
         final ModelNode load = parseSimpleLoadProvider(reader);
         config.get(SIMPLE_LOAD_PROVIDER).set(load);
         break;
       case DYNAMIC_LOAD_PROVIDER:
         final ModelNode dynload = parseDynamicLoadProvider(reader);
         config.get(DYNAMIC_LOAD_PROVIDER).set(dynload);
         break;
       case SSL:
         final ModelNode ssl = parseSSL(reader);
         config.get(SSL).set(ssl);
         break;
       default:
         unexpectedElement(reader);
     }
   }
   return config;
 }
Exemple #5
0
 static ModelNode getConnectorRemove(final Locale locale) {
   final ResourceBundle bundle = getResourceBundle(locale);
   final ModelNode node = new ModelNode();
   node.get(OPERATION_NAME).set(REMOVE);
   node.get(DESCRIPTION).set(bundle.getString("web.connector.remove"));
   return node;
 }
  private ModelNode parseDatabaseBinaryStorage(
      final XMLExtendedStreamReader reader, final String repositoryName) throws XMLStreamException {
    final ModelNode storageType = new ModelNode();
    storageType.get(OP).set(ADD);
    storageType
        .get(OP_ADDR)
        .add(SUBSYSTEM, ModeShapeExtension.SUBSYSTEM_NAME)
        .add(ModelKeys.REPOSITORY, repositoryName)
        .add(ModelKeys.CONFIGURATION, ModelKeys.BINARY_STORAGE)
        .add(ModelKeys.STORAGE_TYPE, ModelKeys.DB_BINARY_STORAGE);

    if (reader.getAttributeCount() > 0) {
      for (int i = 0; i < reader.getAttributeCount(); i++) {
        String attrName = reader.getAttributeLocalName(i);
        String attrValue = reader.getAttributeValue(i);
        Attribute attribute = Attribute.forName(attrName);
        switch (attribute) {
            // The rest go on the ModelNode for the type ...
          case DATA_SOURCE_JNDI_NAME:
            ModelAttributes.DATA_SOURCE_JNDI_NAME.parseAndSetParameter(
                attrValue, storageType, reader);
            break;
          case MIN_VALUE_SIZE:
            ModelAttributes.MINIMUM_BINARY_SIZE.parseAndSetParameter(
                attrValue, storageType, reader);
            break;
          default:
            throw ParseUtils.unexpectedAttribute(reader, i);
        }
      }
    }
    requireNoElements(reader);

    return storageType;
  }
  private Map<ServerIdentity, ControlledProcessState.State> getServerStatuses() {

    Map<ServerIdentity, ControlledProcessState.State> result =
        new HashMap<ServerIdentity, ControlledProcessState.State>();
    ModelNode op = new ModelNode();
    op.get("operation").set("read-children-names");
    op.get("child-type").set("server-config");
    op.get("address").add("host", configuration.getHostName());
    ModelNode opResult = executeForResult(new OperationBuilder(op).build());
    Set<String> servers = new HashSet<String>();
    for (ModelNode server : opResult.asList()) {
      servers.add(server.asString());
    }
    for (String server : servers) {
      ModelNode address = new ModelNode();
      address.add("host", configuration.getHostName());
      address.add("server-config", server);
      String group = readAttribute("group", address).asString();
      if (!readAttribute("auto-start", address).asBoolean()) continue;

      address = new ModelNode();
      address.add("host", configuration.getHostName());
      address.add("server", server);

      ControlledProcessState.State status =
          Enum.valueOf(
              ControlledProcessState.State.class,
              readAttribute("server-state", address).asString().toUpperCase(Locale.ENGLISH));
      ServerIdentity id = new ServerIdentity(configuration.getHostName(), group, server);
      result.put(id, status);
    }

    return result;
  }
    private void writeBoundedQueueThreadPool(
        final XMLExtendedStreamWriter writer, final ModelNode node) throws XMLStreamException {
      writer.writeStartElement(Element.BOUNDED_QUEUE_THREAD_POOL.getLocalName());

      if (node.hasDefined(NAME)) {
        writeAttribute(writer, Attribute.NAME, node.get(NAME));
      }
      if (node.hasDefined(BLOCKING)) {
        writeAttribute(writer, Attribute.BLOCKING, node.get(BLOCKING));
      }
      if (node.hasDefined(ALLOW_CORE_TIMEOUT)) {
        writeAttribute(writer, Attribute.ALLOW_CORE_TIMEOUT, node.get(ALLOW_CORE_TIMEOUT));
      }
      writeRef(writer, node, Element.HANDOFF_EXECUTOR, HANDOFF_EXECUTOR);
      writeRef(writer, node, Element.THREAD_FACTORY, THREAD_FACTORY);
      writeThreads(writer, node, Element.CORE_THREADS);
      writeThreads(writer, node, Element.QUEUE_LENGTH);
      writeThreads(writer, node, Element.MAX_THREADS);
      writeTime(writer, node, Element.KEEPALIVE_TIME);

      if (node.hasDefined(PROPERTIES)) {
        writeProperties(writer, node.get(PROPERTIES));
      }

      writer.writeEndElement();
    }
 private void parseStateTransfer(XMLExtendedStreamReader reader, ModelNode stateTransfer)
     throws XMLStreamException {
   for (int i = 0; i < reader.getAttributeCount(); i++) {
     String value = reader.getAttributeValue(i);
     Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
     switch (attribute) {
       case ENABLED:
         {
           stateTransfer.get(ModelKeys.ENABLED).set(Boolean.parseBoolean(value));
           break;
         }
       case TIMEOUT:
         {
           stateTransfer.get(ModelKeys.TIMEOUT).set(Long.parseLong(value));
           break;
         }
       case FLUSH_TIMEOUT:
         {
           stateTransfer.get(ModelKeys.FLUSH_TIMEOUT).set(Long.parseLong(value));
           break;
         }
       default:
         {
           throw ParseUtils.unexpectedAttribute(reader, i);
         }
     }
   }
   ParseUtils.requireNoContent(reader);
 }
 private void parseClusteredCacheAttribute(
     XMLExtendedStreamReader reader, int index, Attribute attribute, String value, ModelNode cache)
     throws XMLStreamException {
   switch (attribute) {
     case MODE:
       {
         cache.get(ModelKeys.MODE).set(value);
         break;
       }
     case QUEUE_SIZE:
       {
         cache.get(ModelKeys.QUEUE_SIZE).set(Integer.parseInt(value));
         break;
       }
     case QUEUE_FLUSH_INTERVAL:
       {
         cache.get(ModelKeys.QUEUE_FLUSH_INTERVAL).set(Long.parseLong(value));
         break;
       }
     case REMOTE_TIMEOUT:
       {
         cache.get(ModelKeys.REMOTE_TIMEOUT).set(Long.parseLong(value));
         break;
       }
     default:
       {
         this.parseCacheAttribute(reader, index, attribute, value, cache);
       }
   }
 }
  @Test
  public void testJson() throws Exception {
    ModelNode node = new ModelNode();
    node.get("realm").set("demo");
    node.get("resource").set("customer-portal");
    node.get("realm-public-key")
        .set(
            "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrVrCuTtArbgaZzL1hvh0xtL5mc7o0NqPVnYXkLvgcwiC3BjLGw1tGEGoJaXDuSaRllobm53JBhjx33UNv+5z/UMG4kytBWxheNVKnL6GgqlNabMaFfPLPCF8kAgKnsi79NMo+n6KnSY8YeUmec/p2vjO2NjsSAVcWEQMVhJ31LwIDAQAB");
    node.get("auth-url")
        .set("http://localhost:8080/auth-server/rest/realms/demo/protocol/openid-connect/login");
    node.get("code-url")
        .set(
            "http://localhost:8080/auth-server/rest/realms/demo/protocol/openid-connect/access/codes");
    node.get("ssl-required").set("external");
    node.get("expose-token").set(true);

    ModelNode jwtCredential = new ModelNode();
    jwtCredential.get("client-keystore-file").set("/tmp/keystore.jks");
    jwtCredential.get("client-keystore-password").set("changeit");
    ModelNode credential = new ModelNode();
    credential.get("jwt").set(jwtCredential);
    node.get("credentials").set(credential);

    System.out.println("json=" + node.toJSONString(false));
  }
  private void addManagementSecurityRealms(List<ModelNode> updates) {
    if (hostModel.get(CORE_SERVICE, MANAGEMENT, SECURITY_REALM).isDefined()) {
      ModelNode securityRealms = hostModel.get(CORE_SERVICE, MANAGEMENT, SECURITY_REALM);
      Set<String> keys = securityRealms.keys();
      for (String current : keys) {
        ModelNode addOp = new ModelNode();
        ModelNode realmAddress = new ModelNode();
        realmAddress.add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, current);
        addOp.get(OP).set(ADD);
        addOp.get(OP_ADDR).set(realmAddress);
        updates.add(addOp);

        ModelNode currentRealm = securityRealms.get(current);
        if (currentRealm.hasDefined(SERVER_IDENTITY)) {
          addManagementComponentComponent(currentRealm, realmAddress, SERVER_IDENTITY, updates);
        }
        if (currentRealm.hasDefined(AUTHENTICATION)) {
          addManagementComponentComponent(currentRealm, realmAddress, AUTHENTICATION, updates);
        }
        if (currentRealm.hasDefined(AUTHORIZATION)) {
          addManagementComponentComponent(currentRealm, realmAddress, AUTHORIZATION, updates);
        }
      }
    }
  }
  @Override
  public void writeContent(XMLExtendedStreamWriter writer, SubsystemMarshallingContext context)
      throws XMLStreamException {
    context.startSubsystemElement(CURRENT.getUriString(), false);
    final ModelNode node = context.getModelNode();

    if (node.hasDefined(HORNETQ_SERVER)) {
      final ModelNode servers = node.get(HORNETQ_SERVER);
      boolean first = true;
      for (Property prop : servers.asPropertyList()) {
        writeHornetQServer(writer, prop.getName(), prop.getValue());
        if (!first) {
          writeNewLine(writer);
        } else {
          first = false;
        }
      }
    }

    if (node.hasDefined(JMS_BRIDGE)) {
      final ModelNode jmsBridges = node.get(JMS_BRIDGE);
      boolean first = true;
      for (Property prop : jmsBridges.asPropertyList()) {
        writeJmsBridge(writer, prop.getName(), prop.getValue());
        if (!first) {
          writeNewLine(writer);
        } else {
          first = false;
        }
      }
    }
    writer.writeEndElement();
  }
 private static void writeAcceptors(final XMLExtendedStreamWriter writer, final ModelNode node)
     throws XMLStreamException {
   if (node.hasDefined(ACCEPTOR)
       || node.hasDefined(REMOTE_ACCEPTOR)
       || node.hasDefined(IN_VM_ACCEPTOR)) {
     writer.writeStartElement(Element.ACCEPTORS.getLocalName());
     if (node.hasDefined(REMOTE_ACCEPTOR)) {
       for (final Property property : node.get(REMOTE_ACCEPTOR).asPropertyList()) {
         writer.writeStartElement(Element.NETTY_ACCEPTOR.getLocalName());
         writeAcceptorContent(writer, property);
         writer.writeEndElement();
       }
     }
     if (node.hasDefined(IN_VM_ACCEPTOR)) {
       for (final Property property : node.get(IN_VM_ACCEPTOR).asPropertyList()) {
         writer.writeStartElement(Element.IN_VM_ACCEPTOR.getLocalName());
         writeAcceptorContent(writer, property);
         writer.writeEndElement();
       }
     }
     if (node.hasDefined(ACCEPTOR)) {
       for (final Property property : node.get(ACCEPTOR).asPropertyList()) {
         writer.writeStartElement(Element.ACCEPTOR.getLocalName());
         writeAcceptorContent(writer, property);
         writer.writeEndElement();
       }
     }
     writer.writeEndElement();
     writeNewLine(writer);
   }
 }
  @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 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);
        }
      }
    }
    @Override
    public void readElement(final XMLExtendedStreamReader reader, final List<ModelNode> list)
        throws XMLStreamException {

      final ModelNode address = new ModelNode();
      address.add(SUBSYSTEM, SUBSYSTEM_NAME);
      address.protect();

      final ModelNode subsystem = new ModelNode();
      subsystem.get(OP).set(ADD);
      subsystem.get(OP_ADDR).set(address);
      list.add(subsystem);

      // Handle elements
      while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
        switch (Namespace.forUri(reader.getNamespaceURI())) {
          case THREADS_1_0:
            {
              final Element element = Element.forName(reader.getLocalName());
              switch (element) {
                case BOUNDED_QUEUE_THREAD_POOL:
                  {
                    parseBoundedQueueThreadPool(reader, address, list);
                    break;
                  }
                case THREAD_FACTORY:
                  {
                    // Add connector updates
                    parseThreadFactory(reader, address, list);
                    break;
                  }
                case QUEUELESS_THREAD_POOL:
                  {
                    parseQueuelessThreadPool(reader, address, list);
                    break;
                  }
                case SCHEDULED_THREAD_POOL:
                  {
                    parseScheduledThreadPool(reader, address, list);
                    break;
                  }
                case UNBOUNDED_QUEUE_THREAD_POOL:
                  {
                    parseUnboundedQueueThreadPool(reader, address, list);
                    break;
                  }
                default:
                  {
                    throw unexpectedElement(reader);
                  }
              }
              break;
            }
          default:
            {
              throw unexpectedElement(reader);
            }
        }
      }
    }
 private void parseEviction(XMLExtendedStreamReader reader, ModelNode eviction)
     throws XMLStreamException {
   for (int i = 0; i < reader.getAttributeCount(); i++) {
     String value = reader.getAttributeValue(i);
     Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
     switch (attribute) {
       case STRATEGY:
         {
           try {
             EvictionStrategy strategy = EvictionStrategy.valueOf(value);
             eviction.get(ModelKeys.STRATEGY).set(strategy.name());
           } catch (IllegalArgumentException e) {
             throw ParseUtils.invalidAttributeValue(reader, i);
           }
           break;
         }
       case MAX_ENTRIES:
         {
           eviction.get(ModelKeys.MAX_ENTRIES).set(Integer.parseInt(value));
           break;
         }
       case INTERVAL:
         {
           ROOT_LOGGER.deprecatedAttribute(
               attribute.getLocalName(), Element.EVICTION.getLocalName(), "ISPN-1268");
           break;
         }
       default:
         {
           throw ParseUtils.unexpectedAttribute(reader, i);
         }
     }
   }
   ParseUtils.requireNoContent(reader);
 }
  @Override
  public ModelNode buildRequest(CommandContext ctx) throws OperationFormatException {

    ModelNode composite = new ModelNode();
    composite.get("operation").set("composite");
    composite.get("address").setEmptyList();
    ModelNode steps = composite.get("steps");

    final String name = this.name.getValue(ctx.getParsedArguments());
    if (name == null) {
      throw new OperationFormatException("Required argument name are missing.");
    }

    DefaultOperationRequestBuilder builder;

    // undeploy
    builder = new DefaultOperationRequestBuilder();
    builder.setOperationName("undeploy");
    builder.addNode("deployment", name);
    steps.add(builder.buildRequest());

    builder = new DefaultOperationRequestBuilder();
    builder.setOperationName("remove");
    builder.addNode("deployment", name);
    steps.add(builder.buildRequest());
    return composite;
  }
 private void parseExpiration(XMLExtendedStreamReader reader, ModelNode expiration)
     throws XMLStreamException {
   for (int i = 0; i < reader.getAttributeCount(); i++) {
     String value = reader.getAttributeValue(i);
     Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
     switch (attribute) {
       case MAX_IDLE:
         {
           expiration.get(ModelKeys.MAX_IDLE).set(Long.parseLong(value));
           break;
         }
       case LIFESPAN:
         {
           expiration.get(ModelKeys.LIFESPAN).set(Long.parseLong(value));
           break;
         }
       case INTERVAL:
         {
           expiration.get(ModelKeys.INTERVAL).set(Long.parseLong(value));
           break;
         }
       default:
         {
           throw ParseUtils.unexpectedAttribute(reader, i);
         }
     }
   }
   ParseUtils.requireNoContent(reader);
 }
 private ModelNode readAttribute(String name, ModelNode address) {
   ModelNode op = new ModelNode();
   op.get("operation").set("read-attribute");
   op.get("address").set(address);
   op.get("name").set(name);
   return executeForResult(new OperationBuilder(op).build());
 }
  private void parseFileStore(XMLExtendedStreamReader reader, ModelNode store)
      throws XMLStreamException {
    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:
          {
            store.get(ModelKeys.RELATIVE_TO).set(value);
            break;
          }
        case PATH:
          {
            store.get(ModelKeys.PATH).set(value);
            break;
          }
        default:
          {
            this.parseStoreAttribute(reader, i, attribute, value, store);
          }
      }
    }

    this.parseStoreProperties(reader, store);
  }
 private void parseAuthenticator(final XMLExtendedStreamReader reader, final ModelNode repository)
     throws XMLStreamException {
   if (reader.getAttributeCount() > 0) {
     ModelNode authenticator = new ModelNode();
     for (int i = 0; i < reader.getAttributeCount(); i++) {
       String attrName = reader.getAttributeLocalName(i);
       String attrValue = reader.getAttributeValue(i);
       Attribute attribute = Attribute.forName(attrName);
       switch (attribute) {
           // Set these as properties on the repository ModelNode ...
         case NAME:
           ModelAttributes.NAME.parseAndSetParameter(attrValue, authenticator, reader);
           break;
         case CLASSNAME:
           ModelAttributes.CLASSNAME.parseAndSetParameter(attrValue, authenticator, reader);
           if (!authenticator.has(ModelKeys.NAME)) {
             ModelAttributes.NAME.parseAndSetParameter(attrValue, authenticator, reader);
           }
           break;
         case MODULE:
           ModelAttributes.MODULE.parseAndSetParameter(attrValue, authenticator, reader);
           break;
         default:
           authenticator.get(attrName).set(attrValue);
           break;
       }
     }
     if (authenticator.has(ModelKeys.NAME))
       repository.get(ModelKeys.AUTHENTICATORS).add(authenticator);
   }
   requireNoElements(reader);
 }
  private Object getAttribute(
      final ResourceAndRegistration reg,
      final PathAddress address,
      final ObjectName name,
      final String attribute,
      final ResourceAccessControl accessControl)
      throws ReflectionException, AttributeNotFoundException, InstanceNotFoundException {
    final ImmutableManagementResourceRegistration registration = getMBeanRegistration(address, reg);
    final DescriptionProvider provider =
        registration.getModelDescription(PathAddress.EMPTY_ADDRESS);
    if (provider == null) {
      throw MESSAGES.descriptionProviderNotFound(address);
    }
    final ModelNode description = provider.getModelDescription(null);
    final String attributeName = findAttributeName(description.get(ATTRIBUTES), attribute);

    if (!accessControl.isReadableAttribute(attributeName)) {
      throw MESSAGES.notAuthorizedToReadAttribute(attributeName);
    }

    ModelNode op = new ModelNode();
    op.get(OP).set(READ_ATTRIBUTE_OPERATION);
    op.get(OP_ADDR).set(address.toModelNode());
    op.get(NAME).set(attributeName);
    ModelNode result = execute(op);
    String error = getFailureDescription(result);
    if (error != null) {
      throw new AttributeNotFoundException(error);
    }

    return converters.fromModelNode(
        description.require(ATTRIBUTES).require(attributeName), result.get(RESULT));
  }
  @org.junit.Ignore("This fails for some mysterious reason - but this isn't a critical test")
  @Test
  @BMRule(
      name = "Test remove rollback operation",
      targetClass = "org.jboss.as.clustering.jgroups.subsystem.StackRemoveHandler",
      targetMethod = "performRuntime",
      targetLocation = "AT EXIT",
      action = "traceln(\"Injecting rollback fault via Byteman\");$1.setRollbackOnly()")
  public void testProtocolStackRemoveRollback() throws Exception {

    KernelServices services = buildKernelServices();

    ModelNode operation =
        Operations.createCompositeOperation(addStackOp, addTransportOp, addProtocolOp);

    // add a protocol stack
    ModelNode result = services.executeOperation(operation);
    Assert.assertEquals(SUCCESS, result.get(OUTCOME).asString());

    // remove the protocol stack
    // the remove has OperationContext.setRollbackOnly() injected
    // and so is expected to fail
    result = services.executeOperation(removeStackOp);
    Assert.assertEquals(FAILED, result.get(OUTCOME).asString());

    // need to check that all services are correctly re-installed
    ServiceName channelFactoryServiceName =
        ProtocolStackServiceName.CHANNEL_FACTORY.getServiceName("maximal2");
    Assert.assertNotNull(
        "channel factory service not installed",
        services.getContainer().getService(channelFactoryServiceName));
  }
 protected StringBuilder formatResponse(
     CommandContext ctx, ModelNode opResponse, boolean composite, StringBuilder buf) {
   if (!opResponse.hasDefined(Util.RESULT)) {
     return null;
   }
   final ModelNode result = opResponse.get(Util.RESULT);
   if (composite) {
     final Set<String> keys;
     try {
       keys = result.keys();
     } catch (Exception e) {
       ctx.printLine(
           "Failed to get step results from a composite operation response " + opResponse);
       e.printStackTrace();
       return null;
     }
     for (String key : keys) {
       final ModelNode stepResponse = result.get(key);
       buf =
           formatResponse(
               ctx, stepResponse, false, buf); // TODO nested composite ops aren't expected for now
     }
   } else {
     final ModelNodeFormatter formatter = ModelNodeFormatter.Factory.forType(result.getType());
     if (buf == null) {
       buf = new StringBuilder();
     }
     formatter.format(buf, 0, result);
   }
   return buf;
 }
 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;
 }
 @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 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);
        }
      }
    }
  protected ModelNode buildWritePropertyRequest(CommandContext ctx) throws CommandFormatException {

    final String name = this.name.getValue(ctx.getParsedCommandLine(), true);

    ModelNode composite = new ModelNode();
    composite.get(Util.OPERATION).set(Util.COMPOSITE);
    composite.get(Util.ADDRESS).setEmptyList();
    ModelNode steps = composite.get(Util.STEPS);

    final ParsedCommandLine args = ctx.getParsedCommandLine();

    final String profile;
    if (isDependsOnProfile() && ctx.isDomainMode()) {
      profile = this.profile.getValue(args);
      if (profile == null) {
        throw new OperationFormatException("--profile argument value is missing.");
      }
    } else {
      profile = null;
    }

    final Map<String, CommandArgument> nodeProps = loadArguments(ctx, null);
    for (String argName : args.getPropertyNames()) {
      if (isDependsOnProfile() && argName.equals("--profile")
          || this.name.getFullName().equals(argName)) {
        continue;
      }

      final ArgumentWithValue arg = (ArgumentWithValue) nodeProps.get(argName);
      if (arg == null) {
        throw new CommandFormatException("Unrecognized argument name '" + argName + "'");
      }

      DefaultOperationRequestBuilder builder = new DefaultOperationRequestBuilder();
      if (profile != null) {
        builder.addNode(Util.PROFILE, profile);
      }

      for (OperationRequestAddress.Node node : getRequiredAddress()) {
        builder.addNode(node.getType(), node.getName());
      }
      builder.addNode(getRequiredType(), name);
      builder.setOperationName(Util.WRITE_ATTRIBUTE);
      final String propName;
      if (argName.charAt(1) == '-') {
        propName = argName.substring(2);
      } else {
        propName = argName.substring(1);
      }
      builder.addProperty(Util.NAME, propName);

      final String valueString = args.getPropertyValue(argName);
      ModelNode nodeValue = arg.getValueConverter().fromString(valueString);
      builder.getModelNode().get(Util.VALUE).set(nodeValue);

      steps.add(builder.buildRequest());
    }

    return composite;
  }