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