openstack/net-virt/src/main/java/org/opendaylight/ovsdb/openstack/netvirt/LBaaSHandler.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.INeutronLoadBalancerAware;
  14 import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
  15 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
  16 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  17 import org.opendaylight.neutron.spi.INeutronPortCRUD;
  18 import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
  19 import org.opendaylight.neutron.spi.NeutronLoadBalancer;
  20 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  21 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  22 import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
  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.openstack.netvirt.api.NodeCacheListener;
  27 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 import com.google.common.base.Preconditions;
  32
  33 import java.net.HttpURLConnection;
  34 import java.util.List;
  35 import java.util.Map;
  36
  37 /**
  38  * Handle requests for OpenStack Neutron v2.0 LBaaS API calls for /v2.0/loadbalancers.
  39  */
  40
  41 //TODO: Implement INeutronLoadBalancerHealthMonitorAware, INeutronLoadBalancerListenerAware, INeutronLoadBalancerPoolMemberAware,
  42
  43 public class LBaaSHandler extends AbstractHandler
  44         implements INeutronLoadBalancerAware, NodeCacheListener {
  45
  46     private static final Logger logger = LoggerFactory.getLogger(LBaaSHandler.class);
  47
  48     // The implementation for each of these services is resolved by the OSGi Service Manager
  49     private volatile INeutronLoadBalancerCRUD neutronLBCache;
  50     private volatile INeutronLoadBalancerPoolCRUD neutronLBPoolCache;
  51     private volatile INeutronPortCRUD neutronPortsCache;
  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 canCreateNeutronLoadBalancer(NeutronLoadBalancer neutronLB) {
  59         //Always allowed and not wait for pool and members to be created
  60         return HttpURLConnection.HTTP_OK;
  61     }
  62
  63     @Override
  64     public void neutronLoadBalancerCreated(NeutronLoadBalancer neutronLB) {
  65         logger.debug("Neutron LB Creation : {}", neutronLB.toString());
  66         enqueueEvent(new NorthboundEvent(neutronLB, Action.ADD));
  67     }
  68
  69     /**
  70      * Assuming that the pool information is fully populated before this call is made,
  71      * we go with creating the LoadBalancerConfiguration object for this call with
  72      * all information that is necessary to insert flow_mods
  73      */
  74     private void doNeutronLoadBalancerCreate(NeutronLoadBalancer neutronLB) {
  75         Preconditions.checkNotNull(loadBalancerProvider);
  76         LoadBalancerConfiguration lbConfig = extractLBConfiguration(neutronLB);
  77         final List<Node> nodes = nodeCacheManager.getBridgeNodes();
  78
  79         if (!lbConfig.isValid()) {
  80             logger.debug("Neutron LB pool configuration invalid for {} ", lbConfig.getName());
  81         } else if (nodes.isEmpty()) {
  82             logger.debug("Noop with LB {} creation because no nodes available.", lbConfig.getName());
  83         } else {
  84             for (Node node : nodes) {
  85                 loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.ADD);
  86             }
  87         }
  88     }
  89
  90     @Override
  91     public int canUpdateNeutronLoadBalancer(NeutronLoadBalancer delta, NeutronLoadBalancer original) {
  92         //Update allowed anytime, even when the LB has no active pool yet
  93         return HttpURLConnection.HTTP_OK;
  94     }
  95
  96     @Override
  97     public void neutronLoadBalancerUpdated(NeutronLoadBalancer neutronLB) {
  98         logger.debug("Neutron LB Update : {}", neutronLB.toString());
  99         enqueueEvent(new NorthboundEvent(neutronLB, Action.UPDATE));
 100     }
 101
 102     @Override
 103     public int canDeleteNeutronLoadBalancer(NeutronLoadBalancer neutronLB) {
 104         //Always allowed and not wait for pool to stop using it
 105         return HttpURLConnection.HTTP_OK;
 106     }
 107
 108     @Override
 109     public void neutronLoadBalancerDeleted(NeutronLoadBalancer neutronLB) {
 110         logger.debug("Neutron LB Deletion : {}", neutronLB.toString());
 111         enqueueEvent(new NorthboundEvent(neutronLB, Action.DELETE));
 112     }
 113
 114     private void doNeutronLoadBalancerDelete(NeutronLoadBalancer neutronLB) {
 115         Preconditions.checkNotNull(loadBalancerProvider);
 116         LoadBalancerConfiguration lbConfig = extractLBConfiguration(neutronLB);
 117         final List<Node> nodes = nodeCacheManager.getBridgeNodes();
 118
 119         if (!lbConfig.isValid()) {
 120             logger.debug("Neutron LB pool configuration invalid for {} ", lbConfig.getName());
 121         } else if (nodes.isEmpty()) {
 122             logger.debug("Noop with LB {} deletion because no nodes available.", lbConfig.getName());
 123         } else {
 124             for (Node node : nodes) {
 125                 loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.DELETE);
 126             }
 127         }
 128     }
 129
 130     /**
 131      * Process the event.
 132      *
 133      * @param abstractEvent the {@link org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent} event to be handled.
 134      * @see org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher
 135      */
 136     @Override
 137     public void processEvent(AbstractEvent abstractEvent) {
 138         logger.debug("Processing Loadbalancer event " + abstractEvent);
 139         if (!(abstractEvent instanceof NorthboundEvent)) {
 140             logger.error("Unable to process abstract event " + abstractEvent);
 141             return;
 142         }
 143         NorthboundEvent ev = (NorthboundEvent) abstractEvent;
 144         switch (ev.getAction()) {
 145             case ADD:
 146                 doNeutronLoadBalancerCreate(ev.getLoadBalancer());
 147                 break;
 148             case DELETE:
 149                 doNeutronLoadBalancerDelete(ev.getLoadBalancer());
 150                 break;
 151             case UPDATE:
 152                 /**
 153                  * Currently member update requires delete and re-adding
 154                  * Also, weights and weight updates are not supported
 155                  */
 156                 doNeutronLoadBalancerDelete(ev.getLoadBalancer());
 157                 doNeutronLoadBalancerCreate(ev.getLoadBalancer());
 158                 break;
 159             default:
 160                 logger.warn("Unable to process event action " + ev.getAction());
 161                 break;
 162         }
 163     }
 164
 165     /**
 166      * Useful utility for extracting the loadbalancer instance
 167      * configuration from the neutron LB cache
 168      */
 169     public LoadBalancerConfiguration extractLBConfiguration(NeutronLoadBalancer neutronLB) {
 170         String loadBalancerName = neutronLB.getLoadBalancerName();
 171         String loadBalancerVip = neutronLB.getLoadBalancerVipAddress();
 172         String loadBalancerSubnetID = neutronLB.getLoadBalancerVipSubnetID();
 173
 174         LoadBalancerConfiguration lbConfig = new LoadBalancerConfiguration(loadBalancerName, loadBalancerVip);
 175         Map.Entry<String,String> providerInfo = NeutronCacheUtils.getProviderInformation(neutronNetworkCache, neutronSubnetCache, loadBalancerSubnetID);
 176         if (providerInfo != null) {
 177             lbConfig.setProviderNetworkType(providerInfo.getKey());
 178             lbConfig.setProviderSegmentationId(providerInfo.getValue());
 179         }
 180         lbConfig.setVmac(NeutronCacheUtils.getMacAddress(neutronPortsCache, loadBalancerSubnetID, loadBalancerVip));
 181
 182         String memberID, memberIP, memberMAC, memberProtocol, memberSubnetID;
 183         Integer memberPort;
 184         Boolean memberAdminStateIsUp;
 185
 186         for (NeutronLoadBalancerPool neutronLBPool: neutronLBPoolCache.getAllNeutronLoadBalancerPools()) {
 187             List<NeutronLoadBalancerPoolMember> members = neutronLBPool.getLoadBalancerPoolMembers();
 188             memberProtocol = neutronLBPool.getLoadBalancerPoolProtocol();
 189             if (memberProtocol == null) {
 190                 continue;
 191             }
 192
 193             if (!(memberProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_TCP) ||
 194                   memberProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTP) ||
 195                   memberProtocol.equalsIgnoreCase(LoadBalancerConfiguration.PROTOCOL_HTTPS))) {
 196                 continue;
 197             }
 198             for (NeutronLoadBalancerPoolMember neutronLBPoolMember: members) {
 199                 memberAdminStateIsUp = neutronLBPoolMember.getPoolMemberAdminStateIsUp();
 200                 memberSubnetID = neutronLBPoolMember.getPoolMemberSubnetID();
 201                 if (memberSubnetID == null || memberAdminStateIsUp == null) {
 202                     continue;
 203                 }
 204                 else if (memberSubnetID.equals(loadBalancerSubnetID) && memberAdminStateIsUp.booleanValue()) {
 205                     memberID = neutronLBPoolMember.getPoolMemberID();
 206                     memberIP = neutronLBPoolMember.getPoolMemberAddress();
 207                     memberPort = neutronLBPoolMember.getPoolMemberProtoPort();
 208                     if (memberSubnetID == null || memberID == null || memberIP == null || memberPort == null) {
 209                         logger.debug("Neutron LB pool member details incomplete: {}", neutronLBPoolMember);
 210                         continue;
 211                     }
 212                     memberMAC = NeutronCacheUtils.getMacAddress(neutronPortsCache, memberSubnetID, memberIP);
 213                     if (memberMAC == null) {
 214                         continue;
 215                     }
 216                     lbConfig.addMember(memberID, memberIP, memberMAC, memberProtocol, memberPort);
 217                 }
 218             }
 219         }
 220         return lbConfig;
 221     }
 222
 223     /**
 224      * On the addition of a new node, we iterate through all existing loadbalancer
 225      * instances and program the node for all of them. It is sufficient to do that only
 226      * when a node is added, and only for the LB instances (and not individual members).
 227      */
 228     @Override
 229     public void notifyNode(Node node, Action type) {
 230         logger.debug("notifyNode: Node {} update {} from Controller's inventory Service", node, type);
 231         Preconditions.checkNotNull(loadBalancerProvider);
 232
 233         for (NeutronLoadBalancer neutronLB: neutronLBCache.getAllNeutronLoadBalancers()) {
 234             LoadBalancerConfiguration lbConfig = extractLBConfiguration(neutronLB);
 235             if (!lbConfig.isValid()) {
 236                 logger.debug("Neutron LB configuration invalid for {} ", lbConfig.getName());
 237             } else {
 238                if (type.equals(Action.ADD)) {
 239                    loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.ADD);
 240
 241                /* When node disappears, we do nothing for now. Making a call to
 242                 * loadBalancerProvider.programLoadBalancerRules(node, lbConfig, Action.DELETE)
 243                 * can lead to TransactionCommitFailedException. Similarly when node is changed,
 244                 * because of remove followed by add, we do nothing.
 245                 */
 246
 247                  //(type.equals(UpdateType.REMOVED) || type.equals(UpdateType.CHANGED))
 248                } else {
 249                    continue;
 250                }
 251             }
 252         }
 253     }
 254 }