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

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