private void registerOperationAccessConstraints(OperationDefinition od) {
if (constraintUtilizationRegistry != null) {
for (AccessConstraintDefinition acd : od.getAccessConstraints()) {
constraintUtilizationRegistry.registerAccessConstraintOperationUtilization(
acd.getKey(), getPathAddress(), od.getName());
}
}
}
@Override
public void registerOperationHandler(
OperationDefinition definition, OperationStepHandler handler, boolean inherited) {
checkPermission();
if (operationsUpdater.putIfAbsent(
this,
definition.getName(),
new OperationEntry(
handler,
definition.getDescriptionProvider(),
inherited,
definition.getEntryType(),
definition.getFlags(),
definition.getAccessConstraints()))
!= null) {
throw alreadyRegistered("operation handler", definition.getName());
}
registerOperationAccessConstraints(definition);
}
/** @author Tomaz Cerar (c) 2014 Red Hat Inc. */
public class MapOperations {
public static final OperationDefinition MAP_CLEAR_DEFINITION =
new SimpleOperationDefinitionBuilder("map-clear", ControllerResolver.getResolver("global"))
.setParameters(AbstractMapHandler.NAME)
.setRuntimeOnly()
.build();
public static final OperationDefinition MAP_REMOVE_DEFINITION =
new SimpleOperationDefinitionBuilder("map-remove", ControllerResolver.getResolver("global"))
.setParameters(AbstractMapHandler.NAME, AbstractMapHandler.KEY)
.setRuntimeOnly()
.build();
public static final OperationDefinition MAP_GET_DEFINITION =
new SimpleOperationDefinitionBuilder("map-get", ControllerResolver.getResolver("global"))
.setParameters(AbstractMapHandler.NAME, AbstractMapHandler.KEY)
.setRuntimeOnly()
.setReadOnly()
.build();
public static final OperationDefinition MAP_PUT_DEFINITION =
new SimpleOperationDefinitionBuilder("map-put", ControllerResolver.getResolver("global"))
.setParameters(AbstractMapHandler.NAME, AbstractMapHandler.KEY, AbstractMapHandler.VALUE)
.setRuntimeOnly()
.build();
public static final OperationStepHandler MAP_CLEAR_HANDLER = new MapClearHandler();
public static final OperationStepHandler MAP_GET_HANDLER = new MapGetHandler();
public static final OperationStepHandler MAP_REMOVE_HANDLER = new MapRemoveHandler();
public static final OperationStepHandler MAP_PUT_HANDLER = new MapPutHandler();
public static final Set<String> MAP_OPERATION_NAMES =
new HashSet<>(
Arrays.asList(
MAP_CLEAR_DEFINITION.getName(),
MAP_REMOVE_DEFINITION.getName(),
MAP_PUT_DEFINITION.getName(),
MAP_GET_DEFINITION.getName()));
/** @author Tomaz Cerar (c) 2014 Red Hat Inc. */
abstract static class AbstractMapHandler extends AbstractCollectionHandler {
static final SimpleAttributeDefinition KEY =
new SimpleAttributeDefinition("key", ModelType.STRING, false);
AbstractMapHandler(AttributeDefinition... attributes) {
super(attributes);
}
AbstractMapHandler(boolean requiredReadWrite, AttributeDefinition... attributes) {
super(requiredReadWrite, attributes);
}
abstract void updateModel(
final OperationContext context,
ModelNode model,
AttributeDefinition attributeDefinition,
ModelNode attribute)
throws OperationFailedException;
}
/**
* Empty map, note that is not the same as :undefine(name=name-of-attribute)
*
* <p>
*
* <pre>map-clear(name=name-of-attribute)</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class MapClearHandler extends AbstractMapHandler {
private MapClearHandler() {
super(true);
}
void updateModel(
final OperationContext context,
ModelNode model,
AttributeDefinition attributeDefinition,
ModelNode attribute)
throws OperationFailedException {
attribute.setEmptyObject();
}
}
/**
* Get entry from map:
*
* <p>
*
* <pre>:map-get(name=name-of-attribute, key=some-key)</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class MapGetHandler extends AbstractMapHandler {
private MapGetHandler() {
super(false, KEY);
}
void updateModel(
final OperationContext context,
ModelNode model,
AttributeDefinition attributeDefinition,
ModelNode attribute)
throws OperationFailedException {
String key = KEY.resolveModelAttribute(context, model).asString();
context.getResult().set(attribute.get(key));
}
}
/**
* put entry to map
*
* <p>
*
* <pre>:map-put(name=name-of-attribute, key=some-key, value="newvalue")</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class MapPutHandler extends AbstractMapHandler {
private MapPutHandler() {
super(KEY, VALUE);
}
void updateModel(
final OperationContext context,
ModelNode model,
AttributeDefinition attributeDefinition,
ModelNode attribute)
throws OperationFailedException {
String key = KEY.resolveModelAttribute(context, model).asString();
ModelNode value = VALUE.resolveModelAttribute(context, model);
attribute.get(key).set(value);
}
}
/**
* Remove entry from map
*
* <p>
*
* <pre>:map-remove(name=name-of-attribute, key=some-key)</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class MapRemoveHandler extends AbstractMapHandler {
private MapRemoveHandler() {
super(KEY);
}
void updateModel(
final OperationContext context,
ModelNode model,
AttributeDefinition attributeDefinition,
ModelNode attribute)
throws OperationFailedException {
String key = KEY.resolveModelAttribute(context, model).asString();
attribute.remove(key);
}
}
}
public static ModelNode createOperation(
final OperationDefinition operationDefinition, final PathAddress address) {
return getEmptyOperation(operationDefinition.getName(), address.toModelNode());
}
/** @author Tomaz Cerar (c) 2014 Red Hat Inc. */
public class ListOperations {
public static final OperationDefinition LIST_ADD_DEFINITION =
new SimpleOperationDefinitionBuilder("list-add", ControllerResolver.getResolver("global"))
.setParameters(
AbstractCollectionHandler.NAME,
AbstractCollectionHandler.VALUE,
AbstractListHandler.INDEX)
.setRuntimeOnly()
.build();
public static final OperationDefinition LIST_GET_DEFINITION =
new SimpleOperationDefinitionBuilder("list-get", ControllerResolver.getResolver("global"))
.setParameters(AbstractCollectionHandler.NAME, AbstractListHandler.INDEX)
.setRuntimeOnly()
.setReadOnly()
.build();
public static final OperationDefinition LIST_REMOVE_DEFINITION =
new SimpleOperationDefinitionBuilder("list-remove", ControllerResolver.getResolver("global"))
.setParameters(
AbstractCollectionHandler.NAME,
AbstractCollectionHandler.VALUE,
AbstractListHandler.INDEX)
.setRuntimeOnly()
.build();
public static final OperationDefinition LIST_CLEAR_DEFINITION =
new SimpleOperationDefinitionBuilder("list-clear", ControllerResolver.getResolver("global"))
.setParameters(AbstractCollectionHandler.NAME)
.setRuntimeOnly()
.build();
public static final OperationStepHandler LIST_ADD_HANDLER = new ListAddHandler();
public static final OperationStepHandler LIST_REMOVE_HANDLER = new ListRemoveHandler();
public static final OperationStepHandler LIST_GET_HANDLER = new ListGetHandler();
public static final OperationStepHandler LIST_CLEAR_HANDLER = new ListClearHandler();
public static final Set<String> LIST_OPERATION_NAMES =
new HashSet<>(
Arrays.asList(
LIST_CLEAR_DEFINITION.getName(),
LIST_REMOVE_DEFINITION.getName(),
LIST_ADD_DEFINITION.getName(),
LIST_GET_DEFINITION.getName()));
/** @author Tomaz Cerar (c) 2014 Red Hat Inc. */
abstract static class AbstractListHandler extends AbstractCollectionHandler {
static final SimpleAttributeDefinition INDEX =
new SimpleAttributeDefinition("index", ModelType.INT, true);
AbstractListHandler(AttributeDefinition... attributes) {
super(attributes);
}
AbstractListHandler(boolean requiredReadWrite, AttributeDefinition... attributes) {
super(requiredReadWrite, attributes);
}
@Override
public void updateModel(
OperationContext context,
ModelNode model,
AttributeDefinition attributeDefinition,
ModelNode attribute)
throws OperationFailedException {
if (attribute.getType() != ModelType.LIST
&& attributeDefinition.getType() != ModelType.LIST) {
throw ControllerLogger.MGMT_OP_LOGGER.attributeIsWrongType(
attributeDefinition.getName(), ModelType.LIST, attributeDefinition.getType());
}
updateModel(context, model, attribute);
}
abstract void updateModel(
final OperationContext context, ModelNode model, ModelNode listAttribute)
throws OperationFailedException;
}
/**
* Add element to list, with optional index where to put it
*
* <p>
*
* <pre>:list-add(name=list-attribute, value="some value", [index=5])</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class ListAddHandler extends AbstractListHandler {
private ListAddHandler() {
super(VALUE, INDEX);
}
void updateModel(final OperationContext context, ModelNode model, ModelNode listAttribute)
throws OperationFailedException {
String value = VALUE.resolveModelAttribute(context, model).asString();
ModelNode indexNode = INDEX.resolveModelAttribute(context, model);
LinkedList<ModelNode> res =
new LinkedList<>(
listAttribute.isDefined()
? listAttribute.asList()
: Collections.<ModelNode>emptyList());
if (indexNode.isDefined()) {
res.add(indexNode.asInt(), new ModelNode(value));
} else {
res.add(new ModelNode(value));
}
listAttribute.set(res);
}
}
/**
* Add element to list, with optional index where to put it
*
* <p>
*
* <pre>:list-remove(name=list-attribute, value="some value")</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class ListRemoveHandler extends AbstractListHandler {
private ListRemoveHandler() {
super(VALUE, INDEX);
}
void updateModel(final OperationContext context, ModelNode model, ModelNode listAttribute)
throws OperationFailedException {
ModelNode value = VALUE.resolveModelAttribute(context, model);
ModelNode index = INDEX.resolveModelAttribute(context, model);
List<ModelNode> res = new ArrayList<>(listAttribute.asList());
if (index.isDefined()) {
res.remove(index.asInt());
} else {
res.remove(value);
}
listAttribute.set(res);
}
}
/**
* Add element to list, with optional index where to put it
*
* <p>
*
* <pre>:list-remove(name=list-attribute, value="some value")</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class ListGetHandler extends AbstractListHandler {
private ListGetHandler() {
super(false, INDEX);
}
void updateModel(final OperationContext context, ModelNode model, ModelNode listAttribute)
throws OperationFailedException {
int index = INDEX.resolveModelAttribute(context, model).asInt();
if (listAttribute.hasDefined(index)) {
context.getResult().set(listAttribute.get(index));
}
}
}
/**
* Add element to list, with optional index where to put it
*
* <p>
*
* <pre>:list-remove(name=list-attribute, value="some value")</pre>
*
* @author Tomaz Cerar (c) 2014 Red Hat Inc.
*/
public static class ListClearHandler extends AbstractListHandler {
private ListClearHandler() {
super();
}
void updateModel(final OperationContext context, ModelNode model, ModelNode listAttribute)
throws OperationFailedException {
listAttribute.setEmptyList();
}
}
}