Refine search
@Override public void validateResolvedParameter(String parameterName, ModelNode value) throws OperationFailedException { if (name.equals(parameterName)) { ModelNode parameters = value.clone(); if (isConfigured(parameters)) { for (SimpleAttributeDefinition attribute : KEY_STORE_FIELDS) { attribute.getValidator().validateParameter(attribute.getName(), parameters.get(attribute.getName())); } } } }
protected void performRemove(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException { ModelNode param = operation.get(INCLUDE); ModelNode includes = model.get(INCLUDE); ModelNode toRemove = null; typeValidator.validateParameter(INCLUDE, param); ModelNode newList = new ModelNode().setEmptyList(); String group = param.asString(); if (includes.isDefined()) { for (ModelNode included : includes.asList()) { if (!group.equals(included.asString())) { toRemove = newList.add(included); break; } } } if (toRemove != null) { includes.set(newList); } else { throw new OperationFailedException(new ModelNode().set(MESSAGES.groupNotFound(group))); } }
node = ParseUtils.parsePossibleExpression(trimmed); } else { node = new ModelNode().set(trimmed); if (node.getType() != ModelType.EXPRESSION) { elementValidator.validateParameter(getXmlName(), node);
@Override public void updateModel(final OperationContext context, final ModelNode operation, final ModelNode model) throws OperationFailedException { final Resource resource = context.readResourceForUpdate(PathAddress.EMPTY_ADDRESS); final ModelNode handlerName = operation.get(HANDLER_NAME.getName()); // Get the current handlers, add the handler and set the model value final ModelNode handlers = model.get(HANDLERS.getName()).clone(); if (!handlers.isDefined()) { handlers.setEmptyList(); } handlers.add(handlerName); HANDLERS.getValidator().validateParameter(HANDLERS.getName(), handlers); model.get(HANDLERS.getName()).add(handlerName); recordCapabilitiesAndRequirements(context, resource, HANDLERS, new ModelNode().setEmptyList().add(handlerName), new ModelNode()); }
private ModelNode validateOperation(final ModelNode operationObject, final boolean immutableValue) throws OperationFailedException { ModelNode node = new ModelNode(); if(operationObject.has(name)) { node.set(operationObject.get(name)); } if (!immutableValue) { node = convertParameterExpressions(node); node = correctValue(node, node); } if (!node.isDefined() && defaultValue != null && defaultValue.isDefined()) { validator.validateParameter(name, defaultValue); } else { validator.validateParameter(name, node); } return convertToExpectedType(node); }
ModelNode superResult = value.getType() == ModelType.OBJECT ? value : super.resolveValue(resolver, value); if (superResult.getType() != ModelType.OBJECT) { return superResult; ModelNode clone = superResult == value ? value.clone() : superResult; ModelNode result = new ModelNode(); for (AttributeDefinition field : valueTypes) { String fieldName = field.getName(); if (clone.has(fieldName)) { result.get(fieldName).set(field.resolveValue(resolver, clone.get(fieldName))); } else { ModelNode val = field.resolveValue(resolver, new ModelNode()); if (val.isDefined()) { result.get(fieldName).set(val); getValidator().validateParameter(getName(), result); return result;
@Override public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); for (final AttributeDefinition def : NESTED_ATTRIBUTES) { final String name = def.getName(); if (value.hasDefined(name)) { final ModelNode v = value.get(name); if (NESTED_LIST_ATTRIBUTES.contains(def)) { if (ModelType.LIST != v.getType()) { throw new OperationFailedException(new ModelNode().set(MESSAGES.invalidType(v.getType()))); } } else { def.getValidator().validateParameter(name, v); } } } } };
@Override public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); final ModelNode clone = value.clone(); RELATIVE_TO.getValidator().validateParameter(parameterName, clone.get(RELATIVE_TO.getName())); PATH.getValidator().validateParameter(parameterName, clone.get(PATH.getName())); if (value.isDefined()) { // Could have relative-to if (value.hasDefined(RELATIVE_TO.getName())) { final String relativeTo = value.get(RELATIVE_TO.getName()).asString(); // Can't be an absolute path if (AbstractPathService.isAbsoluteUnixOrWindowsPath(relativeTo)) { throw createOperationFailure(LoggingLogger.ROOT_LOGGER.invalidRelativeTo(relativeTo)); } } } } }
@Override public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); final ModelNode clonedValue = value.clone(); final AttributeDefinition[] allowedValues = {MIN_LEVEL, MIN_INCLUSIVE, MAX_LEVEL, MAX_INCLUSIVE}; for (AttributeDefinition valueType : allowedValues) { final ModelNode syntheticValue; // Does the value the type if (clonedValue.has(valueType.getName())) { syntheticValue = clonedValue.get(valueType.getName()); } else if (valueType.getDefaultValue() != null) { // Use the default value syntheticValue = valueType.getDefaultValue(); } else { // Use an undefined value syntheticValue = new ModelNode(); } valueType.getValidator().validateParameter(valueType.getName(), syntheticValue); } } })
@Override public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); if (value.isDefined()) { for (String key : value.keys()) { if (allowedValues.containsKey(key)) { allowedValues.get(key).getValidator().validateParameter(key, value.get(key)); } else { throw new OperationFailedException(new ModelNode().set("invalid type key")); } } } }
public ModelNode resolveModelAttribute(final ExpressionResolver resolver, final ModelNode model) throws OperationFailedException { final ModelNode node = new ModelNode(); if(model.has(name)) { node.set(model.get(name)); } if (!node.isDefined() && defaultValue.isDefined()) { node.set(defaultValue); } final ModelNode resolved = resolver.resolveExpressions(node); validator.validateParameter(name, resolved); return resolved; }
ModelNode node; if (trimmed != null) { if (attribute.isAllowExpression()) { node = ParseUtils.parsePossibleExpression(trimmed); } else { node = new ModelNode().set(trimmed); if (node.getType() != ModelType.EXPRESSION) { switch (attribute.getType()) { case BIG_DECIMAL: node.set(node.asBigDecimal()); validator = ((MapAttributeDefinition) attribute).getElementValidator(); } else { validator = attribute.getValidator(); validator.validateParameter(attribute.getXmlName(), node);
@Override public void validateParameter(String parameterName, ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); if (value.isDefined()) { List<ModelNode> list = value.asList(); int size = list.size(); if (size < min) { throw new OperationFailedException(new ModelNode().set(MESSAGES.invalidMinSize(size, parameterName, min))); } else if (size > max) { throw new OperationFailedException(new ModelNode().set(MESSAGES.invalidMaxSize(size, parameterName, max))); } else { for (ModelNode element : list) { elementValidator.validateParameter(parameterName, element); } } } }
@Override public void validateParameter(String parameterName, ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); if (value.isDefined()) { List<Property> list = value.asPropertyList(); int size = list.size(); if (size < min) { throw new OperationFailedException(new ModelNode().set(MESSAGES.invalidMinSize(size, parameterName, min))); } else if (size > max) { throw new OperationFailedException(new ModelNode().set(MESSAGES.invalidMaxSize(size, parameterName, max))); } else { for (Property property : list) { elementValidator.validateParameter(parameterName, property.getValue()); } } } }
private static void checkModelAgainstDefinition(final ModelNode model, ManagementResourceRegistration rr, Stack<PathElement> stack) { final Set<String> children = rr.getChildNames(PathAddress.EMPTY_ADDRESS); final Set<String> attributeNames = rr.getAttributeNames(PathAddress.EMPTY_ADDRESS); for (ModelNode el : model.asList()) { String name = el.asProperty().getName(); ModelNode value = el.asProperty().getValue(); if (attributeNames.contains(name)) { AttributeAccess aa = rr.getAttributeAccess(PathAddress.EMPTY_ADDRESS, name); if (!value.isDefined()) { Assert.assertTrue(getComparePathAsString(stack) + " Attribute " + name + " does not allow null", (!ad.isRequired() || ad.getDefaultValue() == null)); } else { if (ad.isRequired() && value.isDefined()){ ad.getValidator().validateParameter(name, value); Assert.fail(getComparePathAsString(stack) + " validation for attribute '" + name + "' failed, " + e.getFailureDescription().asString());
/** * Overrides the superclass implementation to allow the value type's AttributeDefinition to in turn * resolve each element. * * {@inheritDoc} */ @Override public ModelNode resolveValue(ExpressionResolver resolver, ModelNode value) throws OperationFailedException { // Pass non-LIST values through the superclass so it can reject weird values and, in the odd chance // that's how this object is set up, turn undefined into a default list value. ModelNode superResult = value.getType() == ModelType.LIST ? value : super.resolveValue(resolver, value); // If it's not a LIST (almost certainly UNDEFINED), then nothing more we can do if (superResult.getType() != ModelType.LIST) { return superResult; } // Resolve each element. // Don't mess with the original value ModelNode clone = superResult == value ? value.clone() : superResult; ModelNode result = new ModelNode(); result.setEmptyList(); for (ModelNode element : clone.asList()) { result.add(valueType.resolveValue(resolver, element)); } // Validate the entire list getValidator().validateParameter(getName(), result); return result; }
@Override public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); if (value.isDefined()) { for (AttributeDefinition ad : allowedValues.values()) { String key = ad.getName(); // Don't modify the value by calls to get(), because that's best in general. // Plus modifying it results in an irrelevant test failure in full where the test // isn't expecting the modification and complains. // Changing the test is too much trouble. ModelNode toTest = value.has(key) ? value.get(key) : new ModelNode(); ad.getValidator().validateParameter(key, toTest); } } } }
public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); if (value.isDefined()) { if (value.asProperty().getName().length() < 1) { throw new OperationFailedException(new ModelNode().set(MESSAGES.invalidMinLength(value.asProperty().getName(), parameterName, 1))); } if (valueValidator != null) { valueValidator.validateParameter(parameterName, value.asProperty().getValue()); } } } }
public void validate(ModelNode operation) throws OperationFailedException { for (Map.Entry<String, ParameterValidator> entry : validators.entrySet()) { String paramName = entry.getKey(); ModelNode paramVal = operation.has(paramName) ? operation.get(paramName) : new ModelNode(); entry.getValue().validateParameter(paramName, paramVal); } }
@Override public void validateParameter(final String parameterName, final ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); for (final AttributeDefinition def : NESTED_ATTRIBUTES) { final String name = def.getName(); if (value.hasDefined(name)) { final ModelNode v = value.get(name); if (NESTED_LIST_ATTRIBUTES.contains(def)) { if (ModelType.LIST != v.getType()) { throw new OperationFailedException(ControllerLogger.ROOT_LOGGER.invalidType(v.getType())); } } else { def.getValidator().validateParameter(name, v); } } } } };