transcriber/src/main/java/org/opendaylight/neutron/transcriber/NeutronLoadBalancerPoolInterface.java

   1 /*
   2  * Copyright (c) 2014, 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.neutron.transcriber;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.collect.ImmutableBiMap;
  13 import com.google.common.util.concurrent.CheckedFuture;
  14 import java.util.ArrayList;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Set;
  18 import java.util.concurrent.ExecutionException;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  24 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  25 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
  26 import org.opendaylight.neutron.spi.NeutronID;
  27 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  28 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  29 import org.opendaylight.neutron.spi.NeutronLoadBalancerSessionPersistence;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolBase;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttp;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttps;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTerminatedHttps;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.Pools;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.Pool;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.PoolBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.PoolKey;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.Members;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.Member;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.MemberBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.pool.attributes.SessionPersistenceBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 public final class NeutronLoadBalancerPoolInterface
  51         extends AbstractNeutronInterface<Pool, Pools, PoolKey, NeutronLoadBalancerPool>
  52         implements INeutronLoadBalancerPoolCRUD {
  53     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
  54
  55     private static final ImmutableBiMap<Class<? extends ProtocolBase>,
  56             String> PROTOCOL_MAP = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>, String>()
  57                     .put(ProtocolHttp.class, "HTTP").put(ProtocolHttps.class, "HTTPS").put(ProtocolTcp.class, "TCP")
  58                     .put(ProtocolTerminatedHttps.class, "TERMINATED_HTTPS").build();
  59
  60     NeutronLoadBalancerPoolInterface(DataBroker db) {
  61         super(PoolBuilder.class, db);
  62     }
  63
  64     @Override
  65     protected List<Pool> getDataObjectList(Pools pools) {
  66         return pools.getPool();
  67     }
  68
  69     @Override
  70     protected Pool toMd(NeutronLoadBalancerPool pool) {
  71         final PoolBuilder poolBuilder = new PoolBuilder();
  72         poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
  73         if (pool.getLoadBalancerPoolHealthMonitorID() != null) {
  74             poolBuilder.setHealthmonitorId(toUuid(pool.getLoadBalancerPoolHealthMonitorID()));
  75         }
  76         if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
  77             poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
  78         }
  79         if (pool.getLoadBalancerPoolListeners() != null) {
  80             final List<Uuid> listListener = new ArrayList<Uuid>();
  81             for (final NeutronID neutronId : pool.getLoadBalancerPoolListeners()) {
  82                 listListener.add(toUuid(neutronId.getID()));
  83             }
  84             poolBuilder.setListeners(listListener);
  85         }
  86         // because members are another container, we don't want to copy
  87         // it over, so just skip it here
  88         if (pool.getName() != null) {
  89             poolBuilder.setName(pool.getName());
  90         }
  91         if (pool.getLoadBalancerPoolProtocol() != null) {
  92             final ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper = PROTOCOL_MAP.inverse();
  93             poolBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(pool.getLoadBalancerPoolProtocol()));
  94         }
  95         if (pool.getLoadBalancerPoolSessionPersistence() != null) {
  96             final NeutronLoadBalancerSessionPersistence sessionPersistence = pool
  97                     .getLoadBalancerPoolSessionPersistence();
  98             final SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
  99             sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
 100             sessionPersistenceBuilder.setType(sessionPersistence.getType());
 101             poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
 102         }
 103         if (pool.getTenantID() != null) {
 104             poolBuilder.setTenantId(toUuid(pool.getTenantID()));
 105         }
 106         if (pool.getID() != null) {
 107             poolBuilder.setUuid(toUuid(pool.getID()));
 108         } else {
 109             LOGGER.warn("Attempting to write neutron load balancer pool without UUID");
 110         }
 111         return poolBuilder.build();
 112     }
 113
 114     protected NeutronLoadBalancerPool fromMd(Pool pool) {
 115         final NeutronLoadBalancerPool answer = new NeutronLoadBalancerPool();
 116         if (pool.isAdminStateUp() != null) {
 117             answer.setLoadBalancerPoolAdminStateIsUp(pool.isAdminStateUp());
 118         }
 119         if (pool.getHealthmonitorId() != null) {
 120             answer.setLoadBalancerPoolHealthMonitorID(pool.getHealthmonitorId().getValue());
 121         }
 122         if (pool.getLbAlgorithm() != null) {
 123             answer.setLoadBalancerPoolLbAlgorithm(pool.getLbAlgorithm());
 124         }
 125         if (pool.getListeners() != null) {
 126             final List<NeutronID> ids = new ArrayList<NeutronID>();
 127             for (final Uuid id : pool.getListeners()) {
 128                 ids.add(new NeutronID(id.getValue()));
 129             }
 130             answer.setLoadBalancerPoolListeners(ids);
 131         }
 132         if (pool.getMembers() != null) {
 133             final List<NeutronLoadBalancerPoolMember> members = new ArrayList<NeutronLoadBalancerPoolMember>();
 134             for (final Member member : pool.getMembers().getMember()) {
 135                 members.add(fromMemberMd(member));
 136             }
 137             answer.setLoadBalancerPoolMembers(members);
 138         }
 139         if (pool.getName() != null) {
 140             answer.setName(pool.getName());
 141         }
 142         if (pool.getProtocol() != null) {
 143             answer.setLoadBalancerPoolProtocol(PROTOCOL_MAP.get(pool.getProtocol()));
 144         }
 145         if (pool.getSessionPersistence() != null) {
 146             final NeutronLoadBalancerSessionPersistence sessionPersistence =
 147                     new NeutronLoadBalancerSessionPersistence();
 148             sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
 149             sessionPersistence.setType(pool.getSessionPersistence().getType());
 150
 151             answer.setLoadBalancerSessionPersistence(sessionPersistence);
 152         }
 153         if (pool.getTenantId() != null) {
 154             answer.setTenantID(pool.getTenantId());
 155         }
 156         if (pool.getUuid() != null) {
 157             answer.setID(pool.getUuid().getValue());
 158         }
 159         return answer;
 160     }
 161
 162     public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) {
 163         final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
 164         if (member == null) {
 165             return false;
 166         }
 167         return true;
 168     }
 169
 170     public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
 171         final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
 172         if (member == null) {
 173             return null;
 174         }
 175         return fromMemberMd(member);
 176     }
 177
 178     public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid) {
 179         final Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<
 180                 NeutronLoadBalancerPoolMember>();
 181         final Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
 182         if (members != null) {
 183             for (final Member member : members.getMember()) {
 184                 allLoadBalancerPoolMembers.add(fromMemberMd(member));
 185             }
 186         }
 187         LOGGER.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
 188                 allLoadBalancerPoolMembers.size());
 189         final List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
 190         ans.addAll(allLoadBalancerPoolMembers);
 191         return ans;
 192     }
 193
 194     public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input) {
 195         if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
 196             return false;
 197         }
 198         addMemberMd(toMd(poolUuid), input);
 199         return true;
 200     }
 201
 202     public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
 203         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 204             return false;
 205         }
 206         return removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
 207     }
 208
 209     public boolean updateNeutronLoadBalancerPoolMember(String poolUuid, String uuid,
 210             NeutronLoadBalancerPoolMember delta) {
 211         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 212             return false;
 213         }
 214         updateMemberMd(toMd(poolUuid), delta);
 215         return true;
 216     }
 217
 218     public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid, String loadBalancerPoolMemberID) {
 219         return !neutronLoadBalancerPoolMemberExists(poolUuid, loadBalancerPoolMemberID);
 220     }
 221
 222     protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool, Member item) {
 223         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey())
 224                 .child(Members.class).child(Member.class, item.getKey());
 225     }
 226
 227     protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
 228         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey())
 229                 .child(Members.class);
 230     }
 231
 232     static NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
 233         final NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
 234         if (member.isAdminStateUp() != null) {
 235             answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
 236         }
 237         if (member.getAddress() != null) {
 238             answer.setPoolMemberAddress(String.valueOf(member.getAddress().getValue()));
 239         }
 240         if (member.getProtocolPort() != null) {
 241             answer.setPoolMemberProtoPort(member.getProtocolPort());
 242         }
 243         if (member.getUuid() != null) {
 244             answer.setID(member.getUuid().getValue());
 245             answer.setPoolID(member.getUuid().getValue());
 246         }
 247         if (member.getSubnetId() != null) {
 248             answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
 249         }
 250         if (member.getTenantId() != null) {
 251             answer.setTenantID(member.getTenantId());
 252         }
 253         if (member.getWeight() != null) {
 254             answer.setPoolMemberWeight(member.getWeight());
 255         }
 256         return answer;
 257     }
 258
 259     protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
 260         final MemberBuilder memberBuilder = new MemberBuilder();
 261         memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
 262         if (member.getPoolMemberAddress() != null) {
 263             final IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
 264             memberBuilder.setAddress(ipAddress);
 265         }
 266         if (member.getPoolMemberProtoPort() != null) {
 267             memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
 268         }
 269         if (member.getID() != null) {
 270             memberBuilder.setUuid(toUuid(member.getID()));
 271         }
 272         if (member.getPoolMemberSubnetID() != null) {
 273             memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
 274         }
 275         if (member.getTenantID() != null) {
 276             memberBuilder.setTenantId(toUuid(member.getTenantID()));
 277         }
 278         if (member.getPoolMemberWeight() != null) {
 279             memberBuilder.setWeight(member.getPoolMemberWeight());
 280         }
 281         return memberBuilder.build();
 282     }
 283
 284     protected Member toMemberMd(String uuid) {
 285         final MemberBuilder memberBuilder = new MemberBuilder();
 286         memberBuilder.setUuid(toUuid(uuid));
 287         return memberBuilder.build();
 288     }
 289
 290     protected <
 291             T extends org.opendaylight.yangtools.yang.binding.DataObject> T readMemberMd(InstanceIdentifier<T> path) {
 292         T result = null;
 293         final ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction();
 294         final CheckedFuture<Optional<T>,
 295                 ReadFailedException> future = transaction.read(LogicalDatastoreType.CONFIGURATION, path);
 296         if (future != null) {
 297             Optional<T> optional;
 298             try {
 299                 optional = future.checkedGet();
 300                 if (optional.isPresent()) {
 301                     result = optional.get();
 302                 }
 303             } catch (final ReadFailedException e) {
 304                 LOGGER.warn("Failed to read {}", path, e);
 305             }
 306         }
 307         transaction.close();
 308         return result;
 309     }
 310
 311     protected boolean addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 312         // TODO think about adding existence logic
 313         return updateMemberMd(pool, neutronObject);
 314     }
 315
 316     protected boolean updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 317         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 318         final Member item = toMemberMd(neutronObject);
 319         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 320         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
 321         final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 322         try {
 323             future.get();
 324         } catch (InterruptedException | ExecutionException e) {
 325             LOGGER.warn("Transation failed ", e);
 326             return false;
 327         }
 328         return true;
 329     }
 330
 331     protected boolean removeMemberMd(Pool pool, Member item) {
 332         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 333         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 334         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
 335         final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 336         try {
 337             future.get();
 338         } catch (InterruptedException | ExecutionException e) {
 339             LOGGER.warn("Transation failed ", e);
 340             return false;
 341         }
 342         return true;
 343     }
 344 }