2 * Copyright IBM Corporation, 2013. All rights reserved.
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
9 package org.opendaylight.controller.networkconfig.neutron.implementation;
11 import org.apache.felix.dm.Component;
12 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
13 import org.opendaylight.controller.configuration.IConfigurationContainerAware;
14 import org.opendaylight.controller.configuration.IConfigurationContainerService;
15 import org.opendaylight.controller.networkconfig.neutron.INeutronFirewallCRUD;
16 import org.opendaylight.controller.networkconfig.neutron.INeutronFirewallPolicyCRUD;
17 import org.opendaylight.controller.networkconfig.neutron.INeutronFirewallRuleCRUD;
18 import org.opendaylight.controller.networkconfig.neutron.INeutronFloatingIPCRUD;
19 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerCRUD;
20 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerHealthMonitorCRUD;
21 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerListenerCRUD;
22 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolCRUD;
23 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolMemberCRUD;
24 import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
25 import org.opendaylight.controller.networkconfig.neutron.INeutronPortCRUD;
26 import org.opendaylight.controller.networkconfig.neutron.INeutronRouterCRUD;
27 import org.opendaylight.controller.networkconfig.neutron.INeutronSecurityGroupCRUD;
28 import org.opendaylight.controller.networkconfig.neutron.INeutronSecurityRuleCRUD;
29 import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;
30 import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
31 import org.slf4j.Logger;
32 import org.slf4j.LoggerFactory;
34 import java.util.Dictionary;
35 import java.util.Hashtable;
37 public class Activator extends ComponentActivatorAbstractBase {
38 protected static final Logger logger = LoggerFactory
39 .getLogger(Activator.class);
42 * Function called when the activator starts just after some
43 * initializations are done by the
44 * ComponentActivatorAbstractBase.
53 * Function called when the activator stops just before the
54 * cleanup done by ComponentActivatorAbstractBase
58 public void destroy() {
63 * Function that is used to communicate to dependency manager the
64 * list of known implementations for services inside a container
67 * @return An array containing all the CLASS objects that will be
68 * instantiated in order to get an fully working implementation
72 public Object[] getImplementations() {
73 Object[] res = { NeutronFloatingIPInterface.class,
74 NeutronRouterInterface.class,
75 NeutronPortInterface.class,
76 NeutronSubnetInterface.class,
77 NeutronNetworkInterface.class,
78 NeutronSecurityGroupInterface.class,
79 NeutronSecurityRuleInterface.class,
80 NeutronFirewallInterface.class,
81 NeutronFirewallPolicyInterface.class,
82 NeutronFirewallRuleInterface.class,
83 NeutronLoadBalancerInterface.class,
84 NeutronLoadBalancerPoolInterface.class,
85 NeutronLoadBalancerListenerInterface.class,
86 NeutronLoadBalancerHealthMonitorInterface.class,
87 NeutronLoadBalancerPoolMemberInterface.class};
92 * Function that is called when configuration of the dependencies
95 * @param c dependency manager Component object, used for
96 * configuring the dependencies exported and imported
97 * @param imp Implementation class that is being configured,
98 * needed as long as the same routine can configure multiple
100 * @param containerName The containerName being configured, this allow
101 * also optional per-container different behavior if needed, usually
102 * should not be the case though.
105 public void configureInstance(Component c, Object imp, String containerName) {
106 if (imp.equals(NeutronFloatingIPInterface.class)) {
107 // export the service
109 new String[] { INeutronFloatingIPCRUD.class.getName(),
110 IConfigurationContainerAware.class.getName()}, null);
111 Dictionary<String, String> props = new Hashtable<String, String>();
112 props.put("salListenerName", "neutron");
113 c.add(createContainerServiceDependency(containerName)
114 .setService(IClusterContainerServices.class)
115 .setCallbacks("setClusterContainerService",
116 "unsetClusterContainerService").setRequired(true));
117 c.add(createContainerServiceDependency(containerName).setService(
118 IConfigurationContainerService.class).setCallbacks(
119 "setConfigurationContainerService",
120 "unsetConfigurationContainerService").setRequired(true));
122 if (imp.equals(NeutronRouterInterface.class)) {
123 // export the service
125 new String[] { INeutronRouterCRUD.class.getName(),
126 IConfigurationContainerAware.class.getName()}, null);
127 Dictionary<String, String> props = new Hashtable<String, String>();
128 props.put("salListenerName", "neutron");
129 c.add(createContainerServiceDependency(containerName)
130 .setService(IClusterContainerServices.class)
131 .setCallbacks("setClusterContainerService",
132 "unsetClusterContainerService").setRequired(true));
133 c.add(createContainerServiceDependency(containerName).setService(
134 IConfigurationContainerService.class).setCallbacks(
135 "setConfigurationContainerService",
136 "unsetConfigurationContainerService").setRequired(true));
138 if (imp.equals(NeutronPortInterface.class)) {
139 // export the service
141 new String[] { INeutronPortCRUD.class.getName(),
142 IConfigurationContainerAware.class.getName()}, null);
143 Dictionary<String, String> props = new Hashtable<String, String>();
144 props.put("salListenerName", "neutron");
145 c.add(createContainerServiceDependency(containerName)
146 .setService(IClusterContainerServices.class)
147 .setCallbacks("setClusterContainerService",
148 "unsetClusterContainerService").setRequired(true));
149 c.add(createContainerServiceDependency(containerName).setService(
150 IConfigurationContainerService.class).setCallbacks(
151 "setConfigurationContainerService",
152 "unsetConfigurationContainerService").setRequired(true));
154 if (imp.equals(NeutronSubnetInterface.class)) {
155 // export the service
157 new String[] { INeutronSubnetCRUD.class.getName(),
158 IConfigurationContainerAware.class.getName()}, null);
159 Dictionary<String, String> props = new Hashtable<String, String>();
160 props.put("salListenerName", "neutron");
161 c.add(createContainerServiceDependency(containerName)
162 .setService(IClusterContainerServices.class)
163 .setCallbacks("setClusterContainerService",
164 "unsetClusterContainerService").setRequired(true));
165 c.add(createContainerServiceDependency(containerName).setService(
166 IConfigurationContainerService.class).setCallbacks(
167 "setConfigurationContainerService",
168 "unsetConfigurationContainerService").setRequired(true));
170 if (imp.equals(NeutronNetworkInterface.class)) {
171 // export the service
173 new String[] { INeutronNetworkCRUD.class.getName(),
174 IConfigurationContainerAware.class.getName()}, null);
175 Dictionary<String, String> props = new Hashtable<String, String>();
176 props.put("salListenerName", "neutron");
177 c.add(createContainerServiceDependency(containerName)
178 .setService(IClusterContainerServices.class)
179 .setCallbacks("setClusterContainerService",
180 "unsetClusterContainerService").setRequired(true));
181 c.add(createContainerServiceDependency(containerName).setService(
182 IConfigurationContainerService.class).setCallbacks(
183 "setConfigurationContainerService",
184 "unsetConfigurationContainerService").setRequired(true));
186 if (imp.equals(NeutronSecurityGroupInterface.class)) {
187 // export the service
189 new String[] { INeutronSecurityGroupCRUD.class.getName(),
190 IConfigurationContainerAware.class.getName()}, null);
191 Dictionary<String, String> props = new Hashtable<String, String>();
192 props.put("salListenerName", "neutron");
193 c.add(createContainerServiceDependency(containerName)
194 .setService(IClusterContainerServices.class)
195 .setCallbacks("setClusterContainerService",
196 "unsetClusterContainerService").setRequired(true));
197 c.add(createContainerServiceDependency(containerName).setService(
198 IConfigurationContainerService.class).setCallbacks(
199 "setConfigurationContainerService",
200 "unsetConfigurationContainerService").setRequired(true));
202 if (imp.equals(NeutronSecurityRuleInterface.class)) {
203 // export the service
205 new String[] { INeutronSecurityRuleCRUD.class.getName(),
206 IConfigurationContainerAware.class.getName()}, null);
207 Dictionary<String, String> props = new Hashtable<String, String>();
208 props.put("salListenerName", "neutron");
209 c.add(createContainerServiceDependency(containerName)
210 .setService(IClusterContainerServices.class)
211 .setCallbacks("setClusterContainerService",
212 "unsetClusterContainerService").setRequired(true));
213 c.add(createContainerServiceDependency(containerName).setService(
214 IConfigurationContainerService.class).setCallbacks(
215 "setConfigurationContainerService",
216 "unsetConfigurationContainerService").setRequired(true));
218 if (imp.equals(NeutronFirewallInterface.class)) {
219 // export the service
221 new String[] { INeutronFirewallCRUD.class.getName(),
222 IConfigurationContainerAware.class.getName()}, null);
223 Dictionary<String, String> props = new Hashtable<String, String>();
224 props.put("salListenerName", "neutron");
225 c.add(createContainerServiceDependency(containerName)
226 .setService(IClusterContainerServices.class)
227 .setCallbacks("setClusterContainerService",
228 "unsetClusterContainerService").setRequired(true));
229 c.add(createContainerServiceDependency(containerName).setService(
230 IConfigurationContainerService.class).setCallbacks(
231 "setConfigurationContainerService",
232 "unsetConfigurationContainerService").setRequired(true));
234 if (imp.equals(NeutronFirewallPolicyInterface.class)) {
235 // export the service
237 new String[] { INeutronFirewallPolicyCRUD.class.getName(),
238 IConfigurationContainerAware.class.getName()}, null);
239 Dictionary<String, String> props = new Hashtable<String, String>();
240 props.put("salListenerName", "neutron");
241 c.add(createContainerServiceDependency(containerName)
242 .setService(IClusterContainerServices.class)
243 .setCallbacks("setClusterContainerService",
244 "unsetClusterContainerService").setRequired(true));
245 c.add(createContainerServiceDependency(containerName).setService(
246 IConfigurationContainerService.class).setCallbacks(
247 "setConfigurationContainerService",
248 "unsetConfigurationContainerService").setRequired(true));
250 if (imp.equals(NeutronFirewallRuleInterface.class)) {
251 // export the service
253 new String[] { INeutronFirewallRuleCRUD.class.getName(),
254 IConfigurationContainerAware.class.getName()}, null);
255 Dictionary<String, String> props = new Hashtable<String, String>();
256 props.put("salListenerName", "neutron");
257 c.add(createContainerServiceDependency(containerName)
258 .setService(IClusterContainerServices.class)
259 .setCallbacks("setClusterContainerService",
260 "unsetClusterContainerService").setRequired(true));
261 c.add(createContainerServiceDependency(containerName).setService(
262 IConfigurationContainerService.class).setCallbacks(
263 "setConfigurationContainerService",
264 "unsetConfigurationContainerService").setRequired(true));
266 if (imp.equals(NeutronLoadBalancerInterface.class)) {
267 // export the service
269 new String[] { INeutronLoadBalancerCRUD.class.getName(),
270 IConfigurationContainerAware.class.getName()}, null);
271 Dictionary<String, String> props = new Hashtable<String, String>();
272 props.put("salListenerName", "neutron");
273 c.add(createContainerServiceDependency(containerName)
274 .setService(IClusterContainerServices.class)
275 .setCallbacks("setClusterContainerService",
276 "unsetClusterContainerService").setRequired(true));
277 c.add(createContainerServiceDependency(containerName).setService(
278 IConfigurationContainerService.class).setCallbacks(
279 "setConfigurationContainerService",
280 "unsetConfigurationContainerService").setRequired(true));
282 if (imp.equals(NeutronLoadBalancerListenerInterface.class)) {
283 // export the service
285 new String[] { INeutronLoadBalancerListenerCRUD.class.getName(),
286 IConfigurationContainerAware.class.getName()}, null);
287 Dictionary<String, String> props = new Hashtable<String, String>();
288 props.put("salListenerName", "neutron");
289 c.add(createContainerServiceDependency(containerName)
290 .setService(IClusterContainerServices.class)
291 .setCallbacks("setClusterContainerService",
292 "unsetClusterContainerService").setRequired(true));
293 c.add(createContainerServiceDependency(containerName).setService(
294 IConfigurationContainerService.class).setCallbacks(
295 "setConfigurationContainerService",
296 "unsetConfigurationContainerService").setRequired(true));
298 if (imp.equals(NeutronLoadBalancerPoolInterface.class)) {
299 // export the service
301 new String[] { INeutronLoadBalancerPoolCRUD.class.getName(),
302 IConfigurationContainerAware.class.getName()}, null);
303 Dictionary<String, String> props = new Hashtable<String, String>();
304 props.put("salListenerName", "neutron");
305 c.add(createContainerServiceDependency(containerName)
306 .setService(IClusterContainerServices.class)
307 .setCallbacks("setClusterContainerService",
308 "unsetClusterContainerService").setRequired(true));
309 c.add(createContainerServiceDependency(containerName).setService(
310 IConfigurationContainerService.class).setCallbacks(
311 "setConfigurationContainerService",
312 "unsetConfigurationContainerService").setRequired(true));
314 if (imp.equals(NeutronLoadBalancerHealthMonitorInterface.class)) {
315 // export the service
317 new String[] { INeutronLoadBalancerHealthMonitorCRUD.class.getName(),
318 IConfigurationContainerAware.class.getName()}, null);
319 Dictionary<String, String> props = new Hashtable<String, String>();
320 props.put("salListenerName", "neutron");
321 c.add(createContainerServiceDependency(containerName)
322 .setService(IClusterContainerServices.class)
323 .setCallbacks("setClusterContainerService",
324 "unsetClusterContainerService").setRequired(true));
325 c.add(createContainerServiceDependency(containerName).setService(
326 IConfigurationContainerService.class).setCallbacks(
327 "setConfigurationContainerService",
328 "unsetConfigurationContainerService").setRequired(true));
330 if (imp.equals(NeutronLoadBalancerPoolMemberInterface.class)) {
331 // export the service
333 new String[] { INeutronLoadBalancerPoolMemberCRUD.class.getName(),
334 IConfigurationContainerAware.class.getName()}, null);
335 Dictionary<String, String> props = new Hashtable<String, String>();
336 props.put("salListenerName", "neutron");
337 c.add(createContainerServiceDependency(containerName)
338 .setService(IClusterContainerServices.class)
339 .setCallbacks("setClusterContainerService",
340 "unsetClusterContainerService").setRequired(true));
341 c.add(createContainerServiceDependency(containerName).setService(
342 IConfigurationContainerService.class).setCallbacks(
343 "setConfigurationContainerService",
344 "unsetConfigurationContainerService").setRequired(true));