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<>();
  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<>();
 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<>();
 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         final Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
 181         if (members != null) {
 182             for (final Member member : members.getMember()) {
 183                 allLoadBalancerPoolMembers.add(fromMemberMd(member));
 184             }
 185         }
 186         LOGGER.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
 187                 allLoadBalancerPoolMembers.size());
 188         final List<NeutronLoadBalancerPoolMember> ans = new ArrayList<>();
 189         ans.addAll(allLoadBalancerPoolMembers);
 190         return ans;
 191     }
 192
 193     public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input) {
 194         if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
 195             return false;
 196         }
 197         addMemberMd(toMd(poolUuid), input);
 198         return true;
 199     }
 200
 201     public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
 202         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 203             return false;
 204         }
 205         return removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
 206     }
 207
 208     public boolean updateNeutronLoadBalancerPoolMember(String poolUuid, String uuid,
 209             NeutronLoadBalancerPoolMember delta) {
 210         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 211             return false;
 212         }
 213         updateMemberMd(toMd(poolUuid), delta);
 214         return true;
 215     }
 216
 217     public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid, String loadBalancerPoolMemberID) {
 218         return !neutronLoadBalancerPoolMemberExists(poolUuid, loadBalancerPoolMemberID);
 219     }
 220
 221     protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool, Member item) {
 222         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey())
 223                 .child(Members.class).child(Member.class, item.getKey());
 224     }
 225
 226     protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
 227         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey())
 228                 .child(Members.class);
 229     }
 230
 231     static NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
 232         final NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
 233         if (member.isAdminStateUp() != null) {
 234             answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
 235         }
 236         if (member.getAddress() != null) {
 237             answer.setPoolMemberAddress(String.valueOf(member.getAddress().getValue()));
 238         }
 239         if (member.getProtocolPort() != null) {
 240             answer.setPoolMemberProtoPort(member.getProtocolPort());
 241         }
 242         if (member.getUuid() != null) {
 243             answer.setID(member.getUuid().getValue());
 244             answer.setPoolID(member.getUuid().getValue());
 245         }
 246         if (member.getSubnetId() != null) {
 247             answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
 248         }
 249         if (member.getTenantId() != null) {
 250             answer.setTenantID(member.getTenantId());
 251         }
 252         if (member.getWeight() != null) {
 253             answer.setPoolMemberWeight(member.getWeight());
 254         }
 255         return answer;
 256     }
 257
 258     protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
 259         final MemberBuilder memberBuilder = new MemberBuilder();
 260         memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
 261         if (member.getPoolMemberAddress() != null) {
 262             final IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
 263             memberBuilder.setAddress(ipAddress);
 264         }
 265         if (member.getPoolMemberProtoPort() != null) {
 266             memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
 267         }
 268         if (member.getID() != null) {
 269             memberBuilder.setUuid(toUuid(member.getID()));
 270         }
 271         if (member.getPoolMemberSubnetID() != null) {
 272             memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
 273         }
 274         if (member.getTenantID() != null) {
 275             memberBuilder.setTenantId(toUuid(member.getTenantID()));
 276         }
 277         if (member.getPoolMemberWeight() != null) {
 278             memberBuilder.setWeight(member.getPoolMemberWeight());
 279         }
 280         return memberBuilder.build();
 281     }
 282
 283     protected Member toMemberMd(String uuid) {
 284         final MemberBuilder memberBuilder = new MemberBuilder();
 285         memberBuilder.setUuid(toUuid(uuid));
 286         return memberBuilder.build();
 287     }
 288
 289     protected <
 290             T extends org.opendaylight.yangtools.yang.binding.DataObject> T readMemberMd(InstanceIdentifier<T> path) {
 291         T result = null;
 292         final ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction();
 293         final CheckedFuture<Optional<T>,
 294                 ReadFailedException> future = transaction.read(LogicalDatastoreType.CONFIGURATION, path);
 295         if (future != null) {
 296             Optional<T> optional;
 297             try {
 298                 optional = future.checkedGet();
 299                 if (optional.isPresent()) {
 300                     result = optional.get();
 301                 }
 302             } catch (final ReadFailedException e) {
 303                 LOGGER.warn("Failed to read {}", path, e);
 304             }
 305         }
 306         transaction.close();
 307         return result;
 308     }
 309
 310     protected boolean addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 311         // TODO think about adding existence logic
 312         return updateMemberMd(pool, neutronObject);
 313     }
 314
 315     protected boolean updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 316         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 317         final Member item = toMemberMd(neutronObject);
 318         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 319         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
 320         final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 321         try {
 322             future.get();
 323         } catch (InterruptedException | ExecutionException e) {
 324             LOGGER.warn("Transation failed ", e);
 325             return false;
 326         }
 327         return true;
 328     }
 329
 330     protected boolean removeMemberMd(Pool pool, Member item) {
 331         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 332         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 333         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
 334         final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 335         try {
 336             future.get();
 337         } catch (InterruptedException | ExecutionException e) {
 338             LOGGER.warn("Transation failed ", e);
 339             return false;
 340         }
 341         return true;
 342     }
 343 }