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 java.util.ArrayList;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Map.Entry;
  15 import java.util.Set;
  16 import java.util.concurrent.ExecutionException;
  17
  18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  19 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  20 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  23 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  24 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  25 import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
  26 import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
  27 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
  28 import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
  29 import org.opendaylight.neutron.spi.NeutronLoadBalancer_SessionPersistence;
  30 import org.opendaylight.neutron.spi.Neutron_ID;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.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.pool.Members;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.Member;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.MemberBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.pool.attributes.SessionPersistenceBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47 import org.osgi.framework.BundleContext;
  48 import org.osgi.framework.ServiceRegistration;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51
  52 import com.google.common.base.Optional;
  53 import com.google.common.collect.ImmutableBiMap;
  54 import com.google.common.util.concurrent.CheckedFuture;
  55
  56 public class NeutronLoadBalancerPoolInterface extends AbstractNeutronInterface<Pool, Pools, NeutronLoadBalancerPool> implements INeutronLoadBalancerPoolCRUD {
  57     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
  58
  59     private static final ImmutableBiMap<Class<? extends ProtocolBase>,String> PROTOCOL_MAP
  60             = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>,String>()
  61             .put(ProtocolHttp.class,"HTTP")
  62             .put(ProtocolHttps.class,"HTTPS")
  63             .put(ProtocolTcp.class,"TCP")
  64             .put(ProtocolTerminatedHttps.class,"TERMINATED_HTTPS")
  65             .build();
  66
  67     private static final int DEDASHED_UUID_LENGTH = 32;
  68     private static final int DEDASHED_UUID_START = 0;
  69     private static final int DEDASHED_UUID_DIV1 = 8;
  70     private static final int DEDASHED_UUID_DIV2 = 12;
  71     private static final int DEDASHED_UUID_DIV3 = 16;
  72     private static final int DEDASHED_UUID_DIV4 = 20;
  73
  74     NeutronLoadBalancerPoolInterface(ProviderContext providerContext) {
  75         super(providerContext);
  76     }
  77
  78     @Override
  79     public boolean neutronLoadBalancerPoolExists(String uuid) {
  80         return exists(uuid);
  81     }
  82
  83     @Override
  84     public NeutronLoadBalancerPool getNeutronLoadBalancerPool(String uuid) {
  85         return get(uuid);
  86     }
  87
  88     @Override
  89     protected List<Pool> getDataObjectList(Pools pools) {
  90         return pools.getPool();
  91     }
  92
  93     @Override
  94     public List<NeutronLoadBalancerPool> getAllNeutronLoadBalancerPools() {
  95         return getAll();
  96     }
  97
  98     @Override
  99     public boolean addNeutronLoadBalancerPool(NeutronLoadBalancerPool input) {
 100         //TODO: add code to find INeutronLoadBalancerPoolAware services and call newtorkCreated on them
 101         return add(input);
 102     }
 103
 104     @Override
 105     public boolean removeNeutronLoadBalancerPool(String uuid) {
 106         return remove(uuid);
 107     }
 108
 109     @Override
 110     public boolean updateNeutronLoadBalancerPool(String uuid, NeutronLoadBalancerPool delta) {
 111         return update(uuid, delta);
 112     }
 113
 114     @Override
 115     public boolean neutronLoadBalancerPoolInUse(String loadBalancerPoolUUID) {
 116         return !exists(loadBalancerPoolUUID);
 117     }
 118
 119     @Override
 120     protected Pool toMd(String uuid) {
 121         PoolBuilder poolBuilder = new PoolBuilder();
 122         poolBuilder.setUuid(toUuid(uuid));
 123         return poolBuilder.build();
 124     }
 125
 126     @Override
 127     protected InstanceIdentifier<Pool> createInstanceIdentifier(Pool pool) {
 128         return InstanceIdentifier.create(Neutron.class)
 129                 .child(Pools.class)
 130                 .child(Pool.class, pool.getKey());
 131     }
 132
 133     @Override
 134     protected InstanceIdentifier<Pools> createInstanceIdentifier() {
 135         return InstanceIdentifier.create(Neutron.class)
 136                 .child(Pools.class);
 137     }
 138
 139     @Override
 140     protected Pool toMd(NeutronLoadBalancerPool pool) {
 141         PoolBuilder poolBuilder = new PoolBuilder();
 142         poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
 143         if (pool.getLoadBalancerPoolDescription() != null) {
 144             poolBuilder.setDescr(pool.getLoadBalancerPoolDescription());
 145         }
 146         if (pool.getNeutronLoadBalancerPoolHealthMonitorID() != null) {
 147             poolBuilder.setHealthmonitorId(toUuid(pool.getNeutronLoadBalancerPoolHealthMonitorID()));
 148         }
 149         if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
 150             poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
 151         }
 152         if (pool.getLoadBalancerPoolListeners() != null) {
 153             List<Uuid> listListener = new ArrayList<Uuid>();
 154             for (Neutron_ID neutron_id : pool.getLoadBalancerPoolListeners()) {
 155                 listListener.add(toUuid(neutron_id.getID()));
 156             }
 157             poolBuilder.setListeners(listListener);
 158         }
 159         // because members are another container, we don't want to copy
 160         // it over, so just skip it here
 161         if (pool.getLoadBalancerPoolName() != null) {
 162             poolBuilder.setName(pool.getLoadBalancerPoolName());
 163         }
 164         if (pool.getLoadBalancerPoolProtocol() != null) {
 165             ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper =
 166                 PROTOCOL_MAP.inverse();
 167             poolBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(pool.getLoadBalancerPoolProtocol()));
 168         }
 169         if (pool.getLoadBalancerPoolSessionPersistence() != null) {
 170             NeutronLoadBalancer_SessionPersistence sessionPersistence = pool.getLoadBalancerPoolSessionPersistence();
 171             SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
 172             sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
 173             sessionPersistenceBuilder.setType(sessionPersistence.getType());
 174             poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
 175         }
 176         if (pool.getTenantID() != null) {
 177             poolBuilder.setTenantId(toUuid(pool.getTenantID()));
 178         }
 179         if (pool.getID() != null) {
 180             poolBuilder.setUuid(toUuid(pool.getID()));
 181         } else {
 182             LOGGER.warn("Attempting to write neutron load balancer pool without UUID");
 183         }
 184         return poolBuilder.build();
 185     }
 186
 187     protected NeutronLoadBalancerPool fromMd(Pool pool) {
 188         NeutronLoadBalancerPool answer = new NeutronLoadBalancerPool();
 189         if (pool.isAdminStateUp() != null) {
 190             answer.setLoadBalancerPoolAdminStateIsUp(pool.isAdminStateUp());
 191         }
 192         if (pool.getDescr() != null) {
 193             answer.setLoadBalancerPoolDescription(pool.getDescr());
 194         }
 195         if (pool.getHealthmonitorId() != null) {
 196             answer.setNeutronLoadBalancerPoolHealthMonitorID(pool.getHealthmonitorId().getValue());
 197         }
 198         if (pool.getLbAlgorithm() != null) {
 199             answer.setLoadBalancerPoolLbAlgorithm(pool.getLbAlgorithm());
 200         }
 201         if (pool.getListeners() != null) {
 202             List<Neutron_ID> ids = new ArrayList<Neutron_ID>();
 203             for (Uuid id : pool.getListeners()) {
 204                 ids.add(new Neutron_ID(id.getValue()));
 205             }
 206             answer.setLoadBalancerPoolListeners(ids);
 207         }
 208         if (pool.getMembers() != null) {
 209             List<NeutronLoadBalancerPoolMember> members = new ArrayList<NeutronLoadBalancerPoolMember>();
 210             for (Member member: pool.getMembers().getMember()) {
 211                 members.add(fromMemberMd(member));
 212             }
 213             answer.setLoadBalancerPoolMembers(members);
 214         }
 215         if (pool.getName() != null) {
 216             answer.setLoadBalancerPoolName(pool.getName());
 217         }
 218         if (pool.getProtocol() != null) {
 219             answer.setLoadBalancerPoolProtocol(PROTOCOL_MAP.get(pool.getProtocol()));
 220         }
 221         if (pool.getSessionPersistence() != null) {
 222             NeutronLoadBalancer_SessionPersistence sessionPersistence = new NeutronLoadBalancer_SessionPersistence();
 223             sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
 224             sessionPersistence.setType(pool.getSessionPersistence().getType());
 225
 226             answer.setLoadBalancerSessionPersistence(sessionPersistence);
 227         }
 228         if (pool.getTenantId() != null) {
 229             answer.setTenantID(pool.getTenantId());
 230         }
 231         if (pool.getUuid() != null) {
 232             answer.setID(pool.getUuid().getValue());
 233         }
 234         return answer;
 235     }
 236
 237     public static void registerNewInterface(BundleContext context,
 238                                             ProviderContext providerContext,
 239                                             List<ServiceRegistration<?>> registrations) {
 240         NeutronLoadBalancerPoolInterface neutronLoadBalancerPoolInterface = new NeutronLoadBalancerPoolInterface(providerContext);
 241         ServiceRegistration<INeutronLoadBalancerPoolCRUD> neutronLoadBalancerPoolInterfaceRegistration = context.registerService(INeutronLoadBalancerPoolCRUD.class, neutronLoadBalancerPoolInterface, null);
 242         if(neutronLoadBalancerPoolInterfaceRegistration != null) {
 243             registrations.add(neutronLoadBalancerPoolInterfaceRegistration);
 244         }
 245     }
 246
 247     public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) {
 248         Member member = readMemberMd(
 249                 createMemberInstanceIdentifier(toMd(poolUuid),
 250                                                toMemberMd(uuid)));
 251         if (member == null) {
 252             return false;
 253         }
 254         return true;
 255     }
 256
 257     public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(
 258             String poolUuid, String uuid) {
 259         Member member = readMemberMd(
 260                 createMemberInstanceIdentifier(toMd(poolUuid),
 261                                                toMemberMd(uuid)));
 262         if (member == null) {
 263             return null;
 264         }
 265         return fromMemberMd(member);
 266     }
 267
 268     public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid) {
 269         Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<NeutronLoadBalancerPoolMember>();
 270         Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
 271         if (members != null) {
 272             for (Member member: members.getMember()) {
 273                 allLoadBalancerPoolMembers.add(fromMemberMd(member));
 274             }
 275         }
 276         LOGGER.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
 277                 allLoadBalancerPoolMembers.size());
 278         List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
 279         ans.addAll(allLoadBalancerPoolMembers);
 280         return ans;
 281     }
 282
 283     public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input) {
 284         if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
 285             return false;
 286         }
 287         addMemberMd(toMd(poolUuid), input);
 288         return true;
 289     }
 290
 291     public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
 292         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 293             return false;
 294         }
 295         return removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
 296     }
 297
 298     public boolean updateNeutronLoadBalancerPoolMember(String poolUuid,
 299             String uuid, NeutronLoadBalancerPoolMember delta) {
 300         if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
 301             return false;
 302         }
 303         updateMemberMd(toMd(poolUuid), delta);
 304         return true;
 305     }
 306
 307     public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid,
 308             String loadBalancerPoolMemberID) {
 309         return !neutronLoadBalancerPoolMemberExists(poolUuid,
 310                                                     loadBalancerPoolMemberID);
 311     }
 312
 313     protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool,
 314             Member item) {
 315         return InstanceIdentifier.create(Neutron.class)
 316             .child(Pools.class)
 317             .child(Pool.class, pool.getKey())
 318             .child(Members.class)
 319             .child(Member.class, item.getKey());
 320     }
 321
 322     protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
 323         return InstanceIdentifier.create(Neutron.class)
 324             .child(Pools.class)
 325             .child(Pool.class, pool.getKey())
 326             .child(Members.class);
 327     }
 328
 329     static NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
 330         NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
 331         if (member.isAdminStateUp() != null) {
 332             answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
 333         }
 334         if (member.getAddress() != null) {
 335             answer.setPoolMemberAddress(String.valueOf(member.getAddress().getValue()));
 336         }
 337         if (member.getProtocolPort() != null) {
 338             answer.setPoolMemberProtoPort(member.getProtocolPort());
 339         }
 340         if (member.getUuid() != null) {
 341             answer.setID(member.getUuid().getValue());
 342             answer.setPoolID(member.getUuid().getValue());
 343         }
 344         if (member.getSubnetId() != null) {
 345             answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
 346         }
 347         if (member.getTenantId() != null) {
 348             answer.setTenantID(member.getTenantId());
 349         }
 350         if (member.getWeight() != null) {
 351             answer.setPoolMemberWeight(member.getWeight());
 352         }
 353         return answer;
 354     }
 355
 356     protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
 357         MemberBuilder memberBuilder = new MemberBuilder();
 358         memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
 359         if (member.getPoolMemberAddress() != null) {
 360             IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
 361             memberBuilder.setAddress(ipAddress);
 362         }
 363         if (member.getPoolMemberProtoPort() != null) {
 364             memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
 365         }
 366         if (member.getID() != null) {
 367             memberBuilder.setUuid(toUuid(member.getID()));
 368         }
 369         if (member.getPoolMemberSubnetID() != null) {
 370             memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
 371         }
 372         if (member.getTenantID() != null) {
 373             memberBuilder.setTenantId(toUuid(member.getTenantID()));
 374         }
 375         if (member.getPoolMemberWeight() != null) {
 376             memberBuilder.setWeight(member.getPoolMemberWeight());
 377         }
 378         return memberBuilder.build();
 379     }
 380
 381     protected Member toMemberMd(String uuid) {
 382         MemberBuilder memberBuilder = new MemberBuilder();
 383         memberBuilder.setUuid(toUuid(uuid));
 384         return memberBuilder.build();
 385     }
 386
 387     protected <T extends org.opendaylight.yangtools.yang.binding.DataObject> T readMemberMd(InstanceIdentifier<T> path) {
 388         T result = null;
 389         final ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction();
 390         CheckedFuture<Optional<T>, ReadFailedException> future = transaction.read(LogicalDatastoreType.CONFIGURATION, path);
 391         if (future != null) {
 392             Optional<T> optional;
 393             try {
 394                 optional = future.checkedGet();
 395                 if (optional.isPresent()) {
 396                     result = optional.get();
 397                 }
 398             } catch (ReadFailedException e) {
 399                 LOGGER.warn("Failed to read {}", path, e);
 400             }
 401         }
 402         transaction.close();
 403         return result;
 404     }
 405
 406     protected boolean addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 407         // TODO think about adding existence logic
 408         return updateMemberMd(pool, neutronObject);
 409     }
 410
 411     protected boolean updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
 412         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 413         Member item = toMemberMd(neutronObject);
 414         InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 415         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item,true);
 416         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 417         try {
 418             future.get();
 419         } catch (InterruptedException | ExecutionException e) {
 420             LOGGER.warn("Transation failed ",e);
 421             return false;
 422         }
 423         return true;
 424     }
 425
 426     protected boolean removeMemberMd(Pool pool, Member item) {
 427         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
 428         InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
 429         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
 430         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 431         try {
 432             future.get();
 433         } catch (InterruptedException | ExecutionException e) {
 434             LOGGER.warn("Transation failed ",e);
 435             return false;
 436         }
 437         return true;
 438     }
 439 }