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.rev141002.floatingips.attributes.Floatingips;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev141002.floatingips.attributes.floatingips.Floatingip;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev141002.floatingips.attributes.floatingips.FloatingipBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.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, 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     public List<NeutronFloatingIP> getAll() {
  57         Set<NeutronFloatingIP> allIPs = new HashSet<NeutronFloatingIP>();
  58         Floatingips fips = readMd(createInstanceIdentifier());
  59         if (fips != null) {
  60             for (Floatingip fip: fips.getFloatingip()) {
  61                 allIPs.add(fromMd(fip));
  62             }
  63         }
  64         LOGGER.debug("Exiting getAllFloatingIPs, Found {} FloatingIPs", allIPs.size());
  65         List<NeutronFloatingIP> ans = new ArrayList<NeutronFloatingIP>();
  66         ans.addAll(allIPs);
  67         return ans;
  68     }
  69
  70     @Override
  71     public List<NeutronFloatingIP> getAllFloatingIPs() {
  72         return getAll();
  73     }
  74
  75     @Override
  76     public boolean addFloatingIP(NeutronFloatingIP input) {
  77         return add(input);
  78     }
  79
  80     @Override
  81     public boolean removeFloatingIP(String uuid) {
  82         return remove(uuid);
  83     }
  84
  85     @Override
  86     public boolean updateFloatingIP(String uuid, NeutronFloatingIP delta) {
  87         NeutronFloatingIP target = getFloatingIP(uuid);
  88         if (target == null) {
  89             return false;
  90         }
  91         delta.setPortUUID(target.getPortUUID());
  92         delta.setFixedIPAddress(target.getFixedIPAddress());
  93         return updateMd(delta);
  94     }
  95
  96     @Override
  97     protected Floatingip toMd(String uuid) {
  98         FloatingipBuilder floatingipBuilder = new FloatingipBuilder();
  99         floatingipBuilder.setUuid(toUuid(uuid));
 100         return floatingipBuilder.build();
 101     }
 102
 103     @Override
 104     protected Floatingip toMd(NeutronFloatingIP floatingIp) {
 105         FloatingipBuilder floatingipBuilder = new FloatingipBuilder();
 106         if (floatingIp.getFixedIPAddress() != null) {
 107             floatingipBuilder.setFixedIpAddress(new IpAddress(floatingIp.getFixedIPAddress().toCharArray()));
 108         }
 109         if(floatingIp.getFloatingIPAddress() != null) {
 110             floatingipBuilder.setFloatingIpAddress(new IpAddress(floatingIp.getFloatingIPAddress().toCharArray()));
 111         }
 112         if (floatingIp.getFloatingNetworkUUID() != null) {
 113             floatingipBuilder.setFloatingNetworkId(toUuid(floatingIp.getFloatingNetworkUUID()));
 114         }
 115         if (floatingIp.getPortUUID() != null) {
 116             floatingipBuilder.setPortId(toUuid(floatingIp.getPortUUID()));
 117         }
 118         if (floatingIp.getRouterUUID() != null) {
 119             floatingipBuilder.setRouterId(toUuid(floatingIp.getRouterUUID()));
 120         }
 121         if (floatingIp.getStatus() != null) {
 122             floatingipBuilder.setStatus(floatingIp.getStatus());
 123         }
 124         if (floatingIp.getTenantUUID() != null) {
 125             floatingipBuilder.setTenantId(toUuid(floatingIp.getTenantUUID()));
 126         }
 127         if (floatingIp.getID() != null) {
 128             floatingipBuilder.setUuid(toUuid(floatingIp.getID()));
 129         }
 130         else {
 131             LOGGER.warn("Attempting to write neutron floating IP without UUID");
 132         }
 133         return floatingipBuilder.build();
 134     }
 135
 136     protected NeutronFloatingIP fromMd(Floatingip fip) {
 137         NeutronFloatingIP result = new NeutronFloatingIP();
 138         result.setID(String.valueOf(fip.getUuid().getValue()));
 139         if (fip.getFloatingNetworkId() != null) {
 140             result.setFloatingNetworkUUID(String.valueOf(fip.getFloatingNetworkId().getValue()));
 141         }
 142         if (fip.getPortId() != null) {
 143             result.setPortUUID(String.valueOf(fip.getPortId().getValue()));
 144         }
 145         if (fip.getFixedIpAddress() != null ) {
 146             result.setFixedIPAddress(String.valueOf(fip.getFixedIpAddress().getValue()));
 147         }
 148         if (fip.getFloatingIpAddress() != null) {
 149             result.setFloatingIPAddress(String.valueOf(fip.getFloatingIpAddress().getValue()));
 150         }
 151         if (fip.getTenantId() != null) {
 152             result.setTenantUUID(String.valueOf(fip.getTenantId().getValue()));
 153         }
 154         if (fip.getRouterId() != null) {
 155             result.setRouterUUID(String.valueOf(fip.getRouterId().getValue()));
 156         }
 157         result.setStatus(fip.getStatus());
 158         return result;
 159     }
 160
 161     @Override
 162     protected InstanceIdentifier<Floatingip> createInstanceIdentifier(
 163             Floatingip item) {
 164         return InstanceIdentifier.create(Neutron.class)
 165                 .child(Floatingips.class)
 166                 .child(Floatingip.class,item.getKey());
 167     }
 168
 169     protected InstanceIdentifier<Floatingips> createInstanceIdentifier() {
 170         return InstanceIdentifier.create(Neutron.class)
 171                 .child(Floatingips.class);
 172     }
 173
 174     public static void registerNewInterface(BundleContext context,
 175                                             ProviderContext providerContext,
 176                                             List<ServiceRegistration<?>> registrations) {
 177         NeutronFloatingIPInterface neutronFloatingIPInterface = new NeutronFloatingIPInterface(providerContext);
 178         ServiceRegistration<INeutronFloatingIPCRUD> neutronFloatingIPInterfaceRegistration = context.registerService(INeutronFloatingIPCRUD.class, neutronFloatingIPInterface, null);
 179         if (neutronFloatingIPInterfaceRegistration != null) {
 180             registrations.add(neutronFloatingIPInterfaceRegistration);
 181         }
 182     }
 183 }