Expand implementation of Neutron Service APIs in Lisp

[lispflowmapping.git] / mappingservice / neutron / src / main / java / org / opendaylight / lispflowmapping / neutron / Activator.java

diff --git a/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/Activator.java b/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/Activator.java
index d2422d96a5b9afc91c8fcc36d6c472e8c29f5315..53c1c5b25db0d5789ce4cb5dee4f302a5a96a51f 100644 (file)
--- a/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/Activator.java
+++ b/mappingservice/neutron/src/main/java/org/opendaylight/lispflowmapping/neutron/Activator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Contextream, Inc. and others.  All rights reserved.
+ * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
@@ -8,6 +8,7 @@
 
 package org.opendaylight.lispflowmapping.neutron;
 
+
 import java.util.Dictionary;
 import java.util.Hashtable;
 
@@ -15,13 +16,15 @@ import org.apache.felix.dm.Component;
 import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
 import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkAware;
+import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetAware;
+import org.opendaylight.controller.networkconfig.neutron.INeutronPortAware;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * Main application activator class for registering the dependencies and
- * initialising the Mapping Service application.
- * 
+ * Initializing the Mapping Service application.
+ *
  */
 
 public class Activator extends ComponentActivatorAbstractBase {
@@ -34,40 +37,46 @@ public class Activator extends ComponentActivatorAbstractBase {
     /**
      * Function called when the activator starts just after some initializations
      * are done by the ComponentActivatorAbstractBase.
-     * 
+     *
      */
     @Override
     public void init() {
+        logger.debug("LISP Neutron Service is initialized!");
+
     }
 
     /**
      * Function called when the activator stops just before the cleanup done by
      * ComponentActivatorAbstractBase
-     * 
+     *
      */
     @Override
     public void destroy() {
+        logger.debug("LISP Neutron Service is destroyed!");
     }
 
     /**
      * Function that is used to communicate to dependency manager the list of
      * known implementations for services inside a container
-     * 
-     * 
+     *
+     *
      * @return An array containing all the CLASS objects that will be
      *         instantiated in order to get an fully working implementation
      *         Object
      */
     @Override
     public Object[] getImplementations() {
-        Object[] res = { LispNeutronService.class };
+        Object[] res = { LispNeutronService.class,
+                                        LispNeutronSubnetHandler.class,
+                                        LispNeutronPortHandler.class,
+                                        LispNeutronNetworkHandler.class};
         return res;
     }
 
     /**
      * Function that is called when configuration of the dependencies is
      * required.
-     * 
+     *
      * @param c
      *            dependency manager Component object, used for configuring the
      *            dependencies exported and imported
@@ -81,54 +90,31 @@ public class Activator extends ComponentActivatorAbstractBase {
      */
     @Override
     public void configureInstance(Component c, Object imp, String containerName) {
-        
-        //partially based on OpenDove code
+        Dictionary<String, String> props = new Hashtable<String, String>();
+        props.put("name", "mappingservice");
+
         if (imp.equals(LispNeutronService.class)) {
-            c.setInterface(
-                    new String[] { INeutronNetworkAware.class.getName(),
-                               ILispNeutronService.class.getName()}, //Is this necessary? 
-                               null); // null or props here?
-            Dictionary<String, String> props = new Hashtable<String, String>();
-            props.put("name", "mappingservice");
-            c.add(createContainerServiceDependency(containerName)
-                       .setService(IFlowMapping.class)
-                       .setCallbacks("setFlowMappingService", "unsetFlowMappingService")
-                    .setRequired(true));
+            c.setInterface(ILispNeutronService.class.getName(), props);
         }
-    }
-    
-    
 
-    /**
-     * Method which tells how many Global implementations are supported by the
-     * bundle. This way we can tune the number of components created. This
-     * components will be created ONLY at the time of bundle startup and will be
-     * destroyed only at time of bundle destruction, this is the major
-     * difference with the implementation retrieved via getImplementations where
-     * all of them are assumed to be in a container !
-     * 
-     * 
-     * @return The list of implementations the bundle will support, in Global
-     *         version
-     */
-    @Override
-    protected Object[] getGlobalImplementations() {
-        return null;
-    }
+        if (imp.equals(LispNeutronNetworkHandler.class)) {
+            c.setInterface(new String[] { ILispNeutronService.class.getName(), INeutronNetworkAware.class.getName()}, props);
+        }
+
+        if (imp.equals(LispNeutronSubnetHandler.class)) {
+               c.setInterface(new String[] { ILispNeutronService.class.getName(), INeutronSubnetAware.class.getName()}, props);
+        }
+
+        if (imp.equals(LispNeutronPortHandler.class)) {
+            c.setInterface(new String[] { ILispNeutronService.class.getName(), INeutronPortAware.class.getName()}, props);
+        }
+
+        c.add(createContainerServiceDependency(containerName)
+                       .setService(IFlowMapping.class)
+                       .setCallbacks("setMappingService", "unsetMappingService")
+                .setRequired(true));
 
-    /**
-     * Configure the dependency for a given instance Global
-     * 
-     * @param c
-     *            Component assigned for this instance, this will be what will
-     *            be used for configuration
-     * @param imp
-     *            implementation to be configured
-     * @param containerName
-     *            container on which the configuration happens
-     */
-    @Override
-    protected void configureGlobalInstance(Component c, Object imp) {
 
     }
+
 }