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.controller.networkconfig.neutron.INeutronLoadBalancerCRUD;
  14 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolAware;
  15 import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
  16 import org.opendaylight.controller.networkconfig.neutron.INeutronPortCRUD;
  17 import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;
  18 import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancer;
  19 import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPool;
  20 import org.opendaylight.controller.networkconfig.neutron.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     @Override
  69     public void neutronLoadBalancerPoolCreated(NeutronLoadBalancerPool neutronLBPool) {
  70         logger.debug("Neutron LB Pool Creation : {}", neutronLBPool.toString());
  71         enqueueEvent(new NorthboundEvent(neutronLBPool, Action.ADD));
  72     }
  73
  74     /**
  75      * Assuming that the pool information is fully populated before this call is made,
  76      * we go with creating the LoadBalancerConfiguration object for this call with
  77      * all information that is necessary to insert flow_mods
  78      */
  79     private void doNeutronLoadBalancerPoolCreate(NeutronLoadBalancerPool neutronLBPool) {
  80         Preconditions.checkNotNull(loadBalancerProvider);
  81         List<LoadBalancerConfiguration> lbConfigList = extractLBConfiguration(neutronLBPool);
  82         if (lbConfigList == null) {
  83             logger.debug("Neutron LB configuration invalid for pool {} ", neutronLBPool.getLoadBalancerPoolID());
  84         } else if (lbConfigList.size() == 0) {
  85             logger.debug("No Neutron LB VIP not created yet for pool {} ", neutronLBPool.getLoadBalancerPoolID());
  86         } else if (this.switchManager.getNodes().size() == 0) {
  87             logger.debug("Noop with LB pool {} creation because no nodes available.", neutronLBPool.getLoadBalancerPoolID());
  88         } else {
  89             for (LoadBalancerConfiguration lbConfig: lbConfigList) {
  90                 if (!lbConfig.isValid()) {
  91                     logger.debug("Neutron LB pool configuration invalid for {} ", lbConfig.getName());
  92                     continue;
  93                 } else {
  94                     for (Node node: this.switchManager.getNodes())
  95                         loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.ADD);
  96                 }
  97             }
  98         }
  99     }
 100
 101     @Override
 102     public int canUpdateNeutronLoadBalancerPool(NeutronLoadBalancerPool delta, NeutronLoadBalancerPool original) {
 103         return HttpURLConnection.HTTP_NOT_IMPLEMENTED;
 104     }
 105
 106     @Override
 107     public void neutronLoadBalancerPoolUpdated(NeutronLoadBalancerPool neutronLBPool) {
 108         logger.debug("Neutron LB Pool Update : {}", neutronLBPool.toString());
 109         enqueueEvent(new NorthboundEvent(neutronLBPool, Action.UPDATE));
 110     }
 111
 112     @Override
 113     public int canDeleteNeutronLoadBalancerPool(NeutronLoadBalancerPool neutronLBPool) {
 114         String poolProtocol = neutronLBPool.getLoadBalancerPoolProtocol();
 115         if (poolProtocol == null)
 116             return HttpURLConnection.HTTP_BAD_REQUEST;
 117         else if (!(poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_TCP) ||
 118                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTP) ||
 119                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTPS)))
 120             return HttpURLConnection.HTTP_NOT_ACCEPTABLE;
 121         else
 122             return HttpURLConnection.HTTP_OK;
 123     }
 124
 125     @Override
 126     public void neutronLoadBalancerPoolDeleted(NeutronLoadBalancerPool neutronLBPool) {
 127         logger.debug("Neutron LB Pool Deletion : {}", neutronLBPool.toString());
 128         enqueueEvent(new NorthboundEvent(neutronLBPool, Action.DELETE));
 129     }
 130
 131     private void doNeutronLoadBalancerPoolDelete(NeutronLoadBalancerPool neutronLBPool) {
 132         Preconditions.checkNotNull(loadBalancerProvider);
 133
 134         List<LoadBalancerConfiguration> lbConfigList = extractLBConfiguration(neutronLBPool);
 135         if (lbConfigList == null) {
 136             logger.debug("Neutron LB configuration invalid for pool {} ", neutronLBPool.getLoadBalancerPoolID());
 137         } else if (lbConfigList.size() == 0) {
 138             logger.debug("No Neutron LB VIP not created yet for pool {} ", neutronLBPool.getLoadBalancerPoolID());
 139         } else if (this.switchManager.getNodes().size() == 0) {
 140             logger.debug("Noop with LB pool {} deletion because no nodes available.", neutronLBPool.getLoadBalancerPoolID());
 141         } else {
 142             for (LoadBalancerConfiguration lbConfig: lbConfigList) {
 143                 if (!lbConfig.isValid()) {
 144                     logger.debug("Neutron LB pool configuration invalid for {} ", lbConfig.getName());
 145                     continue;
 146                 } else {
 147                     for (Node node: this.switchManager.getNodes())
 148                         loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.DELETE);
 149                 }
 150             }
 151         }
 152     }
 153
 154     /**
 155      * Process the event.
 156      *
 157      * @param abstractEvent the {@link org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent} event to be handled.
 158      * @see org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher
 159      */
 160     @Override
 161     public void processEvent(AbstractEvent abstractEvent) {
 162         logger.debug("Processing Loadbalancer Pool event " + abstractEvent);
 163         if (!(abstractEvent instanceof NorthboundEvent)) {
 164             logger.error("Unable to process abstract event " + abstractEvent);
 165             return;
 166         }
 167         NorthboundEvent ev = (NorthboundEvent) abstractEvent;
 168         switch (ev.getAction()) {
 169             case ADD:
 170                 doNeutronLoadBalancerPoolCreate(ev.getLoadBalancerPool());
 171                 break;
 172             case DELETE:
 173                 doNeutronLoadBalancerPoolDelete(ev.getLoadBalancerPool());
 174                 break;
 175             case UPDATE:
 176                 /**
 177                  * Typical upgrade involves changing algorithm. Right now
 178                  * we do not support this flexibility. TODO
 179                  */
 180                 logger.warn("Load balancer pool update is not supported");
 181                 break;
 182             default:
 183                 logger.warn("Unable to process event action " + ev.getAction());
 184                 break;
 185         }
 186     }
 187
 188     /**
 189      * Useful utility for extracting the loadbalancer instance. With
 190      * each LB pool, we allow multiple VIP and LB to be instantiated.
 191      */
 192     public List<LoadBalancerConfiguration> extractLBConfiguration(NeutronLoadBalancerPool neutronLBPool) {
 193         String poolProtocol = neutronLBPool.getLoadBalancerPoolProtocol();
 194         if (poolProtocol == null)
 195             return null;
 196         if (!(poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTP) ||
 197                 poolProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTPS)))
 198             return null;
 199
 200         List<NeutronLoadBalancerPoolMember> poolMembers = neutronLBPool.getLoadBalancerPoolMembers();
 201         if (poolMembers.size() == 0) {
 202             logger.debug("Neutron LB pool is empty: {}", neutronLBPool);
 203             return null;
 204         }
 205
 206         List<LoadBalancerConfiguration> lbConfigList = Lists.newLinkedList();
 207
 208         /* Iterate over all the Loadbalancers created so far and identify VIP
 209          */
 210         String loadBalancerSubnetID, loadBalancerVip=null, loadBalancerName=null;
 211         for (NeutronLoadBalancer neutronLB: neutronLBCache.getAllNeutronLoadBalancers()) {
 212             loadBalancerSubnetID = neutronLB.getLoadBalancerVipSubnetID();
 213             loadBalancerName = neutronLB.getLoadBalancerName();
 214             loadBalancerVip = neutronLB.getLoadBalancerVipAddress();
 215
 216             LoadBalancerConfiguration lbConfig = new LoadBalancerConfiguration(loadBalancerName, loadBalancerVip);
 217             Map.Entry<String,String> providerInfo = NeutronCacheUtils.getProviderInformation(neutronNetworkCache, neutronSubnetCache, loadBalancerSubnetID);
 218             if (providerInfo != null) {
 219                 lbConfig.setProviderNetworkType(providerInfo.getKey());
 220                 lbConfig.setProviderSegmentationId(providerInfo.getValue());
 221             }
 222             lbConfig.setVmac(NeutronCacheUtils.getMacAddress(neutronPortsCache, loadBalancerSubnetID, loadBalancerVip));
 223
 224             /* Iterate over all the members in this pool and find those in same
 225              * subnet as the VIP. Those will be included in the lbConfigList
 226              */
 227             String memberSubnetID, memberIP, memberID, memberMAC;
 228             Integer memberPort;
 229             Boolean memberAdminStateIsUp;
 230             for (NeutronLoadBalancerPoolMember neutronLBPoolMember: neutronLBPool.getLoadBalancerPoolMembers()) {
 231                 memberAdminStateIsUp = neutronLBPoolMember.getPoolMemberAdminStateIsUp();
 232                 memberSubnetID = neutronLBPoolMember.getPoolMemberSubnetID();
 233                 if (memberSubnetID == null || memberAdminStateIsUp == null)
 234                     continue;
 235                 else if (memberSubnetID.equals(loadBalancerSubnetID) && memberAdminStateIsUp.booleanValue()) {
 236                     memberID = neutronLBPoolMember.getPoolMemberID();
 237                     memberIP = neutronLBPoolMember.getPoolMemberAddress();
 238                     memberPort = neutronLBPoolMember.getPoolMemberProtoPort();
 239                     if (memberSubnetID == null || memberID == null || memberIP == null || memberPort == null) {
 240                         logger.debug("Neutron LB pool member details incomplete: {}", neutronLBPoolMember);
 241                         continue;
 242                     }
 243                     memberMAC = NeutronCacheUtils.getMacAddress(neutronPortsCache, memberSubnetID, memberIP);
 244                     if (memberMAC == null)
 245                         continue;
 246                     lbConfig.addMember(memberID, memberIP, memberMAC, poolProtocol, memberPort);
 247                 }
 248             }
 249
 250             if (lbConfig.getMembers().size() > 0)
 251                 lbConfigList.add(lbConfig);
 252         }
 253
 254         return lbConfigList;
 255     }
 256 }