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