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 javax.inject.Inject;
  18 import javax.inject.Singleton;
  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.inet.types.rev130715.IpAddressBuilder;
  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.DataObject;
  48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  49 import org.opendaylight.yangtools.yang.common.OperationFailedException;
  50 import org.ops4j.pax.cdi.api.OsgiServiceProvider;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 @Singleton
  55 @OsgiServiceProvider(classes = INeutronLoadBalancerPoolCRUD.class)
  56 public final class NeutronLoadBalancerPoolInterface
  57         extends AbstractNeutronInterface<Pool, Pools, PoolKey, NeutronLoadBalancerPool>
  58         implements INeutronLoadBalancerPoolCRUD {
  59
  60     private static final Logger LOG = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
  61
  62     private static final ImmutableBiMap<Class<? extends ProtocolBase>,
  63             String> PROTOCOL_MAP = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>, String>()
  64                     .put(ProtocolHttp.class, "HTTP").put(ProtocolHttps.class, "HTTPS").put(ProtocolTcp.class, "TCP")
  65                     .put(ProtocolTerminatedHttps.class, "TERMINATED_HTTPS").build();
  66
  67     @Inject
  68     public NeutronLoadBalancerPoolInterface(DataBroker db) {
  69         super(PoolBuilder.class, db);
  70     }
  71
  72     @Override
  73     protected List<Pool> getDataObjectList(Pools pools) {
  74         return pools.getPool();
  75     }
  76
  77     @Override
  78     protected Pool toMd(NeutronLoadBalancerPool pool) {
  79         final PoolBuilder poolBuilder = new PoolBuilder();
  80         toMdBaseAttributes(pool, poolBuilder);
  81         poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
  82         if (pool.getLoadBalancerPoolHealthMonitorID() != null) {
  83             poolBuilder.setHealthmonitorId(toUuid(pool.getLoadBalancerPoolHealthMonitorID()));
  84         }
  85         if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
  86             poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
  87         }
  88         if (pool.getLoadBalancerPoolListeners() != null) {
  89             final List<Uuid> listListener = new ArrayList<>();
  90             for (final NeutronID neutronId : pool.getLoadBalancerPoolListeners()) {
  91                 listListener.add(toUuid(neutronId.getID()));
  92             }
  93             poolBuilder.setListeners(listListener);
  94         }
  95         // because members are another container, we don't want to copy
  96         // it over, so just skip it here
  97         if (pool.getLoadBalancerPoolProtocol() != null) {
  98             final ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper = PROTOCOL_MAP.inverse();
  99             poolBuilder.setProtocol(mapper.get(pool.getLoadBalancerPoolProtocol()));
 100         }
 101         if (pool.getLoadBalancerPoolSessionPersistence() != null) {
 102             final NeutronLoadBalancerSessionPersistence sessionPersistence = pool
 103                     .getLoadBalancerPoolSessionPersistence();
 104             final SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
 105             sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
 106             sessionPersistenceBuilder.setType(sessionPersistence.getType());
 107             poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
 108         }
 109         return poolBuilder.build();
 110     }
 111
 112     @Override
 113     protected NeutronLoadBalancerPool fromMd(Pool pool) {
 114         final NeutronLoadBalancerPool answer = new NeutronLoadBalancerPool();
 115         fromMdBaseAttributes(pool, answer);
 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.getProtocol() != null) {
 140             answer.setLoadBalancerPoolProtocol(PROTOCOL_MAP.get(pool.getProtocol()));
 141         }
 142         if (pool.getSessionPersistence() != null) {
 143             NeutronLoadBalancerSessionPersistence sessionPersistence = new NeutronLoadBalancerSessionPersistence();
 144             sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
 145             sessionPersistence.setType(pool.getSessionPersistence().getType());
 146
 147             answer.setLoadBalancerSessionPersistence(sessionPersistence);
 148         }
 149         return answer;
 150     }
 151
 152     @Override
 153     public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) throws ReadFailedException {
 154         final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
 155         if (member == null) {
 156             return false;
 157         }
 158         return true;
 159     }
 160
 161     @Override
 162     public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String poolUuid, String uuid)
 163             throws ReadFailedException {
 164         final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
 165         if (member == null) {
 166             return null;
 167         }
 168         return fromMemberMd(member);
 169     }
 170
 171     @Override
 172     public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid)
 173             throws ReadFailedException {
 174         final Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<>();
 175         final Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
 176         if (members != null) {
 177             for (final Member member : members.getMember()) {
 178                 allLoadBalancerPoolMembers.add(fromMemberMd(member));
 179             }
 180         }
 181         LOG.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
 182                 allLoadBalancerPoolMembers.size());
 183         final List<NeutronLoadBalancerPoolMember> ans = new ArrayList<>();
 184         ans.addAll(allLoadBalancerPoolMembers);
 185         return ans;
 186     }
 187
 188     @Override
 189     public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input)
 190             throws OperationFailedException {
 191         if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
 192             return false;
 193         }
 194         addMemberMd(toMd(poolUuid), input);
 195         return true;
 196     }
 197
 198     @Override
 199     public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) throws OperationFailedException {
 200         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 201             return false;
 202         }
 203         removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
 204         return true;
 205     }
 206
 207     @Override
 208     public boolean updateNeutronLoadBalancerPoolMember(String poolUuid, String uuid,
 209             NeutronLoadBalancerPoolMember delta) throws OperationFailedException {
 210         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 211             return false;
 212         }
 213         updateMemberMd(toMd(poolUuid), delta);
 214         return true;
 215     }
 216
 217     @Override
 218     public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid, String loadBalancerPoolMemberID)
 219             throws ReadFailedException {
 220         return !neutronLoadBalancerPoolMemberExists(poolUuid, loadBalancerPoolMemberID);
 221     }
 222
 223     protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool, Member item) {
 224         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.key())
 225                 .child(Members.class).child(Member.class, item.key());
 226     }
 227
 228     protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
 229         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.key())
 230                 .child(Members.class);
 231     }
 232
 233     protected NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
 234         final NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
 235         fromMdIds(member, answer);
 236         if (member.isAdminStateUp() != null) {
 237             answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
 238         }
 239         if (member.getAddress() != null) {
 240             answer.setPoolMemberAddress(member.getAddress().stringValue());
 241         }
 242         if (member.getProtocolPort() != null) {
 243             answer.setPoolMemberProtoPort(member.getProtocolPort());
 244         }
 245         if (member.getSubnetId() != null) {
 246             answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
 247         }
 248         if (member.getWeight() != null) {
 249             answer.setPoolMemberWeight(member.getWeight());
 250         }
 251         return answer;
 252     }
 253
 254     protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
 255         final MemberBuilder memberBuilder = toMdIds(member, MemberBuilder.class);
 256         memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
 257         if (member.getPoolMemberAddress() != null) {
 258             final IpAddress ipAddress = IpAddressBuilder.getDefaultInstance(member.getPoolMemberAddress());
 259             memberBuilder.setAddress(ipAddress);
 260         }
 261         if (member.getPoolMemberProtoPort() != null) {
 262             memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
 263         }
 264         if (member.getPoolMemberSubnetID() != null) {
 265             memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
 266         }
 267         if (member.getPoolMemberWeight() != null) {
 268             memberBuilder.setWeight(member.getPoolMemberWeight());
 269         }
 270         return memberBuilder.build();
 271     }
 272
 273     private Member toMemberMd(String uuid) {
 274         final MemberBuilder memberBuilder = new MemberBuilder();
 275         memberBuilder.setUuid(toUuid(uuid));
 276         return memberBuilder.build();
 277     }
 278
 279     private <T extends DataObject> T readMemberMd(InstanceIdentifier<T> path) throws ReadFailedException {
 280         T result = null;
 281         try (ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction()) {
 282             final CheckedFuture<Optional<T>, ReadFailedException> future = transaction
 283                     .read(LogicalDatastoreType.CONFIGURATION, path);
 284             if (future != null) {
 285                 Optional<T> optional;
 286                 optional = future.checkedGet();
 287                 if (optional.isPresent()) {
 288                     result = optional.get();
 289                 }
 290             }
 291         }
 292         return result;
 293     }
 294
 295     private void addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject)
 296             throws TransactionCommitFailedException {
 297         // TODO think about adding existence logic
 298         updateMemberMd(pool, neutronObject);
 299     }
 300
 301     private void updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject)
 302             throws TransactionCommitFailedException {
 303         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 304         final Member item = toMemberMd(neutronObject);
 305         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 306         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
 307         transaction.submit().checkedGet();
 308     }
 309
 310     private void removeMemberMd(Pool pool, Member item) throws TransactionCommitFailedException {
 311         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 312         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 313         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
 314         transaction.submit().checkedGet();
 315     }
 316 }