Best Java code snippets using org.jboss.as.controller.SimpleAttributeDefinitionBuilder (Showing top 20 results out of 369)

Attribute(String name, ModelType type, ModelNode defaultValue) {
  this.definition = new SimpleAttributeDefinitionBuilder(name, type)
      .setAllowExpression(true)
      .setRequired(false)
      .setDefaultValue(defaultValue)
      .setFlags(AttributeAccess.Flag.RESTART_RESOURCE_SERVICES)
      .build();
}

  @Override
  public SimpleAttributeDefinitionBuilder apply(SimpleAttributeDefinitionBuilder builder) {
    return builder.setDefaultValue(new ModelNode(StartMode.LAZY.name()))
        .setValidator(new EnumValidator<>(StartMode.class))
        ;
  }
},

LockingMetric(String name, ModelType type) {
  this.definition = new SimpleAttributeDefinitionBuilder(name, type, true).setStorageRuntime().build();
}

Attribute(String attributeName, ModelType type, CapabilityReference capabilityReference) {
  this.definition = new SimpleAttributeDefinitionBuilder(attributeName, type)
      .setRequired(false)
      .setFlags(AttributeAccess.Flag.RESTART_RESOURCE_SERVICES)
      .setAllowExpression(false)
      .setCapabilityReference(capabilityReference)
      .setValidator(new StringLengthValidator(1))
      .setAccessConstraints(SensitiveTargetAccessConstraintDefinition.SSL_REF)
      .build();
}

public static SimpleAttributeDefinitionBuilder create(final String name, final ModelNode node) {
  ModelType type = node.get(ModelDescriptionConstants.TYPE).asType();
  boolean nillable = node.get(ModelDescriptionConstants.NILLABLE).asBoolean(true);
  boolean expressionAllowed = node.get(ModelDescriptionConstants.EXPRESSIONS_ALLOWED).asBoolean(false);
  ModelNode defaultValue = node.get(ModelDescriptionConstants.DEFAULT);
  return SimpleAttributeDefinitionBuilder.create(name, type, nillable)
      .setDefaultValue(defaultValue)
      .setAllowExpression(expressionAllowed);
}

private static SimpleAttributeDefinition createIntAttribute(String name, Attribute attribute, int defaultValue) {
  return SimpleAttributeDefinitionBuilder.create(name, ModelType.INT, true)
      .setDefaultValue(new ModelNode().set(defaultValue))
      .setXmlName(attribute.getLocalName())
      .setValidator(new IntRangeValidator(1, true))
      .setAllowExpression(true)
      .build();
}

@Override
public void registerAttributes(ManagementResourceRegistration resourceRegistration) {
  if (deployed) {
    SimpleAttributeDefinition runtimeAttribute = new SimpleAttributeDefinitionBuilder(Constants.CONNECTION_PROPERTY_VALUE).setFlags(AttributeAccess.Flag.STORAGE_RUNTIME).build();
    resourceRegistration.registerReadOnlyAttribute(runtimeAttribute, XMLDataSourceRuntimeHandler.INSTANCE);
  } else {
    resourceRegistration.registerReadOnlyAttribute(Constants.CONNECTION_PROPERTY_VALUE, null);
  }
}

  @Override
  public SimpleAttributeDefinitionBuilder apply(SimpleAttributeDefinitionBuilder builder) {
    return builder.setAllowExpression(true)
        .setRequired(false)
        .setDefaultValue(new ModelNode("RSA"))
        ;
  }
},

  @Override
  public SimpleAttributeDefinitionBuilder apply(SimpleAttributeDefinitionBuilder builder) {
    return builder.setDefaultValue(new ModelNode(false));
  }
},

private static SimpleAttributeDefinition create(final String name) {
  return SimpleAttributeDefinitionBuilder.create(name, BOOLEAN)
      .setDefaultValue(new ModelNode(false))
      .setRequired(false)
      .setFlags(RESTART_NONE)
      .build();
}

  private static SimpleAttributeDefinition createBooleanAttributeDefinition(String name) {
    return SimpleAttributeDefinitionBuilder.create(name, ModelType.BOOLEAN)
        .setDefaultValue(new ModelNode(true))
        .setAllowNull(true)
        .setAllowExpression(true)
        .setAttributeMarshaller(new WrappedAttributeMarshaller(Attribute.VALUE))
        .build();
  }
}

ManagementResourceRegistration registration = context.getResourceRegistrationForUpdate();
String protocolName = context.getCurrentAddressValue();
String moduleName = ProtocolResourceDefinition.Attribute.MODULE.resolveModelAttribute(context, resource.getModel()).asString();
Class<? extends Protocol> protocolClass = ChannelRuntimeResourceRegistration.findProtocolClass(context, protocolName, moduleName);
if (registration.getPathAddress().getLastElement().isWildcard()) {
  OverrideDescriptionProvider provider = new OverrideDescriptionProvider() {
    @Override
  registration = registration.registerOverrideModel(protocolName, provider);
  String name = attribute.getName();
  FieldType type = FieldType.valueOf(attribute.getType());
  registration.registerMetric(new SimpleAttributeDefinitionBuilder(name, type.getModelType()).setStorageRuntime().build(), handler);

  private static SimpleAttributeDefinition createBooleanAttributeDefinition(String name) {
    return SimpleAttributeDefinitionBuilder.create(name, ModelType.BOOLEAN)
        .setDefaultValue(new ModelNode(true))
        .setRequired(false)
        .setAllowExpression(true)
        .setAttributeMarshaller(new WrappedAttributeMarshaller(Attribute.VALUE))
        .build();
  }
}

@Override
public void registerChildren(ManagementResourceRegistration resourceRegistration) {
  resourceRegistration.registerSubModel(new CamelContextResource(subsystemState));
  if (registerRuntimeOnly) {
    AttributeDefinition eldef = new SimpleAttributeDefinitionBuilder("dummy", ModelType.STRING, false).build();
    AttributeDefinition attdef = new SimpleListAttributeDefinition.Builder(ModelConstants.ENDPOINTS, eldef).setStorageRuntime().build();
    resourceRegistration.registerReadOnlyAttribute(attdef, new CamelRuntimeOnlyHandler());
  }
}

  @Override
  public SimpleAttributeDefinitionBuilder apply(SimpleAttributeDefinitionBuilder builder) {
    return builder.setDefaultValue(new ModelNode(ServerEnvironment.SERVER_DATA_DIR))
        .setCapabilityReference(new CapabilityReference(Capability.PERSISTENCE, CommonUnaryRequirement.PATH))
        ;
  }
},

  @Override
  public SimpleAttributeDefinitionBuilder apply(SimpleAttributeDefinitionBuilder builder) {
    return builder.setDefaultValue(new ModelNode(false))
        .setDeprecated(JGroupsModel.VERSION_4_0_0.getVersion())
        ;
  }
},

  @Override
  public void register(ManagementResourceRegistration registration) {
    SimpleOperationDefinitionBuilder builder = new SimpleOperationDefinitionBuilder(ModelDescriptionConstants.ADD, this.descriptor.getDescriptionResolver()).withFlag(OperationEntry.Flag.RESTART_NONE);
    if (registration.isOrderedChildResource()) {
      builder.addParameter(SimpleAttributeDefinitionBuilder.create(ModelDescriptionConstants.ADD_INDEX, ModelType.INT, true).build());
    }
    for (AttributeDefinition attribute : this.descriptor.getAttributes()) {
      builder.addParameter(attribute);
    }
    for (AttributeDefinition parameter : this.descriptor.getExtraParameters()) {
      builder.addParameter(parameter);
    }
    for (AttributeDefinition attribute : this.descriptor.getAttributeTranslations().keySet()) {
      builder.addParameter(attribute);
    }
    registration.registerOperationHandler(builder.build(), this.descriptor.getAddOperationTransformation().apply(this));
  }
}

ThreadPoolResourceDefinition(String name, int defaultMinThreads, int defaultMaxThreads, int defaultQueueLength, long defaultKeepAliveTime, JGroupsModel deprecation) {
  Parameters parameters = new Parameters(pathElement(name), JGroupsExtension.SUBSYSTEM_RESOLVER.createChildResolver(pathElement(name), pathElement(PathElement.WILDCARD_VALUE)));
  this.deprecated = (deprecation != null);
  if (this.deprecated) {
    parameters.setDeprecatedSince(deprecation.getVersion());
  }
  this.definition = new SimpleResourceDefinition(parameters);
  this.minThreads = new SimpleAttribute(createBuilder("min-threads", ModelType.INT, new ModelNode(defaultMinThreads), new IntRangeValidatorBuilder().min(0), deprecation).build());
  this.maxThreads = new SimpleAttribute(createBuilder("max-threads", ModelType.INT, new ModelNode(defaultMaxThreads), new IntRangeValidatorBuilder().min(0), deprecation).build());
  this.queueLength = new SimpleAttribute(createBuilder("queue-length", ModelType.INT, new ModelNode(defaultQueueLength), new IntRangeValidatorBuilder().min(0), deprecation).setDeprecated(JGroupsModel.VERSION_6_0_0.getVersion()).build());
  this.keepAliveTime = new SimpleAttribute(createBuilder("keepalive-time", ModelType.LONG, new ModelNode(defaultKeepAliveTime), new LongRangeValidatorBuilder().min(0), deprecation).build());
}

ScheduledThreadPoolResourceDefinition(String name, int defaultMaxThreads, long defaultKeepaliveTime) {
  PathElement path = pathElement(name);
  this.definition = new SimpleResourceDefinition(path, InfinispanExtension.SUBSYSTEM_RESOLVER.createChildResolver(path, pathElement(PathElement.WILDCARD_VALUE)));
  this.maxThreads = new SimpleAttribute(createBuilder("max-threads", ModelType.INT, new ModelNode(defaultMaxThreads), new IntRangeValidatorBuilder().min(0)).build());
  this.keepAliveTime = new SimpleAttribute(createBuilder("keepalive-time", ModelType.LONG, new ModelNode(defaultKeepaliveTime), new LongRangeValidatorBuilder().min(0)).build());
}

SimpleOperationDefinitionBuilder builder = new SimpleOperationDefinitionBuilder(NamingSubsystemModel.REBIND, getResourceDescriptionResolver())
    .addParameter(SimpleAttributeDefinitionBuilder.create(BINDING_TYPE)
        .setValidator(new EnumValidator<>(BindingType.class, EnumSet.complementOf(EnumSet.of(BindingType.EXTERNAL_CONTEXT))))
        .build())
    .addParameter(TYPE)
    .addParameter(VALUE)
    .addParameter(LOOKUP)
    .addParameter(ENVIRONMENT);
resourceRegistration.registerOperationHandler(builder.build(), new OperationStepHandler() {
  @Override
  public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {