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