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