@Override
  public void registerAttributes(ManagementResourceRegistration registry) {
    super.registerAttributes(registry);

    AttributeDefinition[] attributes = deployed ? getDeploymentAttributes() : ATTRIBUTES;
    for (AttributeDefinition attr : attributes) {
      if (registerRuntimeOnly || !attr.getFlags().contains(AttributeAccess.Flag.STORAGE_RUNTIME)) {
        if (deployed) {
          registry.registerReadOnlyAttribute(attr, JMSQueueConfigurationRuntimeHandler.INSTANCE);
        } else {
          if (attr == CommonAttributes.DESTINATION_ENTRIES) {
            registry.registerReadWriteAttribute(
                attr, null, JMSQueueConfigurationWriteHandler.INSTANCE);
          } else {
            registry.registerReadOnlyAttribute(attr, null);
          }
        }
      }
    }

    if (registerRuntimeOnly) {
      for (AttributeDefinition attr : READONLY_ATTRIBUTES) {
        registry.registerReadOnlyAttribute(attr, JMSQueueReadAttributeHandler.INSTANCE);
      }

      for (AttributeDefinition metric : METRICS) {
        registry.registerMetric(metric, JMSQueueReadAttributeHandler.INSTANCE);
      }
    }
  }
 @Override
 protected void populateModel(ModelNode operation, ModelNode model)
     throws OperationFailedException {
   for (AttributeDefinition def : ATTRIBUTES) {
     def.validateAndSet(operation, model);
   }
 }
 public void registerAttributes(final ManagementResourceRegistration registry) {
   final EnumSet<AttributeAccess.Flag> flags =
       EnumSet.of(AttributeAccess.Flag.RESTART_ALL_SERVICES);
   for (AttributeDefinition attr : CommonAttributes.DIVERT_ATTRIBUTES) {
     registry.registerReadWriteAttribute(attr.getName(), null, this, flags);
   }
 }
 private static Set<String> namesFromDefinitions(AttributeDefinition... attributes) {
   final Set<String> names = new HashSet<String>();
   for (final AttributeDefinition def : attributes) {
     names.add(def.getName());
   }
   return names;
 }
 @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();
   }
 }
 protected Map<String, AttributeDefinition> getAttributeMap() {
   Map<String, AttributeDefinition> res = new HashMap<>();
   for (AttributeDefinition def : getAttributes()) {
     res.put(def.getName(), def);
   }
   return res;
 }
Example #7
0
 @Override
 protected void populateModel(ModelNode operation, ModelNode model)
     throws OperationFailedException {
   for (AttributeDefinition attr : listenerDefinition.getAttributes()) {
     attr.validateAndSet(operation, model);
   }
 }
 @Override
 public void execute(final OperationContext context, final ModelNode ignored)
     throws OperationFailedException {
   final Resource resource = context.readResource(PathAddress.EMPTY_ADDRESS);
   final ModelNode model = resource.getModel();
   for (final AttributeDefinition definition : InterfaceDescription.ROOT_ATTRIBUTES) {
     final String attributeName = definition.getName();
     final boolean has = model.hasDefined(attributeName);
     if (!has && isRequired(definition, model)) {
       throw new OperationFailedException(new ModelNode().set(MESSAGES.required(attributeName)));
     }
     if (has) {
       if (!isAllowed(definition, model)) {
         // TODO probably move this into AttributeDefinition
         String[] alts = definition.getAlternatives();
         StringBuilder sb = null;
         if (alts != null) {
           for (String alt : alts) {
             if (model.hasDefined(alt)) {
               if (sb == null) {
                 sb = new StringBuilder();
               } else {
                 sb.append(", ");
               }
               sb.append(alt);
             }
           }
         }
         throw new OperationFailedException(
             new ModelNode().set(MESSAGES.invalidAttributeCombo(attributeName, sb)));
       }
     }
   }
   context.completeStep();
 }
Example #9
0
 @Override
 protected void populateModel(ModelNode operation, ModelNode model)
     throws OperationFailedException {
   for (final AttributeDefinition attribute : CommonAttributes.RESOURCE_ADAPTER_ATTRIBUTE) {
     attribute.validateAndSet(operation, model);
   }
 }
Example #10
0
 private static void writeConnectorServices(XMLExtendedStreamWriter writer, ModelNode node)
     throws XMLStreamException {
   if (!node.isDefined()) {
     return;
   }
   List<Property> properties = node.asPropertyList();
   if (!properties.isEmpty()) {
     writer.writeStartElement(Element.CONNECTOR_SERVICES.getLocalName());
     for (final Property property : node.asPropertyList()) {
       writer.writeStartElement(Element.CONNECTOR_SERVICE.getLocalName());
       writer.writeAttribute(Attribute.NAME.getLocalName(), property.getName());
       final ModelNode service = property.getValue();
       for (AttributeDefinition attribute : ConnectorServiceDefinition.ATTRIBUTES) {
         attribute.marshallAsElement(property.getValue(), writer);
       }
       // TODO use a custom attribute marshaller
       if (service.hasDefined(CommonAttributes.PARAM)) {
         for (Property param : service.get(CommonAttributes.PARAM).asPropertyList()) {
           writer.writeEmptyElement(Element.PARAM.getLocalName());
           writer.writeAttribute(Attribute.KEY.getLocalName(), param.getName());
           writer.writeAttribute(
               Attribute.VALUE.getLocalName(),
               param.getValue().get(ConnectorServiceParamDefinition.VALUE.getName()).asString());
         }
       }
       writer.writeEndElement();
     }
     writer.writeEndElement();
     writeNewLine(writer);
   }
 }
  // TODO move this kind of logic into AttributeDefinition itself
  private static ModelNode validateResolvedModel(
      final AttributeDefinition definition,
      final OperationContext context,
      final ModelNode subModel)
      throws OperationFailedException {
    final String attributeName = definition.getName();
    final boolean has = subModel.has(attributeName);
    if (!has && definition.isRequired(subModel)) {
      throw ServerMessages.MESSAGES.attributeIsRequired(attributeName);
    }
    ModelNode result;
    if (has) {
      if (!definition.isAllowed(subModel)) {
        if (subModel.hasDefined(attributeName)) {
          throw ServerMessages.MESSAGES.attributeNotAllowedWhenAlternativeIsPresent(
              attributeName, Arrays.asList(definition.getAlternatives()));
        } else {
          // create the undefined node
          result = new ModelNode();
        }
      } else {
        result = definition.resolveModelAttribute(context, subModel);
      }
    } else {
      // create the undefined node
      result = new ModelNode();
    }

    return result;
  }
 @Override
 protected void populateModel(ModelNode operation, ModelNode model)
     throws OperationFailedException {
   for (AttributeDefinition attribute :
       KeyStoreProviderResourceDefinition.INSTANCE.getAttributes()) {
     attribute.validateAndSet(operation, model);
   }
 }
Example #13
0
 /**
  * Test whether the operation has a defined criteria attribute.
  *
  * @param operation the operation
  * @return
  */
 public static boolean isOperationDefined(final ModelNode operation) {
   for (final AttributeDefinition def : ROOT_ATTRIBUTES) {
     if (operation.hasDefined(def.getName())) {
       return true;
     }
   }
   return false;
 }
Example #14
0
 /**
  * Populate the given node in the persistent configuration model based on the values in the given
  * operation.
  *
  * @param operation the operation
  * @param model persistent configuration model node that corresponds to the address of {@code
  *     operation}
  * @throws org.jboss.as.controller.OperationFailedException if {@code operation} is invalid or
  *     populating the model otherwise fails
  */
 @Override
 protected void populateModel(ModelNode operation, ModelNode model)
     throws OperationFailedException {
   for (AttributeDefinition attribute : ModClusterConfigResourceDefinition.ATTRIBUTES) {
     attribute.validateAndSet(operation, model);
   }
   ModClusterConfigResourceDefinition.SIMPLE_LOAD_PROVIDER.validateAndSet(operation, model);
 }
 private void registerAttributeAccessConstraints(AttributeDefinition ad) {
   if (constraintUtilizationRegistry != null) {
     for (AccessConstraintDefinition acd : ad.getAccessConstraints()) {
       constraintUtilizationRegistry.registerAccessConstraintAttributeUtilization(
           acd.getKey(), getPathAddress(), ad.getName());
     }
   }
 }
 /**
  * Creates a handler that doesn't validate values.
  *
  * @param attributes all persistent attributes of the
  * @param runtimeAttributes attributes whose updated value can immediately be applied to the
  *     runtime
  */
 public ThreadsWriteAttributeOperationHandler(
     AttributeDefinition[] attributes, AttributeDefinition[] runtimeAttributes) {
   super(attributes);
   this.attributes = attributes;
   for (AttributeDefinition attr : runtimeAttributes) {
     this.runtimeAttributes.put(attr.getName(), attr);
   }
 }
 @Override
 protected void populateModel(OperationContext context, ModelNode operation, Resource resource)
     throws OperationFailedException {
   checkNoOtherProtocol(context, operation);
   ModelNode model = resource.getModel();
   for (AttributeDefinition def : attributes) {
     def.validateAndSet(operation, model);
   }
 }
 @Override
 public void registerAttributes(ManagementResourceRegistration registry) {
   OperationStepHandler writeHandler = new ConnectorServiceWriteAttributeHandler(ATTRIBUTES);
   for (AttributeDefinition attr : ATTRIBUTES) {
     if (!attr.getFlags().contains(STORAGE_RUNTIME)) {
       registry.registerReadWriteAttribute(attr, null, writeHandler);
     }
   }
 }
  public static ModelNode createKeystoreAddOperation(
      final PathAddress storeAddress, final ModelNode store) {
    ModelNode storeAdd = Util.createAddOperation(storeAddress);
    for (AttributeDefinition def : TlsKeyStore.CLIENT_CERT_ATTRIBUTES) {
      storeAdd.get(def.getName()).set(store.get(def.getName()));
    }

    return storeAdd;
  }
 protected void populateModel(final ModelNode operation, final ModelNode model)
     throws OperationFailedException {
   NAME.validateAndSet(operation, model);
   for (AttributeDefinition attr : attributes) {
     if (attr == VALUE) { // don't validate VALUE attribute WFCORE-826
       model.get(VALUE.getName()).set(operation.get(VALUE.getName()));
     } else {
       attr.validateAndSet(operation, model);
     }
   }
 }
Example #21
0
  /** Create an "add" operation using the existing model */
  public static ModelNode getAddOperation(final ModelNode address, ModelNode subModel) {

    final ModelNode operation =
        org.jboss.as.controller.operations.common.Util.getEmptyOperation(ADD, address);
    for (AttributeDefinition attr : CommonAttributes.CONNECTOR_SERVICE_ATTRIBUTES) {
      if (subModel.hasDefined(attr.getName())) {
        operation.get(attr.getName()).set(subModel.get(attr.getName()));
      }
    }
    return operation;
  }
  @Override
  public void registerAttributes(ManagementResourceRegistration registry) {
    super.registerAttributes(registry);

    OperationStepHandler attributeHandler = new ReloadRequiredWriteAttributeHandler(ATTRIBUTES);
    for (AttributeDefinition attr : ATTRIBUTES) {
      if (registerRuntimeOnly || !attr.getFlags().contains(AttributeAccess.Flag.STORAGE_RUNTIME)) {
        registry.registerReadWriteAttribute(attr, null, attributeHandler);
      }
    }
  }
 public void marshallAsAttribute(
     AttributeDefinition attribute,
     ModelNode resourceModel,
     boolean marshallDefault,
     XMLStreamWriter writer)
     throws javax.xml.stream.XMLStreamException {
   if (isMarshallable(attribute, resourceModel)) {
     writer.writeAttribute(
         attribute.getXmlName(), resourceModel.get(attribute.getName()).asString());
   }
 }
Example #24
0
  @Override
  protected void populateModel(ModelNode operation, ModelNode model)
      throws OperationFailedException {

    model.setEmptyObject();

    for (final AttributeDefinition attributeDefinition :
        CommonAttributes.CONNECTOR_SERVICE_ATTRIBUTES) {
      attributeDefinition.validateAndSet(operation, model);
    }
  }
 @Override
 public TransformedOperation transformOperation(
     TransformationContext context, PathAddress address, ModelNode operation) {
   ModelNode legacyOperation = this.transformer.transformOperation(operation);
   for (AttributeDefinition attribute : this.attributes) {
     String name = attribute.getName();
     if (operation.hasDefined(name)) {
       legacyOperation.get(name).set(operation.get(name));
     }
   }
   return new TransformedOperation(legacyOperation, OperationResultTransformer.ORIGINAL_RESULT);
 }
Example #26
0
  /**
   * Wrap a simple attribute def as list.
   *
   * @param def the attribute definition
   * @return the list attribute def
   */
  @Deprecated
  private static ListAttributeDefinition wrapAsList(final AttributeDefinition def) {
    final ListAttributeDefinition list =
        new ListAttributeDefinition(def.getName(), true, def.getValidator()) {

          @Override
          public ModelNode getNoTextDescription(boolean forOperation) {
            final ModelNode model = super.getNoTextDescription(forOperation);
            setValueType(model);
            return model;
          }

          @Override
          protected void addValueTypeDescription(
              final ModelNode node, final ResourceBundle bundle) {
            setValueType(node);
          }

          @Override
          public void marshallAsElement(
              final ModelNode resourceModel,
              final boolean marshalDefault,
              final XMLStreamWriter writer)
              throws XMLStreamException {
            throw new RuntimeException();
          }

          @Override
          protected void addAttributeValueTypeDescription(
              ModelNode node,
              ResourceDescriptionResolver resolver,
              Locale locale,
              ResourceBundle bundle) {
            setValueType(node);
          }

          @Override
          protected void addOperationParameterValueTypeDescription(
              ModelNode node,
              String operationName,
              ResourceDescriptionResolver resolver,
              Locale locale,
              ResourceBundle bundle) {
            setValueType(node);
          }

          private void setValueType(ModelNode node) {
            node.get(ModelDescriptionConstants.VALUE_TYPE).set(ModelType.STRING);
          }
        };
    return list;
  }
Example #27
0
  @Override
  protected void populateModel(ModelNode operation, ModelNode model)
      throws OperationFailedException {
    // attributes
    for (AttributeDefinition attribute : ModelAttributes.REPOSITORY_ATTRIBUTES) {
      attribute.validateAndSet(operation, model);
    }

    // metrics
    for (final AttributeDefinition metric : ModelMetrics.ALL_METRICS) {
      metric.validateAndSet(operation, model);
    }
  }
Example #28
0
        @Override
        public void execute(final OperationContext context, final ModelNode operation)
            throws OperationFailedException {
          final Resource resource = context.createResource(PathAddress.EMPTY_ADDRESS);
          final ModelNode model = resource.getModel();
          final String path =
              PathAddress.pathAddress(operation.require(OP_ADDR)).getLastElement().getValue();

          for (AttributeDefinition attribute : getAttributes(path)) {
            attribute.validateAndSet(operation, model);
          }
          reloadRequiredStep(context);
          context.stepCompleted();
        }
  public void persist(XMLExtendedStreamWriter writer, ModelNode model, String namespaceURI)
      throws XMLStreamException {
    boolean wildcard = getPathElement().isWildcard();
    model =
        wildcard
            ? model.get(getPathElement().getKey())
            : model.get(getPathElement().getKeyValuePair());
    if (!model.isDefined() && !useValueAsElementName()) {
      return;
    }
    boolean isSubsystem = getPathElement().getKey().equals(ModelDescriptionConstants.SUBSYSTEM);

    boolean writeWrapper = getXmlWrapperElement() != null;
    if (writeWrapper) {
      writeStartElement(writer, namespaceURI, getXmlWrapperElement());
    }

    if (wildcard) {
      for (Property p : model.asPropertyList()) {
        if (useValueAsElementName()) {
          writeStartElement(writer, namespaceURI, p.getName());
        } else {
          writeStartElement(writer, namespaceURI, getXmlElementName());
          writer.writeAttribute(NAME, p.getName());
        }
        for (AttributeDefinition def : getAttributes()) {
          def.getAttributeMarshaller().marshallAsAttribute(def, p.getValue(), false, writer);
        }
        persistChildren(writer, p.getValue());
        writer.writeEndElement();
      }
    } else {
      if (useValueAsElementName()) {
        writeStartElement(writer, namespaceURI, getPathElement().getValue());
      } else if (isSubsystem) {
        startSubsystemElement(writer, namespaceURI, getChildren().isEmpty());
      } else {
        writeStartElement(writer, namespaceURI, getXmlElementName());
      }
      for (AttributeDefinition def : getAttributes()) {
        def.getAttributeMarshaller().marshallAsAttribute(def, model, false, writer);
      }
      persistChildren(writer, model);
      writer.writeEndElement();
    }

    if (writeWrapper) {
      writer.writeEndElement();
    }
  }
 private static void configureAttributes(
     Map<String, FailedOperationTransformationConfig.PathAddressConfig> map,
     AttributeDefinition[] rejectedExpression,
     AttributeDefinition[] newAttributes) {
   RejectExpressionsConfig rejectExpressionsConfig =
       new RejectExpressionsConfig(rejectedExpression);
   for (AttributeDefinition attr : rejectedExpression) {
     map.put(attr.getName(), rejectExpressionsConfig);
   }
   NewAttributesConfig newAttributesConfig = new NewAttributesConfig(newAttributes);
   for (AttributeDefinition attr : newAttributes) {
     map.put(attr.getName(), newAttributesConfig);
   }
 }