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

   1 /*
   2  * Copyright (C) 2013 Red Hat, Inc. and others...
   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, Dave Tucker
   9  */
  10 package org.opendaylight.ovsdb.openstack.netvirt.impl;
  11
  12 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  13 import org.opendaylight.neutron.spi.INeutronPortCRUD;
  14 import org.opendaylight.neutron.spi.NeutronNetwork;
  15 import org.opendaylight.neutron.spi.NeutronPort;
  16 import org.opendaylight.ovsdb.lib.notation.OvsdbSet;
  17 import org.opendaylight.ovsdb.lib.notation.Row;
  18 import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
  19 import org.opendaylight.ovsdb.openstack.netvirt.api.MdsalConsumer;
  20 import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
  21 import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbConfigurationService;
  22 import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbConnectionService;
  23 import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
  24 import org.opendaylight.ovsdb.openstack.netvirt.api.VlanConfigurationCache;
  25 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  26 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  27 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  28
  29 import com.google.common.base.Preconditions;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 import java.util.List;
  34 import java.util.Map;
  35
  36 public class TenantNetworkManagerImpl implements TenantNetworkManager {
  37     static final Logger logger = LoggerFactory.getLogger(TenantNetworkManagerImpl.class);
  38
  39     // The implementation for each of these services is resolved by the OSGi Service Manager
  40     private volatile OvsdbConfigurationService ovsdbConfigurationService;
  41     private volatile OvsdbConnectionService connectionService;
  42     private volatile MdsalConsumer mdsalConsumer;
  43     private volatile INeutronNetworkCRUD neutronNetworkCache;
  44     private volatile INeutronPortCRUD neutronPortCache;
  45     private volatile VlanConfigurationCache vlanConfigurationCache;
  46
  47     public TenantNetworkManagerImpl() {
  48     }
  49
  50     @Override
  51     public int getInternalVlan(Node node, String networkId) {
  52         Integer vlan = vlanConfigurationCache.getInternalVlan(node, networkId);
  53         if (vlan == null) return 0;
  54         return vlan;
  55     }
  56
  57     @Override
  58     public void reclaimInternalVlan(Node node, String portUUID, NeutronNetwork network) {
  59         int vlan = vlanConfigurationCache.reclaimInternalVlan(node, network.getID());
  60         if (vlan <= 0) {
  61             logger.debug("Unable to get an internalVlan for Network {}", network);
  62             return;
  63         }
  64         logger.debug("Removed Vlan {} on {}", vlan, portUUID);
  65     }
  66
  67     @Override
  68     public void programInternalVlan(Node node, String portUUID, NeutronNetwork network) {
  69         /* TODO SB_MIGRATION */
  70         Preconditions.checkNotNull(ovsdbConfigurationService);
  71
  72         int vlan = vlanConfigurationCache.getInternalVlan(node, network.getID());
  73         logger.debug("Programming Vlan {} on {}", vlan, portUUID);
  74         if (vlan <= 0) {
  75             logger.debug("Unable to get an internalVlan for Network {}", network);
  76             return;
  77         }
  78
  79         Port port = ovsdbConfigurationService.createTypedRow(node, Port.class);
  80         OvsdbSet<Long> tags = new OvsdbSet<>();
  81         tags.add((long) vlan);
  82         port.setTag(tags);
  83         ovsdbConfigurationService.updateRow(node, port.getSchema().getName(), null, portUUID, port.getRow());
  84     }
  85
  86     @Override
  87     public boolean isTenantNetworkPresentInNode(Node node, String segmentationId) {
  88         /* TODO SB_MIGRATION */
  89         Preconditions.checkNotNull(ovsdbConfigurationService);
  90
  91         String networkId = this.getNetworkId(segmentationId);
  92         if (networkId == null) {
  93             logger.debug("Tenant Network not found with Segmenation-id {}",segmentationId);
  94             return false;
  95         }
  96
  97         try {
  98             /* TODO SB_MIGRATION this code was already commented out
  99             // Vlan Tag based identification
 100             Map<String, Row> portTable = ovsdbConfigService.getRows(node, Port.NAME.getName());
 101             if (portTable == null) {
 102                 logger.debug("Port table is null for Node {} ", node);
 103                 return false;
 104             }
 105
 106             for (Row row : portTable.values()) {
 107                 Port port = (Port)row;
 108                 Set<BigInteger> tags = port.getTag();
 109                 if (tags.contains(internalVlan)) {
 110                     logger.debug("Tenant Network {} with Segmenation-id {} is present in Node {} / Port {}",
 111                                   networkId, segmentationId, node, port);
 112                     return true;
 113                 }
 114             }
 115              */ //TODO SB_MIGRATION this code was already commented out
 116             // External-id based more accurate VM Location identification
 117             Map<String, Row> ifTable = ovsdbConfigurationService.getRows(node, ovsdbConfigurationService.getTableName(node, Interface.class));
 118             if (ifTable == null) {
 119                 logger.debug("Interface table is null for Node {} ", node);
 120                 return false;
 121             }
 122
 123             for (Row row : ifTable.values()) {
 124                 Interface intf = ovsdbConfigurationService.getTypedRow(node, Interface.class, row);
 125                 Map<String, String> externalIds = intf.getExternalIdsColumn().getData();
 126                 if (externalIds != null && externalIds.get(Constants.EXTERNAL_ID_INTERFACE_ID) != null) {
 127                     if (this.isInterfacePresentInTenantNetwork(externalIds.get(Constants.EXTERNAL_ID_INTERFACE_ID), networkId)) {
 128                         logger.debug("Tenant Network {} with Segmentation-id {} is present in Node {} / Interface {}",
 129                                       networkId, segmentationId, node, intf);
 130                         return true;
 131                     }
 132                 }
 133             }
 134
 135         } catch (Exception e) {
 136             logger.error("Error while trying to determine if network is present on node", e);
 137             return false;
 138         }
 139
 140         logger.debug("Tenant Network {} with Segmenation-id {} is NOT present in Node {}",
 141                 networkId, segmentationId, node);
 142
 143         return false;
 144     }
 145
 146     @Override
 147     public String getNetworkId(String segmentationId) {
 148         List <NeutronNetwork> networks = neutronNetworkCache.getAllNetworks();
 149         for (NeutronNetwork network : networks) {
 150             if (network.getProviderSegmentationID().equalsIgnoreCase(segmentationId)) return network.getNetworkUUID();
 151         }
 152         return null;
 153     }
 154
 155     @Override
 156     public NeutronNetwork getTenantNetwork(Interface intf) {
 157         logger.trace("getTenantNetwork for {}", intf);
 158         if (intf == null) return null;
 159         Map<String, String> externalIds = intf.getExternalIdsColumn().getData();
 160         logger.trace("externalIds {}", externalIds);
 161         if (externalIds == null) return null;
 162         String neutronPortId = externalIds.get(Constants.EXTERNAL_ID_INTERFACE_ID);
 163         if (neutronPortId == null) return null;
 164         NeutronPort neutronPort = neutronPortCache.getPort(neutronPortId);
 165         logger.trace("neutronPort {}", neutronPort);
 166         if (neutronPort == null) return null;
 167         NeutronNetwork neutronNetwork = neutronNetworkCache.getNetwork(neutronPort.getNetworkUUID());
 168         logger.debug("{} mapped to {}", intf, neutronNetwork);
 169         return neutronNetwork;
 170     }
 171
 172     @Override
 173     public int networkCreated (Node node, String networkId) {
 174         return vlanConfigurationCache.assignInternalVlan(node, networkId);
 175     }
 176
 177     @Override
 178     public void networkDeleted(String id) {
 179         //ToDo: Delete? This method does nothing how we dropped container support...
 180     }
 181
 182     private boolean isInterfacePresentInTenantNetwork (String portId, String networkId) {
 183         NeutronPort neutronPort = neutronPortCache.getPort(portId);
 184         return neutronPort != null && neutronPort.getNetworkUUID().equalsIgnoreCase(networkId);
 185     }
 186
 187 }