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.base.Preconditions;
13 import com.google.common.cache.CacheBuilder;
14 import com.google.common.cache.CacheLoader;
15 import com.google.common.cache.LoadingCache;
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 = Preconditions.checkNotNull(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 public ContainerNode toNormalizedNodeNotification(final Notification data) {
127 // FIXME: Should the cast to DataObject be necessary?
128 return serializeDataObject((DataObject) data,
129 // javac does not like a methodhandle here
130 (iface, domWriter) -> newNotificationWriter(iface.asSubclass(Notification.class), domWriter));
134 public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
135 // FIXME: Should the cast to DataObject be necessary?
136 return serializeDataObject((DataObject) data, this::newRpcWriter);
140 public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
141 final RpcInput input) {
142 return serializeDataObject(input, (iface, domWriter) -> newActionInputWriter(action, domWriter));
146 public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
147 final RpcOutput output) {
148 return serializeDataObject(output, (iface, domWriter) -> newActionOutputWriter(action, domWriter));
152 public BindingLazyContainerNode<RpcInput> toLazyNormalizedNodeActionInput(
153 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcInput input) {
154 return new LazyActionInputContainerNode(identifier, input, this, action);
158 public BindingLazyContainerNode<RpcOutput> toLazyNormalizedNodeActionOutput(
159 final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcOutput output) {
160 return new LazyActionOutputContainerNode(identifier, output, this, action);
163 private <T extends DataContainer> ContainerNode serializeDataObject(final DataObject data,
164 final BiFunction<Class<? extends T>, NormalizedNodeStreamWriter, BindingStreamEventWriter> newWriter) {
165 final NormalizedNodeResult result = new NormalizedNodeResult();
166 // We create DOM stream writer which produces normalized nodes
167 final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
168 @SuppressWarnings("unchecked")
169 final Class<? extends DataObject> type = (Class<? extends DataObject>) data.getImplementedInterface();
170 final BindingStreamEventWriter writer = newWriter.apply((Class<T>)type, domWriter);
172 getSerializer(type).serialize(data, writer);
173 } catch (final IOException e) {
174 LOG.error("Unexpected failure while serializing data {}", data, e);
175 throw new IllegalStateException("Failed to create normalized node", e);
177 return (ContainerNode) result.getResult();
180 private static boolean isBindingRepresentable(final NormalizedNode<?, ?> data) {
181 if (data instanceof ChoiceNode) {
184 if (data instanceof LeafNode<?>) {
187 if (data instanceof LeafSetNode) {
190 if (data instanceof LeafSetEntryNode<?>) {
193 if (data instanceof MapNode) {
196 if (data instanceof UnkeyedListNode) {
204 public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
205 final NormalizedNode<?, ?> data) {
206 if (!isBindingRepresentable(data)) {
210 final List<PathArgument> builder = new ArrayList<>();
211 final NodeCodecContext<?> codec = codecContext.getCodecContextNode(path, builder);
214 LOG.warn("Path {} does not have a binding equivalent, should have been caught earlier ({})", path,
220 final DataObject lazyObj = codec.deserialize(data);
221 final InstanceIdentifier<?> bindingPath = InstanceIdentifier.create(builder);
222 return new SimpleEntry<>(bindingPath, lazyObj);
226 public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
227 final NotificationCodecContext<?> codec = codecContext.getNotificationContext(path);
228 return codec.deserialize(data);
232 public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
233 final RpcInputCodec<?> codec = codecContext.getRpcInputCodec(path);
234 return codec.deserialize(data);
238 public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
239 final ContainerNode input) {
240 return (T) requireNonNull(codecContext.getActionCodec(action).input().deserialize(requireNonNull(input)));
244 public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
245 final ContainerNode output) {
246 return (T) requireNonNull(codecContext.getActionCodec(action).output().deserialize(requireNonNull(output)));
250 public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
251 final InstanceIdentifier<?> path, final NormalizedNodeStreamWriter domWriter) {
252 return codecContext.newWriter(path, domWriter);
256 public BindingStreamEventWriter newWriter(final InstanceIdentifier<?> path,
257 final NormalizedNodeStreamWriter domWriter) {
258 return codecContext.newWriterWithoutIdentifier(path, domWriter);
262 public BindingStreamEventWriter newNotificationWriter(final Class<? extends Notification> notification,
263 final NormalizedNodeStreamWriter streamWriter) {
264 return codecContext.newNotificationWriter(notification, streamWriter);
268 public BindingStreamEventWriter newActionInputWriter(final Class<? extends Action<?, ?, ?>> action,
269 final NormalizedNodeStreamWriter domWriter) {
270 return codecContext.getActionCodec(action).input().createWriter(domWriter);
274 public BindingStreamEventWriter newActionOutputWriter(final Class<? extends Action<?, ?, ?>> action,
275 final NormalizedNodeStreamWriter domWriter) {
276 return codecContext.getActionCodec(action).output().createWriter(domWriter);
280 public BindingStreamEventWriter newRpcWriter(final Class<? extends DataContainer> rpcInputOrOutput,
281 final NormalizedNodeStreamWriter streamWriter) {
282 return codecContext.newRpcWriter(rpcInputOrOutput,streamWriter);
285 public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(
286 final InstanceIdentifier<T> path) {
287 final DataObjectCodecContext<?,?> ctx = (DataObjectCodecContext<?,?>) codecContext.getCodecContextNode(path,
289 return new DeserializeFunction<>(ctx);
293 public BindingCodecTree create(final BindingRuntimeContext context) {
294 return new BindingCodecContext(context, this);
298 @SuppressWarnings("checkstyle:illegalCatch")
299 public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
300 final ModuleInfoBackedContext strategy = ModuleInfoBackedContext.create();
301 for (final Class<?> bindingCls : bindingClasses) {
303 strategy.registerModuleInfo(BindingReflections.getModuleInfo(bindingCls));
304 } catch (final Exception e) {
305 throw new IllegalStateException(
306 "Could not create BindingRuntimeContext from class " + bindingCls.getName(), e);
309 final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(strategy, context);
310 return create(runtimeCtx);
314 private static final class DeserializeFunction<T> implements Function<Optional<NormalizedNode<?, ?>>, Optional<T>> {
315 private final DataObjectCodecContext<?,?> ctx;
317 DeserializeFunction(final DataObjectCodecContext<?,?> ctx) {
321 @SuppressWarnings("unchecked")
323 public Optional<T> apply(final Optional<NormalizedNode<?, ?>> input) {
324 return input.map(data -> (T) ctx.deserialize(data));
328 private final class GeneratorLoader extends CacheLoader<Class<? extends DataContainer>, DataObjectSerializer> {
330 public DataObjectSerializer load(final Class<? extends DataContainer> key) {
331 final DataObjectSerializerImplementation prototype = generator.getSerializer(key);
332 return new DataObjectSerializerProxy(prototype);
336 private final class DataObjectSerializerProxy
337 implements DataObjectSerializer, Delegator<DataObjectSerializerImplementation> {
338 private final DataObjectSerializerImplementation delegate;
340 DataObjectSerializerProxy(final DataObjectSerializerImplementation delegate) {
341 this.delegate = delegate;
345 public DataObjectSerializerImplementation getDelegate() {
350 public void serialize(final DataObject obj, final BindingStreamEventWriter stream) throws IOException {
351 delegate.serialize(BindingNormalizedNodeCodecRegistry.this, obj, stream);
356 private abstract static class AbstractLazyActionContainerNode<T extends DataObject>
357 extends AbstractBindingLazyContainerNode<T, BindingNormalizedNodeCodecRegistry> {
358 protected final Class<? extends Action<?, ?, ?>> action;
360 AbstractLazyActionContainerNode(final NodeIdentifier identifier, final T bindingData,
361 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
362 super(identifier, bindingData, context);
363 this.action = requireNonNull(action);
368 private static final class LazyActionInputContainerNode extends AbstractLazyActionContainerNode<RpcInput> {
369 LazyActionInputContainerNode(final NodeIdentifier identifier, final RpcInput bindingData,
370 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
371 super(identifier, bindingData, context, action);
375 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
376 return context.toNormalizedNodeActionInput(action, getDataObject());
381 private static final class LazyActionOutputContainerNode extends AbstractLazyActionContainerNode<RpcOutput> {
382 LazyActionOutputContainerNode(final NodeIdentifier identifier, final RpcOutput bindingData,
383 final BindingNormalizedNodeCodecRegistry context, final Class<? extends Action<?, ?, ?>> action) {
384 super(identifier, bindingData, context, action);
388 protected ContainerNode computeContainerNode(final BindingNormalizedNodeCodecRegistry context) {
389 return context.toNormalizedNodeActionOutput(action, getDataObject());