import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
+import org.opendaylight.ovsdb.openstack.netvirt.api.MultiTenantAwareRouter;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.impl.BridgeConfigurationManagerImpl;
import org.opendaylight.ovsdb.openstack.netvirt.impl.ConfigurationServiceImpl;
import org.opendaylight.ovsdb.openstack.netvirt.impl.EventDispatcherImpl;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.OpenstackRouter;
import org.opendaylight.ovsdb.openstack.netvirt.impl.ProviderNetworkManagerImpl;
import org.opendaylight.ovsdb.openstack.netvirt.impl.TenantNetworkManagerImpl;
import org.opendaylight.ovsdb.openstack.netvirt.impl.VlanConfigurationCacheImpl;
ProviderNetworkManagerImpl.class,
EventDispatcherImpl.class,
FWaasHandler.class,
- LBaaSHandler.class};
+ LBaaSHandler.class,
+ NeutronL3Adapter.class,
+ OpenstackRouter.class};
return res;
}
Properties floatingIPHandlerPorperties = new Properties();
floatingIPHandlerPorperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
AbstractEvent.HandlerType.NEUTRON_FLOATING_IP);
- c.setInterface(new String[] {INeutronFloatingIPAware.class.getName(),
- AbstractHandler.class.getName()},
+ c.setInterface(new String[]{INeutronFloatingIPAware.class.getName(),
+ AbstractHandler.class.getName()},
floatingIPHandlerPorperties);
- c.add(createServiceDependency().setService(OvsdbConfigurationService.class).setRequired(true));
- c.add(createServiceDependency().setService(OvsdbConnectionService.class).setRequired(true));
- c.add(createServiceDependency().setService(OvsdbInventoryListener.class).setRequired(true));
c.add(createServiceDependency().setService(EventDispatcher.class).setRequired(true));
+ c.add(createServiceDependency().setService(NeutronL3Adapter.class).setRequired(true));
}
if (imp.equals(NetworkHandler.class)) {
Properties networkHandlerProperties = new Properties();
networkHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY,
AbstractEvent.HandlerType.NEUTRON_NETWORK);
- c.setInterface(new String[] {INeutronNetworkAware.class.getName(),
- AbstractHandler.class.getName()},
+ c.setInterface(new String[]{INeutronNetworkAware.class.getName(),
+ AbstractHandler.class.getName()},
networkHandlerProperties);
c.add(createServiceDependency().setService(TenantNetworkManager.class).setRequired(true));
c.add(createServiceDependency().setService(BridgeConfigurationManager.class).setRequired(true));
c.add(createServiceDependency().setService(INeutronNetworkCRUD.class).setRequired(true));
c.add(createServiceDependency().setService(OvsdbInventoryListener.class).setRequired(true));
c.add(createServiceDependency().setService(EventDispatcher.class).setRequired(true));
+ c.add(createServiceDependency().setService(NeutronL3Adapter.class).setRequired(true));
}
if (imp.equals(SubnetHandler.class)) {
Properties subnetHandlerProperties = new Properties();
subnetHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_SUBNET);
- c.setInterface(new String[] {INeutronSubnetAware.class.getName(),
- AbstractHandler.class.getName()},
+ c.setInterface(new String[]{INeutronSubnetAware.class.getName(),
+ AbstractHandler.class.getName()},
subnetHandlerProperties);
c.add(createServiceDependency().setService(EventDispatcher.class).setRequired(true));
+ c.add(createServiceDependency().setService(NeutronL3Adapter.class).setRequired(true));
}
if (imp.equals(PortHandler.class)) {
Properties portHandlerProperties = new Properties();
portHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_PORT);
- c.setInterface(new String[] {INeutronPortAware.class.getName(),
- AbstractHandler.class.getName()},
+ c.setInterface(new String[]{INeutronPortAware.class.getName(),
+ AbstractHandler.class.getName()},
portHandlerProperties);
c.add(createServiceDependency().setService(OvsdbConfigurationService.class).setRequired(true));
c.add(createServiceDependency().setService(OvsdbConnectionService.class).setRequired(true));
c.add(createServiceDependency().setService(OvsdbInventoryListener.class).setRequired(true));
c.add(createServiceDependency().setService(EventDispatcher.class).setRequired(true));
+ c.add(createServiceDependency().setService(NeutronL3Adapter.class).setRequired(true));
}
if (imp.equals(RouterHandler.class)) {
Properties routerHandlerProperties = new Properties();
routerHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.NEUTRON_ROUTER);
- c.setInterface(new String[] {INeutronRouterAware.class.getName(),
- AbstractHandler.class.getName()},
+ c.setInterface(new String[]{INeutronRouterAware.class.getName(),
+ AbstractHandler.class.getName()},
routerHandlerProperties);
- c.add(createServiceDependency().setService(OvsdbConfigurationService.class).setRequired(true));
- c.add(createServiceDependency().setService(OvsdbConnectionService.class).setRequired(true));
- c.add(createServiceDependency().setService(OvsdbInventoryListener.class).setRequired(true));
c.add(createServiceDependency().setService(EventDispatcher.class).setRequired(true));
+ c.add(createServiceDependency().setService(NeutronL3Adapter.class).setRequired(true));
}
if (imp.equals(SouthboundHandler.class)) {
Properties southboundHandlerProperties = new Properties();
southboundHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.SOUTHBOUND);
- c.setInterface(new String[] {OvsdbInventoryListener.class.getName(),
- IInventoryListener.class.getName(),
- AbstractHandler.class.getName()},
+ c.setInterface(new String[]{OvsdbInventoryListener.class.getName(),
+ IInventoryListener.class.getName(),
+ AbstractHandler.class.getName()},
southboundHandlerProperties);
c.add(createServiceDependency().setService(
org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService.class).setRequired(true));
c.add(createServiceDependency().setService(OvsdbConfigurationService.class).setRequired(true));
c.add(createServiceDependency().setService(OvsdbConnectionService.class).setRequired(true));
c.add(createServiceDependency().setService(EventDispatcher.class).setRequired(true));
+ c.add(createServiceDependency().setService(NeutronL3Adapter.class).setRequired(true));
}
if (imp.equals(LBaaSHandler.class)) {
.setService(AbstractHandler.class)
.setCallbacks("eventHandlerAdded", "eventHandlerRemoved"));
}
+
+ if (imp.equals(NeutronL3Adapter.class)) {
+ c.setInterface(NeutronL3Adapter.class.getName(), null);
+
+ c.add(createServiceDependency().setService(MultiTenantAwareRouter.class).setRequired(true));
+ // TODO: it will require MultiTenantRouterForwardingProvider
+ // c.add(createServiceDependency().setService(MultiTenantRouterForwardingProvider.class).setRequired(true));
+ }
+
+ if (imp.equals(OpenstackRouter.class)) {
+ c.setInterface(MultiTenantAwareRouter.class.getName(), null);
+ }
}
}
import org.opendaylight.controller.networkconfig.neutron.INeutronFloatingIPAware;
import org.opendaylight.controller.networkconfig.neutron.NeutronFloatingIP;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
-import org.opendaylight.ovsdb.plugin.api.OvsdbInventoryListener;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
static final Logger logger = LoggerFactory.getLogger(FloatingIPHandler.class);
// The implementation for each of these services is resolved by the OSGi Service Manager
- private volatile OvsdbConfigurationService ovsdbConfigurationService;
- private volatile OvsdbConnectionService connectionService;
- private volatile OvsdbInventoryListener ovsdbInventoryListener;
+ private volatile NeutronL3Adapter neutronL3Adapter;
/**
* Services provide this interface method to indicate if the specified floatingIP can be created
*/
@Override
public void neutronFloatingIPCreated(NeutronFloatingIP floatingIP) {
- logger.debug(" Floating IP created {}, uuid {}",
- floatingIP.getFixedIPAddress(),
- floatingIP.getFloatingIPUUID());
+ enqueueEvent(new NorthboundEvent(floatingIP, AbstractEvent.Action.ADD));
}
/**
*/
@Override
public void neutronFloatingIPUpdated(NeutronFloatingIP floatingIP) {
- logger.debug(" Floating IP updated {}, uuid {}",
- floatingIP.getFixedIPAddress(),
- floatingIP.getFloatingIPUUID());
+ enqueueEvent(new NorthboundEvent(floatingIP, AbstractEvent.Action.UPDATE));
}
/**
*/
@Override
public void neutronFloatingIPDeleted(NeutronFloatingIP floatingIP) {
- logger.debug(" Floating IP deleted {}, uuid {}",
- floatingIP.getFixedIPAddress(),
- floatingIP.getFloatingIPUUID());
+ enqueueEvent(new NorthboundEvent(floatingIP, AbstractEvent.Action.DELETE));
}
/**
}
NorthboundEvent ev = (NorthboundEvent) abstractEvent;
switch (ev.getAction()) {
- // TODO: add handling of events here, once callbacks do something
- // other than logging.
+ case ADD:
+ // fall through
+ case DELETE:
+ // fall through
+ case UPDATE:
+ neutronL3Adapter.handleNeutronFloatingIPEvent(ev.getNeutronFloatingIP(), ev.getAction());
+ break;
default:
logger.warn("Unable to process event action " + ev.getAction());
break;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
import org.opendaylight.ovsdb.plugin.api.OvsdbInventoryListener;
private volatile OvsdbConnectionService connectionService;
private volatile INeutronNetworkCRUD neutronNetworkCache;
private volatile OvsdbInventoryListener ovsdbInventoryListener;
+ private volatile NeutronL3Adapter neutronL3Adapter;
/**
* Invoked when a network creation is requested
return;
}
+ enqueueEvent(new NorthboundEvent(network, AbstractEvent.Action.ADD));
+ }
+ private void doNeutronNetworkCreated(NeutronNetwork network) {
+ neutronL3Adapter.handleNeutronNetworkEvent(network, AbstractEvent.Action.ADD);
}
/**
*/
@Override
public void neutronNetworkUpdated(NeutronNetwork network) {
- logger.trace("neutronNetworkUpdated: network: {}", network);
- return;
+ enqueueEvent(new NorthboundEvent(network, AbstractEvent.Action.UPDATE));
+ }
+ private void doNeutronNetworkUpdated(NeutronNetwork network) {
+ neutronL3Adapter.handleNeutronNetworkEvent(network, AbstractEvent.Action.UPDATE);
}
/**
*/
@Override
public void neutronNetworkDeleted(NeutronNetwork network) {
+ enqueueEvent(new NorthboundEvent(network, AbstractEvent.Action.DELETE));
+ }
+ private void doNeutronNetworkDeleted(NeutronNetwork network) {
+ neutronL3Adapter.handleNeutronNetworkEvent(network, AbstractEvent.Action.DELETE);
int result = canDeleteNetwork(network);
logger.trace("canDeleteNetwork: network: {}", network);
}
NorthboundEvent ev = (NorthboundEvent) abstractEvent;
switch (ev.getAction()) {
- // TODO: add handling of events here, once callbacks do something
- // other than logging.
+ case ADD:
+ doNeutronNetworkCreated(ev.getNeutronNetwork());
+ break;
+ case UPDATE:
+ doNeutronNetworkUpdated(ev.getNeutronNetwork());
+ break;
+ case DELETE:
+ doNeutronNetworkDeleted(ev.getNeutronNetwork());
+ break;
default:
logger.warn("Unable to process event action " + ev.getAction());
break;
package org.opendaylight.ovsdb.openstack.netvirt;
+import org.opendaylight.controller.networkconfig.neutron.NeutronFloatingIP;
+import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
+import org.opendaylight.controller.networkconfig.neutron.NeutronRouter;
+import org.opendaylight.controller.networkconfig.neutron.NeutronRouter_Interface;
+import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
public class NorthboundEvent extends AbstractEvent {
private NeutronPort port;
+ private NeutronSubnet subnet;
+ private NeutronRouter router;
+ private NeutronRouter_Interface routerInterface;
+ private NeutronFloatingIP neutronFloatingIP;
+ private NeutronNetwork neutronNetwork;
NorthboundEvent(NeutronPort port, Action action) {
super(HandlerType.NEUTRON_PORT, action);
this.port = port;
}
+ NorthboundEvent(NeutronSubnet subnet, Action action) {
+ super(HandlerType.NEUTRON_SUBNET, action);
+ this.subnet = subnet;
+ }
+
+ NorthboundEvent(NeutronRouter router, Action action) {
+ super(HandlerType.NEUTRON_ROUTER, action);
+ this.router = router;
+ }
+
+ NorthboundEvent(NeutronRouter router, NeutronRouter_Interface routerInterface, Action action) {
+ super(HandlerType.NEUTRON_ROUTER, action);
+ this.router = router;
+ this.routerInterface = routerInterface;
+ }
+
+ NorthboundEvent(NeutronFloatingIP neutronFloatingIP, Action action) {
+ super(HandlerType.NEUTRON_FLOATING_IP, action);
+ this.neutronFloatingIP = neutronFloatingIP;
+ }
+
+ NorthboundEvent(NeutronNetwork neutronNetwork, Action action) {
+ super(HandlerType.NEUTRON_NETWORK, action);
+ this.neutronNetwork = neutronNetwork;
+ }
+
public NeutronPort getPort() {
return port;
}
+ public NeutronSubnet getSubnet() {
+ return subnet;
+ }
+ public NeutronRouter getRouter() {
+ return router;
+ }
+ public NeutronRouter_Interface getRouterInterface() {
+ return routerInterface;
+ }
+ public NeutronFloatingIP getNeutronFloatingIP() {
+ return neutronFloatingIP;
+ }
+ public NeutronNetwork getNeutronNetwork() {
+ return neutronNetwork;
+ }
@Override
public String toString() {
- return "NorthboundEvent [action=" + super.getAction() + ", port=" + port + "]";
+ return "NorthboundEvent [action=" + super.getAction()
+ + ", port=" + port
+ + ", subnet=" + subnet
+ + ", router=" + router
+ + ", routerInterface=" + routerInterface
+ + ", floatingIP=" + neutronFloatingIP
+ + ", network=" + neutronNetwork
+ + "]";
}
@Override
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((port == null) ? 0 : port.hashCode());
+ result = prime * result + ((subnet == null) ? 0 : subnet.hashCode());
+ result = prime * result + ((router == null) ? 0 : router.hashCode());
+ result = prime * result + ((routerInterface == null) ? 0 : routerInterface.hashCode());
+ result = prime * result + ((neutronFloatingIP == null) ? 0 : neutronFloatingIP.hashCode());
+ result = prime * result + ((neutronNetwork == null) ? 0 : neutronNetwork.hashCode());
return result;
}
return false;
} else if (!port.equals(other.port))
return false;
+ if (subnet == null) {
+ if (other.subnet != null)
+ return false;
+ } else if (!subnet.equals(other.subnet))
+ return false;
+ if (router == null) {
+ if (other.router != null)
+ return false;
+ } else if (!router.equals(other.router))
+ return false;
+ if (routerInterface == null) {
+ if (other.routerInterface != null)
+ return false;
+ } else if (!routerInterface.equals(other.routerInterface))
+ return false;
+ if (neutronFloatingIP == null) {
+ if (other.neutronFloatingIP != null)
+ return false;
+ } else if (!neutronFloatingIP.equals(other.neutronFloatingIP))
+ return false;
+ if (neutronNetwork == null) {
+ if (other.neutronNetwork != null)
+ return false;
+ } else if (!neutronNetwork.equals(other.neutronNetwork))
+ return false;
return true;
}
}
import org.opendaylight.ovsdb.lib.notation.Row;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
import org.opendaylight.ovsdb.plugin.api.OvsdbInventoryListener;
private volatile OvsdbConfigurationService ovsdbConfigurationService;
private volatile OvsdbConnectionService connectionService;
private volatile OvsdbInventoryListener ovsdbInventoryListener;
+ private volatile NeutronL3Adapter neutronL3Adapter;
/**
* Invoked when a port creation is requested
* @param port An instance of new Neutron Port object.
*/
@Override
- public void neutronPortCreated(NeutronPort port) {
- int result = canCreatePort(port);
+ public void neutronPortCreated(NeutronPort neutronPort) {
+ int result = canCreatePort(neutronPort);
if (result != HttpURLConnection.HTTP_CREATED) {
logger.error(" Port create validation failed result - {} ", result);
return;
}
- enqueueEvent(new NorthboundEvent(port, NorthboundEvent.Action.ADD));
+ enqueueEvent(new NorthboundEvent(neutronPort, NorthboundEvent.Action.ADD));
}
- private void doNeutronPortCreated(NeutronPort port) {
+ private void doNeutronPortCreated(NeutronPort neutronPort) {
logger.debug(" Port-ADD successful for tenant-id - {}," +
" network-id - {}, port-id - {}",
- port.getTenantID(), port.getNetworkUUID(),
- port.getID());
+ neutronPort.getTenantID(), neutronPort.getNetworkUUID(),
+ neutronPort.getID());
+ neutronL3Adapter.handleNeutronPortEvent(neutronPort, NorthboundEvent.Action.ADD);
}
/**
* @param port An instance of modified Neutron Port object.
*/
@Override
- public void neutronPortUpdated(NeutronPort port) {
+ public void neutronPortUpdated(NeutronPort neutronPort) {
+ enqueueEvent(new NorthboundEvent(neutronPort, NorthboundEvent.Action.UPDATE));
+ }
+ private void doNeutronPortUpdated(NeutronPort neutronPort) {
+ logger.debug("Handling neutron update port " + neutronPort);
+ neutronL3Adapter.handleNeutronPortEvent(neutronPort, NorthboundEvent.Action.UPDATE);
}
/**
}
private void doNeutronPortDeleted(NeutronPort neutronPort) {
logger.debug("Handling neutron delete port " + neutronPort);
+ neutronL3Adapter.handleNeutronPortEvent(neutronPort, NorthboundEvent.Action.DELETE);
List<Node> nodes = connectionService.getNodes();
for (Node node : nodes) {
case DELETE:
doNeutronPortDeleted(ev.getPort());
break;
+ case UPDATE:
+ doNeutronPortUpdated(ev.getPort());
+ break;
default:
logger.warn("Unable to process event action " + ev.getAction());
break;
import org.opendaylight.controller.networkconfig.neutron.INeutronRouterAware;
import org.opendaylight.controller.networkconfig.neutron.NeutronRouter;
import org.opendaylight.controller.networkconfig.neutron.NeutronRouter_Interface;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
-import org.opendaylight.ovsdb.plugin.api.OvsdbInventoryListener;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
static final Logger logger = LoggerFactory.getLogger(RouterHandler.class);
// The implementation for each of these services is resolved by the OSGi Service Manager
- private volatile OvsdbConfigurationService ovsdbConfigurationService;
- private volatile OvsdbConnectionService connectionService;
- private volatile OvsdbInventoryListener ovsdbInventoryListener;
+ private volatile NeutronL3Adapter neutronL3Adapter;
/**
* Services provide this interface method to indicate if the specified router can be created
*/
@Override
public void neutronRouterCreated(NeutronRouter router) {
- logger.debug(" Router created {}, uuid {}", router.getName(), router.getRouterUUID());
+ enqueueEvent(new NorthboundEvent(router, AbstractEvent.Action.ADD));
}
/**
*/
@Override
public void neutronRouterUpdated(NeutronRouter router) {
- logger.debug(" Router updated {}", router.getName());
+ enqueueEvent(new NorthboundEvent(router, AbstractEvent.Action.UPDATE));
}
/**
*/
@Override
public void neutronRouterDeleted(NeutronRouter router) {
- logger.debug(" Router deleted {}, uuid {}", router.getName(), router.getRouterUUID());
+ enqueueEvent(new NorthboundEvent(router, AbstractEvent.Action.DELETE));
}
/**
*/
@Override
public void neutronRouterInterfaceAttached(NeutronRouter router, NeutronRouter_Interface routerInterface) {
- logger.debug(" Router {} interface {} attached. Subnet {}", router.getName(), routerInterface.getPortUUID(),
- routerInterface.getSubnetUUID());
+ enqueueEvent(new NorthboundEvent(router, routerInterface, AbstractEvent.Action.ADD));
}
/**
*/
@Override
public void neutronRouterInterfaceDetached(NeutronRouter router, NeutronRouter_Interface routerInterface) {
- logger.debug(" Router {} interface {} detached. Subnet {}", router.getName(), routerInterface.getPortUUID(),
- routerInterface.getSubnetUUID());
+ enqueueEvent(new NorthboundEvent(router, routerInterface, AbstractEvent.Action.DELETE));
}
/**
}
NorthboundEvent ev = (NorthboundEvent) abstractEvent;
switch (ev.getAction()) {
- // TODO: add handling of events here, once callbacks do something
- // other than logging.
+ case ADD:
+ // fall through
+ case DELETE:
+ // fall through
+ case UPDATE:
+ if (ev.getRouterInterface() == null) {
+ neutronL3Adapter.handleNeutronRouterEvent(ev.getRouter(), ev.getAction());
+ } else {
+ neutronL3Adapter.handleNeutronRouterInterfaceEvent(ev.getRouter(),
+ ev.getRouterInterface(),
+ ev.getAction());
+ }
+ break;
default:
logger.warn("Unable to process event action " + ev.getAction());
break;
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
import org.opendaylight.ovsdb.plugin.api.OvsdbInventoryListener;
private volatile NetworkingProviderManager networkingProviderManager;
private volatile OvsdbConfigurationService ovsdbConfigurationService;
private volatile OvsdbConnectionService connectionService;
+ private volatile NeutronL3Adapter neutronL3Adapter;
void init() {
nodeCache = Lists.newArrayList();
logger.trace("Interface update of node: {}, uuid: {}", node, uuid);
NeutronNetwork network = tenantNetworkManager.getTenantNetwork(intf);
if (network != null) {
+ neutronL3Adapter.handleInterfaceEvent(node, intf, network, AbstractEvent.Action.UPDATE);
if (bridgeConfigurationManager.createLocalNetwork(node, network))
networkingProviderManager.getProvider(node).handleInterfaceUpdate(network, node, intf);
} else {
logger.debug("handleInterfaceDelete: node: {}, uuid: {}, isLastInstanceOnNode: {}, interface: {}",
node, uuid, isLastInstanceOnNode, intf);
+ neutronL3Adapter.handleInterfaceEvent(node, intf, network, AbstractEvent.Action.DELETE);
List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(node);
if (intf.getTypeColumn().getData().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN) ||
intf.getTypeColumn().getData().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) ||
import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetAware;
import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import com.google.common.base.Preconditions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
static final Logger logger = LoggerFactory.getLogger(SubnetHandler.class);
+ // The implementation for each of these services is resolved by the OSGi Service Manager
+ private volatile NeutronL3Adapter neutronL3Adapter;
+
@Override
public int canCreateSubnet(NeutronSubnet subnet) {
return HttpURLConnection.HTTP_CREATED;
@Override
public void neutronSubnetCreated(NeutronSubnet subnet) {
- logger.debug("Neutron Subnet Creation : {}", subnet.toString());
+ enqueueEvent(new NorthboundEvent(subnet, NorthboundEvent.Action.ADD));
}
@Override
@Override
public void neutronSubnetUpdated(NeutronSubnet subnet) {
- // TODO Auto-generated method stub
-
+ enqueueEvent(new NorthboundEvent(subnet, NorthboundEvent.Action.UPDATE));
}
@Override
@Override
public void neutronSubnetDeleted(NeutronSubnet subnet) {
- // TODO Auto-generated method stub
-
+ enqueueEvent(new NorthboundEvent(subnet, NorthboundEvent.Action.DELETE));
}
/**
}
NorthboundEvent ev = (NorthboundEvent) abstractEvent;
switch (ev.getAction()) {
- // TODO: add handling of events here, once callbacks do something
- // other than logging.
+ case ADD:
+ // fall through
+ case DELETE:
+ // fall through
+ case UPDATE:
+ Preconditions.checkNotNull(neutronL3Adapter);
+ neutronL3Adapter.handleNeutronSubnetEvent(ev.getSubnet(), ev.getAction());
+ break;
default:
logger.warn("Unable to process event action " + ev.getAction());
break;
--- /dev/null
+/*
+ * Copyright (C) 2014 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Authors : Dave Tucker, Flavio Fernandes
+ */
+
+package org.opendaylight.ovsdb.openstack.netvirt.impl;
+
+import org.opendaylight.controller.networkconfig.neutron.NeutronFloatingIP;
+import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
+import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
+import org.opendaylight.controller.networkconfig.neutron.NeutronRouter;
+import org.opendaylight.controller.networkconfig.neutron.NeutronRouter_Interface;
+import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent;
+import org.opendaylight.ovsdb.openstack.netvirt.NorthboundEvent;
+import org.opendaylight.ovsdb.openstack.netvirt.api.MultiTenantAwareRouter;
+import org.opendaylight.ovsdb.openstack.netvirt.api.MultiTenantRouterForwardingProvider;
+import org.opendaylight.ovsdb.schema.openvswitch.Interface;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Neutron L3 Adapter implements a hub-like adapter for the various Neutron events. Based on
+ * these events, the abstract router callbacks can be generated to the multi-tenant aware router,
+ * as well as the multi-tenant router forwarding provider.
+ */
+public class NeutronL3Adapter {
+
+ /**
+ * Logger instance.
+ */
+ static final Logger logger = LoggerFactory.getLogger(NeutronL3Adapter.class);
+
+ // The implementation for each of these services is resolved by the OSGi Service Manager
+ private volatile MultiTenantAwareRouter multiTenantAwareRouter;
+ private volatile MultiTenantRouterForwardingProvider multiTenantRouterForwardingProvider;
+
+ //
+ // Callbacks from OVSDB's northbound handlers
+ //
+
+ public void handleNeutronSubnetEvent(final NeutronSubnet subnet, NorthboundEvent.Action action) {
+ logger.debug("Neutron subnet {} event : {}", action, subnet.toString());
+
+ // TODO
+ }
+
+ public void handleNeutronPortEvent(final NeutronPort neutronPort, NorthboundEvent.Action action) {
+ logger.debug("Neutron port {} event : {}", action, neutronPort.toString());
+
+ // TODO
+
+ }
+
+ public void handleNeutronRouterEvent(final NeutronRouter neutronRouter, NorthboundEvent.Action action) {
+ logger.debug("Neutron router {} event : {}", action, neutronRouter.toString());
+
+ // TODO
+
+ }
+
+ public void handleNeutronRouterInterfaceEvent(final NeutronRouter neutronRouter,
+ final NeutronRouter_Interface neutronRouterInterface,
+ NorthboundEvent.Action action) {
+ logger.debug(" Router {} interface {} attached. Subnet {}", neutronRouter.getName(),
+ neutronRouterInterface.getPortUUID(),
+ neutronRouterInterface.getSubnetUUID());
+
+ // TODO
+
+ }
+
+ public void handleNeutronFloatingIPEvent(final NeutronFloatingIP neutronFloatingIP,
+ NorthboundEvent.Action action) {
+ logger.debug(" Floating IP {} {}, uuid {}", action,
+ neutronFloatingIP.getFixedIPAddress(),
+ neutronFloatingIP.getFloatingIPUUID());
+
+ // TODO
+ }
+
+ public void handleNeutronNetworkEvent(final NeutronNetwork neutronNetwork, NorthboundEvent.Action action) {
+ logger.debug("neutronNetwork {}: network: {}", action, neutronNetwork);
+
+ // TODO
+ }
+
+ //
+ // Callbacks from OVSDB's southbound handler
+ //
+
+ public void handleInterfaceEvent(final Node node, final Interface intf, NeutronNetwork neutronNetwork,
+ AbstractEvent.Action action) {
+ logger.debug("southbound interface {} node:{} interface:{}, neutronNetwork:{}",
+ action, node, intf, neutronNetwork);
+
+ // TODO
+ }
+
+}
import java.util.UUID;
/**
- * OpenStack router implements the MultiTenantAwareRouter interfaces
- * It provides routing functionality for multiple tenants in an OpenStack cloud
+ * OpenStack router implements the MultiTenantAwareRouter interfaces It provides routing functionality for multiple
+ * tenants in an OpenStack cloud
*/
public class OpenstackRouter implements MultiTenantAwareRouter {
+ @Override
+ public void addInterface(UUID tenantId, String interfaceName, Set<InterfaceAddress> addresses) {
- @Override
- public void addInterface(UUID tenantId, String interfaceName, Set<InterfaceAddress> addresses) {
+ }
- }
+ @Override
+ public void addInterface(UUID tenantId, String interfaceName, String macAddress, Set<InterfaceAddress> addresses) {
- @Override
- public void addInterface(UUID tenantId, String interfaceName, String macAddress, Set<InterfaceAddress> addresses) {
+ }
- }
+ @Override
+ public void updateInterface(UUID tenantId, String interfaceName, Set<InterfaceAddress> addresses) {
- @Override
- public void updateInterface(UUID tenantId, String interfaceName, Set<InterfaceAddress> addresses) {
+ }
- }
+ @Override
+ public void updateInterface(UUID tenantId, String interfaceName, String macAddress,
+ Set<InterfaceAddress> addresses) {
- @Override
- public void updateInterface(UUID tenantId, String interfaceName, String macAddress, Set<InterfaceAddress> addresses) {
+ }
- }
+ @Override
+ public void removeInterface(UUID tenantId, String interfaceName) {
- @Override
- public void removeInterface(UUID tenantId, String interfaceName) {
+ }
- }
+ @Override
+ public void addRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop) {
- @Override
- public void addRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop) {
+ }
- }
+ @Override
+ public void addRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop, Integer priority) {
- @Override
- public void addRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop, Integer priority) {
+ }
- }
+ @Override
+ public void removeRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop) {
- @Override
- public void removeRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop) {
+ }
- }
+ @Override
+ public void removeRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop, Integer priority) {
- @Override
- public void removeRoute(UUID tenantId, InterfaceAddress destination, InetAddress nextHop, Integer priority) {
+ }
- }
+ @Override
+ public void addDefaultRoute(UUID tenantId, InetAddress nextHop) {
- @Override
- public void addDefaultRoute(UUID tenantId, InetAddress nextHop) {
+ }
- }
+ @Override
+ public void addDefaultRoute(UUID tenantId, InetAddress nextHop, Integer priority) {
- @Override
- public void addDefaultRoute(UUID tenantId, InetAddress nextHop, Integer priority) {
-
- }
+ }
}
Code Review / ovsdb.git / commitdiff