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 com.google.common.base.Preconditions;
  13 import java.util.List;
  14 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  15 import org.opendaylight.neutron.spi.INeutronPortCRUD;
  16 import org.opendaylight.neutron.spi.NeutronNetwork;
  17 import org.opendaylight.neutron.spi.NeutronPort;
  18 import org.opendaylight.ovsdb.openstack.netvirt.ConfigInterface;
  19 import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
  20 import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
  21 import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
  22 import org.opendaylight.ovsdb.openstack.netvirt.api.VlanConfigurationCache;
  23 import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  25 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  26 import org.osgi.framework.BundleContext;
  27 import org.osgi.framework.ServiceReference;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 public class TenantNetworkManagerImpl implements ConfigInterface, TenantNetworkManager {
  32     static final Logger logger = LoggerFactory.getLogger(TenantNetworkManagerImpl.class);
  33     private INeutronNetworkCRUD neutronNetworkCache;
  34     private INeutronPortCRUD neutronPortCache;
  35     private VlanConfigurationCache vlanConfigurationCache;
  36     private Southbound southbound;
  37
  38     @Override
  39     public int getInternalVlan(Node node, String networkId) {
  40         Integer vlan = vlanConfigurationCache.getInternalVlan(node, networkId);
  41         if (vlan == null) {
  42             return 0;
  43         }
  44         return vlan;
  45     }
  46
  47     @Override
  48     public void reclaimInternalVlan(Node node, NeutronNetwork network) {
  49         int vlan = vlanConfigurationCache.reclaimInternalVlan(node, network.getID());
  50         if (vlan <= 0) {
  51             logger.debug("Unable to get an internalVlan for Network {}", network);
  52             return;
  53         }
  54         logger.debug("Removed Vlan {} on {}", vlan);
  55     }
  56
  57     @Override
  58     public void programInternalVlan(Node node, OvsdbTerminationPointAugmentation tp, NeutronNetwork network) {
  59         int vlan = vlanConfigurationCache.getInternalVlan(node, network.getID());
  60         logger.debug("Programming Vlan {} on {}", vlan, tp);
  61         if (vlan <= 0) {
  62             logger.debug("Unable to get an internalVlan for Network {}", network);
  63             return;
  64         }
  65
  66         southbound.addVlanToTp(vlan);
  67     }
  68
  69     @Override
  70     public boolean isTenantNetworkPresentInNode(Node node, String segmentationId) {
  71         String networkId = this.getNetworkId(segmentationId);
  72         if (networkId == null) {
  73             logger.debug("Tenant Network not found with Segmenation-id {}",segmentationId);
  74             return false;
  75         }
  76
  77         try {
  78             List<OvsdbTerminationPointAugmentation> ports = southbound.getTerminationPointsOfBridge(node);
  79             for (OvsdbTerminationPointAugmentation port : ports) {
  80                 String ifaceId = southbound.getInterfaceExternalIdsValue(port, Constants.EXTERNAL_ID_INTERFACE_ID);
  81                 if (ifaceId != null && isInterfacePresentInTenantNetwork(ifaceId, networkId)) {
  82                     logger.debug("Tenant Network {} with Segmentation-id {} is present in Node {} / Interface {}",
  83                             networkId, segmentationId, node, port);
  84                     return true;
  85                 }
  86             }
  87         } catch (Exception e) {
  88             logger.error("Error while trying to determine if network is present on node", e);
  89             return false;
  90         }
  91
  92         logger.debug("Tenant Network {} with Segmenation-id {} is NOT present in Node {}",
  93                 networkId, segmentationId, node);
  94
  95         return false;
  96     }
  97
  98     @Override
  99     public String getNetworkId(String segmentationId) {
 100         Preconditions.checkNotNull(neutronNetworkCache);
 101         List <NeutronNetwork> networks = neutronNetworkCache.getAllNetworks();
 102         for (NeutronNetwork network : networks) {
 103             if (network.getProviderSegmentationID() != null &&
 104                     network.getProviderSegmentationID().equalsIgnoreCase(segmentationId)) {
 105                 return network.getNetworkUUID();
 106             }
 107         }
 108         return null;
 109     }
 110
 111     @Override
 112     public NeutronNetwork getTenantNetwork(OvsdbTerminationPointAugmentation terminationPointAugmentation) {
 113         Preconditions.checkNotNull(neutronNetworkCache);
 114         Preconditions.checkNotNull(neutronPortCache);
 115         NeutronNetwork neutronNetwork = null;
 116
 117         logger.debug("getTenantNetwork for {}", terminationPointAugmentation);
 118         String neutronPortId = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
 119                 Constants.EXTERNAL_ID_INTERFACE_ID);
 120         if (neutronPortId != null) {
 121             NeutronPort neutronPort = neutronPortCache.getPort(neutronPortId);
 122             if (neutronPort != null) {
 123                 neutronNetwork = neutronNetworkCache.getNetwork(neutronPort.getNetworkUUID());
 124                 if (neutronNetwork != null) {
 125                     logger.debug("mapped to {}", neutronNetwork);
 126                 } else {
 127                     logger.debug("getTenantNetwork: did not find neutronNetwork in cache from neutronPort {}",
 128                                  neutronPortId);
 129                 }
 130             } else {
 131                 logger.info("getTenantNetwork did not find neutronPort {} from termination point {}",
 132                         neutronPortId, terminationPointAugmentation.getName());
 133             }
 134         } else {
 135             logger.debug("getTenantNetwork: did not find {} in external_ids", Constants.EXTERNAL_ID_INTERFACE_ID);
 136         }
 137         return neutronNetwork;
 138     }
 139
 140     @Override
 141     public NeutronPort getTenantPort(OvsdbTerminationPointAugmentation terminationPointAugmentation) {
 142         Preconditions.checkNotNull(neutronPortCache);
 143         NeutronPort neutronPort = null;
 144
 145         logger.trace("getTenantPort for {}", terminationPointAugmentation.getName());
 146         String neutronPortId = southbound.getInterfaceExternalIdsValue(terminationPointAugmentation,
 147                 Constants.EXTERNAL_ID_INTERFACE_ID);
 148         if (neutronPortId != null) {
 149             neutronPort = neutronPortCache.getPort(neutronPortId);
 150         }
 151         if (neutronPort != null) {
 152             logger.debug("mapped to {}", neutronPort);
 153         } else {
 154             logger.warn("getTenantPort did not find port for {}", terminationPointAugmentation.getName());
 155         }
 156
 157         return neutronPort;
 158     }
 159
 160     @Override
 161     public int networkCreated (Node node, String networkId) {
 162         return vlanConfigurationCache.assignInternalVlan(node, networkId);
 163     }
 164
 165     @Override
 166     public void networkDeleted(String id) {
 167         //ToDo: Delete? This method does nothing since container support was dropped...
 168     }
 169
 170     private boolean isInterfacePresentInTenantNetwork (String portId, String networkId) {
 171         NeutronPort neutronPort = neutronPortCache.getPort(portId);
 172         return neutronPort != null && neutronPort.getNetworkUUID().equalsIgnoreCase(networkId);
 173     }
 174
 175     @Override
 176     public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
 177         vlanConfigurationCache =
 178                 (VlanConfigurationCache) ServiceHelper.getGlobalInstance(VlanConfigurationCache.class, this);
 179         southbound =
 180                 (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
 181     }
 182
 183     @Override
 184     public void setDependencies(Object impl) {
 185         if (impl instanceof INeutronNetworkCRUD) {
 186             neutronNetworkCache = (INeutronNetworkCRUD)impl;
 187         } else if (impl instanceof INeutronPortCRUD) {
 188             neutronPortCache = (INeutronPortCRUD)impl;
 189         }
 190     }
 191 }