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

   1 /*
   2  * Copyright (c) 2013, 2015 Red Hat, Inc. and others. 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.netvirt.openstack.netvirt;
  10
  11 import java.net.HttpURLConnection;
  12 import java.util.List;
  13
  14 import org.opendaylight.netvirt.openstack.netvirt.api.NodeCacheManager;
  15 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronNetwork;
  16 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronNetworkCRUD;
  17 import org.opendaylight.netvirt.openstack.netvirt.translator.iaware.INeutronNetworkAware;
  18 import org.opendaylight.netvirt.openstack.netvirt.api.Action;
  19 import org.opendaylight.netvirt.openstack.netvirt.api.BridgeConfigurationManager;
  20 import org.opendaylight.netvirt.openstack.netvirt.api.EventDispatcher;
  21 import org.opendaylight.netvirt.openstack.netvirt.api.Southbound;
  22 import org.opendaylight.netvirt.openstack.netvirt.api.TenantNetworkManager;
  23 import org.opendaylight.netvirt.openstack.netvirt.impl.NeutronL3Adapter;
  24 import org.opendaylight.netvirt.utils.servicehelper.ServiceHelper;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  26 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  27
  28 import org.osgi.framework.ServiceReference;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31
  32 /**
  33  * Handle requests for Neutron Network.
  34  */
  35 public class NetworkHandler extends AbstractHandler implements INeutronNetworkAware, ConfigInterface {
  36     private static final Logger LOG = LoggerFactory.getLogger(NetworkHandler.class);
  37     public static final String NETWORK_TYPE_VXLAN = "vxlan";
  38     public static final String NETWORK_TYPE_GRE = "gre";
  39     public static final String NETWORK_TYPE_VLAN = "vlan";
  40
  41     // The implementation for each of these services is resolved by the OSGi Service Manager
  42     private volatile TenantNetworkManager tenantNetworkManager;
  43     private volatile BridgeConfigurationManager bridgeConfigurationManager;
  44     private volatile NodeCacheManager nodeCacheManager;
  45     private volatile INeutronNetworkCRUD neutronNetworkCache;
  46     private volatile NeutronL3Adapter neutronL3Adapter;
  47     private volatile Southbound southbound;
  48
  49     /**
  50      * Invoked when a network creation is requested
  51      * to indicate if the specified network can be created.
  52      *
  53      * @param network  An instance of proposed new Neutron Network object.
  54      * @return A HTTP status code to the creation request.
  55      */
  56     @Override
  57     public int canCreateNetwork(NeutronNetwork network) {
  58         return HttpURLConnection.HTTP_OK;
  59     }
  60
  61     /**
  62      * Invoked to take action after a network has been created.
  63      *
  64      * @param network  An instance of new Neutron Network object.
  65      */
  66     @Override
  67     public void neutronNetworkCreated(NeutronNetwork network) {
  68         enqueueEvent(new NorthboundEvent(network, Action.ADD));
  69     }
  70     private void doNeutronNetworkCreated(NeutronNetwork network) {
  71         neutronL3Adapter.handleNeutronNetworkEvent(network, Action.ADD);
  72     }
  73
  74     /**
  75      * Invoked when a network update is requested
  76      * to indicate if the specified network can be changed
  77      * using the specified delta.
  78      *
  79      * @param delta     Updates to the network object using patch semantics.
  80      * @param original  An instance of the Neutron Network object
  81      *                  to be updated.
  82      * @return A HTTP status code to the update request.
  83      */
  84     @Override
  85     public int canUpdateNetwork(NeutronNetwork delta,
  86                                 NeutronNetwork original) {
  87         return HttpURLConnection.HTTP_OK;
  88     }
  89
  90     /**
  91      * Invoked to take action after a network has been updated.
  92      *
  93      * @param network An instance of modified Neutron Network object.
  94      */
  95     @Override
  96     public void neutronNetworkUpdated(NeutronNetwork network) {
  97         enqueueEvent(new NorthboundEvent(network, Action.UPDATE));
  98     }
  99     private void doNeutronNetworkUpdated(NeutronNetwork network) {
 100         neutronL3Adapter.handleNeutronNetworkEvent(network, Action.UPDATE);
 101     }
 102
 103     /**
 104      * Invoked when a network deletion is requested
 105      * to indicate if the specified network can be deleted.
 106      *
 107      * @param network  An instance of the Neutron Network object to be deleted.
 108      * @return A HTTP status code to the deletion request.
 109      */
 110     @Override
 111     public int canDeleteNetwork(NeutronNetwork network) {
 112         return HttpURLConnection.HTTP_OK;
 113     }
 114
 115     /**
 116      * Invoked to take action after a network has been deleted.
 117      *
 118      * @param network  An instance of deleted Neutron Network object.
 119      */
 120     @Override
 121     public void neutronNetworkDeleted(NeutronNetwork network) {
 122         enqueueEvent(new NorthboundEvent(network, Action.DELETE));
 123     }
 124     private void doNeutronNetworkDeleted(NeutronNetwork network) {
 125         neutronL3Adapter.handleNeutronNetworkEvent(network, Action.DELETE);
 126
 127         /* Is this the last Neutron tenant network */
 128         List <NeutronNetwork> networks;
 129         if (neutronNetworkCache != null) {
 130             networks = neutronNetworkCache.getAllNetworks();
 131             if (networks.isEmpty()) {
 132                 LOG.trace("neutronNetworkDeleted: last tenant network, delete tunnel ports...");
 133                 List<Node> nodes = nodeCacheManager.getNodes();
 134
 135                 for (Node node : nodes) {
 136                     List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(node);
 137                     try {
 138                         List<OvsdbTerminationPointAugmentation> ports = southbound.getTerminationPointsOfBridge(node);
 139                         for (OvsdbTerminationPointAugmentation port : ports) {
 140                             if (southbound.isTunnel(port)) {
 141                                 LOG.trace("Delete tunnel interface {}", port.getName());
 142                                 southbound.deleteTerminationPoint(node, port.getName());
 143                             } else if (!phyIfName.isEmpty() && phyIfName.contains(port.getName())) {
 144                                 LOG.trace("Delete physical interface {}", port.getName());
 145                                 southbound.deleteTerminationPoint(node, port.getName());
 146                             }
 147                         }
 148                     } catch (Exception e) {
 149                         LOG.error("Exception during handlingNeutron network delete", e);
 150                     }
 151                 }
 152             }
 153         }
 154         tenantNetworkManager.networkDeleted(network.getID());
 155     }
 156
 157     /**
 158      * Process the event.
 159      *
 160      * @param abstractEvent the {@link AbstractEvent} event to be handled.
 161      * @see EventDispatcher
 162      */
 163     @Override
 164     public void processEvent(AbstractEvent abstractEvent) {
 165         if (!(abstractEvent instanceof NorthboundEvent)) {
 166             LOG.error("Unable to process abstract event {}", abstractEvent);
 167             return;
 168         }
 169         NorthboundEvent ev = (NorthboundEvent) abstractEvent;
 170         switch (ev.getAction()) {
 171             case ADD:
 172                 doNeutronNetworkCreated(ev.getNeutronNetwork());
 173                 break;
 174             case UPDATE:
 175                 doNeutronNetworkUpdated(ev.getNeutronNetwork());
 176                 break;
 177             case DELETE:
 178                 doNeutronNetworkDeleted(ev.getNeutronNetwork());
 179                 break;
 180             default:
 181                 LOG.warn("Unable to process event action {}", ev.getAction());
 182                 break;
 183         }
 184     }
 185
 186     @Override
 187     public void setDependencies(ServiceReference serviceReference) {
 188         tenantNetworkManager =
 189                 (TenantNetworkManager) ServiceHelper.getGlobalInstance(TenantNetworkManager.class, this);
 190         bridgeConfigurationManager =
 191                 (BridgeConfigurationManager) ServiceHelper.getGlobalInstance(BridgeConfigurationManager.class, this);
 192         nodeCacheManager =
 193                 (NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
 194         neutronL3Adapter =
 195                 (NeutronL3Adapter) ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, this);
 196         southbound =
 197                 (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
 198         eventDispatcher =
 199                 (EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
 200         eventDispatcher.eventHandlerAdded(serviceReference, this);
 201     }
 202
 203     @Override
 204     public void setDependencies(Object impl) {
 205         if (impl instanceof INeutronNetworkCRUD) {
 206             neutronNetworkCache = (INeutronNetworkCRUD)impl;
 207         }
 208     }
 209 }