opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ComponentActivator.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.compatibility;
   9
  10 import java.util.Dictionary;
  11 import java.util.Hashtable;
  12
  13 import org.apache.felix.dm.Component;
  14 import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
  15 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  16 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  17 import org.opendaylight.controller.sal.compatibility.adsal.DataPacketServiceAdapter;
  18 import org.opendaylight.controller.sal.compatibility.topology.TopologyAdapter;
  19 import org.opendaylight.controller.sal.compatibility.topology.TopologyProvider;
  20 import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
  21 import org.opendaylight.controller.sal.core.Node.NodeIDType;
  22 import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
  23 import org.opendaylight.controller.sal.discovery.IDiscoveryService;
  24 import org.opendaylight.controller.sal.flowprogrammer.IPluginInFlowProgrammerService;
  25 import org.opendaylight.controller.sal.flowprogrammer.IPluginOutFlowProgrammerService;
  26 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
  27 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
  28 import org.opendaylight.controller.sal.packet.IPluginInDataPacketService;
  29 import org.opendaylight.controller.sal.packet.IPluginOutDataPacketService;
  30 import org.opendaylight.controller.sal.reader.IPluginInReadService;
  31 import org.opendaylight.controller.sal.reader.IPluginOutReadService;
  32 import org.opendaylight.controller.sal.topology.IPluginInTopologyService;
  33 import org.opendaylight.controller.sal.topology.IPluginOutTopologyService;
  34 import org.opendaylight.controller.sal.utils.GlobalConstants;
  35 import org.opendaylight.controller.sal.utils.INodeConnectorFactory;
  36 import org.opendaylight.controller.sal.utils.INodeFactory;
  37 import org.osgi.framework.BundleContext;
  38
  39 import com.google.common.base.Preconditions;
  40
  41 public class ComponentActivator extends ComponentActivatorAbstractBase {
  42     private final INodeConnectorFactory nodeConnectorFactory = new MDSalNodeConnectorFactory();
  43     private final DataPacketServiceAdapter dataPacketService = new DataPacketServiceAdapter();
  44     private final InventoryAndReadAdapter inventory = new InventoryAndReadAdapter();
  45     private final FlowProgrammerAdapter flow = new FlowProgrammerAdapter();
  46     private final DataPacketAdapter dataPacket = new DataPacketAdapter();
  47     private final TopologyProvider tpProvider = new TopologyProvider();
  48     private final INodeFactory nodeFactory = new MDSalNodeFactory();
  49     private final TopologyAdapter topology = new TopologyAdapter();
  50     private BundleContext context;
  51
  52     public INodeConnectorFactory getNodeConnectorFactory() {
  53         return nodeConnectorFactory;
  54     }
  55
  56     public DataPacketServiceAdapter getDataPacketService() {
  57         return dataPacketService;
  58     }
  59
  60     public InventoryAndReadAdapter getInventory() {
  61         return inventory;
  62     }
  63
  64     public FlowProgrammerAdapter getFlow() {
  65         return flow;
  66     }
  67
  68     public DataPacketAdapter getDataPacket() {
  69         return dataPacket;
  70     }
  71
  72     public TopologyProvider getTpProvider() {
  73         return tpProvider;
  74     }
  75
  76     public INodeFactory getNodeFactory() {
  77         return nodeFactory;
  78     }
  79
  80     public TopologyAdapter getTopology() {
  81         return topology;
  82     }
  83
  84     @Override
  85     protected void init() {
  86         // TODO: deprecated, should be removed soon
  87         NodeIDType.registerIDType(NodeMapping.MD_SAL_TYPE, String.class);
  88         NodeConnectorIDType.registerIDType(NodeMapping.MD_SAL_TYPE, String.class, NodeMapping.MD_SAL_TYPE);
  89     }
  90
  91     @Override
  92     public void start(final BundleContext context) {
  93         super.start(context);
  94         this.context = Preconditions.checkNotNull(context);
  95     }
  96
  97     public ProviderContext setBroker(final BindingAwareBroker broker) {
  98         return broker.registerProvider(new SalCompatibilityProvider(this), context);
  99     }
 100
 101     @Override
 102     protected Object[] getGlobalImplementations() {
 103         return new Object[] {
 104                 flow,
 105                 inventory,
 106                 dataPacket,
 107                 nodeFactory,
 108                 nodeConnectorFactory,
 109                 topology,
 110                 tpProvider,
 111                 this // Used for setBroker callback
 112         };
 113     }
 114
 115     @Override
 116     protected void configureGlobalInstance(final Component c, final Object imp) {
 117         if (imp instanceof DataPacketAdapter) {
 118             _configure((DataPacketAdapter)imp, c);
 119         } else if (imp instanceof FlowProgrammerAdapter) {
 120             _configure((FlowProgrammerAdapter)imp, c);
 121         } else if (imp instanceof InventoryAndReadAdapter) {
 122             _configure((InventoryAndReadAdapter)imp, c);
 123         } else if (imp instanceof ComponentActivator) {
 124             _configure((ComponentActivator)imp, c);
 125         } else if (imp instanceof MDSalNodeConnectorFactory) {
 126             _configure((MDSalNodeConnectorFactory)imp, c);
 127         } else if (imp instanceof MDSalNodeFactory) {
 128             _configure((MDSalNodeFactory)imp, c);
 129         } else if (imp instanceof TopologyAdapter) {
 130             _configure((TopologyAdapter)imp, c);
 131         } else if (imp instanceof TopologyProvider) {
 132             _configure((TopologyProvider)imp, c);
 133         } else {
 134             throw new IllegalArgumentException(String.format("Unhandled implementation class %s", imp.getClass()));
 135         }
 136     }
 137
 138     @Override
 139     protected Object[] getImplementations() {
 140         return new Object[] {
 141                 dataPacketService,
 142         };
 143     }
 144
 145     @Override
 146     protected void configureInstance(final Component c, final Object imp, final String containerName) {
 147         if (imp instanceof ComponentActivator) {
 148             _instanceConfigure((ComponentActivator)imp, c, containerName);
 149         } else if (imp instanceof DataPacketServiceAdapter) {
 150             _instanceConfigure((DataPacketServiceAdapter)imp, c, containerName);
 151         } else {
 152             throw new IllegalArgumentException(String.format("Unhandled implementation class %s", imp.getClass()));
 153         }
 154     }
 155
 156     private void _configure(final MDSalNodeFactory imp, final Component it) {
 157         it.setInterface(INodeFactory.class.getName(), properties());
 158     }
 159
 160     private void _configure(final MDSalNodeConnectorFactory imp, final Component it) {
 161         it.setInterface(INodeConnectorFactory.class.getName(), properties());
 162     }
 163
 164     private void _configure(final ComponentActivator imp, final Component it) {
 165         it.add(createServiceDependency()
 166                 .setService(BindingAwareBroker.class)
 167                 .setCallbacks("setBroker", "setBroker")
 168                 .setRequired(true));
 169     }
 170
 171     private void _configure(final DataPacketAdapter imp, final Component it) {
 172         it.add(createServiceDependency()
 173                 .setService(IPluginOutDataPacketService.class)
 174                 .setCallbacks("setDataPacketPublisher", "setDataPacketPublisher")
 175                 .setRequired(false));
 176     }
 177
 178     private void _configure(final FlowProgrammerAdapter imp, final Component it) {
 179         it.setInterface(IPluginInFlowProgrammerService.class.getName(), properties());
 180         it.add(createServiceDependency()
 181                 .setService(IPluginOutFlowProgrammerService.class)
 182                 .setCallbacks("setFlowProgrammerPublisher", "setFlowProgrammerPublisher")
 183                 .setRequired(false));
 184         it.add(createServiceDependency()
 185                 .setService(IClusterGlobalServices.class)
 186                 .setCallbacks("setClusterGlobalServices", "unsetClusterGlobalServices")
 187                 .setRequired(false));
 188     }
 189
 190     private void _instanceConfigure(final DataPacketServiceAdapter imp, final Component it, final String containerName) {
 191         it.setInterface(IPluginInDataPacketService.class.getName(), properties());
 192     }
 193
 194     private void _instanceConfigure(final ComponentActivator imp, final Component it, final String containerName) {
 195         // No-op
 196     }
 197
 198     private void _configure(final InventoryAndReadAdapter imp, final Component it) {
 199         it.setInterface(new String[] {
 200                 IPluginInInventoryService.class.getName(),
 201                 IPluginInReadService.class.getName(),
 202         }, properties());
 203
 204         it.add(createServiceDependency()
 205                 .setService(IPluginOutReadService.class)
 206                 .setCallbacks("setReadPublisher", "unsetReadPublisher")
 207                 .setRequired(false));
 208         it.add(createServiceDependency()
 209                 .setService(IPluginOutInventoryService.class)
 210                 .setCallbacks("setInventoryPublisher", "unsetInventoryPublisher")
 211                 .setRequired(false));
 212         it.add(createServiceDependency()
 213                 .setService(IDiscoveryService.class)
 214                 .setCallbacks("setDiscoveryPublisher", "setDiscoveryPublisher")
 215                 .setRequired(false));
 216     }
 217
 218     private void _configure(final TopologyAdapter imp, final Component it) {
 219         it.setInterface(IPluginInTopologyService.class.getName(), properties());
 220
 221         it.add(createServiceDependency()
 222                 .setService(IPluginOutTopologyService.class)
 223                 .setCallbacks("setTopologyPublisher", "setTopologyPublisher")
 224                 .setRequired(false));
 225     }
 226
 227     private void _configure(final TopologyProvider imp, final Component it) {
 228         it.add(createServiceDependency()
 229                 .setService(IPluginOutTopologyService.class)
 230                 .setCallbacks("setTopologyPublisher", "setTopologyPublisher")
 231                 .setRequired(false));
 232     }
 233
 234     private Dictionary<String,Object> properties() {
 235         final Hashtable<String,Object> props = new Hashtable<String, Object>();
 236         props.put(GlobalConstants.PROTOCOLPLUGINTYPE.toString(), NodeIDType.OPENFLOW);
 237         props.put("protocolName", NodeIDType.OPENFLOW);
 238         return props;
 239     }
 240 }