openstack/net-virt/src/main/java/org/opendaylight/ovsdb/openstack/netvirt/LBaaSPoolHandler.java

   1 /*
   2  * Copyright (C) 2014 SDN Hub, LLC.
   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  * Authors : Srini Seetharaman
   9  */
  10
  11 package org.opendaylight.ovsdb.openstack.netvirt;
  12
  13 import java.net.HttpURLConnection;
  14 import java.util.List;
  15 import java.util.Map;
  16
  17 import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
  18 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolAware;
  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.NeutronLoadBalancer;
  23 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  24 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  25 import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
  26 import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
  27 import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
  28 import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerProvider;
  29 import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
  30 import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
  31 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  32 import org.osgi.framework.BundleContext;
  33 import org.osgi.framework.ServiceReference;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 import com.google.common.base.Preconditions;
  38 import com.google.common.collect.Lists;
  39
  40 /**
  41  * Handle requests for OpenStack Neutron v2.0 LBaaS API calls for
  42  * /v2.0/pools . It is possible that each pool spans multiple subnets.
  43  * In that case, the user should be creating a separate VIP for each subnet.
  44  */
  45
  46 public class LBaaSPoolHandler extends AbstractHandler
  47         implements INeutronLoadBalancerPoolAware, ConfigInterface {
  48
  49     private static final Logger LOG = LoggerFactory.getLogger(LBaaSPoolHandler.class);
  50
  51     // The implementation for each of these services is resolved by the OSGi Service Manager
  52     private volatile INeutronLoadBalancerCRUD neutronLBCache;
  53     private volatile INeutronPortCRUD neutronPortCache;
  54     private volatile INeutronNetworkCRUD neutronNetworkCache;
  55     private volatile INeutronSubnetCRUD neutronSubnetCache;
  56     private volatile LoadBalancerProvider loadBalancerProvider;
  57     private volatile NodeCacheManager nodeCacheManager;
  58
  59     @Override
  60     public int canCreateNeutronLoadBalancerPool(NeutronLoadBalancerPool neutronLBPool) {
  61         String poolProtocol = neutronLBPool.getLoadBalancerPoolProtocol();
  62         if (poolProtocol == null) {
  63             return HttpURLConnection.HTTP_BAD_REQUEST;
  64         } else if (!(poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_TCP) ||
  65                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTP) ||
  66                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTPS))) {
  67             return HttpURLConnection.HTTP_NOT_ACCEPTABLE;
  68         } else {
  69             return HttpURLConnection.HTTP_OK;
  70         }
  71     }
  72
  73     @Override
  74     public void neutronLoadBalancerPoolCreated(NeutronLoadBalancerPool neutronLBPool) {
  75         LOG.debug("Neutron LB Pool Creation : {}", neutronLBPool.toString());
  76         enqueueEvent(new NorthboundEvent(neutronLBPool, Action.ADD));
  77     }
  78
  79     /**
  80      * Assuming that the pool information is fully populated before this call is made,
  81      * we go with creating the LoadBalancerConfiguration object for this call with
  82      * all information that is necessary to insert flow_mods
  83      */
  84     private void doNeutronLoadBalancerPoolCreate(NeutronLoadBalancerPool neutronLBPool) {
  85         Preconditions.checkNotNull(loadBalancerProvider);
  86         List<LoadBalancerConfiguration> lbConfigList = extractLBConfiguration(neutronLBPool);
  87         final List<Node> nodes = nodeCacheManager.getBridgeNodes();
  88         if (lbConfigList == null) {
  89             LOG.debug("Neutron LB configuration invalid for pool {} ", neutronLBPool.getLoadBalancerPoolID());
  90         } else if (lbConfigList.size() == 0) {
  91             LOG.debug("No Neutron LB VIP not created yet for pool {} ", neutronLBPool.getLoadBalancerPoolID());
  92         } else if (nodes.isEmpty()) {
  93             LOG.debug("Noop with LB pool {} creation because no nodes available.", neutronLBPool.getLoadBalancerPoolID());
  94         } else {
  95             for (LoadBalancerConfiguration lbConfig: lbConfigList) {
  96                 if (!lbConfig.isValid()) {
  97                     LOG.debug("Neutron LB pool configuration invalid for {} ", lbConfig.getName());
  98                 } else {
  99                     for (Node node : nodes) {
 100                         loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.ADD);
 101                     }
 102                 }
 103             }
 104         }
 105     }
 106
 107     @Override
 108     public int canUpdateNeutronLoadBalancerPool(NeutronLoadBalancerPool delta, NeutronLoadBalancerPool original) {
 109         return HttpURLConnection.HTTP_NOT_IMPLEMENTED;
 110     }
 111
 112     @Override
 113     public void neutronLoadBalancerPoolUpdated(NeutronLoadBalancerPool neutronLBPool) {
 114         LOG.debug("Neutron LB Pool Update : {}", neutronLBPool.toString());
 115         enqueueEvent(new NorthboundEvent(neutronLBPool, Action.UPDATE));
 116     }
 117
 118     @Override
 119     public int canDeleteNeutronLoadBalancerPool(NeutronLoadBalancerPool neutronLBPool) {
 120         String poolProtocol = neutronLBPool.getLoadBalancerPoolProtocol();
 121         if (poolProtocol == null) {
 122             return HttpURLConnection.HTTP_BAD_REQUEST;
 123         } else if (!(poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_TCP) ||
 124                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTP) ||
 125                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTPS))) {
 126             return HttpURLConnection.HTTP_NOT_ACCEPTABLE;
 127         } else {
 128             return HttpURLConnection.HTTP_OK;
 129         }
 130     }
 131
 132     @Override
 133     public void neutronLoadBalancerPoolDeleted(NeutronLoadBalancerPool neutronLBPool) {
 134         LOG.debug("Neutron LB Pool Deletion : {}", neutronLBPool.toString());
 135         enqueueEvent(new NorthboundEvent(neutronLBPool, Action.DELETE));
 136     }
 137
 138     private void doNeutronLoadBalancerPoolDelete(NeutronLoadBalancerPool neutronLBPool) {
 139         Preconditions.checkNotNull(loadBalancerProvider);
 140
 141         List<LoadBalancerConfiguration> lbConfigList = extractLBConfiguration(neutronLBPool);
 142         final List<Node> nodes = nodeCacheManager.getBridgeNodes();
 143         if (lbConfigList == null) {
 144             LOG.debug("Neutron LB configuration invalid for pool {} ", neutronLBPool.getLoadBalancerPoolID());
 145         } else if (lbConfigList.size() == 0) {
 146             LOG.debug("No Neutron LB VIP not created yet for pool {} ", neutronLBPool.getLoadBalancerPoolID());
 147         } else if (nodes.isEmpty()) {
 148             LOG.debug("Noop with LB pool {} deletion because no nodes available.", neutronLBPool.getLoadBalancerPoolID());
 149         } else {
 150             for (LoadBalancerConfiguration lbConfig: lbConfigList) {
 151                 if (!lbConfig.isValid()) {
 152                     LOG.debug("Neutron LB pool configuration invalid for {} ", lbConfig.getName());
 153                 } else {
 154                     for (Node node : nodes) {
 155                         loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.DELETE);
 156                     }
 157                 }
 158             }
 159         }
 160     }
 161
 162     /**
 163      * Process the event.
 164      *
 165      * @param abstractEvent the {@link org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent} event to be handled.
 166      * @see org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher
 167      */
 168     @Override
 169     public void processEvent(AbstractEvent abstractEvent) {
 170         LOG.debug("Processing Loadbalancer Pool event {}", abstractEvent);
 171         if (!(abstractEvent instanceof NorthboundEvent)) {
 172             LOG.error("Unable to process abstract event {}", abstractEvent);
 173             return;
 174         }
 175         NorthboundEvent ev = (NorthboundEvent) abstractEvent;
 176         switch (ev.getAction()) {
 177             case ADD:
 178                 doNeutronLoadBalancerPoolCreate(ev.getLoadBalancerPool());
 179                 break;
 180             case DELETE:
 181                 doNeutronLoadBalancerPoolDelete(ev.getLoadBalancerPool());
 182                 break;
 183             case UPDATE:
 184                 /**
 185                  * Typical upgrade involves changing algorithm. Right now
 186                  * we do not support this flexibility. TODO
 187                  */
 188                 LOG.warn("Load balancer pool update is not supported");
 189                 break;
 190             default:
 191                 LOG.warn("Unable to process event action {}", ev.getAction());
 192                 break;
 193         }
 194     }
 195
 196     /**
 197      * Useful utility for extracting the loadbalancer instance. With
 198      * each LB pool, we allow multiple VIP and LB to be instantiated.
 199      */
 200     public List<LoadBalancerConfiguration> extractLBConfiguration(NeutronLoadBalancerPool neutronLBPool) {
 201         String poolProtocol = neutronLBPool.getLoadBalancerPoolProtocol();
 202         if (poolProtocol == null) {
 203             return null;
 204         }
 205         if (!(poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTP) ||
 206                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTPS))) {
 207             return null;
 208         }
 209
 210         List<NeutronLoadBalancerPoolMember> poolMembers = neutronLBPool.getLoadBalancerPoolMembers();
 211         if (poolMembers.size() == 0) {
 212             LOG.debug("Neutron LB pool is empty: {}", neutronLBPool);
 213             return null;
 214         }
 215
 216         List<LoadBalancerConfiguration> lbConfigList = Lists.newLinkedList();
 217
 218         /* Iterate over all the Loadbalancers created so far and identify VIP
 219          */
 220         String loadBalancerSubnetID, loadBalancerVip=null, loadBalancerName=null;
 221         for (NeutronLoadBalancer neutronLB: neutronLBCache.getAllNeutronLoadBalancers()) {
 222             loadBalancerSubnetID = neutronLB.getLoadBalancerVipSubnetID();
 223             loadBalancerName = neutronLB.getLoadBalancerName();
 224             loadBalancerVip = neutronLB.getLoadBalancerVipAddress();
 225
 226             LoadBalancerConfiguration lbConfig = new LoadBalancerConfiguration(loadBalancerName, loadBalancerVip);
 227             Map.Entry<String,String> providerInfo = NeutronCacheUtils.getProviderInformation(neutronNetworkCache, neutronSubnetCache, loadBalancerSubnetID);
 228             if (providerInfo != null) {
 229                 lbConfig.setProviderNetworkType(providerInfo.getKey());
 230                 lbConfig.setProviderSegmentationId(providerInfo.getValue());
 231             }
 232             lbConfig.setVmac(NeutronCacheUtils.getMacAddress(neutronPortCache, loadBalancerSubnetID, loadBalancerVip));
 233
 234             /* Iterate over all the members in this pool and find those in same
 235              * subnet as the VIP. Those will be included in the lbConfigList
 236              */
 237             String memberSubnetID, memberIP, memberID, memberMAC;
 238             Integer memberPort;
 239             Boolean memberAdminStateIsUp;
 240             for (NeutronLoadBalancerPoolMember neutronLBPoolMember: neutronLBPool.getLoadBalancerPoolMembers()) {
 241                 memberAdminStateIsUp = neutronLBPoolMember.getPoolMemberAdminStateIsUp();
 242                 memberSubnetID = neutronLBPoolMember.getPoolMemberSubnetID();
 243                 if (memberSubnetID == null || memberAdminStateIsUp == null) {
 244                     continue;
 245                 } else if (memberSubnetID.equals(loadBalancerSubnetID) && memberAdminStateIsUp.booleanValue()) {
 246                     memberID = neutronLBPoolMember.getPoolMemberID();
 247                     memberIP = neutronLBPoolMember.getPoolMemberAddress();
 248                     memberPort = neutronLBPoolMember.getPoolMemberProtoPort();
 249                     if (memberSubnetID == null || memberID == null || memberIP == null || memberPort == null) {
 250                         LOG.debug("Neutron LB pool member details incomplete: {}", neutronLBPoolMember);
 251                         continue;
 252                     }
 253                     memberMAC = NeutronCacheUtils.getMacAddress(neutronPortCache, memberSubnetID, memberIP);
 254                     if (memberMAC == null) {
 255                         continue;
 256                     }
 257                     lbConfig.addMember(memberID, memberIP, memberMAC, poolProtocol, memberPort);
 258                 }
 259             }
 260
 261             if (lbConfig.getMembers().size() > 0) {
 262                 lbConfigList.add(lbConfig);
 263             }
 264         }
 265
 266         return lbConfigList;
 267     }
 268
 269     @Override
 270     public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
 271         loadBalancerProvider =
 272                 (LoadBalancerProvider) ServiceHelper.getGlobalInstance(LoadBalancerProvider.class, this);
 273         nodeCacheManager =
 274                 (NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
 275         eventDispatcher =
 276                 (EventDispatcher) ServiceHelper.getGlobalInstance(EventDispatcher.class, this);
 277         eventDispatcher.eventHandlerAdded(
 278                 bundleContext.getServiceReference(INeutronLoadBalancerPoolAware.class.getName()), this);
 279     }
 280
 281     @Override
 282     public void setDependencies(Object impl) {
 283         if (impl instanceof INeutronNetworkCRUD) {
 284             neutronNetworkCache = (INeutronNetworkCRUD)impl;
 285         } else if (impl instanceof INeutronPortCRUD) {
 286             neutronPortCache = (INeutronPortCRUD)impl;
 287         } else if (impl instanceof INeutronSubnetCRUD) {
 288             neutronSubnetCache = (INeutronSubnetCRUD)impl;
 289         } else if (impl instanceof INeutronLoadBalancerCRUD) {
 290             neutronLBCache = (INeutronLoadBalancerCRUD)impl;
 291         } else if (impl instanceof LoadBalancerProvider) {
 292             loadBalancerProvider = (LoadBalancerProvider)impl;
 293         }
 294     }
 295 }