protected void parseRemote(final XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { final int count = reader.getAttributeCount(); ModelNode operation = Util.createAddOperation(SUBSYSTEM_PATH.append(SERVICE, REMOTE)); final EnumSet<EJB3SubsystemXMLAttribute> required = EnumSet.of(EJB3SubsystemXMLAttribute.CONNECTOR_REF, EJB3SubsystemXMLAttribute.THREAD_POOL_NAME); for (int i = 0; i < count; i++) { requireNoNamespaceAttribute(reader, i); final String value = reader.getAttributeValue(i); final EJB3SubsystemXMLAttribute attribute = EJB3SubsystemXMLAttribute.forName(reader.getAttributeLocalName(i)); required.remove(attribute); switch (attribute) { case CONNECTOR_REF: EJB3RemoteResourceDefinition.CONNECTOR_REF.parseAndSetParameter(value, operation, reader); break; case THREAD_POOL_NAME: EJB3RemoteResourceDefinition.THREAD_POOL_NAME.parseAndSetParameter(value, operation, reader); break; default: throw unexpectedAttribute(reader, i); } } if (!required.isEmpty()) { throw missingRequired(reader, required); } operation.get(EJB3SubsystemModel.EXECUTE_IN_WORKER).set(new ModelNode(false)); requireNoContent(reader); operations.add(operation); }
@Override public ModelNode transformOperation(ModelNode operation) { if (operation.get(NAME).asString().equals(PROPERTIES)) { String key = operation.get("key").asString(); PathAddress address = Operations.getPathAddress(operation); ModelNode transformedOperation = Util.createOperation(READ_ATTRIBUTE_OPERATION, address.append(PathElement.pathElement(PROPERTY, key))); transformedOperation.get(NAME).set(VALUE); return transformedOperation; } return operation; } }
@Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { operationDeprecated(context, operation); PathAddress address = translateProxyPath(context); String type = operation.require(LoadMetricResourceDefinition.Attribute.TYPE.getName()).asString(); PathAddress metricPath = PathAddress.pathAddress(DynamicLoadProviderResourceDefinition.LEGACY_PATH, LoadMetricResourceDefinition.pathElement(type)); PathAddress metricPathAddress = address.append(metricPath); ModelNode metricOperation = Util.createRemoveOperation(metricPathAddress); OperationEntry removeOperationEntry = context.getResourceRegistration().getOperationEntry(PathAddress.pathAddress(metricPath), ModelDescriptionConstants.REMOVE); context.addStep(metricOperation, removeOperationEntry.getOperationHandler(), OperationContext.Stage.MODEL, true); } };
private void parseBackups(XMLExtendedStreamReader reader, PathAddress cacheAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { PathAddress address = cacheAddress.append(BackupsResourceDefinition.PATH); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { XMLElement element = XMLElement.forName(reader.getLocalName()); switch (element) { case BACKUP: { this.parseBackup(reader, address, operations); break; } default: { throw ParseUtils.unexpectedElement(reader); } } } }
@Override public void readElement(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { PathAddress address = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, SecurityExtension.SUBSYSTEM_NAME)); final ModelNode subsystemNode = Util.createAddOperation(address); operations.add(subsystemNode); requireNoAttributes(reader); final EnumSet<Element> visited = EnumSet.noneOf(Element.class); while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); if (!visited.add(element)) { throw unexpectedElement(reader); } readElement(reader, element, operations, address, subsystemNode); } }
private void parseJobRepository(final XMLExtendedStreamReader reader, final PathAddress subsystemAddress, final String name, final List<ModelNode> ops) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final String localName = reader.getLocalName(); final Element element = Element.forName(localName); if (element == Element.IN_MEMORY) { ops.add(Util.createAddOperation(subsystemAddress.append(InMemoryJobRepositoryDefinition.NAME, name))); ParseUtils.requireNoContent(reader); } else if (element == Element.JDBC) { final Map<Attribute, String> attributes = AttributeParsers.readRequiredAttributes(reader, EnumSet.of(Attribute.DATA_SOURCE)); final ModelNode op = Util.createAddOperation(subsystemAddress.append(JdbcJobRepositoryDefinition.NAME, name)); JdbcJobRepositoryDefinition.DATA_SOURCE.parseAndSetParameter(attributes.get(Attribute.DATA_SOURCE), op, reader); ops.add(op); ParseUtils.requireNoContent(reader); } else { throw ParseUtils.unexpectedElement(reader); } } } }
private void parseCustomStore(XMLExtendedStreamReader reader, PathAddress cacheAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { PathAddress address = cacheAddress.append(CustomStoreResourceDefinition.PATH); PathAddress operationKey = cacheAddress.append(StoreResourceDefinition.WILDCARD_PATH); if (operations.containsKey(operationKey)) { throw ParseUtils.unexpectedElement(reader); } ModelNode operation = Util.createAddOperation(address); operations.put(operationKey, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { XMLAttribute attribute = XMLAttribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case CLASS: { readAttribute(reader, i, operation, CustomStoreResourceDefinition.Attribute.CLASS); break; } default: { this.parseStoreAttribute(reader, i, operation); } } } if (!operation.hasDefined(CustomStoreResourceDefinition.Attribute.CLASS.getName())) { throw ParseUtils.missingRequired(reader, EnumSet.of(XMLAttribute.CLASS)); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseStoreElement(reader, address, operations); } }
private void parseAuthProtocol(XMLExtendedStreamReader reader, PathAddress stackAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String type = require(reader, XMLAttribute.TYPE); PathAddress address = stackAddress.append(ProtocolResourceDefinition.pathElement(type)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseProtocolAttribute(reader, i, operation); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseAuthProtocolElement(reader, address, operations); } if (!operations.containsKey(address.append(AuthTokenResourceDefinition.WILDCARD_PATH))) { throw ParseUtils.missingOneOf(reader, EnumSet.of(XMLElement.PLAIN_TOKEN, XMLElement.DIGEST_TOKEN, XMLElement.CIPHER_TOKEN)); } }
private void parseRolloutPlans(XMLExtendedStreamReader reader, ModelNode address, List<ModelNode> list) throws XMLStreamException { String hash = readStringAttributeElement(reader, Attribute.SHA1.getLocalName()); ModelNode addAddress = address.clone().add(MANAGEMENT_CLIENT_CONTENT, ROLLOUT_PLANS); ModelNode addOp = Util.getEmptyOperation(ADD, addAddress); try { addOp.get(HASH).set(HashUtil.hexStringToByteArray(hash)); } catch (final Exception e) { throw ControllerLogger.ROOT_LOGGER.invalidSha1Value(e, hash, Attribute.SHA1.getLocalName(), reader.getLocation()); } list.add(addOp); }
public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { final ModelNode opAddr = operation.require(OP_ADDR); final String idName = PathAddress.pathAddress(opAddr).getLastElement().getValue(); final boolean isModule; if (!model.hasDefined(ARCHIVE.getName()) && !model.hasDefined(MODULE.getName())) { throw ConnectorLogger.ROOT_LOGGER.archiveOrModuleRequired(); if (model.get(ARCHIVE.getName()).isDefined()) { isModule = false; archiveOrModuleName = model.get(ARCHIVE.getName()).asString(); archiveOrModuleName = model.get(MODULE.getName()).asString(); final ModelNode compensating = Util.getEmptyOperation(ADD, opAddr); if (model.hasDefined(RESOURCEADAPTERS_NAME)) {
private void parseInvalidationCache(XMLExtendedStreamReader reader, PathAddress containerAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String name = require(reader, XMLAttribute.NAME); PathAddress address = containerAddress.append(InvalidationCacheResourceDefinition.pathElement(name)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseClusteredCacheAttribute(reader, i, address, operations); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseCacheElement(reader, address, operations); } }
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { if (operation.get(NAME).asString().equals(PROPERTIES)) { ModelNode newValue = context.readResourceFromRoot(resolvedAddress).getModel().get(PROPERTIES).clone(); if (initialValue.equals(newValue) || (initialValue.isDefined() && initialValue.asPropertyList().isEmpty() && !newValue.isDefined())) { ModelNode addOp = Util.createAddOperation(legacyAddress.append(PathElement.pathElement(PROPERTY, key))); addOp.get(VALUE).set(value); operations.add(addOp); if (!oldPropValue.equals(value)) { ModelNode writeOp = Util.getWriteAttributeOperation(legacyAddress.append(PathElement.pathElement(PROPERTY, key)), VALUE, value); operations.add(writeOp); ModelNode removeOperation = Util.createRemoveOperation(legacyAddress.append(PathElement.pathElement(PROPERTY, prop.getKey()))); operations.add(removeOperation);
@Override public OperationStepHandler apply(OperationStepHandler handler) { return (context, operation) -> { if (operation.hasDefined(this.attribute.getName())) { // Translate deprecated table attribute into separate add table operation ModelNode addTableOperation = Util.createAddOperation(context.getCurrentAddress().append(this.path)); ModelNode parameters = operation.get(this.attribute.getName()); for (Property parameter : parameters.asPropertyList()) { addTableOperation.get(parameter.getName()).set(parameter.getValue()); } context.addStep(addTableOperation, context.getResourceRegistration().getOperationHandler(PathAddress.pathAddress(this.path), ModelDescriptionConstants.ADD), context.getCurrentStage()); } handler.execute(context, operation); }; }
private void parseObjectMemory(XMLExtendedStreamReader reader, PathAddress cacheAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { PathAddress address = cacheAddress.append(ObjectMemoryResourceDefinition.PATH); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseMemoryAttribute(reader, i, operation); } ParseUtils.requireNoContent(reader); }
@Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { // If this is a legacy configuration containing a default-stack, but no default-channel, then fabricate a default channel using the default stack // This ensures that the default channel factory capability is available to the /subsystem=infinispan/cache-container=*/transport=jgroups resource, which requires them // We can drop this compatibility workaround after we drop support for model version 3.0. if (!operation.hasDefined(Attribute.DEFAULT_CHANNEL.getName()) && operation.hasDefined(Attribute.DEFAULT_STACK.getName())) { String defaultChannel = "auto"; PathAddress channelAddress = context.getCurrentAddress().append(ChannelResourceDefinition.pathElement(defaultChannel)); ModelNode channelOperation = Util.createAddOperation(channelAddress); channelOperation.get(ChannelResourceDefinition.Attribute.STACK.getName()).set(operation.get(Attribute.DEFAULT_STACK.getName())); context.addStep(channelOperation, context.getRootResourceRegistration().getOperationHandler(channelAddress, ModelDescriptionConstants.ADD), OperationContext.Stage.MODEL); operation.get(Attribute.DEFAULT_CHANNEL.getName()).set(new ModelNode(defaultChannel)); } handler.execute(context, operation); } };
public static ModelNode getReadAttributeOperation(final PathAddress address, String attributeName) { ModelNode op = createEmptyOperation(READ_ATTRIBUTE_OPERATION, address); op.get(NAME).set(attributeName); return op; }
public static void checkMapModels(KernelServices services, ModelVersion version, PathAddress address, String... properties) throws Exception { final ModelNode readResource = Util.createEmptyOperation(READ_RESOURCE_OPERATION, address); readResource.get(RECURSIVE).set(true); readResource.get(INCLUDE_DEFAULTS).set(false); ModelNode mainModel = services.executeForResult(readResource.clone()); checkMainMapModel(mainModel, properties); final ModelNode legacyModel; if (address.getLastElement().getKey().equals("transport")) { //TODO get rid of this once the PathAddress transformer works properly //Temporary workaround readResource.get(OP_ADDR).set(address.subAddress(0, address.size() - 1).append("transport", "TRANSPORT").toModelNode()); legacyModel = services.getLegacyServices(version).executeForResult(readResource); } else { legacyModel = ModelTestUtils.checkResultAndGetContents(services.executeOperation(version, services.transformOperation(version, readResource.clone()))); } checkLegacyChildResourceModel(legacyModel, properties); }
private void setServerName(final ModelNode address, final List<ModelNode> operationList, final ModelNode value) { if (value != null && value.isDefined() && value.asString().length() > 0) { final ModelNode update = Util.getWriteAttributeOperation(address, NAME, value); operationList.add(update); } }
public static ModelNode createMapClearOperation(PathAddress address, Attribute attribute) { ModelNode operation = Util.createOperation(MapOperations.MAP_CLEAR_DEFINITION, address); operation.get(ModelDescriptionConstants.NAME).set(attribute.getName()); return operation; }
private void testNonMapTransformersWork(KernelServices services, ModelVersion version) throws Exception { final PathAddress stackAddr = PathAddress.pathAddress(SUBSYSTEM, getMainSubsystemName()).append("stack", "test"); ModelNode addStack = Util.createAddOperation(stackAddr); executeOpInBothControllersWithAttachments(services, version, addStack); final PathAddress transportAddr = stackAddr.append("transport", "tcp"); ModelNode addTransport = Util.createAddOperation(transportAddr); addTransport.get(SocketBindingProtocolResourceDefinition.Attribute.SOCKET_BINDING.getName()).set("some-binding"); addTransport.get(MODULE).set("do.reject"); TransformedOperation op = services.executeInMainAndGetTheTransformedOperation(addTransport, version); Assert.assertTrue(op.rejectOperation(success())); final PathAddress protocolAddr = stackAddr.append("protocol", "PING"); ModelNode addProtocol = Util.createAddOperation(protocolAddr); addProtocol.get(MODULE).set("do.reject"); op = services.executeInMainAndGetTheTransformedOperation(addProtocol, version); Assert.assertTrue(op.rejectOperation(success())); op = services.executeInMainAndGetTheTransformedOperation(Util.getWriteAttributeOperation(transportAddr, MODULE, "reject.this"), version); Assert.assertTrue(op.rejectOperation(success())); op = services.executeInMainAndGetTheTransformedOperation(Util.getWriteAttributeOperation(protocolAddr, MODULE, "reject.this"), version); Assert.assertTrue(op.rejectOperation(success())); }