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