opendaylight/networkconfiguration/neutron/implementation/src/main/java/org/opendaylight/controller/networkconfig/neutron/implementation/Activator.java

   1 /*
   2  * Copyright IBM Corporation, 2013.  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
   9 package org.opendaylight.controller.networkconfig.neutron.implementation;
  10
  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;
  33
  34 import java.util.Dictionary;
  35 import java.util.Hashtable;
  36
  37 public class Activator extends ComponentActivatorAbstractBase {
  38     protected static final Logger logger = LoggerFactory
  39     .getLogger(Activator.class);
  40
  41     /**
  42      * Function called when the activator starts just after some
  43      * initializations are done by the
  44      * ComponentActivatorAbstractBase.
  45      *
  46      */
  47     @Override
  48     public void init() {
  49
  50     }
  51
  52     /**
  53      * Function called when the activator stops just before the
  54      * cleanup done by ComponentActivatorAbstractBase
  55      *
  56      */
  57     @Override
  58     public void destroy() {
  59
  60     }
  61
  62     /**
  63      * Function that is used to communicate to dependency manager the
  64      * list of known implementations for services inside a container
  65      *
  66      *
  67      * @return An array containing all the CLASS objects that will be
  68      * instantiated in order to get an fully working implementation
  69      * Object
  70      */
  71     @Override
  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};
  88         return res;
  89     }
  90
  91     /**
  92      * Function that is called when configuration of the dependencies
  93      * is required.
  94      *
  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
  99      * implementations
 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.
 103      */
 104     @Override
 105     public void configureInstance(Component c, Object imp, String containerName) {
 106         if (imp.equals(NeutronFloatingIPInterface.class)) {
 107             // export the service
 108             c.setInterface(
 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));
 121         }
 122         if (imp.equals(NeutronRouterInterface.class)) {
 123             // export the service
 124             c.setInterface(
 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));
 137         }
 138         if (imp.equals(NeutronPortInterface.class)) {
 139             // export the service
 140             c.setInterface(
 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));
 153         }
 154         if (imp.equals(NeutronSubnetInterface.class)) {
 155             // export the service
 156             c.setInterface(
 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));
 169         }
 170         if (imp.equals(NeutronNetworkInterface.class)) {
 171             // export the service
 172             c.setInterface(
 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));
 185         }
 186         if (imp.equals(NeutronSecurityGroupInterface.class)) {
 187             // export the service
 188             c.setInterface(
 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));
 201         }
 202         if (imp.equals(NeutronSecurityRuleInterface.class)) {
 203             // export the service
 204             c.setInterface(
 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));
 217         }
 218         if (imp.equals(NeutronFirewallInterface.class)) {
 219             // export the service
 220             c.setInterface(
 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));
 233         }
 234         if (imp.equals(NeutronFirewallPolicyInterface.class)) {
 235             // export the service
 236             c.setInterface(
 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));
 249         }
 250         if (imp.equals(NeutronFirewallRuleInterface.class)) {
 251             // export the service
 252             c.setInterface(
 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));
 265         }
 266         if (imp.equals(NeutronLoadBalancerInterface.class)) {
 267             // export the service
 268             c.setInterface(
 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));
 281         }
 282         if (imp.equals(NeutronLoadBalancerListenerInterface.class)) {
 283             // export the service
 284             c.setInterface(
 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));
 297         }
 298         if (imp.equals(NeutronLoadBalancerPoolInterface.class)) {
 299             // export the service
 300             c.setInterface(
 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));
 313         }
 314         if (imp.equals(NeutronLoadBalancerHealthMonitorInterface.class)) {
 315             // export the service
 316             c.setInterface(
 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));
 329         }
 330         if (imp.equals(NeutronLoadBalancerPoolMemberInterface.class)) {
 331             // export the service
 332             c.setInterface(
 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));
 345         }
 346     }
 347 }