openstack/net-virt/src/main/java/org/opendaylight/ovsdb/openstack/netvirt/ConfigActivator.java

   1 package org.opendaylight.ovsdb.openstack.netvirt;
   2
   3 import java.util.ArrayList;
   4 import java.util.Dictionary;
   5 import java.util.Hashtable;
   6 import java.util.List;
   7 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
   8 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
   9 import org.opendaylight.neutron.spi.*;
  10 import org.opendaylight.ovsdb.openstack.netvirt.api.*;
  11 import org.opendaylight.ovsdb.openstack.netvirt.impl.*;
  12 import org.osgi.framework.BundleActivator;
  13 import org.osgi.framework.BundleContext;
  14 import org.osgi.framework.ServiceReference;
  15 import org.osgi.framework.ServiceRegistration;
  16 import org.osgi.util.tracker.ServiceTracker;
  17 import org.slf4j.Logger;
  18 import org.slf4j.LoggerFactory;
  19
  20 public class ConfigActivator implements BundleActivator {
  21     private static final Logger LOG = LoggerFactory.getLogger(ConfigActivator.class);
  22     private List<ServiceRegistration<?>> registrations = new ArrayList<ServiceRegistration<?>>();
  23     private ProviderContext providerContext;
  24     private ServiceTracker INeutronNetworkCRUDTracker;
  25     private ServiceTracker INeutronPortCRUDTracker;
  26     private ServiceTracker INeutronLoadBalancerCRUDTracker;
  27     private ServiceTracker INeutronLoadBalancerPoolCRUDTracker;
  28     private ServiceTracker INeutronSubnetCRUDTracker;
  29     private ServiceTracker LoadBalancerProviderTracker;
  30     private ServiceTracker ArpProviderTracker;
  31     private ServiceTracker InboundNatProviderTracker;
  32     private ServiceTracker OutboundNatProviderTracker;
  33     private ServiceTracker RoutingProviderTracker;
  34     private ServiceTracker L3ForwardingProviderTracker;
  35
  36     public ConfigActivator(ProviderContext providerContext) {
  37         this.providerContext = providerContext;
  38     }
  39
  40     @Override
  41     public void start(BundleContext context) throws Exception {
  42         LOG.info("ConfigActivator start:");
  43
  44         ConfigurationServiceImpl configurationService = new ConfigurationServiceImpl();
  45         registerService(context, new String[] {ConfigurationService.class.getName()},
  46                 null, configurationService);
  47
  48         BridgeConfigurationManagerImpl bridgeConfigurationManager = new BridgeConfigurationManagerImpl();
  49         registerService(context, new String[] {BridgeConfigurationManager.class.getName()},
  50                 null, bridgeConfigurationManager);
  51
  52         final TenantNetworkManagerImpl tenantNetworkManager = new TenantNetworkManagerImpl();
  53         registerService(context, new String[] {TenantNetworkManager.class.getName()},
  54                 null, tenantNetworkManager);
  55
  56         VlanConfigurationCacheImpl vlanConfigurationCache = new VlanConfigurationCacheImpl();
  57         registerService(context, new String[] {VlanConfigurationCache.class.getName()},
  58                 null, vlanConfigurationCache);
  59
  60         Dictionary<String, Object> floatingIPHandlerProperties = new Hashtable<>();
  61         floatingIPHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
  62                 AbstractEvent.HandlerType.NEUTRON_FLOATING_IP);
  63         FloatingIPHandler floatingIPHandler = new FloatingIPHandler();
  64         registerService(context,
  65                 new String[] {INeutronFloatingIPAware.class.getName(), AbstractHandler.class.getName()},
  66                 floatingIPHandlerProperties, floatingIPHandler);
  67
  68         Dictionary<String, Object> networkHandlerProperties = new Hashtable<>();
  69         networkHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_NETWORK);
  70         final NetworkHandler networkHandler = new NetworkHandler();
  71         registerService(context,
  72                 new String[]{INeutronNetworkAware.class.getName(), AbstractHandler.class.getName()},
  73                 networkHandlerProperties, networkHandler);
  74
  75         Dictionary<String, Object> subnetHandlerProperties = new Hashtable<>();
  76         subnetHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_SUBNET);
  77         SubnetHandler subnetHandler = new SubnetHandler();
  78         registerService(context,
  79                 new String[] {INeutronSubnetAware.class.getName(), AbstractHandler.class.getName()},
  80                 subnetHandlerProperties, subnetHandler);
  81
  82         Dictionary<String, Object> portHandlerProperties = new Hashtable<>();
  83         portHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_PORT);
  84         PortHandler portHandler = new PortHandler();
  85         registerService(context,
  86                 new String[]{INeutronPortAware.class.getName(), AbstractHandler.class.getName()},
  87                 portHandlerProperties, portHandler);
  88
  89         Dictionary<String, Object> routerHandlerProperties = new Hashtable<>();
  90         routerHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_ROUTER);
  91         RouterHandler routerHandler = new RouterHandler();
  92         registerService(context,
  93                 new String[]{INeutronRouterAware.class.getName(), AbstractHandler.class.getName()},
  94                 routerHandlerProperties, routerHandler);
  95
  96         Dictionary<String, Object> southboundHandlerProperties = new Hashtable<>();
  97         southboundHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.SOUTHBOUND);
  98         SouthboundHandler southboundHandler = new SouthboundHandler();
  99         registerService(context,
 100                 new String[]{OvsdbInventoryListener.class.getName(),
 101                         NodeCacheListener.class.getName(),
 102                         AbstractHandler.class.getName()},
 103                 southboundHandlerProperties, southboundHandler);
 104
 105         Dictionary<String, Object> lbaasHandlerProperties = new Hashtable<>();
 106         lbaasHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
 107                 AbstractEvent.HandlerType.NEUTRON_LOAD_BALANCER);
 108         final LBaaSHandler lBaaSHandler = new LBaaSHandler();
 109         registerService(context,
 110                 new String[]{INeutronLoadBalancerAware.class.getName(),
 111                         NodeCacheListener.class.getName(), AbstractHandler.class.getName()},
 112                 lbaasHandlerProperties, lBaaSHandler);
 113
 114         Dictionary<String, Object> lbaasPoolHandlerProperties = new Hashtable<>();
 115         lbaasPoolHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
 116                 AbstractEvent.HandlerType.NEUTRON_LOAD_BALANCER_POOL);
 117         final LBaaSPoolHandler lBaaSPoolHandler = new LBaaSPoolHandler();
 118         registerService(context,
 119                 new String[]{INeutronLoadBalancerPoolAware.class.getName(),
 120                         AbstractHandler.class.getName()}, lbaasPoolHandlerProperties, lBaaSPoolHandler);
 121
 122         Dictionary<String, Object> lbaasPoolMemberHandlerProperties = new Hashtable<>();
 123         lbaasPoolMemberHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
 124                 AbstractEvent.HandlerType.NEUTRON_LOAD_BALANCER_POOL_MEMBER);
 125         final LBaaSPoolMemberHandler lBaaSPoolMemberHandler = new LBaaSPoolMemberHandler();
 126         registerService(context,
 127                 new String[]{INeutronLoadBalancerPoolMemberAware.class.getName(),
 128                         AbstractHandler.class.getName()}, lbaasPoolMemberHandlerProperties, lBaaSPoolMemberHandler);
 129
 130         Dictionary<String, Object> portSecurityHandlerProperties = new Hashtable<>();
 131         portSecurityHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
 132                 AbstractEvent.HandlerType.NEUTRON_PORT_SECURITY);
 133         PortSecurityHandler portSecurityHandler = new PortSecurityHandler();
 134         registerService(context,
 135                 new String[]{INeutronSecurityRuleAware.class.getName(),
 136                         INeutronSecurityGroupAware.class.getName(), AbstractHandler.class.getName()},
 137                 portSecurityHandlerProperties, portSecurityHandler);
 138
 139         final SecurityServicesImpl securityServices = new SecurityServicesImpl();
 140         registerService(context,
 141                 new String[]{SecurityServicesManager.class.getName()}, null, securityServices);
 142
 143         Dictionary<String, Object> fWaasHandlerProperties = new Hashtable<>();
 144         fWaasHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_FWAAS);
 145         FWaasHandler fWaasHandler = new FWaasHandler();
 146         registerService(context,
 147                 new String[]{INeutronFirewallAware.class.getName(),
 148                         INeutronFirewallRuleAware.class.getName(), INeutronFirewallPolicyAware.class.getName(),
 149                         AbstractHandler.class.getName()}, fWaasHandlerProperties, fWaasHandler);
 150
 151         ProviderNetworkManagerImpl providerNetworkManager = new ProviderNetworkManagerImpl();
 152         registerService(context,
 153                 new String[]{NetworkingProviderManager.class.getName()}, null, providerNetworkManager);
 154
 155         EventDispatcherImpl eventDispatcher = new EventDispatcherImpl();
 156         registerService(context,
 157                 new String[]{EventDispatcher.class.getName()}, null, eventDispatcher);
 158
 159         final NeutronL3Adapter neutronL3Adapter = new NeutronL3Adapter();
 160         registerService(context,
 161                 new String[]{NeutronL3Adapter.class.getName()}, null, neutronL3Adapter);
 162
 163         OpenstackRouter openstackRouter = new OpenstackRouter();
 164         registerService(context,
 165                 new String[]{MultiTenantAwareRouter.class.getName()}, null, openstackRouter);
 166
 167         Southbound southbound = new SouthboundImpl(providerContext.getSALService(DataBroker.class));
 168         registerService(context,
 169                 new String[]{Southbound.class.getName()}, null, southbound);
 170
 171         Dictionary<String, Object> nodeCacheManagerProperties = new Hashtable<>();
 172         nodeCacheManagerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NODE);
 173         NodeCacheManagerImpl nodeCacheManager = new NodeCacheManagerImpl();
 174         registerService(context,
 175                 new String[]{NodeCacheManager.class.getName(), AbstractHandler.class.getName()},
 176                 nodeCacheManagerProperties, nodeCacheManager);
 177
 178         OvsdbInventoryServiceImpl ovsdbInventoryService = new OvsdbInventoryServiceImpl(providerContext);
 179         registerService(context,
 180                 new String[] {OvsdbInventoryService.class.getName()}, null, ovsdbInventoryService);
 181
 182         ovsdbInventoryService.setDependencies(context, null);
 183         nodeCacheManager.setDependencies(context, null);
 184         openstackRouter.setDependencies(context, null);
 185         neutronL3Adapter.setDependencies(context, null);
 186         eventDispatcher.setDependencies(context, null);
 187         providerNetworkManager.setDependencies(context, null);
 188         fWaasHandler.setDependencies(context, null);
 189         securityServices.setDependencies(context, null);
 190         portSecurityHandler.setDependencies(context, null);
 191         lBaaSPoolMemberHandler.setDependencies(context, null);
 192         lBaaSPoolHandler.setDependencies(context, null);
 193         lBaaSHandler.setDependencies(context, null);
 194         southboundHandler.setDependencies(context, null);
 195         routerHandler.setDependencies(context, null);
 196         portHandler.setDependencies(context, null);
 197         subnetHandler.setDependencies(context, null);
 198         networkHandler.setDependencies(context, null);
 199         floatingIPHandler.setDependencies(context, null);
 200         vlanConfigurationCache.setDependencies(context, null);
 201         tenantNetworkManager.setDependencies(context, null);
 202         bridgeConfigurationManager.setDependencies(context, null);
 203         configurationService.setDependencies(context, null);
 204
 205         // TODO check if services are already available and setDependencies
 206         // addingService may not be called if the service is already available when the ServiceTracker
 207         // is started
 208         @SuppressWarnings("unchecked")
 209         ServiceTracker INeutronNetworkCRUDTracker = new ServiceTracker(context, INeutronNetworkCRUD.class, null) {
 210             @Override
 211             public Object addingService(ServiceReference reference) {
 212                 LOG.info("addingService INeutronNetworkCRUD");
 213                 INeutronNetworkCRUD service = (INeutronNetworkCRUD)context.getService(reference);
 214                 if (service != null) {
 215                     tenantNetworkManager.setDependencies(service);
 216                     networkHandler.setDependencies(service);
 217                     lBaaSHandler.setDependencies(service);
 218                     lBaaSPoolHandler.setDependencies(service);
 219                     lBaaSPoolMemberHandler.setDependencies(service);
 220                     neutronL3Adapter.setDependencies(service);
 221                 }
 222                 return service;
 223             }
 224
 225             /*@Override
 226             public void modifiedService(ServiceReference reference, Object service) {
 227                 LOG.info("modifiedService INeutronNetworkCRUD");
 228                 if (service != null) {
 229                     tenantNetworkManager.setDependencies(service);
 230                     networkHandler.setDependencies(service);
 231                     lBaaSHandler.setDependencies(service);
 232                     lBaaSPoolHandler.setDependencies(service);
 233                     lBaaSPoolMemberHandler.setDependencies(service);
 234                     neutronL3Adapter.setDependencies(service);
 235                 }
 236             }*/
 237
 238         };
 239         INeutronNetworkCRUDTracker.open();
 240         this.INeutronNetworkCRUDTracker = INeutronNetworkCRUDTracker;
 241
 242         @SuppressWarnings("unchecked")
 243         ServiceTracker INeutronSubnetCRUDTracker = new ServiceTracker(context, INeutronSubnetCRUD.class, null) {
 244             @Override
 245             public Object addingService(ServiceReference reference) {
 246                 LOG.info("addingService INeutronSubnetCRUD");
 247                 INeutronSubnetCRUD service = (INeutronSubnetCRUD) context.getService(reference);
 248                 if (service != null) {
 249                     lBaaSHandler.setDependencies(service);
 250                     lBaaSPoolHandler.setDependencies(service);
 251                     lBaaSPoolMemberHandler.setDependencies(service);
 252                     neutronL3Adapter.setDependencies(service);
 253                 }
 254                 return service;
 255             }
 256         };
 257         INeutronSubnetCRUDTracker.open();
 258         this.INeutronSubnetCRUDTracker = INeutronSubnetCRUDTracker;
 259
 260         @SuppressWarnings("unchecked")
 261         ServiceTracker INeutronPortCRUDTracker = new ServiceTracker(context, INeutronPortCRUD.class, null) {
 262             @Override
 263             public Object addingService(ServiceReference reference) {
 264                 LOG.info("addingService INeutronPortCRUD");
 265                 INeutronPortCRUD service = (INeutronPortCRUD) context.getService(reference);
 266                 if (service != null) {
 267                     tenantNetworkManager.setDependencies(service);
 268                     lBaaSHandler.setDependencies(service);
 269                     lBaaSPoolHandler.setDependencies(service);
 270                     lBaaSPoolMemberHandler.setDependencies(service);
 271                     securityServices.setDependencies(service);
 272                     neutronL3Adapter.setDependencies(service);
 273                 }
 274                 return service;
 275             }
 276         };
 277         INeutronPortCRUDTracker.open();
 278         this.INeutronPortCRUDTracker = INeutronPortCRUDTracker;
 279
 280         @SuppressWarnings("unchecked")
 281         ServiceTracker INeutronLoadBalancerCRUDTracker = new ServiceTracker(context,
 282                 INeutronLoadBalancerCRUD.class, null) {
 283             @Override
 284             public Object addingService(ServiceReference reference) {
 285                 LOG.info("addingService INeutronLoadBalancerCRUD");
 286                 INeutronLoadBalancerCRUD service = (INeutronLoadBalancerCRUD) context.getService(reference);
 287                 if (service != null) {
 288                     lBaaSHandler.setDependencies(service);
 289                     lBaaSPoolHandler.setDependencies(service);
 290                     lBaaSPoolMemberHandler.setDependencies(service);
 291                 }
 292                 return service;
 293             }
 294         };
 295         INeutronLoadBalancerCRUDTracker.open();
 296         this.INeutronLoadBalancerCRUDTracker = INeutronLoadBalancerCRUDTracker;
 297
 298         @SuppressWarnings("unchecked")
 299         ServiceTracker INeutronLoadBalancerPoolCRUDTracker = new ServiceTracker(context,
 300                 INeutronLoadBalancerPoolCRUD.class, null) {
 301             @Override
 302             public Object addingService(ServiceReference reference) {
 303                 LOG.info("addingService INeutronLoadBalancerPoolCRUD");
 304                 INeutronLoadBalancerPoolCRUD service =
 305                         (INeutronLoadBalancerPoolCRUD) context.getService(reference);
 306                 if (service != null) {
 307                     lBaaSHandler.setDependencies(service);
 308                     lBaaSPoolMemberHandler.setDependencies(service);
 309                 }
 310                 return service;
 311             }
 312         };
 313         INeutronLoadBalancerPoolCRUDTracker.open();
 314         this.INeutronLoadBalancerPoolCRUDTracker = INeutronLoadBalancerPoolCRUDTracker;
 315
 316         @SuppressWarnings("unchecked")
 317         ServiceTracker LoadBalancerProviderTracker = new ServiceTracker(context,
 318                 LoadBalancerProvider.class, null) {
 319             @Override
 320             public Object addingService(ServiceReference reference) {
 321                 LOG.info("addingService LoadBalancerProvider");
 322                 LoadBalancerProvider service =
 323                         (LoadBalancerProvider) context.getService(reference);
 324                 if (service != null) {
 325                     lBaaSHandler.setDependencies(service);
 326                     lBaaSPoolHandler.setDependencies(service);
 327                     lBaaSPoolMemberHandler.setDependencies(service);
 328                 }
 329                 return service;
 330             }
 331         };
 332         LoadBalancerProviderTracker.open();
 333         this.LoadBalancerProviderTracker = LoadBalancerProviderTracker;
 334
 335         @SuppressWarnings("unchecked")
 336         ServiceTracker ArpProviderTracker = new ServiceTracker(context,
 337                 ArpProvider.class, null) {
 338             @Override
 339             public Object addingService(ServiceReference reference) {
 340                 LOG.info("addingService ArpProvider");
 341                 ArpProvider service =
 342                         (ArpProvider) context.getService(reference);
 343                 if (service != null) {
 344                     neutronL3Adapter.setDependencies(service);
 345                 }
 346                 return service;
 347             }
 348         };
 349         ArpProviderTracker.open();
 350         this.ArpProviderTracker = ArpProviderTracker;
 351
 352         @SuppressWarnings("unchecked")
 353         ServiceTracker InboundNatProviderTracker = new ServiceTracker(context,
 354                 InboundNatProvider.class, null) {
 355             @Override
 356             public Object addingService(ServiceReference reference) {
 357                 LOG.info("addingService InboundNatProvider");
 358                 InboundNatProvider service =
 359                         (InboundNatProvider) context.getService(reference);
 360                 if (service != null) {
 361                     neutronL3Adapter.setDependencies(service);
 362                 }
 363                 return service;
 364             }
 365         };
 366         InboundNatProviderTracker.open();
 367         this.InboundNatProviderTracker = InboundNatProviderTracker;
 368
 369         @SuppressWarnings("unchecked")
 370         ServiceTracker OutboundNatProviderTracker = new ServiceTracker(context,
 371                 OutboundNatProvider.class, null) {
 372             @Override
 373             public Object addingService(ServiceReference reference) {
 374                 LOG.info("addingService OutboundNatProvider");
 375                 OutboundNatProvider service =
 376                         (OutboundNatProvider) context.getService(reference);
 377                 if (service != null) {
 378                     neutronL3Adapter.setDependencies(service);
 379                 }
 380                 return service;
 381             }
 382         };
 383         OutboundNatProviderTracker.open();
 384         this.OutboundNatProviderTracker = OutboundNatProviderTracker;
 385
 386         @SuppressWarnings("unchecked")
 387         ServiceTracker RoutingProviderTracker = new ServiceTracker(context,
 388                 RoutingProvider.class, null) {
 389             @Override
 390             public Object addingService(ServiceReference reference) {
 391                 LOG.info("addingService RoutingProvider");
 392                 RoutingProvider service =
 393                         (RoutingProvider) context.getService(reference);
 394                 if (service != null) {
 395                     neutronL3Adapter.setDependencies(service);
 396                 }
 397                 return service;
 398             }
 399         };
 400         RoutingProviderTracker.open();
 401         this.RoutingProviderTracker = RoutingProviderTracker;
 402
 403         @SuppressWarnings("unchecked")
 404         ServiceTracker L3ForwardingProviderTracker = new ServiceTracker(context,
 405                 L3ForwardingProvider.class, null) {
 406             @Override
 407             public Object addingService(ServiceReference reference) {
 408                 LOG.info("addingService L3ForwardingProvider");
 409                 L3ForwardingProvider service =
 410                         (L3ForwardingProvider) context.getService(reference);
 411                 if (service != null) {
 412                     neutronL3Adapter.setDependencies(service);
 413                 }
 414                 return service;
 415             }
 416         };
 417         L3ForwardingProviderTracker.open();
 418         this.L3ForwardingProviderTracker = L3ForwardingProviderTracker;
 419     }
 420
 421     @Override
 422     public void stop(BundleContext context) throws Exception {
 423         LOG.info("ConfigActivator stop");
 424         /* ServiceTrackers and services are already released when bundle stops
 425         INeutronNetworkCRUDTracker.close();
 426         INeutronPortCRUDTracker.close();
 427         INeutronSubnetCRUDTracker.close();
 428         INeutronLoadBalancerCRUDTracker.close();
 429         INeutronLoadBalancerPoolCRUDTracker.close();
 430         LoadBalancerProviderTracker.close();
 431
 432         for (ServiceRegistration registration : registrations) {
 433             if (registration != null) {
 434                 registration.unregister();
 435             }
 436         }*/
 437     }
 438
 439     private ServiceRegistration<?> registerService(BundleContext bundleContext, String[] interfaces,
 440                                                    Dictionary<String, Object> properties, Object impl) {
 441         ServiceRegistration<?> serviceRegistration = bundleContext.registerService(interfaces, impl, properties);
 442         if (serviceRegistration != null) {
 443             registrations.add(serviceRegistration);
 444         }
 445         return serviceRegistration;
 446     }
 447 }