opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/DataBrokerImpl.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.sal.binding.impl;
   9
  10 import java.util.Map;
  11 import java.util.Map.Entry;
  12 import java.util.Set;
  13 import java.util.concurrent.atomic.AtomicLong;
  14
  15 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
  16 import org.opendaylight.controller.md.sal.common.api.data.DataReader;
  17 import org.opendaylight.controller.md.sal.common.impl.routing.AbstractDataReadRouter;
  18 import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataBroker;
  19 import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
  20 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  21 import org.opendaylight.yangtools.concepts.Registration;
  22 import org.opendaylight.yangtools.yang.binding.DataObject;
  23 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  24 import org.opendaylight.yangtools.yang.binding.util.DataObjectReadingUtil;
  25
  26 import com.google.common.base.Predicate;
  27 import com.google.common.collect.ImmutableList;
  28 import com.google.common.collect.ImmutableMap;
  29 import com.google.common.collect.ImmutableMap.Builder;
  30 import com.google.common.collect.Maps;
  31
  32 @Deprecated
  33 public class DataBrokerImpl extends
  34         AbstractDataBroker<InstanceIdentifier<? extends DataObject>, DataObject, DataChangeListener> //
  35         implements DataProviderService, AutoCloseable {
  36
  37     private final static class ContainsWildcarded implements Predicate<InstanceIdentifier<? extends DataObject>> {
  38
  39         private final InstanceIdentifier<? extends DataObject> key;
  40
  41         public ContainsWildcarded(final InstanceIdentifier<? extends DataObject> key) {
  42             this.key = key;
  43         }
  44
  45         @Override
  46         public boolean apply(final InstanceIdentifier<? extends DataObject> input) {
  47             return key.containsWildcarded(input);
  48         }
  49     }
  50
  51     private final static class IsContainedWildcarded implements Predicate<InstanceIdentifier<? extends DataObject>> {
  52
  53         private final InstanceIdentifier<? extends DataObject> key;
  54
  55         public IsContainedWildcarded(final InstanceIdentifier<? extends DataObject> key) {
  56             this.key = key;
  57         }
  58
  59         @Override
  60         public boolean apply(final InstanceIdentifier<? extends DataObject> input) {
  61             return input.containsWildcarded(key);
  62         }
  63     }
  64
  65     private final AtomicLong nextTransaction = new AtomicLong();
  66     private final AtomicLong createdTransactionsCount = new AtomicLong();
  67     private final DelegatingDataReadRouter router = new DelegatingDataReadRouter();
  68     private DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject> rootCommitHandler;
  69
  70     public DataBrokerImpl() {
  71         setDataReadRouter(router);
  72     }
  73
  74     public void setDataReadDelegate(final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> delegate) {
  75         router.setDelegate(delegate);
  76     }
  77
  78     public AtomicLong getCreatedTransactionsCount() {
  79         return createdTransactionsCount;
  80     }
  81
  82     @Override
  83     public DataTransactionImpl beginTransaction() {
  84         String transactionId = "BA-" + nextTransaction.getAndIncrement();
  85         createdTransactionsCount.getAndIncrement();
  86         return new DataTransactionImpl(transactionId, this);
  87     }
  88
  89     @Override
  90     public void close() {
  91
  92     }
  93
  94     @Override
  95     protected Predicate<InstanceIdentifier<? extends DataObject>> createContainsPredicate(
  96             final InstanceIdentifier<? extends DataObject> key) {
  97         return new ContainsWildcarded(key);
  98     }
  99
 100     @Override
 101     protected Predicate<InstanceIdentifier<? extends DataObject>> createIsContainedPredicate(
 102             final InstanceIdentifier<? extends DataObject> key) {
 103         return new IsContainedWildcarded(key);
 104     }
 105
 106     @SuppressWarnings({ "unchecked", "rawtypes" })
 107     @Override
 108     protected Map<InstanceIdentifier<? extends DataObject>, DataObject> deepGetBySubpath(
 109             final Map<InstanceIdentifier<? extends DataObject>, DataObject> dataSet,
 110             final InstanceIdentifier<? extends DataObject> path) {
 111         Builder<InstanceIdentifier<? extends DataObject>, DataObject> builder = ImmutableMap.builder();
 112         Map<InstanceIdentifier<? extends DataObject>, DataObject> potential = Maps.filterKeys(dataSet,
 113                 createIsContainedPredicate(path));
 114         for (Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry : potential.entrySet()) {
 115             try {
 116                 builder.putAll(DataObjectReadingUtil.readData(entry.getValue(), (InstanceIdentifier) entry.getKey(),
 117                         path));
 118             } catch (Exception e) {
 119                 // FIXME : Log exception;
 120             }
 121         }
 122         return builder.build();
 123
 124     }
 125
 126     public class DelegatingDataReadRouter extends
 127             AbstractDataReadRouter<InstanceIdentifier<? extends DataObject>, DataObject> {
 128
 129         private DataReader<InstanceIdentifier<? extends DataObject>, DataObject> delegate;
 130
 131         @Override
 132         public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
 133             return delegate.readConfigurationData(path);
 134         }
 135
 136         public void setDelegate(final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> delegate) {
 137             this.delegate = delegate;
 138         }
 139
 140         @Override
 141         public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
 142             return delegate.readOperationalData(path);
 143         }
 144
 145         @Override
 146         protected DataObject merge(final InstanceIdentifier<? extends DataObject> path, final Iterable<DataObject> data) {
 147             throw new UnsupportedOperationException("Not supported");
 148         }
 149
 150         @Override
 151         public Registration registerConfigurationReader(
 152                 final InstanceIdentifier<? extends DataObject> path,
 153                 final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> reader) {
 154             throw new UnsupportedOperationException("Not supported");
 155         }
 156
 157         @Override
 158         public Registration registerOperationalReader(
 159                 final InstanceIdentifier<? extends DataObject> path,
 160                 final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> reader) {
 161             throw new UnsupportedOperationException("Not supported");
 162         }
 163     }
 164
 165     @Override
 166     protected ImmutableList<DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject>> affectedCommitHandlers(
 167             final Set<InstanceIdentifier<? extends DataObject>> paths) {
 168         ImmutableList.Builder<DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject>> handlersBuilder = ImmutableList.builder();
 169         return handlersBuilder //
 170                 .add(rootCommitHandler) //
 171                 .addAll(super.affectedCommitHandlers(paths)) //
 172                 .build();
 173     }
 174
 175     public void setRootCommitHandler(final DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject> commitHandler) {
 176         rootCommitHandler = commitHandler;
 177     }
 178
 179 }