Package org.jboss.as.controller.transform

Examples of org.jboss.as.controller.transform.OperationTransformer

87
88
89
90
91
92
93
94
95
96
97
            return createTransformer(first);
        }
    }

    protected OperationTransformer createTransformer(final TransformationRule first) {
        return new OperationTransformer() {
            @Override
            public TransformedOperation transformOperation(final TransformationContext ctx, final PathAddress address, final ModelNode operation) throws OperationFailedException {

                if(discardPolicy == DiscardPolicy.SILENT) {
                    return OperationTransformer.DISCARD.transformOperation(ctx, address, operation);
View Full Code Here
106
107
108
109
110
111
112
113
114
115
     * @return the operation transformers
     */
    protected Map<String, OperationTransformer> buildOperationTransformers(AttributeTransformationDescriptionBuilderImpl.AttributeTransformationDescriptionBuilderRegistry registry) {
        final Map<String, OperationTransformer> operations = new HashMap<String, OperationTransformer>();
        for(final Map.Entry<String, OperationTransformationEntry> entry: operationTransformers.entrySet()) {
            final OperationTransformer transformer = entry.getValue().getOperationTransformer(registry);
            operations.put(entry.getKey(), transformer);
        }
        return operations;
    }
View Full Code Here
209
210
211
212
213
214
215
216
217
218
219
                    }
                }, WebConnectorDefinition.REDIRECT_PORT.getName())
                .end()
                .addOperationTransformationOverride(UNDEFINE_ATTRIBUTE_OPERATION)
                .inheritResourceAttributeDefinitions() // although probably not necessary
                .setCustomOperationTransformer(new OperationTransformer() {
                    @Override
                    public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                        final String attributeName = operation.require(NAME).asString();
                        if (WebConnectorDefinition.REDIRECT_PORT.getName().equals(attributeName)) {
                            final ModelNode transformed = new ModelNode();
View Full Code Here
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
        Map<String, OperationTransformer> writeAttributeTransformers = new HashMap<>();
        Map<String, OperationTransformer> undefineAttributeTransformers = new HashMap<>();

        if (InfinispanModel.VERSION_3_0_0.requiresTransformation(version)) {
            // Convert BATCH -> NONE, and include write-attribute:name=batching
            OperationTransformer addTransformer = new OperationTransformer() {
                @Override
                public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                    if (operation.hasDefined(MODE.getName())) {
                        ModelNode mode = operation.get(MODE.getName());
                        if ((mode.getType() == ModelType.STRING) && (TransactionMode.valueOf(mode.asString()) == TransactionMode.BATCH)) {
                            mode.set(TransactionMode.NONE.name());
                            ModelNode writeBatchingOperation = OperationFactory.createWriteAttributeOperation(cacheAddress(address), CacheResourceDefinition.BATCHING.getName(), new ModelNode(true));
                            return new TransformedOperation(OperationFactory.createCompositeOperation(writeBatchingOperation, operation), OperationResultTransformer.ORIGINAL_RESULT);
                        }
                    }
                    return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT);
                }
            };
            addOperationTransformers.add(addTransformer);

            // Additionally include undefine-attribute:name=batching
            OperationTransformer removeTransformer = new OperationTransformer() {
                @Override
                public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                    ModelNode undefineBatchingOperation = OperationFactory.createUndefineAttributeOperation(cacheAddress(address), CacheResourceDefinition.BATCHING.getName());
                    return new TransformedOperation(OperationFactory.createCompositeOperation(undefineBatchingOperation, operation), OperationResultTransformer.ORIGINAL_RESULT);
                }
            };
            removeOperationTransformers.add(removeTransformer);

            // If read-attribute:name=batching is true, return BATCH, otherwise use result from read-attribute:name=mode
            OperationTransformer readAttributeTransformer = new OperationTransformer() {
                @Override
                public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                    ModelNode readBatchingOperation = OperationFactory.createReadAttributeOperation(cacheAddress(address), CacheResourceDefinition.BATCHING.getName());
                    OperationResultTransformer resultTransformer = new OperationResultTransformer() {
                        @Override
                        public ModelNode transformResult(ModelNode result) {
                            ModelNode readBatchingResult = result.get(0);
                            return readBatchingResult.asBoolean() ? new ModelNode(TransactionMode.BATCH.name()) : result.get(1);
                        }
                    };
                    return new TransformedOperation(OperationFactory.createCompositeOperation(readBatchingOperation, operation), resultTransformer);
                }
            };
            readAttributeTransformers.put(MODE.getName(), readAttributeTransformer);

            // Convert BATCH -> NONE, and include write-attribute:name=batching
            OperationTransformer writeAttributeTransformer = new OperationTransformer() {
                @Override
                public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                    ModelNode mode = operation.hasDefined(ModelDescriptionConstants.VALUE) ? operation.get(ModelDescriptionConstants.VALUE) : null;
                    boolean batching = (mode != null) && (mode.getType() == ModelType.STRING) ? (TransactionMode.valueOf(mode.asString()) == TransactionMode.BATCH) : false;
                    if (batching) {
View Full Code Here
44
45
46
47
48
49
50
51
    }

    @Override
    public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
        String name = operation.get(ModelDescriptionConstants.NAME).asString();
        OperationTransformer transformer = this.transformers.get(name);
        return (transformer != null) ? transformer.transformOperation(context, address, operation) : new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT);
    }
View Full Code Here
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
        TransformationDescription.Tools.register(builder.build(), subsystemRegistration, ModelVersion.create(1, 2, 0));
    }

    private ResourceTransformationDescriptionBuilder registerModuleTransformer(final ResourceTransformationDescriptionBuilder parent, final PathElement childPath,
                                                                               final ModulesToAttributeTransformer transformer, final ChildResourceTransformersRegistrar childRegistrar) {
        final OperationTransformer addOrWriteTransformer = new OperationTransformer() {
            public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation)
                    throws OperationFailedException {
                return transformer.transformParentOperation(context, address, operation);
            }
        };

        ResourceTransformationDescriptionBuilder child = parent.addChildResource(childPath)
                .setCustomResourceTransformer(transformer)
                .addOperationTransformationOverride(ADD).setCustomOperationTransformer(addOrWriteTransformer).inheritResourceAttributeDefinitions().end()
                .addOperationTransformationOverride(WRITE_ATTRIBUTE_OPERATION).setCustomOperationTransformer(addOrWriteTransformer).inheritResourceAttributeDefinitions().end()
                .addOperationTransformationOverride(UNDEFINE_ATTRIBUTE_OPERATION).setCustomOperationTransformer(addOrWriteTransformer).inheritResourceAttributeDefinitions().end()
                .addOperationTransformationOverride(REMOVE)
                    .setCustomOperationTransformer(new OperationTransformer() {
                        public TransformedOperation transformOperation(TransformationContext context, PathAddress address,
                                ModelNode operation) throws OperationFailedException {
                            //Record that we removed the resource and return the original operation
                            return new TransformedOperation(operation, TransformedOperation.ORIGINAL_RESULT);
                        }
View Full Code Here
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
    private void registerTransformers_1_1_0(SubsystemRegistration registration) {

        final TransformersSubRegistration transformers = registration.registerModelTransformers(ModelVersion.create(1, 1, 0), ResourceTransformer.DEFAULT);

        TransformersSubRegistration connectors = transformers.registerSubResource(CONNECTOR_PATH);
        connectors.registerOperationTransformer(ADD, new OperationTransformer() {
            @Override
            public TransformedOperation transformOperation(final TransformationContext context, final PathAddress address, final ModelNode operation)
                    throws OperationFailedException {

                //Don't error on the way out, it might be ignored on the slave
                final boolean hasDefinedVirtualServer = operation.hasDefined(Constants.VIRTUAL_SERVER);
                return new TransformedOperation(operation, new OperationResultTransformer() {

                    @Override
                    public ModelNode transformResult(ModelNode result) {
                        if (!hasDefinedVirtualServer) {
                            return result;
                        }
                        if (result.get(OUTCOME).asString().equals(FAILED)) {
                            result.get(FAILURE_DESCRIPTION).set(WebMessages.MESSAGES.transformationVersion_1_1_0_JBPAPP_9314());
                        }
                        return result;
                    }
                });
            }
        });
        connectors.registerOperationTransformer(WRITE_ATTRIBUTE_OPERATION, new OperationTransformer() {

            @Override
            public TransformedOperation transformOperation(final TransformationContext context, final PathAddress address, final ModelNode operation)
                    throws OperationFailedException {
View Full Code Here
190
191
192
193
194
195
196
197
198
199
200
                node.get(NAME).set(CommonAttributes.SHOW_MODEL);
                node.get(VALUE).set(false);
                return node;
            }
        });
        resolved.registerOperationTransformer(READ_ATTRIBUTE_OPERATION, new OperationTransformer() {

            @Override
            public TransformedOperation transformOperation(final TransformationContext context, final PathAddress address, final ModelNode operation) {
                return new TransformedOperation(null, new OperationResultTransformer() {
                    @Override
View Full Code Here
70
71
72
73
74
75
76
77
78
79
80
                        }
                    }

                }, BOOT_TIME)
                .end()
            .addRawOperationTransformationOverride(UNDEFINE_ATTRIBUTE_OPERATION, new OperationTransformer() {
                @Override
                public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation)
                        throws OperationFailedException {
                    if (operation.get(NAME).asString().equals(BOOT_TIME)) {
                        ModelNode op = operation.clone();
View Full Code Here
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
                }
            }
        });

        TransformersSubRegistration jsfSubsystem = parent.registerSubResource(PathElement.pathElement(SUBSYSTEM, JSF_SUBSYSTEM));
        jsfSubsystem.registerOperationTransformer(ADD, new OperationTransformer() {

            @Override
            public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                if (operation.hasDefined(SLOT_ATTRIBUTE_NAME)) {
                    ModelNode slot = operation.get(SLOT_ATTRIBUTE_NAME);
                    if (!SLOT_DEFAULT_VALUE.equals(slot.asString())) {
                        return new TransformedOperation(operation,
                                new RejectionWithFailurePolicy(MESSAGES.invalidJSFSlotValue(slot.asString())),
                                OperationResultTransformer.ORIGINAL_RESULT);
                    }
                }
                Set<String> attributes = new HashSet<String>();
                for (Property prop : operation.asPropertyList()) {
                    attributes.add(prop.getName());
                }
                attributes.remove(SLOT_ATTRIBUTE_NAME);
                if (!attributes.isEmpty()) {
                    return new TransformedOperation(operation,
                            new RejectionWithFailurePolicy(MESSAGES.unknownAttributesFromSubsystemVersion(ADD,
                                    JSF_SUBSYSTEM,
                                    context.getTarget().getSubsystemVersion(JSF_SUBSYSTEM),
                                    attributes)),
                            OperationResultTransformer.ORIGINAL_RESULT);
                }
                return DISCARD.transformOperation(context, address, operation);
            }
        });

        jsfSubsystem.registerOperationTransformer(WRITE_ATTRIBUTE_OPERATION, new OperationTransformer() {
            @Override
            public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                final String name = operation.require(NAME).asString();
                final ModelNode value = operation.get(ModelDescriptionConstants.VALUE);
                if (SLOT_ATTRIBUTE_NAME.equals(name)) {
                    if (value.isDefined() && value.equals(SLOT_DEFAULT_VALUE)) {
                        return DISCARD.transformOperation(context, address, operation);
                    } else {
                        return new TransformedOperation(operation,
                                new RejectionWithFailurePolicy(MESSAGES.invalidJSFSlotValue(value.asString())),
                                OperationResultTransformer.ORIGINAL_RESULT);
                    }
                }
                // reject the operation for any other attribute
                return new TransformedOperation(operation,
                        new RejectionWithFailurePolicy(MESSAGES.unknownAttributesFromSubsystemVersion(ADD,
                                JSF_SUBSYSTEM,
                                context.getTarget().getSubsystemVersion(JSF_SUBSYSTEM),
                                Arrays.asList(name))),
                        OperationResultTransformer.ORIGINAL_RESULT);
            }
        });
        jsfSubsystem.registerOperationTransformer(UNDEFINE_ATTRIBUTE_OPERATION, new OperationTransformer() {
            @Override
            public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
                String attributeName = operation.require(NAME).asString();
                if (!SLOT_ATTRIBUTE_NAME.equals(attributeName)) {
                    return DEFAULT.transformOperation(context, address, operation);
View Full Code Here
TOP

Related Classes of org.jboss.as.controller.transform.OperationTransformer

  • org.jboss.as.clustering.controller.transform.AttributeOperationTransformer
  • org.jboss.as.clustering.infinispan.subsystem.TransactionResourceDefinition
  • org.jboss.as.configadmin.parser.ConfigAdminExtension
  • org.jboss.as.controller.transform.description.AbstractTransformationDescriptionBuilder
  • org.jboss.as.controller.transform.description.OperationTransformationOverrideBuilderImpl
  • org.jboss.as.core.model.test.MainKernelServicesImpl
  • org.jboss.as.domain.controller.transformers.JSFSubsystemTransformers
  • org.jboss.as.domain.controller.transformers.SystemPropertyTransformers
  • org.jboss.as.jmx.JMXExtension
  • org.jboss.as.messaging.MessagingTransformers
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.