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 java.util.Objects.requireNonNull;
12 import com.google.common.cache.CacheBuilder;
13 import com.google.common.cache.CacheLoader;
14 import com.google.common.cache.LoadingCache;
15 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
16 import java.io.IOException;
17 import java.util.AbstractMap.SimpleEntry;
18 import java.util.ArrayList;
19 import java.util.List;
20 import java.util.Map.Entry;
21 import java.util.Optional;
22 import java.util.function.BiFunction;
23 import java.util.function.Function;
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.concepts.Delegator;
37 import org.opendaylight.yangtools.yang.binding.Action;
38 import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
39 import org.opendaylight.yangtools.yang.binding.DataContainer;
40 import org.opendaylight.yangtools.yang.binding.DataObject;
41 import org.opendaylight.yangtools.yang.binding.DataObjectSerializer;
42 import org.opendaylight.yangtools.yang.binding.DataObjectSerializerImplementation;
43 import org.opendaylight.yangtools.yang.binding.DataObjectSerializerRegistry;
44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
46 import org.opendaylight.yangtools.yang.binding.Notification;
47 import org.opendaylight.yangtools.yang.binding.RpcInput;
48 import org.opendaylight.yangtools.yang.binding.RpcOutput;
49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
51 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
58 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
59 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
60 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
61 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
62 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
63 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
64 import org.slf4j.Logger;
65 import org.slf4j.LoggerFactory;
67 public class BindingNormalizedNodeCodecRegistry implements DataObjectSerializerRegistry,
68 BindingCodecTreeFactory, BindingNormalizedNodeWriterFactory,
69 BindingNormalizedNodeSerializer {
70 private static final Logger LOG = LoggerFactory.getLogger(BindingNormalizedNodeCodecRegistry.class);
72 private final DataObjectSerializerGenerator generator;
73 private final LoadingCache<Class<? extends DataObject>, DataObjectSerializer> serializers;
74 private volatile BindingCodecContext codecContext;
76 public BindingNormalizedNodeCodecRegistry(final DataObjectSerializerGenerator generator) {
77 this.generator = requireNonNull(generator);
78 this.serializers = CacheBuilder.newBuilder().weakKeys().build(new GeneratorLoader());
82 public DataObjectSerializer getSerializer(final Class<? extends DataObject> type) {
83 return serializers.getUnchecked(type);
86 public BindingCodecTree getCodecContext() {
90 public void onBindingRuntimeContextUpdated(final BindingRuntimeContext context) {
91 codecContext = new BindingCodecContext(context, this);
92 generator.onBindingRuntimeContextUpdated(context);
96 public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
97 return codecContext.getInstanceIdentifierCodec().serialize(binding);
101 public InstanceIdentifier<?> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
102 return codecContext.getInstanceIdentifierCodec().deserialize(dom);
106 public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode(
107 final InstanceIdentifier<T> path, final T data) {
108 final NormalizedNodeResult result = new NormalizedNodeResult();
109 // We create DOM stream writer which produces normalized nodes
110 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
112 // We create Binding Stream Writer which translates from Binding to Normalized Nodes
113 final Entry<YangInstanceIdentifier, BindingStreamEventWriter> writeCtx = codecContext.newWriter(path,
116 // We get serializer which reads binding data and uses Binding To Normalized Node writer to write result
118 getSerializer(path.getTargetType()).serialize(data, writeCtx.getValue());
119 } catch (final IOException e) {
120 LOG.error("Unexpected failure while serializing path {} data {}", path, data, e);
121 throw new IllegalStateException("Failed to create normalized node", e);
123 return new SimpleEntry<>(writeCtx.getKey(),result.getResult());
127 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
128 public ContainerNode toNormalizedNodeNotification(final Notification data) {
129 // FIXME: Should the cast to DataObject be necessary?
130 return serializeDataObject((DataObject) data,
131 // javac does not like a methodhandle here
132 (iface, domWriter) -> newNotificationWriter(iface.asSubclass(Notification.class), domWriter));
136 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
137 public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
138 // FIXME: Should the cast to DataObject be necessary?
139 return serializeDataObject((DataObject) data, this::newRpcWriter);
143 public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
144 final RpcInput input) {
145 return serializeDataObject(input, (iface, domWriter) -> newActionInputWriter(action, domWriter));
149 public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
150 final RpcOutput output) {
151 return serializeDataObject(output, (iface, domWriter) -> newActionOutputWriter(action, domWriter));
155 public BindingLazyContainerNode<RpcInput> toLazyNormalizedNodeActionInput(
156 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcInput input) {
157 return new LazyActionInputContainerNode(identifier, input, this, action);
161 public BindingLazyContainerNode<RpcOutput> toLazyNormalizedNodeActionOutput(
162 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcOutput output) {
163 return new LazyActionOutputContainerNode(identifier, output, this, action);
166 private <T extends DataContainer> ContainerNode serializeDataObject(final DataObject data,
167 final BiFunction<Class<? extends T>, NormalizedNodeStreamWriter, BindingStreamEventWriter> newWriter) {
168 final NormalizedNodeResult result = new NormalizedNodeResult();
169 // We create DOM stream writer which produces normalized nodes
170 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
171 final Class<? extends DataObject> type = data.implementedInterface();
172 @SuppressWarnings("unchecked")
173 final BindingStreamEventWriter writer = newWriter.apply((Class<T>)type, domWriter);
175 getSerializer(type).serialize(data, writer);
176 } catch (final IOException e) {
177 LOG.error("Unexpected failure while serializing data {}", data, e);
178 throw new IllegalStateException("Failed to create normalized node", e);
180 return (ContainerNode) result.getResult();
183 private static boolean isBindingRepresentable(final NormalizedNode<?, ?> data) {
184 if (data instanceof ChoiceNode) {
187 if (data instanceof LeafNode<?>) {
190 if (data instanceof LeafSetNode) {
193 if (data instanceof LeafSetEntryNode<?>) {
196 if (data instanceof MapNode) {
199 if (data instanceof UnkeyedListNode) {
207 public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
208 final NormalizedNode<?, ?> data) {
209 if (!isBindingRepresentable(data)) {
213 final List<PathArgument> builder = new ArrayList<>();
214 final BindingDataObjectCodecTreeNode<?> codec = codecContext.getCodecContextNode(path, builder);
217 LOG.warn("Path {} does not have a binding equivalent, should have been caught earlier ({})", path,
223 final DataObject lazyObj = codec.deserialize(data);
224 final InstanceIdentifier<?> bindingPath = InstanceIdentifier.create(builder);
225 return new SimpleEntry<>(bindingPath, lazyObj);
229 public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
230 final NotificationCodecContext<?> codec = codecContext.getNotificationContext(path);
231 return codec.deserialize(data);
235 public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
236 final RpcInputCodec<?> codec = codecContext.getRpcInputCodec(path);
237 return codec.deserialize(data);
241 public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
242 final ContainerNode input) {
243 return (T) requireNonNull(codecContext.getActionCodec(action).input().deserialize(requireNonNull(input)));
247 public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
248 final ContainerNode output) {
249 return (T) requireNonNull(codecContext.getActionCodec(action).output().deserialize(requireNonNull(output)));
253 public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
254 final InstanceIdentifier<?> path, final NormalizedNodeStreamWriter domWriter) {
255 return codecContext.newWriter(path, domWriter);
259 public BindingStreamEventWriter newWriter(final InstanceIdentifier<?> path,
260 final NormalizedNodeStreamWriter domWriter) {
261 return codecContext.newWriterWithoutIdentifier(path, domWriter);
265 public BindingStreamEventWriter newNotificationWriter(final Class<? extends Notification> notification,
266 final NormalizedNodeStreamWriter streamWriter) {
267 return codecContext.newNotificationWriter(notification, streamWriter);
271 public BindingStreamEventWriter newActionInputWriter(final Class<? extends Action<?, ?, ?>> action,
272 final NormalizedNodeStreamWriter domWriter) {
273 return codecContext.getActionCodec(action).input().createWriter(domWriter);
277 public BindingStreamEventWriter newActionOutputWriter(final Class<? extends Action<?, ?, ?>> action,
278 final NormalizedNodeStreamWriter domWriter) {
279 return codecContext.getActionCodec(action).output().createWriter(domWriter);
283 public BindingStreamEventWriter newRpcWriter(final Class<? extends DataContainer> rpcInputOrOutput,
284 final NormalizedNodeStreamWriter streamWriter) {
285 return codecContext.newRpcWriter(rpcInputOrOutput,streamWriter);
288 public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(
289 final InstanceIdentifier<T> path) {
290 final DataObjectCodecContext<?,?> ctx = (DataObjectCodecContext<?,?>) codecContext.getCodecContextNode(path,
292 return new DeserializeFunction<>(ctx);
296 public BindingCodecTree create(final BindingRuntimeContext context) {
297 return new BindingCodecContext(context, this);
301 @SuppressWarnings("checkstyle:illegalCatch")
302 public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
303 final ModuleInfoBackedContext strategy = ModuleInfoBackedContext.create();
304 for (final Class<?> bindingCls : bindingClasses) {
306 strategy.registerModuleInfo(BindingReflections.getModuleInfo(bindingCls));
307 } catch (final Exception e) {
308 throw new IllegalStateException(
309 "Could not create BindingRuntimeContext from class " + bindingCls.getName(), e);
312 final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(strategy, context);
313 return create(runtimeCtx);
317 private static final class DeserializeFunction<T> implements Function<Optional<NormalizedNode<?, ?>>, Optional<T>> {
318 private final DataObjectCodecContext<?,?> ctx;
320 DeserializeFunction(final DataObjectCodecContext<?,?> ctx) {
324 @SuppressWarnings("unchecked")
326 public Optional<T> apply(final Optional<NormalizedNode<?, ?>> input) {
327 return input.map(data -> (T) ctx.deserialize(data));
331 private final class GeneratorLoader extends CacheLoader<Class<? extends DataContainer>, DataObjectSerializer> {
333 public DataObjectSerializer load(final Class<? extends DataContainer> key) {
334 final DataObjectSerializerImplementation prototype = generator.getSerializer(key);
335 return new DataObjectSerializerProxy(prototype);
339 private final class DataObjectSerializerProxy
340 implements DataObjectSerializer, Delegator<DataObjectSerializerImplementation> {
341 private final DataObjectSerializerImplementation delegate;
343 DataObjectSerializerProxy(final DataObjectSerializerImplementation delegate) {
344 this.delegate = delegate;
348 public DataObjectSerializerImplementation getDelegate() {
353 public void serialize(final DataObject obj, final BindingStreamEventWriter stream) throws IOException {
354 delegate.serialize(BindingNormalizedNodeCodecRegistry.this, obj, stream);
359 private abstract static class AbstractLazyActionContainerNode<T extends DataObject>
360 extends AbstractBindingLazyContainerNode<T, BindingNormalizedNodeCodecRegistry> {
361 protected final Class<? extends Action<?, ?, ?>> action;
363 AbstractLazyActionContainerNode(final NodeIdentifier identifier, final T bindingData,
364 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
365 super(identifier, bindingData, context);
366 this.action = requireNonNull(action);
371 private static final class LazyActionInputContainerNode extends AbstractLazyActionContainerNode<RpcInput> {
372 LazyActionInputContainerNode(final NodeIdentifier identifier, final RpcInput bindingData,
373 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
374 super(identifier, bindingData, context, action);
378 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
379 return context.toNormalizedNodeActionInput(action, getDataObject());
384 private static final class LazyActionOutputContainerNode extends AbstractLazyActionContainerNode<RpcOutput> {
385 LazyActionOutputContainerNode(final NodeIdentifier identifier, final RpcOutput bindingData,
386 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
387 super(identifier, bindingData, context, action);
391 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
392 return context.toNormalizedNodeActionOutput(action, getDataObject());