/** {@inheritDoc} */
 @Override
 protected void populateModel(ModelNode operation, ModelNode model)
     throws OperationFailedException {
   // log.info("Populating the model");
   model.setEmptyObject();
   model.get(ModelKeys.MAIL_SESSION);
 }
  void updatePoolService(final OperationContext context, final ModelNode model)
      throws OperationFailedException {

    final ModelNode poolName = poolAttribute.resolveModelAttribute(context, model);

    final ServiceRegistry serviceRegistry = context.getServiceRegistry(true);
    ServiceController existingDefaultPoolConfigService =
        serviceRegistry.getService(poolConfigServiceName);
    // if a default MDB pool is already installed, then remove it first
    if (existingDefaultPoolConfigService != null) {
      context.removeService(existingDefaultPoolConfigService);
    }

    if (poolName.isDefined()) {
      // now install default pool config service which points to an existing pool config service
      final ValueInjectionService<PoolConfig> newDefaultPoolConfigService =
          new ValueInjectionService<PoolConfig>();
      ServiceController<?> newController =
          context
              .getServiceTarget()
              .addService(poolConfigServiceName, newDefaultPoolConfigService)
              .addDependency(
                  PoolConfigService.EJB_POOL_CONFIG_BASE_SERVICE_NAME.append(poolName.asString()),
                  PoolConfig.class,
                  newDefaultPoolConfigService.getInjector())
              .install();
    }
  }
 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 void validateResolveExpressionOnMaster(final ModelNode result) {
   System.out.println(result);
   ModelNode serverResult =
       result.get("server-groups", "main-server-group", "host", "master", "main-one");
   Assert.assertTrue(serverResult.isDefined());
   validateResolveExpressionOnServer(serverResult);
 }
  @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));
  }
 /**
  * Execute an operation and wait until the connection is closed. This is only useful for :reload
  * and :shutdown operations.
  *
  * @param operation the operation to execute
  * @return the operation result
  * @throws IOException for any error
  */
 public ModelNode executeAwaitConnectionClosed(final ModelNode operation) throws IOException {
   final DomainTestClient client = internalGetOrCreateClient();
   final Channel channel = client.getChannel();
   final Connection ref = channel.getConnection();
   ModelNode result = new ModelNode();
   try {
     result = client.execute(operation);
     // IN case the operation wasn't successful, don't bother waiting
     if (!"success".equals(result.get("outcome").asString())) {
       return result;
     }
   } catch (Exception e) {
     if (e instanceof IOException) {
       final Throwable cause = e.getCause();
       if (cause instanceof ExecutionException) {
         // ignore, this might happen if the channel gets closed before we got the response
       } else {
         throw (IOException) e;
       }
     } else {
       throw new RuntimeException(e);
     }
   }
   try {
     if (channel != null) {
       // Wait for the channel to close
       channel.awaitClosed();
     }
     // Wait for the connection to be closed
     connection.awaitConnectionClosed(ref);
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
   }
   return result;
 }
  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;
  }
 @Override
 public void handleRequest(
     final DataInput input,
     final ActiveOperation.ResultHandler<Void> resultHandler,
     final ManagementRequestContext<Void> context)
     throws IOException {
   byte param = input.readByte();
   // If it failed
   if (param != DomainControllerProtocol.PARAM_OK) {
     final byte errorCode = input.readByte();
     final String message = input.readUTF();
     resultHandler.failed(
         new SlaveRegistrationException(
             SlaveRegistrationException.ErrorCode.parseCode(errorCode), message));
     return;
   }
   final ModelNode extensions = new ModelNode();
   extensions.readExternal(input);
   context.executeAsync(
       new ManagementRequestContext.AsyncTask<Void>() {
         @Override
         public void execute(ManagementRequestContext<Void> voidManagementRequestContext)
             throws Exception {
           //
           final ModelNode subsystems = resolveSubsystemVersions(extensions);
           channelHandler.executeRequest(
               context.getOperationId(), new RegisterSubsystemsRequest(subsystems));
         }
       });
 }
 private void writeOptional(
     XMLExtendedStreamWriter writer, Attribute attribute, ModelNode model, String key)
     throws XMLStreamException {
   if (model.hasDefined(key)) {
     writer.writeAttribute(attribute.getLocalName(), model.get(key).asString());
   }
 }
 private void addInterfaces(Map<String, ModelNode> map, ModelNode iface) {
   if (iface.isDefined()) {
     for (Property prop : iface.asPropertyList()) {
       map.put(prop.getName(), prop.getValue());
     }
   }
 }
 /**
  * Apply the remote read domain model result.
  *
  * @param result the domain model result
  * @return whether it was applied successfully or not
  */
 boolean applyDomainModel(ModelNode result) {
   if (!result.hasDefined(ModelDescriptionConstants.RESULT)) {
     return false;
   }
   final List<ModelNode> bootOperations = result.get(ModelDescriptionConstants.RESULT).asList();
   return callback.applyDomainModel(bootOperations);
 }
示例#12
0
 protected void addPath(ModelControllerClient client, Outcome expectedOutcome, String... roles)
     throws IOException {
   ModelNode op = createOpNode(TEST_PATH, ADD);
   op.get(PATH).set("/");
   configureRoles(op, roles);
   RbacUtil.executeOperation(client, op, expectedOutcome);
 }
  @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"));
    }
  }
示例#14
0
  @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());
  }
示例#15
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;
    }
  }
 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);
       }
   }
 }
  private void startServers() {
    ModelNode addr = new ModelNode();
    addr.add(HOST, hostControllerInfo.getLocalHostName());
    ModelNode op = Util.getEmptyOperation(StartServersHandler.OPERATION_NAME, addr);

    getValue().execute(op, null, null, null);
  }
 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 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 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);
 }
 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 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);
 }
示例#23
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 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);
  }
示例#25
0
 private ModelNode getAddSocketBindingOp(Connector conn, int port) {
   ModelNode op =
       createOpNode(
           "socket-binding-group=standard-sockets/socket-binding=test-" + conn.getName(), "add");
   op.get("port").set(port);
   return op;
 }
 @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();
   }
 }
 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;
 }
 protected List<ModelNode> readFile(File file, int expectedRecords) throws IOException {
   List<ModelNode> list = new ArrayList<ModelNode>();
   final BufferedReader reader = new BufferedReader(new FileReader(file));
   try {
     StringWriter writer = null;
     String line = reader.readLine();
     while (line != null) {
       if (DATE_STAMP_PATTERN.matcher(line).find()) {
         if (writer != null) {
           list.add(ModelNode.fromJSONString(writer.getBuffer().toString()));
         }
         writer = new StringWriter();
         writer.append("{");
       } else {
         if (writer != null) writer.append("\n" + line);
       }
       line = reader.readLine();
     }
     if (writer != null) {
       list.add(ModelNode.fromJSONString(writer.getBuffer().toString()));
     }
   } finally {
     IoUtils.safeClose(reader);
   }
   Assert.assertEquals(list.toString(), expectedRecords, list.size());
   return list;
 }
 static void writeAttribute(
     final XMLExtendedStreamWriter writer, final String name, ModelNode node)
     throws XMLStreamException {
   if (node.hasDefined(name)) {
     writer.writeAttribute(name, node.get(name).asString());
   }
 }
  private ModelNode loadDomainModel(File file) throws Exception {
    final QName rootElement = new QName(Namespace.CURRENT.getUriString(), "domain");
    final DomainXml parser = new DomainXml(Module.getBootModuleLoader());
    final XmlConfigurationPersister persister =
        new XmlConfigurationPersister(file, rootElement, parser, parser);
    final List<ModelNode> ops = persister.load();

    final ModelNode model = new ModelNode();
    final ModelController controller =
        createController(
            model,
            new Setup() {
              public void setup(
                  Resource resource, ManagementResourceRegistration rootRegistration) {
                DomainModelUtil.updateCoreModel(resource.getModel());
                DomainModelUtil.initializeMasterDomainRegistry(
                    rootRegistration, persister, null, new MockFileRepository(), null, null);
              }
            });

    final ModelNode caputreModelOp = new ModelNode();
    caputreModelOp.get(OP_ADDR).set(PathAddress.EMPTY_ADDRESS.toModelNode());
    caputreModelOp.get(OP).set("capture-model");

    final List<ModelNode> toRun = new ArrayList<ModelNode>(ops);
    toRun.add(caputreModelOp);

    executeOperations(controller, toRun);

    //
    persister.store(model, null).commit();
    return model;
  }