transcriber/src/main/java/org/opendaylight/neutron/transcriber/NeutronFloatingIPInterface.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.neutron.transcriber;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Map.Entry;
  15 import java.util.Set;
  16
  17 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  18 import org.opendaylight.neutron.spi.INeutronFloatingIPCRUD;
  19 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  20 import org.opendaylight.neutron.spi.INeutronPortCRUD;
  21 import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
  22 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  23 import org.opendaylight.neutron.spi.NeutronFloatingIP;
  24 import org.opendaylight.neutron.spi.NeutronSubnet;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.floatingips.attributes.Floatingips;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.floatingips.attributes.floatingips.Floatingip;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.floatingips.attributes.floatingips.FloatingipBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31 import org.osgi.framework.BundleContext;
  32 import org.osgi.framework.ServiceRegistration;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 public class NeutronFloatingIPInterface extends AbstractNeutronInterface<Floatingip, Floatingips, NeutronFloatingIP> implements INeutronFloatingIPCRUD {
  37     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronFloatingIPInterface.class);
  38
  39     NeutronFloatingIPInterface(ProviderContext providerContext) {
  40         super(providerContext);
  41     }
  42
  43     // IfNBFloatingIPCRUD interface methods
  44
  45     @Override
  46     public boolean floatingIPExists(String uuid) {
  47         return exists(uuid);
  48     }
  49
  50     @Override
  51     public NeutronFloatingIP getFloatingIP(String uuid) {
  52         return get(uuid);
  53     }
  54
  55     @Override
  56     protected List<Floatingip> getDataObjectList(Floatingips fips) {
  57         return fips.getFloatingip();
  58     }
  59
  60     @Override
  61     public List<NeutronFloatingIP> getAllFloatingIPs() {
  62         return getAll();
  63     }
  64
  65     @Override
  66     public boolean addFloatingIP(NeutronFloatingIP input) {
  67         return add(input);
  68     }
  69
  70     @Override
  71     public boolean removeFloatingIP(String uuid) {
  72         return remove(uuid);
  73     }
  74
  75     @Override
  76     public boolean updateFloatingIP(String uuid, NeutronFloatingIP delta) {
  77         NeutronFloatingIP target = getFloatingIP(uuid);
  78         if (target == null) {
  79             return false;
  80         }
  81         target.setPortUUID(delta.getPortUUID());
  82         target.setFixedIPAddress(delta.getFixedIPAddress());
  83         return updateMd(target);
  84     }
  85
  86     @Override
  87     protected Floatingip toMd(String uuid) {
  88         FloatingipBuilder floatingipBuilder = new FloatingipBuilder();
  89         floatingipBuilder.setUuid(toUuid(uuid));
  90         return floatingipBuilder.build();
  91     }
  92
  93     @Override
  94     protected Floatingip toMd(NeutronFloatingIP floatingIp) {
  95         FloatingipBuilder floatingipBuilder = new FloatingipBuilder();
  96         if (floatingIp.getFixedIPAddress() != null) {
  97             floatingipBuilder.setFixedIpAddress(new IpAddress(floatingIp.getFixedIPAddress().toCharArray()));
  98         }
  99         if(floatingIp.getFloatingIPAddress() != null) {
 100             floatingipBuilder.setFloatingIpAddress(new IpAddress(floatingIp.getFloatingIPAddress().toCharArray()));
 101         }
 102         if (floatingIp.getFloatingNetworkUUID() != null) {
 103             floatingipBuilder.setFloatingNetworkId(toUuid(floatingIp.getFloatingNetworkUUID()));
 104         }
 105         if (floatingIp.getPortUUID() != null) {
 106             floatingipBuilder.setPortId(toUuid(floatingIp.getPortUUID()));
 107         }
 108         if (floatingIp.getRouterUUID() != null) {
 109             floatingipBuilder.setRouterId(toUuid(floatingIp.getRouterUUID()));
 110         }
 111         if (floatingIp.getStatus() != null) {
 112             floatingipBuilder.setStatus(floatingIp.getStatus());
 113         }
 114         if (floatingIp.getTenantID() != null) {
 115             floatingipBuilder.setTenantId(toUuid(floatingIp.getTenantID()));
 116         }
 117         if (floatingIp.getID() != null) {
 118             floatingipBuilder.setUuid(toUuid(floatingIp.getID()));
 119         }
 120         else {
 121             LOGGER.warn("Attempting to write neutron floating IP without UUID");
 122         }
 123         return floatingipBuilder.build();
 124     }
 125
 126     protected NeutronFloatingIP fromMd(Floatingip fip) {
 127         NeutronFloatingIP result = new NeutronFloatingIP();
 128         result.setID(fip.getUuid().getValue());
 129         if (fip.getFloatingNetworkId() != null) {
 130             result.setFloatingNetworkUUID(String.valueOf(fip.getFloatingNetworkId().getValue()));
 131         }
 132         if (fip.getPortId() != null) {
 133             result.setPortUUID(String.valueOf(fip.getPortId().getValue()));
 134         }
 135         if (fip.getFixedIpAddress() != null ) {
 136             result.setFixedIPAddress(String.valueOf(fip.getFixedIpAddress().getValue()));
 137         }
 138         if (fip.getFloatingIpAddress() != null) {
 139             result.setFloatingIPAddress(String.valueOf(fip.getFloatingIpAddress().getValue()));
 140         }
 141         if (fip.getTenantId() != null) {
 142             result.setTenantID(fip.getTenantId());
 143         }
 144         if (fip.getRouterId() != null) {
 145             result.setRouterUUID(String.valueOf(fip.getRouterId().getValue()));
 146         }
 147         result.setStatus(fip.getStatus());
 148         return result;
 149     }
 150
 151     @Override
 152     protected InstanceIdentifier<Floatingip> createInstanceIdentifier(
 153             Floatingip item) {
 154         return InstanceIdentifier.create(Neutron.class)
 155                 .child(Floatingips.class)
 156                 .child(Floatingip.class,item.getKey());
 157     }
 158
 159     @Override
 160     protected InstanceIdentifier<Floatingips> createInstanceIdentifier() {
 161         return InstanceIdentifier.create(Neutron.class)
 162                 .child(Floatingips.class);
 163     }
 164
 165     public static void registerNewInterface(BundleContext context,
 166                                             ProviderContext providerContext,
 167                                             List<ServiceRegistration<?>> registrations) {
 168         NeutronFloatingIPInterface neutronFloatingIPInterface = new NeutronFloatingIPInterface(providerContext);
 169         ServiceRegistration<INeutronFloatingIPCRUD> neutronFloatingIPInterfaceRegistration = context.registerService(INeutronFloatingIPCRUD.class, neutronFloatingIPInterface, null);
 170         if (neutronFloatingIPInterfaceRegistration != null) {
 171             registrations.add(neutronFloatingIPInterfaceRegistration);
 172         }
 173     }
 174 }