2 * Copyright (c) 2017 Inocybe Technologies 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.controller.sal.core.compat;
10 import com.google.common.base.Optional;
11 import com.google.common.base.Preconditions;
12 import com.google.common.collect.ClassToInstanceMap;
13 import com.google.common.collect.ForwardingObject;
14 import com.google.common.collect.ImmutableClassToInstanceMap;
15 import com.google.common.collect.ImmutableClassToInstanceMap.Builder;
16 import com.google.common.util.concurrent.CheckedFuture;
17 import com.google.common.util.concurrent.FluentFuture;
18 import com.google.common.util.concurrent.FutureCallback;
19 import com.google.common.util.concurrent.Futures;
20 import com.google.common.util.concurrent.MoreExecutors;
21 import com.google.common.util.concurrent.SettableFuture;
23 import java.util.concurrent.atomic.AtomicReference;
24 import javax.annotation.Nonnull;
25 import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
26 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
27 import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableException;
28 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
29 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
30 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
31 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
32 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
33 import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
34 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
35 import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
36 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
37 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
38 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
39 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
40 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry;
41 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
42 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
43 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
44 import org.opendaylight.mdsal.common.api.CommitInfo;
45 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
46 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
47 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
48 import org.opendaylight.yangtools.concepts.ListenerRegistration;
49 import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
51 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
54 * Adapter between the legacy controller API-based DOMDataBroker and the mdsal API-based DOMDataBroker.
56 * @author Thomas Pantelis
58 public class LegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMDataBroker {
59 private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
60 new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
62 protected TransactionCommitFailedException newWithCause(String message, Throwable cause) {
63 if (cause instanceof org.opendaylight.mdsal.common.api.OptimisticLockFailedException) {
64 return new OptimisticLockFailedException(cause.getMessage(), cause.getCause());
65 } else if (cause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
66 Throwable rootCause = cause.getCause();
67 if (rootCause instanceof org.opendaylight.mdsal.common.api.DataStoreUnavailableException) {
68 rootCause = new DataStoreUnavailableException(rootCause.getMessage(), rootCause.getCause());
71 return new TransactionCommitFailedException(cause.getMessage(), rootCause);
74 return new TransactionCommitFailedException(message, cause);
78 private final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate;
79 private final ClassToInstanceMap<DOMDataBrokerExtension> extensions;
81 public LegacyDOMDataBrokerAdapter(org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
82 this.delegate = delegate;
84 ClassToInstanceMap<org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension> delegateExtensions =
85 delegate.getExtensions();
87 Builder<DOMDataBrokerExtension> extBuilder = ImmutableClassToInstanceMap.builder();
88 final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService delegateTreeChangeService =
89 (org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService) delegateExtensions.get(
90 org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService.class);
91 if (delegateTreeChangeService != null) {
92 extBuilder.put(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
94 public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(
95 DOMDataTreeIdentifier treeId, final L listener) {
96 final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener delegateListener;
97 if (listener instanceof ClusteredDOMDataTreeChangeListener) {
98 delegateListener = (org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener)
99 listener::onDataTreeChanged;
101 delegateListener = listener::onDataTreeChanged;
104 final ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> reg =
105 delegateTreeChangeService.registerDataTreeChangeListener(
106 new org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier(convert(treeId.getDatastoreType()),
107 treeId.getRootIdentifier()), delegateListener);
109 return new ListenerRegistration<L>() {
111 public L getInstance() {
116 public void close() {
124 final org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry delegateCohortRegistry =
125 (org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry) delegateExtensions.get(
126 org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry.class);
127 if (delegateCohortRegistry != null) {
128 extBuilder.put(DOMDataTreeCommitCohortRegistry.class, delegateCohortRegistry::registerCommitCohort);
131 extensions = extBuilder.build();
135 protected org.opendaylight.mdsal.dom.api.DOMDataBroker delegate() {
140 public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
145 public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
146 return new DOMDataReadOnlyTransactionAdapter(delegate().newReadOnlyTransaction());
150 public DOMDataReadWriteTransaction newReadWriteTransaction() {
151 return new DOMDataTransactionAdapter(delegate().newReadWriteTransaction());
155 public DOMDataWriteTransaction newWriteOnlyTransaction() {
156 return new DOMDataTransactionAdapter(delegate().newWriteOnlyTransaction());
160 public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
161 AtomicReference<DOMTransactionChain> legacyChain = new AtomicReference<>();
162 org.opendaylight.mdsal.common.api.TransactionChainListener delegateListener =
163 new org.opendaylight.mdsal.common.api.TransactionChainListener() {
164 @SuppressWarnings("rawtypes")
166 public void onTransactionChainFailed(final org.opendaylight.mdsal.common.api.TransactionChain<?, ?> chain,
167 final org.opendaylight.mdsal.common.api.AsyncTransaction<?, ?> transaction, final Throwable cause) {
168 listener.onTransactionChainFailed(legacyChain.get(),
169 (AsyncTransaction) () -> transaction.getIdentifier(),
170 cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
174 public void onTransactionChainSuccessful(org.opendaylight.mdsal.common.api.TransactionChain<?, ?> chain) {
175 listener.onTransactionChainSuccessful(legacyChain.get());
179 final org.opendaylight.mdsal.dom.api.DOMTransactionChain delegateChain =
180 delegate().createTransactionChain(delegateListener);
181 legacyChain.set(new DOMTransactionChain() {
183 public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
184 return new DOMDataReadOnlyTransactionAdapter(delegateChain.newReadOnlyTransaction());
188 public DOMDataReadWriteTransaction newReadWriteTransaction() {
189 return new DOMDataTransactionAdapter(delegateChain.newReadWriteTransaction());
193 public DOMDataWriteTransaction newWriteOnlyTransaction() {
194 return new DOMDataTransactionAdapter(delegateChain.newWriteOnlyTransaction());
198 public void close() {
199 delegateChain.close();
203 return legacyChain.get();
206 private static org.opendaylight.mdsal.common.api.LogicalDatastoreType convert(LogicalDatastoreType datastoreType) {
207 return org.opendaylight.mdsal.common.api.LogicalDatastoreType.valueOf(datastoreType.name());
210 private static class DOMDataTransactionAdapter implements DOMDataReadWriteTransaction {
211 private final DOMDataTreeReadTransaction readDelegate;
212 private final DOMDataTreeWriteTransaction writeDelegate;
213 private final Object identifier;
215 DOMDataTransactionAdapter(@Nonnull DOMDataTreeReadTransaction readDelegate) {
216 this.readDelegate = Preconditions.checkNotNull(readDelegate);
217 this.identifier = readDelegate.getIdentifier();
218 this.writeDelegate = null;
221 DOMDataTransactionAdapter(@Nonnull DOMDataTreeWriteTransaction writeDelegate) {
222 this.writeDelegate = Preconditions.checkNotNull(writeDelegate);
223 this.identifier = writeDelegate.getIdentifier();
224 this.readDelegate = null;
227 DOMDataTransactionAdapter(@Nonnull DOMDataTreeReadWriteTransaction rwDelegate) {
228 this.readDelegate = Preconditions.checkNotNull(rwDelegate);
229 this.writeDelegate = rwDelegate;
230 this.identifier = readDelegate.getIdentifier();
233 DOMDataTreeReadTransaction readDelegate() {
237 DOMDataTreeWriteTransaction writeDelegate() {
238 return writeDelegate;
242 public Object getIdentifier() {
247 public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
248 YangInstanceIdentifier path) {
249 return MappingCheckedFuture.create(readDelegate().read(convert(store), path).transformAsync(
250 optional -> Futures.immediateFuture(Optional.fromJavaUtil(optional)), MoreExecutors.directExecutor()),
251 ReadFailedExceptionAdapter.INSTANCE);
255 public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
256 YangInstanceIdentifier path) {
257 return MappingCheckedFuture.create(readDelegate().exists(convert(store), path),
258 ReadFailedExceptionAdapter.INSTANCE);
262 public void delete(LogicalDatastoreType store, YangInstanceIdentifier path) {
263 writeDelegate().delete(convert(store), path);
267 public void put(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
268 writeDelegate().put(convert(store), path, data);
272 public void merge(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data) {
273 writeDelegate().merge(convert(store), path, data);
277 public boolean cancel() {
278 return writeDelegate().cancel();
282 public FluentFuture<? extends CommitInfo> commit() {
283 final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
284 writeDelegate().commit().addCallback(new FutureCallback<CommitInfo>() {
286 public void onSuccess(CommitInfo result) {
287 resultFuture.set(result);
291 public void onFailure(Throwable ex) {
292 if (ex instanceof Exception) {
293 resultFuture.setException(COMMIT_EX_MAPPER.apply((Exception)ex));
295 resultFuture.setException(ex);
298 }, MoreExecutors.directExecutor());
304 private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
305 private final DOMDataTransactionAdapter adapter;
307 DOMDataReadOnlyTransactionAdapter(DOMDataTreeReadTransaction delegateTx) {
308 adapter = new DOMDataTransactionAdapter(delegateTx);
312 public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
313 YangInstanceIdentifier path) {
314 return adapter.read(store, path);
318 public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
319 YangInstanceIdentifier path) {
320 return adapter.exists(store, path);
324 public Object getIdentifier() {
325 return adapter.getIdentifier();
329 public void close() {
330 adapter.readDelegate().close();