transcriber/src/main/java/org/opendaylight/neutron/transcriber/NeutronPortInterface.java

   1 /*
   2  * Copyright IBM Corporation, 2013.  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.neutron.transcriber;
  10
  11 import java.lang.reflect.Method;
  12 import java.util.ArrayList;
  13 import java.util.HashSet;
  14 import java.util.Iterator;
  15 import java.util.List;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18 import java.util.concurrent.ConcurrentHashMap;
  19 import java.util.concurrent.ConcurrentMap;
  20
  21 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  22 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  23 import org.opendaylight.neutron.spi.INeutronPortCRUD;
  24 import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
  25 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  26 import org.opendaylight.neutron.spi.NeutronNetwork;
  27 import org.opendaylight.neutron.spi.NeutronPort;
  28 import org.opendaylight.neutron.spi.NeutronPort_AllowedAddressPairs;
  29 import org.opendaylight.neutron.spi.NeutronPort_ExtraDHCPOption;
  30 import org.opendaylight.neutron.spi.NeutronSecurityGroup;
  31 import org.opendaylight.neutron.spi.NeutronSubnet;
  32 import org.opendaylight.neutron.spi.Neutron_IPs;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.port.attrs.AllowedAddressPairs;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.port.attrs.AllowedAddressPairsBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.port.attrs.ExtraDhcpOpts;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.port.attrs.ExtraDhcpOptsBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.port.attrs.FixedIps;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.port.attrs.FixedIpsBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.ports.attributes.Ports;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.ports.attributes.ports.Port;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev141002.ports.attributes.ports.PortBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
  45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 public class NeutronPortInterface extends AbstractNeutronInterface<Port, NeutronPort> implements INeutronPortCRUD {
  50     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronPortInterface.class);
  51     private ConcurrentMap<String, NeutronPort> portDB = new ConcurrentHashMap<String, NeutronPort>();
  52
  53
  54     NeutronPortInterface(ProviderContext providerContext) {
  55         super(providerContext);
  56     }
  57
  58     // this method uses reflection to update an object from it's delta.
  59
  60     private boolean overwrite(Object target, Object delta) {
  61         Method[] methods = target.getClass().getMethods();
  62
  63         for(Method toMethod: methods){
  64             if(toMethod.getDeclaringClass().equals(target.getClass())
  65                     && toMethod.getName().startsWith("set")){
  66
  67                 String toName = toMethod.getName();
  68                 String fromName = toName.replace("set", "get");
  69
  70                 try {
  71                     Method fromMethod = delta.getClass().getMethod(fromName);
  72                     Object value = fromMethod.invoke(delta, (Object[])null);
  73                     if(value != null){
  74                         toMethod.invoke(target, value);
  75                     }
  76                 } catch (Exception e) {
  77                     LOGGER.error(e.getMessage());
  78                     return false;
  79                 }
  80             }
  81         }
  82         return true;
  83     }
  84
  85     // IfNBPortCRUD methods
  86
  87     @Override
  88     public boolean portExists(String uuid) {
  89         return portDB.containsKey(uuid);
  90     }
  91
  92     @Override
  93     public NeutronPort getPort(String uuid) {
  94         if (!portExists(uuid)) {
  95             return null;
  96         }
  97         return portDB.get(uuid);
  98     }
  99
 100     @Override
 101     public List<NeutronPort> getAllPorts() {
 102         Set<NeutronPort> allPorts = new HashSet<NeutronPort>();
 103         for (Entry<String, NeutronPort> entry : portDB.entrySet()) {
 104             NeutronPort port = entry.getValue();
 105             allPorts.add(port);
 106         }
 107         LOGGER.debug("Exiting getAllPorts, Found {} OpenStackPorts", allPorts.size());
 108         List<NeutronPort> ans = new ArrayList<NeutronPort>();
 109         ans.addAll(allPorts);
 110         return ans;
 111     }
 112
 113     @Override
 114     public boolean addPort(NeutronPort input) {
 115         if (portExists(input.getID())) {
 116             return false;
 117         }
 118         portDB.putIfAbsent(input.getID(), input);
 119         // if there are no fixed IPs, allocate one for each subnet in the network
 120         INeutronSubnetCRUD systemCRUD = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
 121         if (input.getFixedIPs() == null){
 122            input.setFixedIPs(new ArrayList<Neutron_IPs>());
 123         }
 124         if (input.getFixedIPs().size() == 0) {
 125             List<Neutron_IPs> list = input.getFixedIPs();
 126             Iterator<NeutronSubnet> subnetIterator = systemCRUD.getAllSubnets().iterator();
 127             while (subnetIterator.hasNext()) {
 128                 NeutronSubnet subnet = subnetIterator.next();
 129                 if (subnet.getNetworkUUID().equals(input.getNetworkUUID())) {
 130                     list.add(new Neutron_IPs(subnet.getID()));
 131                 }
 132             }
 133         }
 134         Iterator<Neutron_IPs> fixedIPIterator = input.getFixedIPs().iterator();
 135         while (fixedIPIterator.hasNext()) {
 136             Neutron_IPs ip = fixedIPIterator.next();
 137             NeutronSubnet subnet = systemCRUD.getSubnet(ip.getSubnetUUID());
 138             if (ip.getIpAddress() == null) {
 139                 ip.setIpAddress(subnet.getLowAddr());
 140             }
 141             if (!ip.getIpAddress().equals(subnet.getGatewayIP())) {
 142                 subnet.allocateIP(ip.getIpAddress());
 143             }
 144             else {
 145                 subnet.setGatewayIPAllocated();
 146             }
 147             subnet.addPort(input);
 148         }
 149         INeutronNetworkCRUD networkIf = NeutronCRUDInterfaces.getINeutronNetworkCRUD(this);
 150
 151         NeutronNetwork network = networkIf.getNetwork(input.getNetworkUUID());
 152         network.addPort(input);
 153         return true;
 154     }
 155
 156     @Override
 157     public boolean removePort(String uuid) {
 158         if (!portExists(uuid)) {
 159             return false;
 160         }
 161         NeutronPort port = getPort(uuid);
 162         portDB.remove(uuid);
 163         INeutronNetworkCRUD networkCRUD = NeutronCRUDInterfaces.getINeutronNetworkCRUD(this);
 164         INeutronSubnetCRUD systemCRUD = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
 165
 166         NeutronNetwork network = networkCRUD.getNetwork(port.getNetworkUUID());
 167         network.removePort(port);
 168         Iterator<Neutron_IPs> fixedIPIterator = port.getFixedIPs().iterator();
 169         while (fixedIPIterator.hasNext()) {
 170             Neutron_IPs ip = fixedIPIterator.next();
 171             NeutronSubnet subnet = systemCRUD.getSubnet(ip.getSubnetUUID());
 172             if (!ip.getIpAddress().equals(subnet.getGatewayIP())) {
 173                 subnet.releaseIP(ip.getIpAddress());
 174             }
 175             else {
 176                 subnet.resetGatewayIPAllocated();
 177             }
 178             subnet.removePort(port);
 179         }
 180         return true;
 181     }
 182
 183     @Override
 184     public boolean updatePort(String uuid, NeutronPort delta) {
 185         if (!portExists(uuid)) {
 186             return false;
 187         }
 188         NeutronPort target = portDB.get(uuid);
 189         // remove old Fixed_IPs
 190         if (delta.getFixedIPs() != null) {
 191             NeutronPort port = getPort(uuid);
 192             INeutronSubnetCRUD systemCRUD = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
 193             for (Neutron_IPs ip: port.getFixedIPs()) {
 194                 NeutronSubnet subnet = systemCRUD.getSubnet(ip.getSubnetUUID());
 195                 subnet.releaseIP(ip.getIpAddress());
 196             }
 197
 198             // allocate new Fixed_IPs
 199             for (Neutron_IPs ip: delta.getFixedIPs()) {
 200                 NeutronSubnet subnet = systemCRUD.getSubnet(ip.getSubnetUUID());
 201                 if (ip.getIpAddress() == null) {
 202                     ip.setIpAddress(subnet.getLowAddr());
 203                 }
 204                 subnet.allocateIP(ip.getIpAddress());
 205             }
 206         }
 207         return overwrite(target, delta);
 208     }
 209
 210     @Override
 211     public boolean macInUse(String macAddress) {
 212         List<NeutronPort> ports = getAllPorts();
 213         Iterator<NeutronPort> portIterator = ports.iterator();
 214         while (portIterator.hasNext()) {
 215             NeutronPort port = portIterator.next();
 216             if (macAddress.equalsIgnoreCase(port.getMacAddress())) {
 217                 return true;
 218             }
 219         }
 220         return false;
 221     }
 222
 223     @Override
 224     public NeutronPort getGatewayPort(String subnetUUID) {
 225         INeutronSubnetCRUD systemCRUD = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
 226         NeutronSubnet subnet = systemCRUD.getSubnet(subnetUUID);
 227         Iterator<NeutronPort> portIterator = getAllPorts().iterator();
 228         while (portIterator.hasNext()) {
 229             NeutronPort port = portIterator.next();
 230             List<Neutron_IPs> fixedIPs = port.getFixedIPs();
 231             if (fixedIPs.size() == 1) {
 232                 if (subnet.getGatewayIP().equals(fixedIPs.get(0).getIpAddress())) {
 233                     return port;
 234                 }
 235             }
 236         }
 237         return null;
 238     }
 239
 240     @Override
 241     protected InstanceIdentifier<Port> createInstanceIdentifier(Port port) {
 242         return InstanceIdentifier.create(Neutron.class)
 243                 .child(Ports.class)
 244                 .child(Port.class, port.getKey());
 245     }
 246
 247     @Override
 248     protected Port toMd(NeutronPort neutronPort) {
 249         PortBuilder portBuilder = new PortBuilder();
 250         portBuilder.setAdminStateUp(neutronPort.isAdminStateUp());
 251         if(neutronPort.getAllowedAddressPairs() != null) {
 252             List<AllowedAddressPairs> listAllowedAddressPairs = new ArrayList<AllowedAddressPairs>();
 253             for (NeutronPort_AllowedAddressPairs allowedAddressPairs : neutronPort.getAllowedAddressPairs()) {
 254                     AllowedAddressPairsBuilder allowedAddressPairsBuilder = new AllowedAddressPairsBuilder();
 255                     allowedAddressPairsBuilder.setIpAddress(allowedAddressPairs.getIpAddress());
 256                     allowedAddressPairsBuilder.setMacAddress(allowedAddressPairs.getMacAddress());
 257                     allowedAddressPairsBuilder.setPortId(allowedAddressPairs.getPortID());
 258                     listAllowedAddressPairs.add(allowedAddressPairsBuilder.build());
 259             }
 260             portBuilder.setAllowedAddressPairs(listAllowedAddressPairs);
 261         }
 262         if (neutronPort.getBindinghostID() != null) {
 263             portBuilder.setBindingProfile(neutronPort.getBindinghostID());
 264         }
 265         if (neutronPort.getDeviceID() != null) {
 266             portBuilder.setDeviceId(toUuid(neutronPort.getDeviceID()));
 267         }
 268         if (neutronPort.getDeviceOwner() != null) {
 269         portBuilder.setDeviceOwner(neutronPort.getDeviceOwner());
 270         }
 271         if (neutronPort.getExtraDHCPOptions() != null) {
 272             List<ExtraDhcpOpts> listExtraDHCPOptions = new ArrayList<ExtraDhcpOpts>();
 273             for (NeutronPort_ExtraDHCPOption extraDHCPOption : neutronPort.getExtraDHCPOptions()) {
 274                 ExtraDhcpOptsBuilder extraDHCPOptsBuilder = new ExtraDhcpOptsBuilder();
 275                 extraDHCPOptsBuilder.setOptName(extraDHCPOption.getName());
 276                 extraDHCPOptsBuilder.setOptValue(extraDHCPOption.getValue());
 277                 listExtraDHCPOptions.add(extraDHCPOptsBuilder.build());
 278             }
 279             portBuilder.setExtraDhcpOpts(listExtraDHCPOptions);
 280         }
 281         if (neutronPort.getFixedIPs() != null) {
 282             List<FixedIps> listNeutronIPs = new ArrayList<FixedIps>();
 283             for (Neutron_IPs neutron_IPs : neutronPort.getFixedIPs()) {
 284                 FixedIpsBuilder fixedIpsBuilder = new FixedIpsBuilder();
 285                 fixedIpsBuilder.setIpAddress(new IpAddress(neutron_IPs.getIpAddress().toCharArray()));
 286                 fixedIpsBuilder.setSubnetId(toUuid(neutron_IPs.getSubnetUUID()));
 287                 listNeutronIPs.add(fixedIpsBuilder.build());
 288             }
 289             portBuilder.setFixedIps(listNeutronIPs);
 290         }
 291         if (neutronPort.getMacAddress() != null) {
 292             portBuilder.setMacAddress(neutronPort.getMacAddress());
 293         }
 294         if (neutronPort.getName() != null) {
 295         portBuilder.setName(neutronPort.getName());
 296         }
 297         if (neutronPort.getNetworkUUID() != null) {
 298         portBuilder.setNetworkId(toUuid(neutronPort.getNetworkUUID()));
 299         }
 300         if (neutronPort.getSecurityGroups() != null) {
 301             List<Uuid> listSecurityGroups = new ArrayList<Uuid>();
 302             for (NeutronSecurityGroup neutronSecurityGroup : neutronPort.getSecurityGroups()) {
 303                 listSecurityGroups.add(toUuid(neutronSecurityGroup.getSecurityGroupUUID()));
 304             }
 305             portBuilder.setSecurityGroups(listSecurityGroups);
 306         }
 307         if (neutronPort.getStatus() != null) {
 308             portBuilder.setStatus(neutronPort.getStatus());
 309         }
 310         if (neutronPort.getTenantID() != null) {
 311             portBuilder.setTenantId(toUuid(neutronPort.getTenantID()));
 312         }
 313         if (neutronPort.getPortUUID() != null) {
 314             portBuilder.setUuid(toUuid(neutronPort.getPortUUID()));
 315         } else {
 316             LOGGER.warn("Attempting to write neutron port without UUID");
 317         }
 318         return portBuilder.build();
 319     }
 320
 321     @Override
 322     protected Port toMd(String uuid) {
 323         PortBuilder portBuilder = new PortBuilder();
 324         portBuilder.setUuid(toUuid(uuid));
 325         return portBuilder.build();
 326     }
 327 }