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