opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/forward/DomForwardedBindingBrokerImpl.java

   1 package org.opendaylight.controller.sal.binding.impl.forward;
   2
   3 import java.util.concurrent.ConcurrentHashMap;
   4 import java.util.concurrent.ConcurrentMap;
   5
   6 import org.opendaylight.controller.sal.binding.api.mount.MountProviderInstance;
   7 import org.opendaylight.controller.sal.binding.impl.RootBindingAwareBroker;
   8 import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingDomConnectorDeployer;
   9 import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector;
  10 import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;
  11 import org.opendaylight.controller.sal.binding.impl.connect.dom.DeserializationException;
  12 import org.opendaylight.controller.sal.core.api.Broker.ProviderSession;
  13 import org.opendaylight.controller.sal.core.api.mount.MountProvisionInstance;
  14 import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
  15 import org.opendaylight.controller.sal.core.api.mount.MountProvisionService.MountProvisionListener;
  16 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  17 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  18
  19 public class DomForwardedBindingBrokerImpl extends RootBindingAwareBroker implements DomForwardedBroker {
  20
  21     private ProviderSession domProviderContext;
  22     private BindingIndependentConnector connector;
  23
  24     private MountProvisionService domMountService;
  25
  26     private final DomMountPointForwardingManager domForwardingManager = new DomMountPointForwardingManager();
  27     private final BindingMountPointForwardingManager bindingForwardingManager = new BindingMountPointForwardingManager();
  28
  29     private ConcurrentMap<InstanceIdentifier<?>, BindingIndependentConnector> connectors = new ConcurrentHashMap<>();
  30     private ConcurrentMap<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> forwarded = new ConcurrentHashMap<>();
  31     private ListenerRegistration<MountProvisionListener> domListenerRegistration;
  32     private ListenerRegistration<org.opendaylight.controller.sal.binding.api.mount.MountProviderService.MountProvisionListener> baListenerRegistration;
  33
  34
  35     public DomForwardedBindingBrokerImpl(String instanceName) {
  36         super(instanceName);
  37     }
  38
  39     @Override
  40     public BindingIndependentConnector getConnector() {
  41         return connector;
  42     }
  43
  44     @Override
  45     public ProviderSession getDomProviderContext() {
  46         return domProviderContext;
  47     }
  48
  49     @Override
  50     public void setConnector(BindingIndependentConnector connector) {
  51         this.connector = connector;
  52     }
  53
  54     @Override
  55     public void setDomProviderContext(ProviderSession domProviderContext) {
  56         this.domProviderContext = domProviderContext;
  57     }
  58
  59     @Override
  60     public void startForwarding() {
  61         BindingDomConnectorDeployer.startDataForwarding(getConnector(), getDataBroker(), getDomProviderContext());
  62         BindingDomConnectorDeployer.startRpcForwarding(getConnector(), getRpcProviderRegistry(),
  63                 getDomProviderContext());
  64         BindingDomConnectorDeployer.startNotificationForwarding(getConnector(), getNotificationBroker(),
  65                 getDomProviderContext());
  66         startMountpointForwarding();
  67     }
  68
  69     private void startMountpointForwarding() {
  70         domMountService = getDomProviderContext().getService(MountProvisionService.class);
  71         if (domMountService != null && getMountManager() != null) {
  72             domListenerRegistration = domMountService.registerProvisionListener(domForwardingManager);
  73             baListenerRegistration = getMountManager().registerProvisionListener(bindingForwardingManager);
  74         }
  75     }
  76
  77     public MountProvisionService getDomMountService() {
  78         return domMountService;
  79     }
  80
  81     public void setDomMountService(MountProvisionService domMountService) {
  82         this.domMountService = domMountService;
  83     }
  84
  85     private void tryToDeployConnector(InstanceIdentifier<?> baPath,
  86             org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath) {
  87         org.opendaylight.yangtools.yang.data.api.InstanceIdentifier previous = forwarded.putIfAbsent(baPath, biPath);
  88         if (previous != null) {
  89             return;
  90         }
  91         MountProviderInstance baMountPoint = getMountManager().createOrGetMountPoint(baPath);
  92         MountProvisionInstance domMountPoint = domMountService.createOrGetMountPoint(biPath);
  93         BindingIndependentConnector connector = createForwarder(baPath, baMountPoint, domMountPoint);
  94         connectors.put(baPath, connector);
  95     }
  96
  97     private BindingIndependentConnector createForwarder(InstanceIdentifier<?> path, MountProviderInstance baMountPoint,
  98             MountProvisionInstance domMountPoint) {
  99         BindingIndependentConnector mountConnector = BindingDomConnectorDeployer.createConnector(getConnector());
 100
 101         BindingDomConnectorDeployer.startDataForwarding(mountConnector, baMountPoint, domMountPoint);
 102         BindingDomConnectorDeployer.startRpcForwarding(mountConnector, baMountPoint, domMountPoint);
 103         BindingDomConnectorDeployer.startNotificationForwarding(mountConnector, baMountPoint, domMountPoint);
 104         // connector.setDomNotificationBroker(domMountPoint);
 105         return connector;
 106     }
 107
 108     public synchronized void tryToDeployDomForwarder(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath) {
 109         InstanceIdentifier<?> baPath;
 110         try {
 111             baPath = connector.getMappingService().fromDataDom(domPath);
 112             BindingIndependentConnector potentialConnector = connectors.get(baPath);
 113             if (potentialConnector != null) {
 114                 return;
 115             }
 116             tryToDeployConnector(baPath, domPath);
 117         } catch (DeserializationException e) {
 118
 119         }
 120     }
 121
 122     public synchronized void tryToDeployBindingForwarder(InstanceIdentifier<?> baPath) {
 123         BindingIndependentConnector potentialConnector = connectors.get(baPath);
 124         if (potentialConnector != null) {
 125             return;
 126         }
 127         org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = connector.getMappingService().toDataDom(baPath);
 128         tryToDeployConnector(baPath, domPath);
 129     }
 130
 131     public synchronized void undeployBindingForwarder(InstanceIdentifier<?> baPath) {
 132         // FIXME: Implement closeMountPoint
 133     }
 134
 135     public synchronized void undeployDomForwarder(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath) {
 136         // FIXME: Implement closeMountPoint
 137     }
 138
 139     private class DomMountPointForwardingManager implements MountProvisionListener {
 140
 141         @Override
 142         public void onMountPointCreated(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) {
 143             tryToDeployDomForwarder(path);
 144         }
 145
 146         @Override
 147         public void onMountPointRemoved(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) {
 148             undeployDomForwarder(path);
 149         }
 150     }
 151
 152     private class BindingMountPointForwardingManager implements
 153             org.opendaylight.controller.sal.binding.api.mount.MountProviderService.MountProvisionListener {
 154
 155         @Override
 156         public void onMountPointCreated(InstanceIdentifier<?> path) {
 157             tryToDeployBindingForwarder(path);
 158         }
 159
 160         @Override
 161         public void onMountPointRemoved(InstanceIdentifier<?> path) {
 162             undeployBindingForwarder(path);
 163         }
 164     }
 165
 166 }