/*
- * Copyright (C) 2014 Red Hat, Inc.
+ * Copyright (c) 2014, 2015 Red Hat, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.neutron.transcriber;
-import java.lang.reflect.Method;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
-import java.util.Map.Entry;
import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
+import org.opendaylight.neutron.spi.NeutronID;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
-import org.opendaylight.neutron.spi.NeutronLoadBalancer_SessionPersistence;
-import org.opendaylight.neutron.spi.Neutron_ID;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerSessionPersistence;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.PoolAttrs.Protocol;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Pool;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pool.Pools;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pool.PoolsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.pool.attrs.SessionPersistenceBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolHttps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTerminatedHttps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.Pools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.Pool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.PoolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.PoolKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.Members;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.Member;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.MemberBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.pool.attributes.SessionPersistenceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
+import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.OperationFailedException;
+import org.ops4j.pax.cdi.api.OsgiServiceProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronLoadBalancerPoolInterface extends AbstractNeutronInterface<Pools, NeutronLoadBalancerPool> implements INeutronLoadBalancerPoolCRUD {
- private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
- private ConcurrentMap<String, NeutronLoadBalancerPool> loadBalancerPoolDB = new ConcurrentHashMap<String, NeutronLoadBalancerPool>();
+@Singleton
+@OsgiServiceProvider(classes = INeutronLoadBalancerPoolCRUD.class)
+public final class NeutronLoadBalancerPoolInterface
+ extends AbstractNeutronInterface<Pool, Pools, PoolKey, NeutronLoadBalancerPool>
+ implements INeutronLoadBalancerPoolCRUD {
+ private static final Logger LOG = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
- NeutronLoadBalancerPoolInterface(ProviderContext providerContext) {
- super(providerContext);
- }
-
- // this method uses reflection to update an object from it's delta.
+ private static final ImmutableBiMap<Class<? extends ProtocolBase>,
+ String> PROTOCOL_MAP = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>, String>()
+ .put(ProtocolHttp.class, "HTTP").put(ProtocolHttps.class, "HTTPS").put(ProtocolTcp.class, "TCP")
+ .put(ProtocolTerminatedHttps.class, "TERMINATED_HTTPS").build();
- private boolean overwrite(Object target, Object delta) {
- Method[] methods = target.getClass().getMethods();
+ @Inject
+ public NeutronLoadBalancerPoolInterface(DataBroker db) {
+ super(PoolBuilder.class, db);
+ }
- for (Method toMethod : methods) {
- if (toMethod.getDeclaringClass().equals(target.getClass())
- && toMethod.getName().startsWith("set")) {
+ @Override
+ protected List<Pool> getDataObjectList(Pools pools) {
+ return pools.getPool();
+ }
- String toName = toMethod.getName();
- String fromName = toName.replace("set", "get");
+ @Override
+ protected Pool toMd(NeutronLoadBalancerPool pool) {
+ final PoolBuilder poolBuilder = new PoolBuilder();
+ toMdBaseAttributes(pool, poolBuilder);
+ poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
+ if (pool.getLoadBalancerPoolHealthMonitorID() != null) {
+ poolBuilder.setHealthmonitorId(toUuid(pool.getLoadBalancerPoolHealthMonitorID()));
+ }
+ if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
+ poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
+ }
+ if (pool.getLoadBalancerPoolListeners() != null) {
+ final List<Uuid> listListener = new ArrayList<>();
+ for (final NeutronID neutronId : pool.getLoadBalancerPoolListeners()) {
+ listListener.add(toUuid(neutronId.getID()));
+ }
+ poolBuilder.setListeners(listListener);
+ }
+ // because members are another container, we don't want to copy
+ // it over, so just skip it here
+ if (pool.getLoadBalancerPoolProtocol() != null) {
+ final ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper = PROTOCOL_MAP.inverse();
+ poolBuilder.setProtocol(mapper.get(pool.getLoadBalancerPoolProtocol()));
+ }
+ if (pool.getLoadBalancerPoolSessionPersistence() != null) {
+ final NeutronLoadBalancerSessionPersistence sessionPersistence = pool
+ .getLoadBalancerPoolSessionPersistence();
+ final SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
+ sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
+ sessionPersistenceBuilder.setType(sessionPersistence.getType());
+ poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
+ }
+ return poolBuilder.build();
+ }
- try {
- Method fromMethod = delta.getClass().getMethod(fromName);
- Object value = fromMethod.invoke(delta, (Object[]) null);
- if (value != null) {
- toMethod.invoke(target, value);
- }
- } catch (Exception e) {
- LOGGER.error(e.getMessage());
- return false;
- }
+ @Override
+ protected NeutronLoadBalancerPool fromMd(Pool pool) {
+ final NeutronLoadBalancerPool answer = new NeutronLoadBalancerPool();
+ fromMdBaseAttributes(pool, answer);
+ if (pool.isAdminStateUp() != null) {
+ answer.setLoadBalancerPoolAdminStateIsUp(pool.isAdminStateUp());
+ }
+ if (pool.getHealthmonitorId() != null) {
+ answer.setLoadBalancerPoolHealthMonitorID(pool.getHealthmonitorId().getValue());
+ }
+ if (pool.getLbAlgorithm() != null) {
+ answer.setLoadBalancerPoolLbAlgorithm(pool.getLbAlgorithm());
+ }
+ if (pool.getListeners() != null) {
+ final List<NeutronID> ids = new ArrayList<>();
+ for (final Uuid id : pool.getListeners()) {
+ ids.add(new NeutronID(id.getValue()));
}
+ answer.setLoadBalancerPoolListeners(ids);
}
- return true;
+ if (pool.getMembers() != null) {
+ final List<NeutronLoadBalancerPoolMember> members = new ArrayList<>();
+ for (final Member member : pool.getMembers().getMember()) {
+ members.add(fromMemberMd(member));
+ }
+ answer.setLoadBalancerPoolMembers(members);
+ }
+ if (pool.getProtocol() != null) {
+ answer.setLoadBalancerPoolProtocol(PROTOCOL_MAP.get(pool.getProtocol()));
+ }
+ if (pool.getSessionPersistence() != null) {
+ NeutronLoadBalancerSessionPersistence sessionPersistence = new NeutronLoadBalancerSessionPersistence();
+ sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
+ sessionPersistence.setType(pool.getSessionPersistence().getType());
+
+ answer.setLoadBalancerSessionPersistence(sessionPersistence);
+ }
+ return answer;
}
@Override
- public boolean neutronLoadBalancerPoolExists(String uuid) {
- return loadBalancerPoolDB.containsKey(uuid);
+ public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) throws ReadFailedException {
+ final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
+ if (member == null) {
+ return false;
+ }
+ return true;
}
@Override
- public NeutronLoadBalancerPool getNeutronLoadBalancerPool(String uuid) {
- if (!neutronLoadBalancerPoolExists(uuid)) {
- LOGGER.debug("No LoadBalancerPool has Been Defined");
+ public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String poolUuid, String uuid)
+ throws ReadFailedException {
+ final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
+ if (member == null) {
return null;
}
- return loadBalancerPoolDB.get(uuid);
+ return fromMemberMd(member);
}
@Override
- public List<NeutronLoadBalancerPool> getAllNeutronLoadBalancerPools() {
- Set<NeutronLoadBalancerPool> allLoadBalancerPools = new HashSet<NeutronLoadBalancerPool>();
- for (Entry<String, NeutronLoadBalancerPool> entry : loadBalancerPoolDB.entrySet()) {
- NeutronLoadBalancerPool loadBalancerPool = entry.getValue();
- allLoadBalancerPools.add(loadBalancerPool);
- }
- LOGGER.debug("Exiting getLoadBalancerPools, Found {} OpenStackLoadBalancerPool", allLoadBalancerPools.size());
- List<NeutronLoadBalancerPool> ans = new ArrayList<NeutronLoadBalancerPool>();
- ans.addAll(allLoadBalancerPools);
+ public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid)
+ throws ReadFailedException {
+ final Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<>();
+ final Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
+ if (members != null) {
+ for (final Member member : members.getMember()) {
+ allLoadBalancerPoolMembers.add(fromMemberMd(member));
+ }
+ }
+ LOG.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
+ allLoadBalancerPoolMembers.size());
+ final List<NeutronLoadBalancerPoolMember> ans = new ArrayList<>();
+ ans.addAll(allLoadBalancerPoolMembers);
return ans;
}
@Override
- public boolean addNeutronLoadBalancerPool(NeutronLoadBalancerPool input) {
- if (neutronLoadBalancerPoolExists(input.getLoadBalancerPoolID())) {
+ public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input)
+ throws OperationFailedException {
+ if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
return false;
}
- loadBalancerPoolDB.putIfAbsent(input.getLoadBalancerPoolID(), input);
- //TODO: add code to find INeutronLoadBalancerPoolAware services and call newtorkCreated on them
+ addMemberMd(toMd(poolUuid), input);
return true;
}
@Override
- public boolean removeNeutronLoadBalancerPool(String uuid) {
- if (!neutronLoadBalancerPoolExists(uuid)) {
+ public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) throws OperationFailedException {
+ if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
return false;
}
- loadBalancerPoolDB.remove(uuid);
- //TODO: add code to find INeutronLoadBalancerPoolAware services and call newtorkDeleted on them
+ removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
return true;
}
@Override
- public boolean updateNeutronLoadBalancerPool(String uuid, NeutronLoadBalancerPool delta) {
- if (!neutronLoadBalancerPoolExists(uuid)) {
+ public boolean updateNeutronLoadBalancerPoolMember(String poolUuid, String uuid,
+ NeutronLoadBalancerPoolMember delta) throws OperationFailedException {
+ if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
return false;
}
- NeutronLoadBalancerPool target = loadBalancerPoolDB.get(uuid);
- return overwrite(target, delta);
+ updateMemberMd(toMd(poolUuid), delta);
+ return true;
}
@Override
- public boolean neutronLoadBalancerPoolInUse(String loadBalancerPoolUUID) {
- return !neutronLoadBalancerPoolExists(loadBalancerPoolUUID);
+ public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid, String loadBalancerPoolMemberID)
+ throws ReadFailedException {
+ return !neutronLoadBalancerPoolMemberExists(poolUuid, loadBalancerPoolMemberID);
}
- @Override
- protected Pools toMd(String uuid) {
- PoolsBuilder poolsBuilder = new PoolsBuilder();
- poolsBuilder.setUuid(toUuid(uuid));
- return poolsBuilder.build();
+ protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool, Member item) {
+ return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.key())
+ .child(Members.class).child(Member.class, item.key());
}
- @Override
- protected InstanceIdentifier<Pools> createInstanceIdentifier(Pools pools) {
- return InstanceIdentifier.create(Neutron.class)
- .child(Pool.class)
- .child(Pools.class, pools.getKey());
+ protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
+ return InstanceIdentifier.create(Neutron.class).child(Pools.class).child(Pool.class, pool.key())
+ .child(Members.class);
}
- @Override
- protected Pools toMd(NeutronLoadBalancerPool pools) {
- PoolsBuilder poolsBuilder = new PoolsBuilder();
- poolsBuilder.setAdminStateUp(pools.getLoadBalancerPoolAdminIsStateIsUp());
- if (pools.getLoadBalancerPoolDescription() != null) {
- poolsBuilder.setDescr(pools.getLoadBalancerPoolDescription());
- }
- if (pools.getNeutronLoadBalancerPoolHealthMonitorID() != null) {
- List<Uuid> listHealthMonitor = new ArrayList<Uuid>();
- listHealthMonitor.add(toUuid(pools.getNeutronLoadBalancerPoolHealthMonitorID()));
- poolsBuilder.setHealthmonitorIds(listHealthMonitor);
- }
- if (pools.getLoadBalancerPoolLbAlgorithm() != null) {
- poolsBuilder.setLbAlgorithm(pools.getLoadBalancerPoolLbAlgorithm());
- }
- if (pools.getLoadBalancerPoolListeners() != null) {
- List<Uuid> listListener = new ArrayList<Uuid>();
- for (Neutron_ID neutron_id : pools.getLoadBalancerPoolListeners()) {
- listListener.add(toUuid(neutron_id.getID()));
- }
- poolsBuilder.setListeners(listListener);
+ protected NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
+ final NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
+ fromMdIds(member, answer);
+ if (member.isAdminStateUp() != null) {
+ answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
}
- if (pools.getLoadBalancerPoolMembers() != null) {
- List<Uuid> listMember = new ArrayList<Uuid>();
- for (NeutronLoadBalancerPoolMember laodBalancerPoolMember : pools.getLoadBalancerPoolMembers()) {
- listMember.add(toUuid(laodBalancerPoolMember.getPoolMemberID()));
-
- }
- poolsBuilder.setMembers(listMember);
+ if (member.getAddress() != null) {
+ answer.setPoolMemberAddress(String.valueOf(member.getAddress().getValue()));
}
- if (pools.getLoadBalancerPoolName() != null) {
- poolsBuilder.setName(pools.getLoadBalancerPoolName());
+ if (member.getProtocolPort() != null) {
+ answer.setPoolMemberProtoPort(member.getProtocolPort());
}
- if (pools.getLoadBalancerPoolProtocol() != null) {
- poolsBuilder.setProtocol(Protocol.valueOf(pools.getLoadBalancerPoolProtocol()));
+ if (member.getSubnetId() != null) {
+ answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
}
- if (pools.getLoadBalancerPoolSessionPersistence() != null) {
- NeutronLoadBalancer_SessionPersistence sessionPersistence = pools.getLoadBalancerPoolSessionPersistence();
- SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
- sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
- sessionPersistenceBuilder.setType(sessionPersistence.getType());
- poolsBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
+ if (member.getWeight() != null) {
+ answer.setPoolMemberWeight(member.getWeight());
+ }
+ return answer;
+ }
+
+ protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
+ final MemberBuilder memberBuilder = toMdIds(member, MemberBuilder.class);
+ memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
+ if (member.getPoolMemberAddress() != null) {
+ final IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
+ memberBuilder.setAddress(ipAddress);
}
- if (pools.getLoadBalancerPoolTenantID() != null) {
- poolsBuilder.setTenantId(toUuid(pools.getLoadBalancerPoolTenantID()));
+ if (member.getPoolMemberProtoPort() != null) {
+ memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
}
- if (pools.getLoadBalancerPoolID() != null) {
- poolsBuilder.setUuid(toUuid(pools.getLoadBalancerPoolID()));
- } else {
- LOGGER.warn("Attempting to write neutron load balancer pool without UUID");
+ if (member.getPoolMemberSubnetID() != null) {
+ memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
}
- return poolsBuilder.build();
+ if (member.getPoolMemberWeight() != null) {
+ memberBuilder.setWeight(member.getPoolMemberWeight());
+ }
+ return memberBuilder.build();
+ }
+
+ private Member toMemberMd(String uuid) {
+ final MemberBuilder memberBuilder = new MemberBuilder();
+ memberBuilder.setUuid(toUuid(uuid));
+ return memberBuilder.build();
+ }
+
+ private <T extends DataObject> T readMemberMd(InstanceIdentifier<T> path) throws ReadFailedException {
+ T result = null;
+ try (ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction()) {
+ final CheckedFuture<Optional<T>, ReadFailedException> future = transaction
+ .read(LogicalDatastoreType.CONFIGURATION, path);
+ if (future != null) {
+ Optional<T> optional;
+ optional = future.checkedGet();
+ if (optional.isPresent()) {
+ result = optional.get();
+ }
+ }
+ }
+ return result;
+ }
+
+ private void addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject)
+ throws TransactionCommitFailedException {
+ // TODO think about adding existence logic
+ updateMemberMd(pool, neutronObject);
+ }
+
+ private void updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject)
+ throws TransactionCommitFailedException {
+ final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
+ final Member item = toMemberMd(neutronObject);
+ final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
+ transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
+ transaction.submit().checkedGet();
+ }
+
+ private void removeMemberMd(Pool pool, Member item) throws TransactionCommitFailedException {
+ final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
+ final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
+ transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
+ transaction.submit().checkedGet();
}
}
Code Review / neutron.git / blobdiff