openstack/net-virt/src/main/java/org/opendaylight/netvirt/openstack/netvirt/translator/iaware/impl/NeutronLoadBalancerPoolChangeListener.java

   1 /*
   2  * Copyright (C) 2015 Red Hat, Inc. 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.netvirt.openstack.netvirt.translator.iaware.impl;
  10
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Map.Entry;
  14
  15 import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  18 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
  19 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancerPool;
  22 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancerPoolMember;
  23 import org.opendaylight.netvirt.openstack.netvirt.translator.Neutron_ID;
  24 import org.opendaylight.netvirt.openstack.netvirt.translator.iaware.INeutronLoadBalancerPoolAware;
  25 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancer_SessionPersistence;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolBase;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttp;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttps;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolIcmp;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.Pools;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.Pool;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.Member;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  36 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  37 import org.opendaylight.yangtools.yang.binding.DataObject;
  38 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  39 import org.slf4j.Logger;
  40 import org.slf4j.LoggerFactory;
  41
  42 import com.google.common.collect.ImmutableBiMap;
  43
  44 public class NeutronLoadBalancerPoolChangeListener implements ClusteredDataChangeListener, AutoCloseable {
  45     private static final Logger LOG = LoggerFactory.getLogger(NeutronLoadBalancerPoolChangeListener.class);
  46
  47     private static final ImmutableBiMap<Class<? extends ProtocolBase>,String> PROTOCOL_MAP
  48             = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>,String>()
  49             .put(ProtocolHttp.class, "HTTP")
  50             .put(ProtocolHttps.class, "HTTPS")
  51             .put(ProtocolIcmp.class, "ICMP")
  52             .put(ProtocolTcp.class,"TCP")
  53             .build();
  54
  55     private ListenerRegistration<DataChangeListener> registration;
  56     private DataBroker db;
  57
  58     public NeutronLoadBalancerPoolChangeListener(DataBroker db){
  59         this.db = db;
  60         InstanceIdentifier<Pool> path = InstanceIdentifier
  61                 .create(Neutron.class)
  62                 .child(Pools.class)
  63                 .child(Pool.class);
  64         LOG.debug("Register listener for Neutron Load Balancer Pool model data changes");
  65         registration =
  66                 this.db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, path, this, AsyncDataBroker.DataChangeScope.ONE);
  67     }
  68
  69     @Override
  70     public void close() throws Exception {
  71         registration.close();
  72     }
  73
  74     @Override
  75     public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
  76         LOG.trace("Data changes : {}", changes);
  77
  78         Object[] subscribers = NeutronIAwareUtil.getInstances(INeutronLoadBalancerPoolAware.class, this);
  79         createPool(changes, subscribers);
  80         updatePool(changes, subscribers);
  81         deletePool(changes, subscribers);
  82     }
  83
  84     private void createPool(
  85             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
  86             Object[] subscribers) {
  87         for (Entry<InstanceIdentifier<?>, DataObject> newPool : changes.getCreatedData().entrySet()) {
  88                 if(newPool.getValue() instanceof Pool){
  89                 NeutronLoadBalancerPool loadBalancerPool = fromMd((Pool) newPool.getValue());
  90                 for (Object entry : subscribers) {
  91                     INeutronLoadBalancerPoolAware subscriber = (INeutronLoadBalancerPoolAware) entry;
  92                     subscriber.neutronLoadBalancerPoolCreated(loadBalancerPool);
  93                 }
  94                 }
  95         }
  96     }
  97     private void updatePool(
  98             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
  99             Object[] subscribers) {
 100         for (Entry<InstanceIdentifier<?>, DataObject> updatePool : changes.getUpdatedData().entrySet()) {
 101                 if(updatePool.getValue() instanceof Pool){
 102                 NeutronLoadBalancerPool loadBalancerPool = fromMd((Pool)updatePool.getValue());
 103                 for(Object entry: subscribers){
 104                     INeutronLoadBalancerPoolAware subscriber = (INeutronLoadBalancerPoolAware) entry;
 105                     subscriber.neutronLoadBalancerPoolUpdated(loadBalancerPool);
 106                 }
 107                 }
 108         }
 109     }
 110     private void deletePool(
 111             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
 112             Object[] subscribers) {
 113         for (InstanceIdentifier<?> deletedPoolPath : changes.getRemovedPaths()) {
 114                 if(deletedPoolPath.getTargetType().equals(Pool.class)){
 115                 NeutronLoadBalancerPool loadBalancerPool = fromMd((Pool)changes.getOriginalData().get(deletedPoolPath));
 116                 for(Object entry: subscribers){
 117                     INeutronLoadBalancerPoolAware subscriber = (INeutronLoadBalancerPoolAware) entry;
 118                     subscriber.neutronLoadBalancerPoolDeleted(loadBalancerPool);
 119                 }
 120                 }
 121         }
 122     }
 123
 124     /*
 125      * This method is borrowed from NeutronLoadBalancerPool.java class of Neutron Northbound class.
 126      * in the original location, this method is called extractFields.
 127      * We will be utilizing similar code from other classes from the same package of neutron project.
 128      */
 129     private NeutronLoadBalancerPool fromMd(Pool pool) {
 130         NeutronLoadBalancerPool result = new NeutronLoadBalancerPool();
 131
 132         result.setID(pool.getUuid().getValue());
 133         if (pool.getTenantId() != null) {
 134             result.setLoadBalancerPoolTenantID(pool.getTenantId().getValue());
 135         }
 136         if (pool.getName() != null) {
 137             result.setLoadBalancerPoolName(pool.getName());
 138         }
 139         if (pool.getProtocol() != null) {
 140             result.setLoadBalancerPoolProtocol(PROTOCOL_MAP.get(pool.getProtocol()));
 141         }
 142         if (pool.getLbAlgorithm() != null) {
 143             result.setLoadBalancerPoolLbAlgorithm(pool.getLbAlgorithm());
 144         }
 145
 146         // TODO: setNeutronLoadBalancerPoolHealthMonitorID is a list? Fill in, when its needed.
 147         if (pool.getHealthmonitorId() != null) {
 148                 result.setNeutronLoadBalancerPoolHealthMonitorID(pool.getHealthmonitorId().getValue());
 149         }
 150
 151         if (pool.isAdminStateUp() != null) {
 152             result.setLoadBalancerPoolAdminStateIsUp(pool.isAdminStateUp());
 153         }
 154
 155         List<Neutron_ID> listeners = new ArrayList();
 156         if (pool.getListeners() != null) {
 157             for (Uuid listenerUuid : pool.getListeners()) {
 158                 listeners.add(new Neutron_ID(listenerUuid.getValue()));
 159             }
 160         }
 161         result.setLoadBalancerPoolListeners(listeners);
 162
 163         if (pool.getSessionPersistence() != null) {
 164             NeutronLoadBalancer_SessionPersistence sessionPersistence = new NeutronLoadBalancer_SessionPersistence();
 165             sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
 166             sessionPersistence.setType(pool.getSessionPersistence().getType());
 167             result.setLoadBalancerSessionPersistence(sessionPersistence);
 168         }
 169
 170         List<NeutronLoadBalancerPoolMember> loadBalancerPoolMembers = new ArrayList();
 171         if (pool.getMembers() != null) {
 172             for (Member member : pool.getMembers().getMember()) {
 173                 NeutronLoadBalancerPoolMember neutronMember = new NeutronLoadBalancerPoolMember();
 174
 175                 neutronMember.setPoolID(pool.getUuid().getValue());
 176                 neutronMember.setPoolMemberID(member.getUuid().getValue());
 177
 178                 // TODO: locate and populate remainder attributes, when its needed
 179                 // member.setPoolMemberAddress(xxx);
 180                 // member.setPoolMemberAdminStateIsUp(xxx);
 181                 // member.setPoolMemberProtoPort(xxx);
 182                 // member.setPoolMemberSubnetID(xxx);
 183                 // member.setPoolMemberTenantID(xxx);
 184                 // member.setPoolMemberWeight(xxx);
 185
 186                 loadBalancerPoolMembers.add(neutronMember);
 187             }
 188         }
 189         result.setLoadBalancerPoolMembers(loadBalancerPoolMembers);
 190
 191         return result;
 192     }
 193 }