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