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

   1 /*
   2  * Copyright (c) 2014, 2015 Red Hat, Inc. 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 com.google.common.collect.ImmutableBiMap;
  12 import java.util.ArrayList;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map.Entry;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentHashMap;
  18 import java.util.concurrent.ConcurrentMap;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancerPool;
  21 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancer_SessionPersistence;
  22 import org.opendaylight.netvirt.openstack.netvirt.translator.Neutron_ID;
  23 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronLoadBalancerPoolCRUD;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolBase;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttp;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttps;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.Pools;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.Pool;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.PoolBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.pool.attributes.SessionPersistenceBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  35 import org.osgi.framework.BundleContext;
  36 import org.osgi.framework.ServiceRegistration;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 /**
  41  * TODO: Migrate this to consume the MD-SAL data store, so that it can read all the data from data store.
  42  * No need to worry about the write/update related methods here. OVSDB net-virt will use these CRUD Interface
  43  * only for reading. We will cleanup these interface/methods later.
  44  */
  45
  46 public class NeutronLoadBalancerPoolInterface extends AbstractNeutronInterface<Pool, NeutronLoadBalancerPool> implements INeutronLoadBalancerPoolCRUD {
  47     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
  48     private ConcurrentMap<String, NeutronLoadBalancerPool> loadBalancerPoolDB = new ConcurrentHashMap<>();
  49
  50     private static final ImmutableBiMap<Class<? extends ProtocolBase>,String> PROTOCOL_MAP
  51             = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>,String>()
  52             .put(ProtocolHttp.class,"HTTP")
  53             .put(ProtocolHttps.class,"HTTPS")
  54             .put(ProtocolTcp.class,"TCP")
  55             .build();
  56
  57     NeutronLoadBalancerPoolInterface(final DataBroker dataBroker) {
  58         super(dataBroker);
  59     }
  60
  61     @Override
  62     public boolean neutronLoadBalancerPoolExists(String uuid) {
  63         return loadBalancerPoolDB.containsKey(uuid);
  64     }
  65
  66     @Override
  67     public NeutronLoadBalancerPool getNeutronLoadBalancerPool(String uuid) {
  68         if (!neutronLoadBalancerPoolExists(uuid)) {
  69             LOGGER.debug("No LoadBalancerPool has Been Defined");
  70             return null;
  71         }
  72         return loadBalancerPoolDB.get(uuid);
  73     }
  74
  75     @Override
  76     public List<NeutronLoadBalancerPool> getAllNeutronLoadBalancerPools() {
  77         Set<NeutronLoadBalancerPool> allLoadBalancerPools = new HashSet<>();
  78         for (Entry<String, NeutronLoadBalancerPool> entry : loadBalancerPoolDB.entrySet()) {
  79             NeutronLoadBalancerPool loadBalancerPool = entry.getValue();
  80             allLoadBalancerPools.add(loadBalancerPool);
  81         }
  82         LOGGER.debug("Exiting getLoadBalancerPools, Found {} OpenStackLoadBalancerPool", allLoadBalancerPools.size());
  83         List<NeutronLoadBalancerPool> ans = new ArrayList<>();
  84         ans.addAll(allLoadBalancerPools);
  85         return ans;
  86     }
  87
  88     @Override
  89     public boolean addNeutronLoadBalancerPool(NeutronLoadBalancerPool input) {
  90         if (neutronLoadBalancerPoolExists(input.getID())) {
  91             return false;
  92         }
  93         loadBalancerPoolDB.putIfAbsent(input.getID(), input);
  94         //TODO: add code to find INeutronLoadBalancerPoolAware services and call newtorkCreated on them
  95         return true;
  96     }
  97
  98     @Override
  99     public boolean removeNeutronLoadBalancerPool(String uuid) {
 100         if (!neutronLoadBalancerPoolExists(uuid)) {
 101             return false;
 102         }
 103         loadBalancerPoolDB.remove(uuid);
 104         //TODO: add code to find INeutronLoadBalancerPoolAware services and call newtorkDeleted on them
 105         return true;
 106     }
 107
 108     @Override
 109     public boolean updateNeutronLoadBalancerPool(String uuid, NeutronLoadBalancerPool delta) {
 110         if (!neutronLoadBalancerPoolExists(uuid)) {
 111             return false;
 112         }
 113         NeutronLoadBalancerPool target = loadBalancerPoolDB.get(uuid);
 114         return overwrite(target, delta);
 115     }
 116
 117     @Override
 118     public boolean neutronLoadBalancerPoolInUse(String loadBalancerPoolUUID) {
 119         return !neutronLoadBalancerPoolExists(loadBalancerPoolUUID);
 120     }
 121
 122     @Override
 123     protected Pool toMd(String uuid) {
 124         PoolBuilder poolsBuilder = new PoolBuilder();
 125         poolsBuilder.setUuid(toUuid(uuid));
 126         return poolsBuilder.build();
 127     }
 128
 129     @Override
 130     protected InstanceIdentifier<Pool> createInstanceIdentifier(Pool pools) {
 131         return InstanceIdentifier.create(Neutron.class)
 132                 .child(Pools.class)
 133                 .child(Pool.class, pools.getKey());
 134     }
 135
 136     @Override
 137     protected Pool toMd(NeutronLoadBalancerPool pool) {
 138         PoolBuilder poolBuilder = new PoolBuilder();
 139         poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
 140         if (pool.getNeutronLoadBalancerPoolHealthMonitorID() != null) {
 141             poolBuilder.setHealthmonitorId(toUuid(pool.getNeutronLoadBalancerPoolHealthMonitorID()));
 142         }
 143         if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
 144             poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
 145         }
 146         if (pool.getLoadBalancerPoolListeners() != null) {
 147             List<Uuid> listListener = new ArrayList<>();
 148             for (Neutron_ID neutron_id : pool.getLoadBalancerPoolListeners()) {
 149                 listListener.add(toUuid(neutron_id.getID()));
 150             }
 151             poolBuilder.setListeners(listListener);
 152         }
 153         // because members are another container, we don't want to copy
 154         // it over, so just skip it here
 155         if (pool.getLoadBalancerPoolName() != null) {
 156             poolBuilder.setName(pool.getLoadBalancerPoolName());
 157         }
 158         if (pool.getLoadBalancerPoolProtocol() != null) {
 159             ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper =
 160                 PROTOCOL_MAP.inverse();
 161             poolBuilder.setProtocol(mapper.get(pool.getLoadBalancerPoolProtocol()));
 162         }
 163         if (pool.getLoadBalancerPoolSessionPersistence() != null) {
 164             NeutronLoadBalancer_SessionPersistence sessionPersistence = pool.getLoadBalancerPoolSessionPersistence();
 165             SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
 166             sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
 167             sessionPersistenceBuilder.setType(sessionPersistence.getType());
 168             poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
 169         }
 170         if (pool.getLoadBalancerPoolTenantID() != null) {
 171             poolBuilder.setTenantId(toUuid(pool.getLoadBalancerPoolTenantID()));
 172         }
 173         if (pool.getID() != null) {
 174             poolBuilder.setUuid(toUuid(pool.getID()));
 175         } else {
 176             LOGGER.warn("Attempting to write neutron load balancer pool without UUID");
 177         }
 178         return poolBuilder.build();
 179     }
 180
 181     public static void registerNewInterface(BundleContext context,
 182                                             final DataBroker dataBroker,
 183                                             List<ServiceRegistration<?>> registrations) {
 184         NeutronLoadBalancerPoolInterface neutronLoadBalancerPoolInterface = new NeutronLoadBalancerPoolInterface(dataBroker);
 185         ServiceRegistration<INeutronLoadBalancerPoolCRUD> neutronLoadBalancerPoolInterfaceRegistration = context.registerService(INeutronLoadBalancerPoolCRUD.class, neutronLoadBalancerPoolInterface, null);
 186         if(neutronLoadBalancerPoolInterfaceRegistration != null) {
 187             registrations.add(neutronLoadBalancerPoolInterfaceRegistration);
 188         }
 189     }
 190 }