openstack/net-virt/src/main/java/org/opendaylight/netvirt/openstack/netvirt/translator/crud/impl/NeutronPortInterface.java

   1 /*
   2  * Copyright (c) 2013, 2015 IBM Corporation 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.netvirt.openstack.netvirt.translator.crud.impl;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  17 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronPort_AllowedAddressPairs;
  18 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronPort_ExtraDHCPOption;
  19 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronPort_VIFDetail;
  20 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronPortCRUD;
  21 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronSecurityGroupCRUD;
  22 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.NeutronCRUDInterfaces;
  23 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronPort;
  24 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronSecurityGroup;
  25 import org.opendaylight.netvirt.openstack.netvirt.translator.Neutron_IPs;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtensionBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.binding.attributes.VifDetails;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.binding.attributes.VifDetailsBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairsBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.ExtraDhcpOpts;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.ExtraDhcpOptsBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.osgi.framework.BundleContext;
  44 import org.osgi.framework.ServiceRegistration;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 public class NeutronPortInterface extends AbstractNeutronInterface<Port, NeutronPort> implements INeutronPortCRUD {
  49     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronPortInterface.class);
  50
  51     NeutronPortInterface(ProviderContext providerContext) {
  52         super(providerContext);
  53     }
  54
  55     // IfNBPortCRUD methods
  56
  57     @Override
  58     public boolean portExists(String uuid) {
  59         Port port = readMd(createInstanceIdentifier(toMd(uuid)));
  60         return port != null;
  61     }
  62
  63     @Override
  64     public NeutronPort getPort(String uuid) {
  65         Port port = readMd(createInstanceIdentifier(toMd(uuid)));
  66         if (port == null) {
  67             return null;
  68         }
  69         return fromMd(port);
  70     }
  71
  72     @Override
  73     public List<NeutronPort> getAllPorts() {
  74         Set<NeutronPort> allPorts = new HashSet<>();
  75         Ports ports = readMd(createInstanceIdentifier());
  76         if (ports != null) {
  77             for (Port port : ports.getPort()) {
  78                 allPorts.add(fromMd(port));
  79             }
  80         }
  81         LOGGER.debug("Exiting getAllPorts, Found {} OpenStackPorts", allPorts.size());
  82         List<NeutronPort> ans = new ArrayList<>();
  83         ans.addAll(allPorts);
  84         return ans;
  85     }
  86
  87     @Override
  88     public boolean addPort(NeutronPort input) {
  89         if (portExists(input.getID())) {
  90             return false;
  91         }
  92         addMd(input);
  93         return true;
  94     }
  95
  96     @Override
  97     public boolean removePort(String uuid) {
  98         if (!portExists(uuid)) {
  99             return false;
 100         }
 101         return removeMd(toMd(uuid));
 102     }
 103
 104     @Override
 105     public boolean updatePort(String uuid, NeutronPort delta) {
 106         if (!portExists(uuid)) {
 107             return false;
 108         }
 109         updateMd(delta);
 110         return true;
 111     }
 112
 113     // @deprecated, will be removed in Boron
 114     @Override
 115     public boolean macInUse(String macAddress) {
 116         return false;
 117     }
 118
 119     // @deprecated, will be removed in Boron
 120     @Override
 121     public NeutronPort getGatewayPort(String subnetUUID) {
 122         return null;
 123     }
 124
 125     @Override
 126     protected InstanceIdentifier<Port> createInstanceIdentifier(Port port) {
 127         return InstanceIdentifier.create(Neutron.class)
 128                 .child(Ports.class)
 129                 .child(Port.class, port.getKey());
 130     }
 131
 132     protected InstanceIdentifier<Ports> createInstanceIdentifier() {
 133         return InstanceIdentifier.create(Neutron.class)
 134                 .child(Ports.class);
 135     }
 136
 137     protected void addExtensions(Port port, NeutronPort result) {
 138         PortBindingExtension binding = port.getAugmentation(PortBindingExtension.class);
 139         result.setBindinghostID(binding.getHostId());
 140         if (binding.getVifDetails() != null) {
 141             List<NeutronPort_VIFDetail> details = new ArrayList<>();
 142             for (VifDetails vifDetail : binding.getVifDetails()) {
 143                 NeutronPort_VIFDetail detail = new NeutronPort_VIFDetail();
 144                 detail.setPortFilter(vifDetail.isPortFilter());
 145                 detail.setOvsHybridPlug(vifDetail.isOvsHybridPlug());
 146                 details.add(detail);
 147             }
 148             result.setVIFDetail(details);
 149         }
 150         result.setBindingvifType(binding.getVifType());
 151         result.setBindingvnicType(binding.getVnicType());
 152     }
 153
 154     protected NeutronPort fromMd(Port port) {
 155         NeutronPort result = new NeutronPort();
 156         result.setAdminStateUp(port.isAdminStateUp());
 157         if (port.getAllowedAddressPairs() != null) {
 158             List<NeutronPort_AllowedAddressPairs> pairs = new ArrayList<>();
 159             for (AllowedAddressPairs mdPair : port.getAllowedAddressPairs()) {
 160                 NeutronPort_AllowedAddressPairs pair = new NeutronPort_AllowedAddressPairs();
 161                 pair.setIpAddress(mdPair.getIpAddress());
 162                 pair.setMacAddress(mdPair.getMacAddress());
 163                 pairs.add(pair);
 164             }
 165             result.setAllowedAddressPairs(pairs);
 166         }
 167         result.setDeviceID(port.getDeviceId());
 168         result.setDeviceOwner(port.getDeviceOwner());
 169         if (port.getExtraDhcpOpts() != null) {
 170             List<NeutronPort_ExtraDHCPOption> options = new ArrayList<>();
 171             for (ExtraDhcpOpts opt : port.getExtraDhcpOpts()) {
 172                 NeutronPort_ExtraDHCPOption arg = new NeutronPort_ExtraDHCPOption();
 173                 arg.setName(opt.getOptName());
 174                 arg.setValue(opt.getOptValue());
 175                 options.add(arg);
 176             }
 177             result.setExtraDHCPOptions(options);
 178         }
 179         if (port.getFixedIps() != null) {
 180             List<Neutron_IPs> ips = new ArrayList<>();
 181             for (FixedIps mdIP : port.getFixedIps()) {
 182                 Neutron_IPs ip = new Neutron_IPs();
 183                 ip.setIpAddress(String.valueOf(mdIP.getIpAddress().getValue()));
 184                 ip.setSubnetUUID(mdIP.getSubnetId().getValue());
 185                 ips.add(ip);
 186             }
 187             result.setFixedIPs(ips);
 188         }
 189         result.setMacAddress(port.getMacAddress());
 190         result.setName(port.getName());
 191         result.setNetworkUUID(String.valueOf(port.getNetworkId().getValue()));
 192         if (port.getSecurityGroups() != null) {
 193             Set<NeutronSecurityGroup> allGroups = new HashSet<>();
 194             NeutronCRUDInterfaces interfaces = new NeutronCRUDInterfaces().fetchINeutronSecurityGroupCRUD(this);
 195             INeutronSecurityGroupCRUD sgIf = interfaces.getSecurityGroupInterface();
 196             for (Uuid sgUuid : port.getSecurityGroups()) {
 197                 NeutronSecurityGroup secGroup = sgIf.getNeutronSecurityGroup(sgUuid.getValue());
 198                 if (secGroup != null) {
 199                     allGroups.add(sgIf.getNeutronSecurityGroup(sgUuid.getValue()));
 200                 }
 201             }
 202             List<NeutronSecurityGroup> groups = new ArrayList<>();
 203             groups.addAll(allGroups);
 204             result.setSecurityGroups(groups);
 205         }
 206         result.setStatus(port.getStatus());
 207         if (port.getTenantId() != null) {
 208             result.setTenantID(String.valueOf(port.getTenantId().getValue()).replace("-", ""));
 209         }
 210         result.setPortUUID(String.valueOf(port.getUuid().getValue()));
 211         addExtensions(port, result);
 212         return result;
 213     }
 214
 215     @Override
 216     protected Port toMd(NeutronPort neutronPort) {
 217         PortBindingExtensionBuilder bindingBuilder = new PortBindingExtensionBuilder();
 218         if (neutronPort.getBindinghostID() != null) {
 219             bindingBuilder.setHostId(neutronPort.getBindinghostID());
 220         }
 221         if (neutronPort.getVIFDetail() != null) {
 222             List<VifDetails> listVifDetail = new ArrayList<>();
 223             for (NeutronPort_VIFDetail detail: neutronPort.getVIFDetail()) {
 224                 VifDetailsBuilder vifDetailsBuilder = new VifDetailsBuilder();
 225                 if (detail.getPortFilter() != null) {
 226                     vifDetailsBuilder.setPortFilter(detail.getPortFilter());
 227                 }
 228                 if (detail.getOvsHybridPlug() != null) {
 229                     vifDetailsBuilder.setOvsHybridPlug(detail.getOvsHybridPlug());
 230                 }
 231                 listVifDetail.add(vifDetailsBuilder.build());
 232             }
 233             bindingBuilder.setVifDetails(listVifDetail);
 234         }
 235         if (neutronPort.getBindingvifType() != null) {
 236             bindingBuilder.setVifType(neutronPort.getBindingvifType());
 237         }
 238         if (neutronPort.getBindingvnicType() != null) {
 239             bindingBuilder.setVnicType(neutronPort.getBindingvnicType());
 240         }
 241
 242         PortBuilder portBuilder = new PortBuilder();
 243         portBuilder.addAugmentation(PortBindingExtension.class,
 244                                     bindingBuilder.build());
 245         portBuilder.setAdminStateUp(neutronPort.isAdminStateUp());
 246         if(neutronPort.getAllowedAddressPairs() != null) {
 247             List<AllowedAddressPairs> listAllowedAddressPairs = new ArrayList<>();
 248             for (NeutronPort_AllowedAddressPairs allowedAddressPairs : neutronPort.getAllowedAddressPairs()) {
 249                     AllowedAddressPairsBuilder allowedAddressPairsBuilder = new AllowedAddressPairsBuilder();
 250                     allowedAddressPairsBuilder.setIpAddress(allowedAddressPairs.getIpAddress());
 251                     allowedAddressPairsBuilder.setMacAddress(allowedAddressPairs.getMacAddress());
 252                     listAllowedAddressPairs.add(allowedAddressPairsBuilder.build());
 253             }
 254             portBuilder.setAllowedAddressPairs(listAllowedAddressPairs);
 255         }
 256         if (neutronPort.getDeviceID() != null) {
 257             portBuilder.setDeviceId(neutronPort.getDeviceID());
 258         }
 259         if (neutronPort.getDeviceOwner() != null) {
 260         portBuilder.setDeviceOwner(neutronPort.getDeviceOwner());
 261         }
 262         if (neutronPort.getExtraDHCPOptions() != null) {
 263             List<ExtraDhcpOpts> listExtraDHCPOptions = new ArrayList<>();
 264             for (NeutronPort_ExtraDHCPOption extraDHCPOption : neutronPort.getExtraDHCPOptions()) {
 265                 ExtraDhcpOptsBuilder extraDHCPOptsBuilder = new ExtraDhcpOptsBuilder();
 266                 extraDHCPOptsBuilder.setOptName(extraDHCPOption.getName());
 267                 extraDHCPOptsBuilder.setOptValue(extraDHCPOption.getValue());
 268                 listExtraDHCPOptions.add(extraDHCPOptsBuilder.build());
 269             }
 270             portBuilder.setExtraDhcpOpts(listExtraDHCPOptions);
 271         }
 272         if (neutronPort.getFixedIPs() != null) {
 273             List<FixedIps> listNeutronIPs = new ArrayList<>();
 274             for (Neutron_IPs neutron_IPs : neutronPort.getFixedIPs()) {
 275                 FixedIpsBuilder fixedIpsBuilder = new FixedIpsBuilder();
 276                 fixedIpsBuilder.setIpAddress(new IpAddress(neutron_IPs.getIpAddress().toCharArray()));
 277                 fixedIpsBuilder.setSubnetId(toUuid(neutron_IPs.getSubnetUUID()));
 278                 listNeutronIPs.add(fixedIpsBuilder.build());
 279             }
 280             portBuilder.setFixedIps(listNeutronIPs);
 281         }
 282         if (neutronPort.getMacAddress() != null) {
 283             portBuilder.setMacAddress(neutronPort.getMacAddress());
 284         }
 285         if (neutronPort.getName() != null) {
 286         portBuilder.setName(neutronPort.getName());
 287         }
 288         if (neutronPort.getNetworkUUID() != null) {
 289         portBuilder.setNetworkId(toUuid(neutronPort.getNetworkUUID()));
 290         }
 291         if (neutronPort.getSecurityGroups() != null) {
 292             List<Uuid> listSecurityGroups = new ArrayList<>();
 293             for (NeutronSecurityGroup neutronSecurityGroup : neutronPort.getSecurityGroups()) {
 294                 listSecurityGroups.add(toUuid(neutronSecurityGroup.getID()));
 295             }
 296             portBuilder.setSecurityGroups(listSecurityGroups);
 297         }
 298         if (neutronPort.getStatus() != null) {
 299             portBuilder.setStatus(neutronPort.getStatus());
 300         }
 301         if (neutronPort.getTenantID() != null) {
 302             portBuilder.setTenantId(toUuid(neutronPort.getTenantID()));
 303         }
 304         if (neutronPort.getPortUUID() != null) {
 305             portBuilder.setUuid(toUuid(neutronPort.getPortUUID()));
 306         } else {
 307             LOGGER.warn("Attempting to write neutron port without UUID");
 308         }
 309         return portBuilder.build();
 310     }
 311
 312     @Override
 313     protected Port toMd(String uuid) {
 314         PortBuilder portBuilder = new PortBuilder();
 315         portBuilder.setUuid(toUuid(uuid));
 316         return portBuilder.build();
 317     }
 318
 319     public static void registerNewInterface(BundleContext context,
 320                                             ProviderContext providerContext,
 321                                             List<ServiceRegistration<?>> registrations) {
 322         NeutronPortInterface neutronPortInterface = new NeutronPortInterface(providerContext);
 323         ServiceRegistration<INeutronPortCRUD> neutronPortInterfaceRegistration = context.registerService(INeutronPortCRUD.class, neutronPortInterface, null);
 324         if(neutronPortInterfaceRegistration != null) {
 325             registrations.add(neutronPortInterfaceRegistration);
 326         }
 327     }
 328 }