2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.mdsal.binding.dom.codec.impl;
10 import static com.google.common.base.Preconditions.checkState;
11 import static java.util.Objects.requireNonNull;
13 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
14 import java.io.IOException;
15 import java.util.AbstractMap.SimpleEntry;
16 import java.util.ArrayList;
17 import java.util.List;
18 import java.util.Map.Entry;
19 import java.util.Optional;
20 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
21 import java.util.function.BiFunction;
22 import java.util.function.Function;
23 import org.eclipse.jdt.annotation.NonNull;
24 import org.eclipse.jdt.annotation.NonNullByDefault;
25 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
26 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
27 import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
28 import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
29 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
30 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeWriterFactory;
31 import org.opendaylight.mdsal.binding.dom.codec.gen.impl.DataObjectSerializerGenerator;
32 import org.opendaylight.mdsal.binding.dom.codec.util.AbstractBindingLazyContainerNode;
33 import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
34 import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
35 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
36 import org.opendaylight.yangtools.yang.binding.Action;
37 import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
38 import org.opendaylight.yangtools.yang.binding.DataContainer;
39 import org.opendaylight.yangtools.yang.binding.DataObject;
40 import org.opendaylight.yangtools.yang.binding.DataObjectSerializer;
41 import org.opendaylight.yangtools.yang.binding.DataObjectSerializerRegistry;
42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
44 import org.opendaylight.yangtools.yang.binding.Notification;
45 import org.opendaylight.yangtools.yang.binding.RpcInput;
46 import org.opendaylight.yangtools.yang.binding.RpcOutput;
47 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
49 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
50 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
51 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
58 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
59 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
60 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
61 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
62 import org.slf4j.Logger;
63 import org.slf4j.LoggerFactory;
65 public class BindingNormalizedNodeCodecRegistry implements DataObjectSerializerRegistry,
66 BindingCodecTreeFactory, BindingNormalizedNodeWriterFactory, BindingNormalizedNodeSerializer {
67 private static final Logger LOG = LoggerFactory.getLogger(BindingNormalizedNodeCodecRegistry.class);
69 private final DataObjectSerializerGenerator generator;
71 private static final AtomicReferenceFieldUpdater<BindingNormalizedNodeCodecRegistry, BindingCodecContext> UPDATER =
72 AtomicReferenceFieldUpdater.newUpdater(BindingNormalizedNodeCodecRegistry.class, BindingCodecContext.class,
74 private volatile BindingCodecContext codecContext;
76 public BindingNormalizedNodeCodecRegistry() {
77 this.generator = null;
80 public BindingNormalizedNodeCodecRegistry(final BindingRuntimeContext codecContext) {
82 onBindingRuntimeContextUpdated(codecContext);
86 public BindingNormalizedNodeCodecRegistry(final DataObjectSerializerGenerator generator) {
87 this.generator = requireNonNull(generator);
91 public DataObjectSerializer getSerializer(final Class<? extends DataObject> type) {
92 return codecContext().getSerializer(type);
95 public BindingCodecTree getCodecContext() {
99 public void onBindingRuntimeContextUpdated(final BindingRuntimeContext context) {
100 // BindingCodecContext is a costly resource. Let us not ditch it unless we have to
101 final BindingCodecContext current = codecContext;
102 if (current != null && context.equals(current.getRuntimeContext())) {
103 LOG.debug("Skipping update of runtime context {}", context);
107 final BindingCodecContext updated = new BindingCodecContext(context, this);
108 if (UPDATER.compareAndSet(this, current, updated)) {
109 if (generator != null) {
110 generator.onBindingRuntimeContextUpdated(context);
113 LOG.warn("Concurrent update of runtime context (expected={} current={}) detected at ", current,
114 codecContext, new Throwable());
118 final @NonNull BindingCodecContext codecContext() {
119 final BindingCodecContext local = codecContext;
120 checkState(local != null, "No context available yet");
125 public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
126 return codecContext.getInstanceIdentifierCodec().serialize(binding);
130 public InstanceIdentifier<?> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
131 return codecContext.getInstanceIdentifierCodec().deserialize(dom);
135 public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode(
136 final InstanceIdentifier<T> path, final T data) {
137 final NormalizedNodeResult result = new NormalizedNodeResult();
138 // We create DOM stream writer which produces normalized nodes
139 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
141 // We create Binding Stream Writer which translates from Binding to Normalized Nodes
142 final Entry<YangInstanceIdentifier, BindingStreamEventWriter> writeCtx = codecContext.newWriter(path,
145 // We get serializer which reads binding data and uses Binding To Normalized Node writer to write result
147 getSerializer(path.getTargetType()).serialize(data, writeCtx.getValue());
148 } catch (final IOException e) {
149 LOG.error("Unexpected failure while serializing path {} data {}", path, data, e);
150 throw new IllegalStateException("Failed to create normalized node", e);
152 return new SimpleEntry<>(writeCtx.getKey(),result.getResult());
156 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
157 public ContainerNode toNormalizedNodeNotification(final Notification data) {
158 // FIXME: Should the cast to DataObject be necessary?
159 return serializeDataObject((DataObject) data,
160 // javac does not like a methodhandle here
161 (iface, domWriter) -> newNotificationWriter(iface.asSubclass(Notification.class), domWriter));
165 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
166 public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
167 // FIXME: Should the cast to DataObject be necessary?
168 return serializeDataObject((DataObject) data, this::newRpcWriter);
172 public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
173 final RpcInput input) {
174 return serializeDataObject(input, (iface, domWriter) -> newActionInputWriter(action, domWriter));
178 public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
179 final RpcOutput output) {
180 return serializeDataObject(output, (iface, domWriter) -> newActionOutputWriter(action, domWriter));
184 public BindingLazyContainerNode<RpcInput> toLazyNormalizedNodeActionInput(
185 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcInput input) {
186 return new LazyActionInputContainerNode(identifier, input, this, action);
190 public BindingLazyContainerNode<RpcOutput> toLazyNormalizedNodeActionOutput(
191 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcOutput output) {
192 return new LazyActionOutputContainerNode(identifier, output, this, action);
195 private <T extends DataContainer> ContainerNode serializeDataObject(final DataObject data,
196 final BiFunction<Class<? extends T>, NormalizedNodeStreamWriter, BindingStreamEventWriter> newWriter) {
197 final NormalizedNodeResult result = new NormalizedNodeResult();
198 // We create DOM stream writer which produces normalized nodes
199 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
200 final Class<? extends DataObject> type = data.implementedInterface();
201 @SuppressWarnings("unchecked")
202 final BindingStreamEventWriter writer = newWriter.apply((Class<T>)type, domWriter);
204 getSerializer(type).serialize(data, writer);
205 } catch (final IOException e) {
206 LOG.error("Unexpected failure while serializing data {}", data, e);
207 throw new IllegalStateException("Failed to create normalized node", e);
209 return (ContainerNode) result.getResult();
212 private static boolean isBindingRepresentable(final NormalizedNode<?, ?> data) {
213 if (data instanceof ChoiceNode) {
216 if (data instanceof LeafNode<?>) {
219 if (data instanceof LeafSetNode) {
222 if (data instanceof LeafSetEntryNode<?>) {
225 if (data instanceof MapNode) {
228 if (data instanceof UnkeyedListNode) {
236 public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
237 final NormalizedNode<?, ?> data) {
238 if (!isBindingRepresentable(data)) {
242 final List<PathArgument> builder = new ArrayList<>();
243 final BindingDataObjectCodecTreeNode<?> codec = codecContext.getCodecContextNode(path, builder);
246 LOG.warn("Path {} does not have a binding equivalent, should have been caught earlier ({})", path,
252 final DataObject lazyObj = codec.deserialize(data);
253 final InstanceIdentifier<?> bindingPath = InstanceIdentifier.create(builder);
254 return new SimpleEntry<>(bindingPath, lazyObj);
258 public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
259 final NotificationCodecContext<?> codec = codecContext.getNotificationContext(path);
260 return codec.deserialize(data);
264 public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
265 final RpcInputCodec<?> codec = codecContext.getRpcInputCodec(path);
266 return codec.deserialize(data);
270 public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
271 final ContainerNode input) {
272 return (T) requireNonNull(codecContext.getActionCodec(action).input().deserialize(requireNonNull(input)));
276 public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
277 final ContainerNode output) {
278 return (T) requireNonNull(codecContext.getActionCodec(action).output().deserialize(requireNonNull(output)));
282 public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
283 final InstanceIdentifier<?> path, final NormalizedNodeStreamWriter domWriter) {
284 return codecContext.newWriter(path, domWriter);
288 public BindingStreamEventWriter newWriter(final InstanceIdentifier<?> path,
289 final NormalizedNodeStreamWriter domWriter) {
290 return codecContext.newWriterWithoutIdentifier(path, domWriter);
294 public BindingStreamEventWriter newNotificationWriter(final Class<? extends Notification> notification,
295 final NormalizedNodeStreamWriter streamWriter) {
296 return codecContext.newNotificationWriter(notification, streamWriter);
300 public BindingStreamEventWriter newActionInputWriter(final Class<? extends Action<?, ?, ?>> action,
301 final NormalizedNodeStreamWriter domWriter) {
302 return codecContext.getActionCodec(action).input().createWriter(domWriter);
306 public BindingStreamEventWriter newActionOutputWriter(final Class<? extends Action<?, ?, ?>> action,
307 final NormalizedNodeStreamWriter domWriter) {
308 return codecContext.getActionCodec(action).output().createWriter(domWriter);
312 public BindingStreamEventWriter newRpcWriter(final Class<? extends DataContainer> rpcInputOrOutput,
313 final NormalizedNodeStreamWriter streamWriter) {
314 return codecContext.newRpcWriter(rpcInputOrOutput,streamWriter);
317 public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(
318 final InstanceIdentifier<T> path) {
319 final DataObjectCodecContext<?,?> ctx = (DataObjectCodecContext<?,?>) codecContext.getCodecContextNode(path,
321 return new DeserializeFunction<>(ctx);
325 public BindingCodecTree create(final BindingRuntimeContext context) {
326 return new BindingCodecContext(context, this);
330 @SuppressWarnings("checkstyle:illegalCatch")
331 public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
332 final ModuleInfoBackedContext strategy = ModuleInfoBackedContext.create();
333 for (final Class<?> bindingCls : bindingClasses) {
335 strategy.registerModuleInfo(BindingReflections.getModuleInfo(bindingCls));
336 } catch (final Exception e) {
337 throw new IllegalStateException(
338 "Could not create BindingRuntimeContext from class " + bindingCls.getName(), e);
341 final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(strategy, context);
342 return create(runtimeCtx);
346 private static final class DeserializeFunction<T> implements Function<Optional<NormalizedNode<?, ?>>, Optional<T>> {
347 private final DataObjectCodecContext<?,?> ctx;
349 DeserializeFunction(final DataObjectCodecContext<?,?> ctx) {
353 @SuppressWarnings("unchecked")
355 public Optional<T> apply(final Optional<NormalizedNode<?, ?>> input) {
356 return input.map(data -> (T) ctx.deserialize(data));
361 private abstract static class AbstractLazyActionContainerNode<T extends DataObject>
362 extends AbstractBindingLazyContainerNode<T, BindingNormalizedNodeCodecRegistry> {
363 protected final Class<? extends Action<?, ?, ?>> action;
365 AbstractLazyActionContainerNode(final NodeIdentifier identifier, final T bindingData,
366 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
367 super(identifier, bindingData, context);
368 this.action = requireNonNull(action);
373 private static final class LazyActionInputContainerNode extends AbstractLazyActionContainerNode<RpcInput> {
374 LazyActionInputContainerNode(final NodeIdentifier identifier, final RpcInput bindingData,
375 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
376 super(identifier, bindingData, context, action);
380 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
381 return context.toNormalizedNodeActionInput(action, getDataObject());
386 private static final class LazyActionOutputContainerNode extends AbstractLazyActionContainerNode<RpcOutput> {
387 LazyActionOutputContainerNode(final NodeIdentifier identifier, final RpcOutput bindingData,
388 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
389 super(identifier, bindingData, context, action);
393 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
394 return context.toNormalizedNodeActionOutput(action, getDataObject());