Merge "Remove remoterpc dead code."
[controller.git] / 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 }