opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/compat/HydrogenDataBrokerAdapter.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.controller.md.sal.binding.compat;
   9
  10 import com.google.common.util.concurrent.FutureCallback;
  11 import com.google.common.util.concurrent.Futures;
  12 import com.google.common.util.concurrent.ListenableFuture;
  13 import java.util.Collections;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.concurrent.ExecutionException;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  22 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  23 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  24 import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
  27 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
  28 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  29 import org.opendaylight.yangtools.concepts.Delegator;
  30 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  31 import org.opendaylight.yangtools.util.ListenerRegistry;
  32 import org.opendaylight.yangtools.yang.binding.DataObject;
  33 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  34 import org.opendaylight.yangtools.yang.common.RpcResult;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 @Deprecated
  39 public class HydrogenDataBrokerAdapter implements DataProviderService, AutoCloseable {
  40
  41     private static final Logger LOG = LoggerFactory.getLogger(HydrogenDataBrokerAdapter.class);
  42
  43     private final DataBroker delegate;
  44
  45     public HydrogenDataBrokerAdapter(final DataBroker dataBroker) {
  46         delegate = dataBroker;
  47         LOG.info("ForwardedBackwardsCompatibleBroker started.");
  48     }
  49
  50     @Override
  51     public DataModificationTransaction beginTransaction() {
  52         return new ForwardedBackwardsCompatibleTransacion(delegate.newReadWriteTransaction());
  53     }
  54
  55     @Override
  56     public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
  57         final DataModificationTransaction tx = beginTransaction();
  58         return tx.readConfigurationData(path);
  59     }
  60
  61     @Override
  62     public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
  63         final DataModificationTransaction tx = beginTransaction();
  64         return tx.readOperationalData(path);
  65     }
  66
  67     @Override
  68     public ListenerRegistration<DataChangeListener> registerDataChangeListener(
  69             final InstanceIdentifier<? extends DataObject> path, final DataChangeListener listener) {
  70
  71
  72         final org.opendaylight.controller.md.sal.binding.api.DataChangeListener asyncOperListener = new BackwardsCompatibleOperationalDataChangeInvoker(listener);
  73         final org.opendaylight.controller.md.sal.binding.api.DataChangeListener asyncCfgListener = new BackwardsCompatibleConfigurationDataChangeInvoker(listener);
  74
  75         final ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> cfgReg = delegate.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, path, asyncCfgListener, DataChangeScope.SUBTREE);
  76         final ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> operReg = delegate.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, path, asyncOperListener, DataChangeScope.SUBTREE);
  77
  78         return new LegacyListenerRegistration(listener,cfgReg,operReg);
  79     }
  80
  81     @Deprecated
  82     private class ForwardedBackwardsCompatibleTransacion implements DataModificationTransaction {
  83
  84         private final ListenerRegistry<DataTransactionListener> listeners = ListenerRegistry.create();
  85         private final Map<InstanceIdentifier<? extends DataObject>, DataObject> updated = new HashMap<>();
  86         private final Map<InstanceIdentifier<? extends DataObject>, DataObject> created = new HashMap<>();
  87         private final Set<InstanceIdentifier<? extends DataObject>> removed = new HashSet<>();
  88         private final Map<InstanceIdentifier<? extends DataObject>, DataObject> original = new HashMap<>();
  89         private TransactionStatus status = TransactionStatus.NEW;
  90
  91         private final Set<InstanceIdentifier<? extends DataObject>> posponedRemovedOperational = new HashSet<>();
  92         private final Set<InstanceIdentifier<? extends DataObject>> posponedRemovedConfiguration = new HashSet<>();
  93
  94         private final ReadWriteTransaction delegate;
  95
  96
  97         @Override
  98         public final TransactionStatus getStatus() {
  99             return status;
 100         }
 101
 102         protected ForwardedBackwardsCompatibleTransacion(final ReadWriteTransaction delegate) {
 103             this.delegate = delegate;
 104             LOG.debug("Tx {} allocated.",getIdentifier());
 105         }
 106
 107         @Override
 108         public void putOperationalData(final InstanceIdentifier<? extends DataObject> path, final DataObject data) {
 109             final boolean previouslyRemoved = posponedRemovedOperational.remove(path);
 110
 111             @SuppressWarnings({ "rawtypes", "unchecked" })
 112             final InstanceIdentifier<DataObject> castedPath = (InstanceIdentifier) path;
 113             if(previouslyRemoved) {
 114                 delegate.put(LogicalDatastoreType.OPERATIONAL, castedPath, data,true);
 115             } else {
 116                 delegate.merge(LogicalDatastoreType.OPERATIONAL, castedPath, data,true);
 117             }
 118         }
 119
 120         @Override
 121         public void putConfigurationData(final InstanceIdentifier<? extends DataObject> path, final DataObject data) {
 122             final boolean previouslyRemoved = posponedRemovedConfiguration.remove(path);
 123             final DataObject originalObj = readConfigurationData(path);
 124             if (originalObj != null) {
 125                 original.put(path, originalObj);
 126
 127             } else {
 128                 created.put(path, data);
 129             }
 130             updated.put(path, data);
 131             @SuppressWarnings({"rawtypes","unchecked"})
 132             final InstanceIdentifier<DataObject> castedPath = (InstanceIdentifier) path;
 133             if(previouslyRemoved) {
 134                 delegate.put(LogicalDatastoreType.CONFIGURATION, castedPath, data,true);
 135             } else {
 136                 delegate.merge(LogicalDatastoreType.CONFIGURATION, castedPath, data,true);
 137             }
 138         }
 139
 140         @Override
 141         public void removeOperationalData(final InstanceIdentifier<? extends DataObject> path) {
 142             posponedRemovedOperational.add(path);
 143         }
 144
 145         @Override
 146         public void removeConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
 147             posponedRemovedConfiguration.add(path);
 148         }
 149
 150         @Override
 151         public Map<InstanceIdentifier<? extends DataObject>, DataObject> getCreatedOperationalData() {
 152             return Collections.emptyMap();
 153         }
 154
 155         @Override
 156         public Map<InstanceIdentifier<? extends DataObject>, DataObject> getCreatedConfigurationData() {
 157             return created;
 158         }
 159
 160         @Override
 161         public Map<InstanceIdentifier<? extends DataObject>, DataObject> getUpdatedOperationalData() {
 162             return Collections.emptyMap();
 163         }
 164
 165         @Override
 166         public Map<InstanceIdentifier<? extends DataObject>, DataObject> getUpdatedConfigurationData() {
 167             return updated;
 168         }
 169
 170         @Override
 171         public Set<InstanceIdentifier<? extends DataObject>> getRemovedConfigurationData() {
 172             return removed;
 173         }
 174
 175         @Override
 176         public Set<InstanceIdentifier<? extends DataObject>> getRemovedOperationalData() {
 177             return Collections.emptySet();
 178         }
 179
 180         @Override
 181         public Map<InstanceIdentifier<? extends DataObject>, DataObject> getOriginalConfigurationData() {
 182             return original;
 183         }
 184
 185         @Override
 186         public Map<InstanceIdentifier<? extends DataObject>, DataObject> getOriginalOperationalData() {
 187             return Collections.emptyMap();
 188         }
 189
 190         @Override
 191         public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
 192             try {
 193                 return delegate.read(LogicalDatastoreType.OPERATIONAL, path).get().orNull();
 194             } catch (InterruptedException | ExecutionException e) {
 195                 LOG.error("Read of {} failed.", path,e);
 196                 return null;
 197             }
 198         }
 199
 200         @Override
 201         public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
 202             try {
 203                 return delegate.read(LogicalDatastoreType.CONFIGURATION, path).get().orNull();
 204             } catch (InterruptedException | ExecutionException e) {
 205                 LOG.error("Read of {} failed.", path,e);
 206                 return null;
 207             }
 208         }
 209
 210         private void changeStatus(final TransactionStatus status) {
 211             LOG.trace("Transaction {} changed status to {}", getIdentifier(), status);
 212             this.status = status;
 213
 214             for(final ListenerRegistration<DataTransactionListener> listener : listeners) {
 215                 try {
 216                     listener.getInstance().onStatusUpdated(this, status);
 217                 } catch (final Exception e) {
 218                     LOG.error("Error during invoking transaction listener {}",listener.getInstance(),e);
 219                 }
 220             }
 221         }
 222
 223         @Override
 224         public ListenableFuture<RpcResult<TransactionStatus>> commit() {
 225
 226             for(final InstanceIdentifier<? extends DataObject> path : posponedRemovedConfiguration) {
 227                 delegate.delete(LogicalDatastoreType.CONFIGURATION, path);
 228             }
 229
 230             for(final InstanceIdentifier<? extends DataObject> path : posponedRemovedOperational) {
 231                 delegate.delete(LogicalDatastoreType.OPERATIONAL, path);
 232             }
 233
 234             changeStatus(TransactionStatus.SUBMITED);
 235
 236             final ListenableFuture<RpcResult<TransactionStatus>> f = delegate.commit();
 237
 238             Futures.addCallback(f, new FutureCallback<RpcResult<TransactionStatus>>() {
 239                 @Override
 240                 public void onSuccess(final RpcResult<TransactionStatus> result) {
 241                     changeStatus(result.getResult());
 242                 }
 243
 244                 @Override
 245                 public void onFailure(final Throwable t) {
 246                     LOG.error("Transaction {} failed to complete", getIdentifier(), t);
 247                     changeStatus(TransactionStatus.FAILED);
 248                 }
 249             });
 250
 251             return f;
 252         }
 253
 254         @Override
 255         public ListenerRegistration<DataTransactionListener> registerListener(final DataTransactionListener listener) {
 256             return listeners.register(listener);
 257         }
 258
 259         @Override
 260         public Object getIdentifier() {
 261             // TODO Auto-generated method stub
 262             return null;
 263         }
 264
 265     }
 266
 267     private static final class LegacyListenerRegistration implements ListenerRegistration<DataChangeListener> {
 268
 269         private final DataChangeListener instance;
 270         private final ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> cfgReg;
 271         private final ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> operReg;
 272
 273         public LegacyListenerRegistration(final DataChangeListener listener,
 274                 final ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> cfgReg,
 275                 final ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> operReg) {
 276             this.instance = listener;
 277             this.cfgReg = cfgReg;
 278             this.operReg = operReg;
 279         }
 280
 281         @Override
 282         public DataChangeListener getInstance() {
 283             return instance;
 284         }
 285
 286         @Override
 287         public void close() {
 288             cfgReg.close();
 289             operReg.close();
 290         }
 291
 292     }
 293
 294     private static class BackwardsCompatibleOperationalDataChangeInvoker implements org.opendaylight.controller.md.sal.binding.api.DataChangeListener, Delegator<DataChangeListener> {
 295
 296         private final org.opendaylight.controller.md.sal.common.api.data.DataChangeListener<?,?> delegate;
 297
 298
 299         public BackwardsCompatibleOperationalDataChangeInvoker(final DataChangeListener listener) {
 300             this.delegate = listener;
 301         }
 302
 303         @SuppressWarnings({ "unchecked", "rawtypes" })
 304         @Override
 305         public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 306
 307             final DataChangeEvent legacyChange = HydrogenDataChangeEvent.createOperational(change);
 308             delegate.onDataChanged(legacyChange);
 309
 310         }
 311
 312         @Override
 313         public DataChangeListener getDelegate() {
 314             return (DataChangeListener) delegate;
 315         }
 316
 317     }
 318
 319     private static class BackwardsCompatibleConfigurationDataChangeInvoker implements org.opendaylight.controller.md.sal.binding.api.DataChangeListener, Delegator<DataChangeListener> {
 320         private final org.opendaylight.controller.md.sal.common.api.data.DataChangeListener<?,?> delegate;
 321
 322         public BackwardsCompatibleConfigurationDataChangeInvoker(final DataChangeListener listener) {
 323             this.delegate = listener;
 324         }
 325
 326         @SuppressWarnings({ "unchecked", "rawtypes" })
 327         @Override
 328         public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 329
 330             final DataChangeEvent legacyChange = HydrogenDataChangeEvent.createConfiguration(change);
 331
 332             delegate.onDataChanged(legacyChange);
 333
 334         }
 335
 336         @Override
 337         public DataChangeListener getDelegate() {
 338             return (DataChangeListener) delegate;
 339         }
 340
 341     }
 342
 343     @Override
 344     public void close() throws Exception {
 345         // TODO Auto-generated method stub
 346     }
 347 }