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 InstanceIdentifier<Pool> createInstanceIdentifier(Pool pool) {
  69         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey());
  70     }
  71
  72     @Override
  73     protected InstanceIdentifier<Pools> createInstanceIdentifier() {
  74         return InstanceIdentifier.create(Neutron.class).child(Pools.class);
  75     }
  76
  77     @Override
  78     protected Pool toMd(NeutronLoadBalancerPool pool) {
  79         final PoolBuilder poolBuilder = new PoolBuilder();
  80         poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
  81         if (pool.getNeutronLoadBalancerPoolHealthMonitorID() != null) {
  82             poolBuilder.setHealthmonitorId(toUuid(pool.getNeutronLoadBalancerPoolHealthMonitorID()));
  83         }
  84         if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
  85             poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
  86         }
  87         if (pool.getLoadBalancerPoolListeners() != null) {
  88             final List<Uuid> listListener = new ArrayList<Uuid>();
  89             for (final Neutron_ID neutron_id : pool.getLoadBalancerPoolListeners()) {
  90                 listListener.add(toUuid(neutron_id.getID()));
  91             }
  92             poolBuilder.setListeners(listListener);
  93         }
  94         // because members are another container, we don't want to copy
  95         // it over, so just skip it here
  96         if (pool.getLoadBalancerPoolName() != null) {
  97             poolBuilder.setName(pool.getLoadBalancerPoolName());
  98         }
  99         if (pool.getLoadBalancerPoolProtocol() != null) {
 100             final ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper = PROTOCOL_MAP.inverse();
 101             poolBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(pool.getLoadBalancerPoolProtocol()));
 102         }
 103         if (pool.getLoadBalancerPoolSessionPersistence() != null) {
 104             final NeutronLoadBalancer_SessionPersistence sessionPersistence = pool
 105                     .getLoadBalancerPoolSessionPersistence();
 106             final SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
 107             sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
 108             sessionPersistenceBuilder.setType(sessionPersistence.getType());
 109             poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
 110         }
 111         if (pool.getTenantID() != null) {
 112             poolBuilder.setTenantId(toUuid(pool.getTenantID()));
 113         }
 114         if (pool.getID() != null) {
 115             poolBuilder.setUuid(toUuid(pool.getID()));
 116         } else {
 117             LOGGER.warn("Attempting to write neutron load balancer pool without UUID");
 118         }
 119         return poolBuilder.build();
 120     }
 121
 122     @Override
 123     protected Pool toMd(String uuid) {
 124         final PoolBuilder poolBuilder = new PoolBuilder();
 125         poolBuilder.setUuid(toUuid(uuid));
 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 =
 162                     new NeutronLoadBalancer_SessionPersistence();
 163             sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
 164             sessionPersistence.setType(pool.getSessionPersistence().getType());
 165
 166             answer.setLoadBalancerSessionPersistence(sessionPersistence);
 167         }
 168         if (pool.getTenantId() != null) {
 169             answer.setTenantID(pool.getTenantId());
 170         }
 171         if (pool.getUuid() != null) {
 172             answer.setID(pool.getUuid().getValue());
 173         }
 174         return answer;
 175     }
 176
 177     public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) {
 178         final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
 179         if (member == null) {
 180             return false;
 181         }
 182         return true;
 183     }
 184
 185     public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
 186         final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
 187         if (member == null) {
 188             return null;
 189         }
 190         return fromMemberMd(member);
 191     }
 192
 193     public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid) {
 194         final Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<
 195                 NeutronLoadBalancerPoolMember>();
 196         final Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
 197         if (members != null) {
 198             for (final Member member : members.getMember()) {
 199                 allLoadBalancerPoolMembers.add(fromMemberMd(member));
 200             }
 201         }
 202         LOGGER.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
 203                 allLoadBalancerPoolMembers.size());
 204         final List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
 205         ans.addAll(allLoadBalancerPoolMembers);
 206         return ans;
 207     }
 208
 209     public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input) {
 210         if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
 211             return false;
 212         }
 213         addMemberMd(toMd(poolUuid), input);
 214         return true;
 215     }
 216
 217     public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
 218         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 219             return false;
 220         }
 221         return removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
 222     }
 223
 224     public boolean updateNeutronLoadBalancerPoolMember(String poolUuid, String uuid,
 225             NeutronLoadBalancerPoolMember delta) {
 226         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 227             return false;
 228         }
 229         updateMemberMd(toMd(poolUuid), delta);
 230         return true;
 231     }
 232
 233     public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid, String loadBalancerPoolMemberID) {
 234         return !neutronLoadBalancerPoolMemberExists(poolUuid, loadBalancerPoolMemberID);
 235     }
 236
 237     protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool, Member item) {
 238         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey())
 239                 .child(Members.class).child(Member.class, item.getKey());
 240     }
 241
 242     protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
 243         return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.getKey())
 244                 .child(Members.class);
 245     }
 246
 247     static NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
 248         final NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
 249         if (member.isAdminStateUp() != null) {
 250             answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
 251         }
 252         if (member.getAddress() != null) {
 253             answer.setPoolMemberAddress(String.valueOf(member.getAddress().getValue()));
 254         }
 255         if (member.getProtocolPort() != null) {
 256             answer.setPoolMemberProtoPort(member.getProtocolPort());
 257         }
 258         if (member.getUuid() != null) {
 259             answer.setID(member.getUuid().getValue());
 260             answer.setPoolID(member.getUuid().getValue());
 261         }
 262         if (member.getSubnetId() != null) {
 263             answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
 264         }
 265         if (member.getTenantId() != null) {
 266             answer.setTenantID(member.getTenantId());
 267         }
 268         if (member.getWeight() != null) {
 269             answer.setPoolMemberWeight(member.getWeight());
 270         }
 271         return answer;
 272     }
 273
 274     protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
 275         final MemberBuilder memberBuilder = new MemberBuilder();
 276         memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
 277         if (member.getPoolMemberAddress() != null) {
 278             final IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
 279             memberBuilder.setAddress(ipAddress);
 280         }
 281         if (member.getPoolMemberProtoPort() != null) {
 282             memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
 283         }
 284         if (member.getID() != null) {
 285             memberBuilder.setUuid(toUuid(member.getID()));
 286         }
 287         if (member.getPoolMemberSubnetID() != null) {
 288             memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
 289         }
 290         if (member.getTenantID() != null) {
 291             memberBuilder.setTenantId(toUuid(member.getTenantID()));
 292         }
 293         if (member.getPoolMemberWeight() != null) {
 294             memberBuilder.setWeight(member.getPoolMemberWeight());
 295         }
 296         return memberBuilder.build();
 297     }
 298
 299     protected Member toMemberMd(String uuid) {
 300         final MemberBuilder memberBuilder = new MemberBuilder();
 301         memberBuilder.setUuid(toUuid(uuid));
 302         return memberBuilder.build();
 303     }
 304
 305     protected <
 306             T extends org.opendaylight.yangtools.yang.binding.DataObject> T readMemberMd(InstanceIdentifier<T> path) {
 307         T result = null;
 308         final ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction();
 309         final CheckedFuture<Optional<T>,
 310                 ReadFailedException> future = transaction.read(LogicalDatastoreType.CONFIGURATION, path);
 311         if (future != null) {
 312             Optional<T> optional;
 313             try {
 314                 optional = future.checkedGet();
 315                 if (optional.isPresent()) {
 316                     result = optional.get();
 317                 }
 318             } catch (final ReadFailedException e) {
 319                 LOGGER.warn("Failed to read {}", path, e);
 320             }
 321         }
 322         transaction.close();
 323         return result;
 324     }
 325
 326     protected boolean addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 327         // TODO think about adding existence logic
 328         return updateMemberMd(pool, neutronObject);
 329     }
 330
 331     protected boolean updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 332         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 333         final Member item = toMemberMd(neutronObject);
 334         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 335         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
 336         final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 337         try {
 338             future.get();
 339         } catch (InterruptedException | ExecutionException e) {
 340             LOGGER.warn("Transation failed ", e);
 341             return false;
 342         }
 343         return true;
 344     }
 345
 346     protected boolean removeMemberMd(Pool pool, Member item) {
 347         final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 348         final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 349         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
 350         final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 351         try {
 352             future.get();
 353         } catch (InterruptedException | ExecutionException e) {
 354             LOGGER.warn("Transation failed ", e);
 355             return false;
 356         }
 357         return true;
 358     }
 359 }