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