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 static java.util.Objects.requireNonNull;
12 import com.google.common.base.Optional;
13 import com.google.common.collect.ClassToInstanceMap;
14 import com.google.common.collect.ForwardingObject;
15 import com.google.common.collect.ImmutableClassToInstanceMap;
16 import com.google.common.collect.ImmutableClassToInstanceMap.Builder;
17 import com.google.common.util.concurrent.CheckedFuture;
18 import com.google.common.util.concurrent.FluentFuture;
19 import com.google.common.util.concurrent.FutureCallback;
20 import com.google.common.util.concurrent.MoreExecutors;
21 import com.google.common.util.concurrent.SettableFuture;
22 import java.util.Collection;
24 import java.util.concurrent.atomic.AtomicReference;
25 import java.util.function.Supplier;
26 import org.eclipse.jdt.annotation.NonNull;
27 import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
28 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
29 import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableException;
30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
31 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
32 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
33 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
34 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
35 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
36 import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
37 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
38 import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
39 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
40 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
41 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
42 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
43 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry;
44 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
45 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
46 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
47 import org.opendaylight.mdsal.common.api.CommitInfo;
48 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadOperations;
49 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
50 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
51 import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
52 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
53 import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
54 import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
55 import org.opendaylight.yangtools.concepts.ListenerRegistration;
56 import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
57 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
58 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
59 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
62 * Adapter between the legacy controller API-based DOMDataBroker and the mdsal API-based DOMDataBroker.
64 * @author Thomas Pantelis
66 @Deprecated(forRemoval = true)
67 public abstract class AbstractLegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMDataBroker {
68 private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
69 new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
71 protected TransactionCommitFailedException newWithCause(final String message, final Throwable cause) {
72 if (cause instanceof org.opendaylight.mdsal.common.api.OptimisticLockFailedException) {
73 return new OptimisticLockFailedException(cause.getMessage(), cause.getCause());
74 } else if (cause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
75 Throwable rootCause = cause.getCause();
76 if (rootCause instanceof org.opendaylight.mdsal.common.api.DataStoreUnavailableException) {
77 rootCause = new DataStoreUnavailableException(rootCause.getMessage(), rootCause.getCause());
80 return new TransactionCommitFailedException(cause.getMessage(), rootCause);
83 return new TransactionCommitFailedException(message, cause);
87 private final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate;
88 private final ClassToInstanceMap<DOMDataBrokerExtension> extensions;
90 public AbstractLegacyDOMDataBrokerAdapter(final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
91 this.delegate = delegate;
93 ClassToInstanceMap<org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension> delegateExtensions =
94 delegate.getExtensions();
96 Builder<DOMDataBrokerExtension> extBuilder = ImmutableClassToInstanceMap.builder();
97 final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService delegateTreeChangeService =
98 (org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService) delegateExtensions.get(
99 org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService.class);
100 if (delegateTreeChangeService != null) {
101 extBuilder.put(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
103 public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(
104 final DOMDataTreeIdentifier treeId, final L listener) {
105 final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener delegateListener;
106 if (listener instanceof ClusteredDOMDataTreeChangeListener) {
107 delegateListener = new ClusteredProxyListener(listener);
109 delegateListener = new ProxyListener(listener);
112 final ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> reg =
113 delegateTreeChangeService.registerDataTreeChangeListener(treeId.toMdsal(), delegateListener);
115 return new ListenerRegistration<L>() {
117 public L getInstance() {
122 public void close() {
130 final org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry delegateCohortRegistry =
131 (org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry) delegateExtensions.get(
132 org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry.class);
133 if (delegateCohortRegistry != null) {
134 extBuilder.put(DOMDataTreeCommitCohortRegistry.class, delegateCohortRegistry::registerCommitCohort);
137 extensions = extBuilder.build();
141 protected org.opendaylight.mdsal.dom.api.DOMDataBroker delegate() {
146 public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
151 public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
152 return new DOMDataReadOnlyTransactionAdapter(delegate().newReadOnlyTransaction());
156 public DOMDataReadWriteTransaction newReadWriteTransaction() {
157 return new DOMDataTransactionAdapter(delegate().newReadWriteTransaction());
161 public DOMDataWriteTransaction newWriteOnlyTransaction() {
162 return new DOMDataTransactionAdapter(delegate().newWriteOnlyTransaction());
166 public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
167 AtomicReference<DOMTransactionChain> legacyChain = new AtomicReference<>();
168 DOMTransactionChainListener delegateListener =
169 new DOMTransactionChainListener() {
171 @SuppressWarnings("rawtypes")
172 public void onTransactionChainFailed(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain,
173 final DOMDataTreeTransaction transaction, final Throwable cause) {
174 listener.onTransactionChainFailed(legacyChain.get(),
175 (AsyncTransaction) () -> transaction.getIdentifier(),
176 cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
180 public void onTransactionChainSuccessful(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain) {
181 listener.onTransactionChainSuccessful(legacyChain.get());
185 final org.opendaylight.mdsal.dom.api.DOMTransactionChain delegateChain =
186 delegate().createTransactionChain(delegateListener);
187 legacyChain.set(new DOMTransactionChain() {
189 public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
190 return new DOMDataReadOnlyTransactionAdapter(wrapException(delegateChain::newReadOnlyTransaction));
194 public DOMDataReadWriteTransaction newReadWriteTransaction() {
195 return new DOMDataTransactionAdapter(wrapException(delegateChain::newReadWriteTransaction));
199 public DOMDataWriteTransaction newWriteOnlyTransaction() {
200 return new DOMDataTransactionAdapter(wrapException(delegateChain::newWriteOnlyTransaction));
204 public void close() {
205 delegateChain.close();
209 return legacyChain.get();
212 abstract org.opendaylight.mdsal.dom.api.DOMTransactionChain createDelegateChain(
213 DOMTransactionChainListener listener);
215 static <T> T wrapException(final Supplier<T> supplier) {
217 return supplier.get();
218 } catch (DOMTransactionChainClosedException e) {
219 throw new TransactionChainClosedException("Transaction chain already closed", e);
223 private static class DOMDataTransactionAdapter implements DOMDataReadWriteTransaction {
224 private final DOMDataTreeReadOperations readDelegate;
225 private final DOMDataTreeWriteTransaction writeDelegate;
226 private final Object identifier;
228 DOMDataTransactionAdapter(final @NonNull DOMDataTreeReadOperations readDelegate, final Object identifier) {
229 this.readDelegate = requireNonNull(readDelegate);
230 this.identifier = requireNonNull(identifier);
231 this.writeDelegate = null;
234 DOMDataTransactionAdapter(final @NonNull DOMDataTreeWriteTransaction writeDelegate) {
235 this.writeDelegate = requireNonNull(writeDelegate);
236 this.identifier = writeDelegate.getIdentifier();
237 this.readDelegate = null;
240 DOMDataTransactionAdapter(final @NonNull DOMDataTreeReadWriteTransaction rwDelegate) {
241 this.readDelegate = requireNonNull(rwDelegate);
242 this.writeDelegate = rwDelegate;
243 this.identifier = rwDelegate.getIdentifier();
246 DOMDataTreeReadOperations readDelegate() {
250 DOMDataTreeWriteTransaction writeDelegate() {
251 return writeDelegate;
255 public Object getIdentifier() {
260 public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
261 final YangInstanceIdentifier path) {
262 return MappingCheckedFuture.create(readDelegate().read(store.toMdsal(), path).transform(
263 Optional::fromJavaUtil, MoreExecutors.directExecutor()), ReadFailedExceptionAdapter.INSTANCE);
267 public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
268 final YangInstanceIdentifier path) {
269 return MappingCheckedFuture.create(readDelegate().exists(store.toMdsal(), path),
270 ReadFailedExceptionAdapter.INSTANCE);
274 public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
275 writeDelegate().delete(store.toMdsal(), path);
279 public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
280 final NormalizedNode<?, ?> data) {
281 writeDelegate().put(store.toMdsal(), path, data);
285 public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
286 final NormalizedNode<?, ?> data) {
287 writeDelegate().merge(store.toMdsal(), path, data);
291 public boolean cancel() {
292 return writeDelegate().cancel();
296 public FluentFuture<? extends CommitInfo> commit() {
297 final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
298 writeDelegate().commit().addCallback(new FutureCallback<CommitInfo>() {
300 public void onSuccess(final CommitInfo result) {
301 resultFuture.set(result);
305 public void onFailure(final Throwable ex) {
306 if (ex instanceof Exception) {
307 resultFuture.setException(COMMIT_EX_MAPPER.apply((Exception)ex));
309 resultFuture.setException(ex);
312 }, MoreExecutors.directExecutor());
314 return FluentFuture.from(resultFuture);
318 private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
319 private final DOMDataTreeReadTransaction transaction;
320 private final DOMDataTransactionAdapter adapter;
322 DOMDataReadOnlyTransactionAdapter(final DOMDataTreeReadTransaction delegateTx) {
323 this.transaction = requireNonNull(delegateTx);
324 adapter = new DOMDataTransactionAdapter(delegateTx, transaction.getIdentifier());
328 public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
329 final YangInstanceIdentifier path) {
330 return adapter.read(store, path);
334 public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
335 final YangInstanceIdentifier path) {
336 return adapter.exists(store, path);
340 public Object getIdentifier() {
341 return adapter.getIdentifier();
345 public void close() {
350 private static class ProxyListener extends ForwardingObject
351 implements org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener {
352 private final DOMDataTreeChangeListener delegate;
354 ProxyListener(final DOMDataTreeChangeListener delegate) {
355 this.delegate = requireNonNull(delegate);
359 public void onDataTreeChanged(Collection<DataTreeCandidate> changes) {
360 delegate.onDataTreeChanged(changes);
364 protected DOMDataTreeChangeListener delegate() {
369 private static final class ClusteredProxyListener extends ProxyListener
370 implements org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener {
372 ClusteredProxyListener(DOMDataTreeChangeListener delegate) {