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

   1 /*
   2  * Copyright (C) 2013 Red Hat, Inc.
   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  * Authors : Madhu Venugopal, Brent Salisbury, Hsin-Yi Shen
   9  */
  10 package org.opendaylight.ovsdb.openstack.netvirt;
  11
  12 import org.opendaylight.neutron.spi.INeutronNetworkAware;
  13 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  14 import org.opendaylight.neutron.spi.NeutronNetwork;
  15 import org.opendaylight.ovsdb.lib.notation.Row;
  16 import org.opendaylight.ovsdb.lib.notation.UUID;
  17 import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
  18 import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
  19 //import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
  20 import org.opendaylight.ovsdb.openstack.netvirt.api.MdsalConsumer;
  21 import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
  22 import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
  23 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  24 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  26
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29
  30 import java.net.HttpURLConnection;
  31 import java.util.List;
  32 import java.util.concurrent.ConcurrentMap;
  33
  34 /**
  35  * Handle requests for Neutron Network.
  36  */
  37 public class NetworkHandler extends AbstractHandler
  38                             implements INeutronNetworkAware {
  39
  40     public static final String NETWORK_TYPE_VXLAN = "vxlan";
  41     public static final String NETWORK_TYPE_GRE = "gre";
  42     public static final String NETWORK_TYPE_VLAN = "vlan";
  43
  44     /**
  45      * Logger instance.
  46      */
  47     static final Logger logger = LoggerFactory.getLogger(NetworkHandler.class);
  48
  49     // The implementation for each of these services is resolved by the OSGi Service Manager
  50     private volatile TenantNetworkManager tenantNetworkManager;
  51     private volatile BridgeConfigurationManager bridgeConfigurationManager;
  52     /* TODO SB_MIGRATION */
  53     //private volatile OvsdbConfigurationService ovsdbConfigurationService;
  54     //private volatile OvsdbConnectionService connectionService;
  55     private volatile MdsalConsumer mdsalConsumer; // TODO SB_MIGRATION
  56     private volatile INeutronNetworkCRUD neutronNetworkCache;
  57     private volatile NeutronL3Adapter neutronL3Adapter;
  58
  59     /**
  60      * Invoked when a network creation is requested
  61      * to indicate if the specified network can be created.
  62      *
  63      * @param network  An instance of proposed new Neutron Network object.
  64      * @return A HTTP status code to the creation request.
  65      */
  66     @Override
  67     public int canCreateNetwork(NeutronNetwork network) {
  68         if (network.isShared()) {
  69             logger.error(" Network shared attribute not supported ");
  70             return HttpURLConnection.HTTP_NOT_ACCEPTABLE;
  71         }
  72
  73         return HttpURLConnection.HTTP_CREATED;
  74     }
  75
  76     /**
  77      * Invoked to take action after a network has been created.
  78      *
  79      * @param network  An instance of new Neutron Network object.
  80      */
  81     @Override
  82     public void neutronNetworkCreated(NeutronNetwork network) {
  83         int result = HttpURLConnection.HTTP_BAD_REQUEST;
  84         logger.trace("neutronNetworkCreated: network: {}", network);
  85         result = canCreateNetwork(network);
  86         if (result != HttpURLConnection.HTTP_CREATED) {
  87             logger.debug("Network creation failed {} ", result);
  88             return;
  89         }
  90
  91         enqueueEvent(new NorthboundEvent(network, Action.ADD));
  92     }
  93     private void doNeutronNetworkCreated(NeutronNetwork network) {
  94         neutronL3Adapter.handleNeutronNetworkEvent(network, Action.ADD);
  95     }
  96
  97     /**
  98      * Invoked when a network update is requested
  99      * to indicate if the specified network can be changed
 100      * using the specified delta.
 101      *
 102      * @param delta     Updates to the network object using patch semantics.
 103      * @param original  An instance of the Neutron Network object
 104      *                  to be updated.
 105      * @return A HTTP status code to the update request.
 106      */
 107     @Override
 108     public int canUpdateNetwork(NeutronNetwork delta,
 109                                 NeutronNetwork original) {
 110         logger.trace("canUpdateNetwork: network delta {} --- original {}", delta, original);
 111         return HttpURLConnection.HTTP_OK;
 112     }
 113
 114     /**
 115      * Invoked to take action after a network has been updated.
 116      *
 117      * @param network An instance of modified Neutron Network object.
 118      */
 119     @Override
 120     public void neutronNetworkUpdated(NeutronNetwork network) {
 121         enqueueEvent(new NorthboundEvent(network, Action.UPDATE));
 122     }
 123     private void doNeutronNetworkUpdated(NeutronNetwork network) {
 124         neutronL3Adapter.handleNeutronNetworkEvent(network, Action.UPDATE);
 125     }
 126
 127     /**
 128      * Invoked when a network deletion is requested
 129      * to indicate if the specified network can be deleted.
 130      *
 131      * @param network  An instance of the Neutron Network object to be deleted.
 132      * @return A HTTP status code to the deletion request.
 133      */
 134     @Override
 135     public int canDeleteNetwork(NeutronNetwork network) {
 136         return HttpURLConnection.HTTP_OK;
 137     }
 138
 139     /**
 140      * Invoked to take action after a network has been deleted.
 141      *
 142      * @param network  An instance of deleted Neutron Network object.
 143      */
 144     @Override
 145     public void neutronNetworkDeleted(NeutronNetwork network) {
 146         enqueueEvent(new NorthboundEvent(network, Action.DELETE));
 147     }
 148     private void doNeutronNetworkDeleted(NeutronNetwork network) {
 149         /* TODO SB_MIGRATION
 150         neutronL3Adapter.handleNeutronNetworkEvent(network, Action.DELETE);
 151
 152         int result = canDeleteNetwork(network);
 153         logger.trace("canDeleteNetwork: network: {}", network);
 154         if  (result != HttpURLConnection.HTTP_OK) {
 155             logger.error(" deleteNetwork validation failed for result - {} ",
 156                     result);
 157             return;
 158         }
 159         *//* Is this the last Neutron tenant network *//*
 160         List <NeutronNetwork> networks;
 161         if (neutronNetworkCache != null) {
 162             networks = neutronNetworkCache.getAllNetworks();
 163             if (networks.isEmpty()) {
 164                 logger.trace("neutronNetworkDeleted: last tenant network, delete tunnel ports...");
 165                 List<Node> nodes = connectionService.getNodes();
 166
 167                 for (Node node : nodes) {
 168                     List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(node);
 169                     try {
 170                         ConcurrentMap<String, Row> ports =
 171                                 this.ovsdbConfigurationService.getRows(node,
 172                                                                 ovsdbConfigurationService.getTableName(node, Port.class));
 173                         if (ports != null) {
 174                             for (Row portRow : ports.values()) {
 175                                 Port port = ovsdbConfigurationService.getTypedRow(node, Port.class, portRow);
 176                                 for (UUID interfaceUuid : port.getInterfacesColumn().getData()) {
 177                                     Row ifaceRow = ovsdbConfigurationService
 178                                             .getRow(node,
 179                                                     ovsdbConfigurationService.getTableName(node, Interface.class),
 180                                                     interfaceUuid.toString());
 181                                     Interface iface = ovsdbConfigurationService.getTypedRow(node, Interface.class, ifaceRow);
 182                                     String interfaceType = iface.getTypeColumn().getData();
 183                                     if (interfaceType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)
 184                                         || interfaceType.equalsIgnoreCase(
 185                                             NetworkHandler.NETWORK_TYPE_GRE)) {
 186                                         *//* delete tunnel ports on this node *//*
 187                                         logger.trace("Delete tunnel interface {}", iface.getName());
 188                                         ovsdbConfigurationService.deleteRow(node,
 189                                                                      ovsdbConfigurationService.getTableName(node, Port.class),
 190                                                                      port.getUuid().toString());
 191                                         break;
 192                                     } else if (!phyIfName.isEmpty() && phyIfName.contains(iface.getName())) {
 193                                         logger.trace("Delete physical interface {}", iface.getName());
 194                                         ovsdbConfigurationService.deleteRow(node,
 195                                                                      ovsdbConfigurationService.getTableName(node, Port.class),
 196                                                                      port.getUuid().toString());
 197                                         break;
 198                                     }
 199                                 }
 200                             }
 201                         }
 202                     } catch (Exception e) {
 203                         logger.error("Exception during handlingNeutron network delete", e);
 204                     }
 205                 }
 206             }
 207         }
 208         tenantNetworkManager.networkDeleted(network.getID());*/
 209     }
 210
 211     /**
 212      * Process the event.
 213      *
 214      * @param abstractEvent the {@link org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent} event to be handled.
 215      * @see org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher
 216      */
 217     @Override
 218     public void processEvent(AbstractEvent abstractEvent) {
 219         if (!(abstractEvent instanceof NorthboundEvent)) {
 220             logger.error("Unable to process abstract event " + abstractEvent);
 221             return;
 222         }
 223         NorthboundEvent ev = (NorthboundEvent) abstractEvent;
 224         switch (ev.getAction()) {
 225             case ADD:
 226                 doNeutronNetworkCreated(ev.getNeutronNetwork());
 227                 break;
 228             case UPDATE:
 229                 doNeutronNetworkUpdated(ev.getNeutronNetwork());
 230                 break;
 231             case DELETE:
 232                 doNeutronNetworkDeleted(ev.getNeutronNetwork());
 233                 break;
 234             default:
 235                 logger.warn("Unable to process event action " + ev.getAction());
 236                 break;
 237         }
 238     }
 239
 240 }