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.BindingLazyContainerNode;
28 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
29 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeWriterFactory;
30 import org.opendaylight.mdsal.binding.dom.codec.gen.impl.DataObjectSerializerGenerator;
31 import org.opendaylight.mdsal.binding.dom.codec.util.AbstractBindingLazyContainerNode;
32 import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
33 import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
34 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
35 import org.opendaylight.yangtools.concepts.Delegator;
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.DataObjectSerializerImplementation;
42 import org.opendaylight.yangtools.yang.binding.DataObjectSerializerRegistry;
43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
45 import org.opendaylight.yangtools.yang.binding.Notification;
46 import org.opendaylight.yangtools.yang.binding.RpcInput;
47 import org.opendaylight.yangtools.yang.binding.RpcOutput;
48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
50 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
51 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
52 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
58 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
59 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
60 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
61 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
62 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
63 import org.slf4j.Logger;
64 import org.slf4j.LoggerFactory;
66 public class BindingNormalizedNodeCodecRegistry implements DataObjectSerializerRegistry,
67 BindingCodecTreeFactory, BindingNormalizedNodeWriterFactory,
68 BindingNormalizedNodeSerializer {
69 private static final Logger LOG = LoggerFactory.getLogger(BindingNormalizedNodeCodecRegistry.class);
71 private final DataObjectSerializerGenerator generator;
72 private final LoadingCache<Class<? extends DataObject>, DataObjectSerializer> serializers;
73 private volatile BindingCodecContext codecContext;
75 public BindingNormalizedNodeCodecRegistry(final DataObjectSerializerGenerator generator) {
76 this.generator = requireNonNull(generator);
77 this.serializers = CacheBuilder.newBuilder().weakKeys().build(new GeneratorLoader());
81 public DataObjectSerializer getSerializer(final Class<? extends DataObject> type) {
82 return serializers.getUnchecked(type);
85 public BindingCodecTree getCodecContext() {
89 public void onBindingRuntimeContextUpdated(final BindingRuntimeContext context) {
90 codecContext = new BindingCodecContext(context, this);
91 generator.onBindingRuntimeContextUpdated(context);
95 public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
96 return codecContext.getInstanceIdentifierCodec().serialize(binding);
100 public InstanceIdentifier<?> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
101 return codecContext.getInstanceIdentifierCodec().deserialize(dom);
105 public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode(
106 final InstanceIdentifier<T> path, final T data) {
107 final NormalizedNodeResult result = new NormalizedNodeResult();
108 // We create DOM stream writer which produces normalized nodes
109 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
111 // We create Binding Stream Writer which translates from Binding to Normalized Nodes
112 final Entry<YangInstanceIdentifier, BindingStreamEventWriter> writeCtx = codecContext.newWriter(path,
115 // We get serializer which reads binding data and uses Binding To Normalized Node writer to write result
117 getSerializer(path.getTargetType()).serialize(data, writeCtx.getValue());
118 } catch (final IOException e) {
119 LOG.error("Unexpected failure while serializing path {} data {}", path, data, e);
120 throw new IllegalStateException("Failed to create normalized node", e);
122 return new SimpleEntry<>(writeCtx.getKey(),result.getResult());
126 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
127 public ContainerNode toNormalizedNodeNotification(final Notification data) {
128 // FIXME: Should the cast to DataObject be necessary?
129 return serializeDataObject((DataObject) data,
130 // javac does not like a methodhandle here
131 (iface, domWriter) -> newNotificationWriter(iface.asSubclass(Notification.class), domWriter));
135 public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
136 // FIXME: Should the cast to DataObject be necessary?
137 return serializeDataObject((DataObject) data, this::newRpcWriter);
141 public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
142 final RpcInput input) {
143 return serializeDataObject(input, (iface, domWriter) -> newActionInputWriter(action, domWriter));
147 public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
148 final RpcOutput output) {
149 return serializeDataObject(output, (iface, domWriter) -> newActionOutputWriter(action, domWriter));
153 public BindingLazyContainerNode<RpcInput> toLazyNormalizedNodeActionInput(
154 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcInput input) {
155 return new LazyActionInputContainerNode(identifier, input, this, action);
159 public BindingLazyContainerNode<RpcOutput> toLazyNormalizedNodeActionOutput(
160 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcOutput output) {
161 return new LazyActionOutputContainerNode(identifier, output, this, action);
164 private <T extends DataContainer> ContainerNode serializeDataObject(final DataObject data,
165 final BiFunction<Class<? extends T>, NormalizedNodeStreamWriter, BindingStreamEventWriter> newWriter) {
166 final NormalizedNodeResult result = new NormalizedNodeResult();
167 // We create DOM stream writer which produces normalized nodes
168 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
169 @SuppressWarnings("unchecked")
170 final Class<? extends DataObject> type = (Class<? extends DataObject>) data.getImplementedInterface();
171 final BindingStreamEventWriter writer = newWriter.apply((Class<T>)type, domWriter);
173 getSerializer(type).serialize(data, writer);
174 } catch (final IOException e) {
175 LOG.error("Unexpected failure while serializing data {}", data, e);
176 throw new IllegalStateException("Failed to create normalized node", e);
178 return (ContainerNode) result.getResult();
181 private static boolean isBindingRepresentable(final NormalizedNode<?, ?> data) {
182 if (data instanceof ChoiceNode) {
185 if (data instanceof LeafNode<?>) {
188 if (data instanceof LeafSetNode) {
191 if (data instanceof LeafSetEntryNode<?>) {
194 if (data instanceof MapNode) {
197 if (data instanceof UnkeyedListNode) {
205 public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
206 final NormalizedNode<?, ?> data) {
207 if (!isBindingRepresentable(data)) {
211 final List<PathArgument> builder = new ArrayList<>();
212 final NodeCodecContext<?> codec = codecContext.getCodecContextNode(path, builder);
215 LOG.warn("Path {} does not have a binding equivalent, should have been caught earlier ({})", path,
221 final DataObject lazyObj = codec.deserialize(data);
222 final InstanceIdentifier<?> bindingPath = InstanceIdentifier.create(builder);
223 return new SimpleEntry<>(bindingPath, lazyObj);
227 public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
228 final NotificationCodecContext<?> codec = codecContext.getNotificationContext(path);
229 return codec.deserialize(data);
233 public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
234 final RpcInputCodec<?> codec = codecContext.getRpcInputCodec(path);
235 return codec.deserialize(data);
239 public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
240 final ContainerNode input) {
241 return (T) requireNonNull(codecContext.getActionCodec(action).input().deserialize(requireNonNull(input)));
245 public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
246 final ContainerNode output) {
247 return (T) requireNonNull(codecContext.getActionCodec(action).output().deserialize(requireNonNull(output)));
251 public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
252 final InstanceIdentifier<?> path, final NormalizedNodeStreamWriter domWriter) {
253 return codecContext.newWriter(path, domWriter);
257 public BindingStreamEventWriter newWriter(final InstanceIdentifier<?> path,
258 final NormalizedNodeStreamWriter domWriter) {
259 return codecContext.newWriterWithoutIdentifier(path, domWriter);
263 public BindingStreamEventWriter newNotificationWriter(final Class<? extends Notification> notification,
264 final NormalizedNodeStreamWriter streamWriter) {
265 return codecContext.newNotificationWriter(notification, streamWriter);
269 public BindingStreamEventWriter newActionInputWriter(final Class<? extends Action<?, ?, ?>> action,
270 final NormalizedNodeStreamWriter domWriter) {
271 return codecContext.getActionCodec(action).input().createWriter(domWriter);
275 public BindingStreamEventWriter newActionOutputWriter(final Class<? extends Action<?, ?, ?>> action,
276 final NormalizedNodeStreamWriter domWriter) {
277 return codecContext.getActionCodec(action).output().createWriter(domWriter);
281 public BindingStreamEventWriter newRpcWriter(final Class<? extends DataContainer> rpcInputOrOutput,
282 final NormalizedNodeStreamWriter streamWriter) {
283 return codecContext.newRpcWriter(rpcInputOrOutput,streamWriter);
286 public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(
287 final InstanceIdentifier<T> path) {
288 final DataObjectCodecContext<?,?> ctx = (DataObjectCodecContext<?,?>) codecContext.getCodecContextNode(path,
290 return new DeserializeFunction<>(ctx);
294 public BindingCodecTree create(final BindingRuntimeContext context) {
295 return new BindingCodecContext(context, this);
299 @SuppressWarnings("checkstyle:illegalCatch")
300 public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
301 final ModuleInfoBackedContext strategy = ModuleInfoBackedContext.create();
302 for (final Class<?> bindingCls : bindingClasses) {
304 strategy.registerModuleInfo(BindingReflections.getModuleInfo(bindingCls));
305 } catch (final Exception e) {
306 throw new IllegalStateException(
307 "Could not create BindingRuntimeContext from class " + bindingCls.getName(), e);
310 final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(strategy, context);
311 return create(runtimeCtx);
315 private static final class DeserializeFunction<T> implements Function<Optional<NormalizedNode<?, ?>>, Optional<T>> {
316 private final DataObjectCodecContext<?,?> ctx;
318 DeserializeFunction(final DataObjectCodecContext<?,?> ctx) {
322 @SuppressWarnings("unchecked")
324 public Optional<T> apply(final Optional<NormalizedNode<?, ?>> input) {
325 return input.map(data -> (T) ctx.deserialize(data));
329 private final class GeneratorLoader extends CacheLoader<Class<? extends DataContainer>, DataObjectSerializer> {
331 public DataObjectSerializer load(final Class<? extends DataContainer> key) {
332 final DataObjectSerializerImplementation prototype = generator.getSerializer(key);
333 return new DataObjectSerializerProxy(prototype);
337 private final class DataObjectSerializerProxy
338 implements DataObjectSerializer, Delegator<DataObjectSerializerImplementation> {
339 private final DataObjectSerializerImplementation delegate;
341 DataObjectSerializerProxy(final DataObjectSerializerImplementation delegate) {
342 this.delegate = delegate;
346 public DataObjectSerializerImplementation getDelegate() {
351 public void serialize(final DataObject obj, final BindingStreamEventWriter stream) throws IOException {
352 delegate.serialize(BindingNormalizedNodeCodecRegistry.this, obj, stream);
357 private abstract static class AbstractLazyActionContainerNode<T extends DataObject>
358 extends AbstractBindingLazyContainerNode<T, BindingNormalizedNodeCodecRegistry> {
359 protected final Class<? extends Action<?, ?, ?>> action;
361 AbstractLazyActionContainerNode(final NodeIdentifier identifier, final T bindingData,
362 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
363 super(identifier, bindingData, context);
364 this.action = requireNonNull(action);
369 private static final class LazyActionInputContainerNode extends AbstractLazyActionContainerNode<RpcInput> {
370 LazyActionInputContainerNode(final NodeIdentifier identifier, final RpcInput bindingData,
371 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
372 super(identifier, bindingData, context, action);
376 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
377 return context.toNormalizedNodeActionInput(action, getDataObject());
382 private static final class LazyActionOutputContainerNode extends AbstractLazyActionContainerNode<RpcOutput> {
383 LazyActionOutputContainerNode(final NodeIdentifier identifier, final RpcOutput bindingData,
384 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
385 super(identifier, bindingData, context, action);
389 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
390 return context.toNormalizedNodeActionOutput(action, getDataObject());