}
grouping listener-attributes {
description "LBaaSV2.0 listener attributes.";
- leaf default-pool-d {
+ leaf default-pool-id {
type yang:uuid;
description "ID of default pool. Must have compatible protocol with listener.";
}
is dependent on the load-balancer provider. Round-robin
must be supported.";
}
- leaf-list healthmonitor-ids {
+ leaf healthmonitor-id {
type yang:uuid;
description "List of healthmonitors associated with this pool.";
}
- leaf-list members {
- type yang:uuid;
- description "List of members that belong to the pool.";
- }
leaf-list listeners {
type yang:uuid;
description "List of listeners that belong to the pool.";
}
}
grouping lbaas-attributes {
- container loadbalancer {
+ container loadbalancers {
description "Container for Loadbalancers.";
- list loadbalancers {
+ list loadbalancer {
key "uuid";
uses attrs:base-attributes;
uses attrs:admin-attributes;
description "List of Loadbalancers.";
}
}
- container listener {
+ container listeners {
description "Container for Listeners.";
- list listeners {
+ list listener {
key "uuid";
uses attrs:base-attributes;
uses listener-attributes;
description "List of Listeners";
}
}
- container pool {
+ container pools {
description "Container for LBaaSV2.0 pools.";
- list pools {
+ list pool {
key "uuid";
uses attrs:base-attributes;
uses pool-attributes;
description "List of Pools";
- container member {
+ container members {
description "Container for pool members.";
- list members {
+ list member {
key "uuid";
uses member-attributes;
description "List of members.";
}
}
}
- container healthmonitor {
+ container healthmonitors {
description "Container for LBaaSV2.0 healthmonitors.";
- list healthmonitors {
+ list healthmonitor {
key "uuid";
uses healthmonitor-attributes;
description "List of healthmonitors.";
boolean neutronLoadBalancerPoolInUse(String uuid);
+ /**
+ * Applications call this interface method to determine if a particular
+ *NeutronLoadBalancerPoolMember object exists
+ *
+ * @param poolUuid
+ * UUID of the NeutronLoadBalancerPool object
+ * @param uuid
+ * UUID of the NeutronLoadBalancerPoolMember object
+ * @return boolean
+ */
+
+ boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid);
+
+ /**
+ * Applications call this interface method to return if a particular
+ * NeutronLoadBalancerPoolMember object exists
+ *
+ * @param poolUuid
+ * UUID of the NeutronLoadBalancerPool object
+ * @param uuid
+ * UUID of the NeutronLoadBalancerPoolMember object
+ * @return {@link org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember}
+ * OpenStackNeutronLoadBalancerPoolMember class
+ */
+
+ NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String poolUuid, String uuid);
+
+ /**
+ * Applications call this interface method to return all NeutronLoadBalancerPoolMember objects
+ *
+ * @param poolUuid
+ * UUID of the NeutronLoadBalancerPool object
+ * @return List of OpenStackNetworks objects
+ */
+
+ List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid);
+
+ /**
+ * Applications call this interface method to add a NeutronLoadBalancerPoolMember object to the
+ * concurrent map
+ *
+ * @param poolUuid
+ * UUID of the NeutronLoadBalancerPool object
+ * @param input
+ * OpenStackNetwork object
+ * @return boolean on whether the object was added or not
+ */
+
+ boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input);
+
+ /**
+ * Applications call this interface method to remove a Neutron NeutronLoadBalancerPoolMember object to the
+ * concurrent map
+ *
+ * @param poolUuid
+ * UUID of the NeutronLoadBalancerPool object
+ * @param uuid
+ * identifier for the NeutronLoadBalancerPoolMember object
+ * @return boolean on whether the object was removed or not
+ */
+
+ boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid);
+
+ /**
+ * Applications call this interface method to edit a NeutronLoadBalancerPoolMember object
+ *
+ * @param poolUuid
+ * identifier of the NeutronLoadBalancerPool object
+ * @param uuid
+ * identifier of the NeutronLoadBalancerPoolMember object
+ * @param delta
+ * OpenStackNeutronLoadBalancerPoolMember object containing changes to apply
+ * @return boolean on whether the object was updated or not
+ */
+
+ boolean updateNeutronLoadBalancerPoolMember(String poolUuid, String uuid, NeutronLoadBalancerPoolMember delta);
+
+ /**
+ * Applications call this interface method to see if a MAC address is in use
+ *
+ * @param poolUuid
+ * identifier of the NeutronLoadBalancerPool object
+ * @param uuid
+ * identifier of the NeutronLoadBalancerPoolMember object
+ * @return boolean on whether the macAddress is already associated with a
+ * port or not
+ */
+
+ boolean neutronLoadBalancerPoolMemberInUse(String poolUuid, String uuid);
}
+++ /dev/null
-/*
- * Copyright (C) 2014 Red Hat, Inc. 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.spi;
-
-import java.util.List;
-
-public interface INeutronLoadBalancerPoolMemberCRUD {
-
- /**
- * Applications call this interface method to determine if a particular
- *NeutronLoadBalancerPoolMember object exists
- *
- * @param uuid
- * UUID of the NeutronLoadBalancerPoolMember object
- * @return boolean
- */
-
- boolean neutronLoadBalancerPoolMemberExists(String uuid);
-
- /**
- * Applications call this interface method to return if a particular
- * NeutronLoadBalancerPoolMember object exists
- *
- * @param uuid
- * UUID of the NeutronLoadBalancerPoolMember object
- * @return {@link org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember}
- * OpenStackNeutronLoadBalancerPoolMember class
- */
-
- NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String uuid);
-
- /**
- * Applications call this interface method to return all NeutronLoadBalancerPoolMember objects
- *
- * @return List of OpenStackNetworks objects
- */
-
- List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers();
-
- /**
- * Applications call this interface method to add a NeutronLoadBalancerPoolMember object to the
- * concurrent map
- *
- * @param input
- * OpenStackNetwork object
- * @return boolean on whether the object was added or not
- */
-
- boolean addNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember input);
-
- /**
- * Applications call this interface method to remove a Neutron NeutronLoadBalancerPoolMember object to the
- * concurrent map
- *
- * @param uuid
- * identifier for the NeutronLoadBalancerPoolMember object
- * @return boolean on whether the object was removed or not
- */
-
- boolean removeNeutronLoadBalancerPoolMember(String uuid);
-
- /**
- * Applications call this interface method to edit a NeutronLoadBalancerPoolMember object
- *
- * @param uuid
- * identifier of the NeutronLoadBalancerPoolMember object
- * @param delta
- * OpenStackNeutronLoadBalancerPoolMember object containing changes to apply
- * @return boolean on whether the object was updated or not
- */
-
- boolean updateNeutronLoadBalancerPoolMember(String uuid, NeutronLoadBalancerPoolMember delta);
-
- /**
- * Applications call this interface method to see if a MAC address is in use
- *
- * @param uuid
- * identifier of the NeutronLoadBalancerPoolMember object
- * @return boolean on whether the macAddress is already associated with a
- * port or not
- */
-
- boolean neutronLoadBalancerPoolMemberInUse(String uuid);
-
-}
private INeutronLoadBalancerPoolCRUD lbpInterface;
private INeutronLoadBalancerListenerCRUD lblInterface;
private INeutronLoadBalancerHealthMonitorCRUD lbhmInterface;
- private INeutronLoadBalancerPoolMemberCRUD lbpmInterface;
private INeutronMeteringLabelCRUD mlInterface;
private INeutronMeteringLabelRuleCRUD mlrInterface;
private INeutronVPNIKEPolicyCRUD ikepInterface;
return lbhmInterface;
}
- public INeutronLoadBalancerPoolMemberCRUD getLoadBalancerPoolMemberInterface() {
- return lbpmInterface;
- }
-
public INeutronMeteringLabelCRUD getMeteringLabelInterface() {
return mlInterface;
}
return this;
}
- public NeutronCRUDInterfaces fetchINeutronLoadBalancerPoolMemberCRUD(Object obj) {
- lbpmInterface = (INeutronLoadBalancerPoolMemberCRUD) getInstances(INeutronLoadBalancerPoolMemberCRUD.class, obj);
- return this;
- }
-
public NeutronCRUDInterfaces fetchINeutronMeteringLabelCRUD(Object obj) {
mlInterface = (INeutronMeteringLabelCRUD) getInstances(INeutronMeteringLabelCRUD.class, obj);
return this;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.io.Serializable;
-import java.util.Iterator;
+import java.util.ArrayList;
import java.util.List;
/**
List<NeutronLoadBalancerPoolMember> loadBalancerPoolMembers;
public NeutronLoadBalancerPool() {
+ loadBalancerPoolMembers = new ArrayList<NeutronLoadBalancerPoolMember>();
}
public String getID() {
/*
* Update the pool_id of the member to that this.loadBalancerPoolID
*/
+ List<NeutronLoadBalancerPoolMember> answer = new ArrayList<NeutronLoadBalancerPoolMember>();
if (loadBalancerPoolMembers != null) {
for (NeutronLoadBalancerPoolMember member: loadBalancerPoolMembers) {
member.setPoolID(loadBalancerPoolID);
+ answer.add(member);
}
- return loadBalancerPoolMembers;
}
- return loadBalancerPoolMembers;
+ return answer;
+ }
+
+ public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String uuid) {
+ for (NeutronLoadBalancerPoolMember member: loadBalancerPoolMembers) {
+ if (uuid.equals(member.getID())) {
+ return member;
+ }
+ }
+ return null;
}
public void setLoadBalancerPoolMembers(List<NeutronLoadBalancerPoolMember> loadBalancerPoolMembers) {
public NeutronLoadBalancerPool extractFields(List<String> fields) {
NeutronLoadBalancerPool ans = new NeutronLoadBalancerPool();
- Iterator<String> i = fields.iterator();
- while (i.hasNext()) {
- String s = i.next();
+ for (String s: fields) {
if (s.equals("id")) {
ans.setID(this.getID());
}
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolAware;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberAware;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberCRUD;
import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
private NeutronCRUDInterfaces getNeutronInterfaces() {
NeutronCRUDInterfaces answer = new NeutronCRUDInterfaces().
- fetchINeutronLoadBalancerPoolCRUD(this).
- fetchINeutronLoadBalancerPoolMemberCRUD(this);
+ fetchINeutronLoadBalancerPoolCRUD(this);
if (answer.getLoadBalancerPoolInterface() == null) {
throw new ServiceUnavailableException(INTERFACE_NAME
+ RestMessages.SERVICEUNAVAILABLE.toString());
}
- if (answer.getLoadBalancerPoolMemberInterface() == null) {
- throw new ServiceUnavailableException(INTERFACE_NAME
- + RestMessages.SERVICEUNAVAILABLE.toString());
- }
return answer;
}
/**
* Add the member from the neutron load balancer pool as well
*/
- singletonPool.addLoadBalancerPoolMember(singleton);
+ loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, singleton);
} else {
Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
for (NeutronLoadBalancerPoolMember test : input.getBulk()) {
service.neutronLoadBalancerPoolMemberCreated(test);
}
}
- singletonPool.addLoadBalancerPoolMember(test);
+ loadBalancerPoolInterface.addNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, test);
}
}
return Response.status(HttpURLConnection.HTTP_CREATED).entity(input).build();
@PathParam("loadBalancerPoolMemberUUID") String loadBalancerPoolMemberUUID,
final NeutronLoadBalancerPoolMemberRequest input) {
INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronInterfaces().getLoadBalancerPoolInterface();
- INeutronLoadBalancerPoolMemberCRUD loadBalancerPoolMemberInterface = getNeutronInterfaces().getLoadBalancerPoolMemberInterface();
NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
-
NeutronLoadBalancerPoolMember singleton = input.getSingleton();
singleton.setPoolID(loadBalancerPoolUUID);
- NeutronLoadBalancerPoolMember original = loadBalancerPoolMemberInterface.getNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID);
+
+ if (singletonPool == null) {
+ throw new ResourceNotFoundException("Pool doesn't Exist");
+ }
+ NeutronLoadBalancerPoolMember original = singletonPool.getNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID);
Object[] instances = NeutronUtil.getInstances(INeutronLoadBalancerPoolMemberAware.class, this);
if (instances != null) {
throw new ServiceUnavailableException(NO_PROVIDER_LIST);
}
- loadBalancerPoolMemberInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolMemberUUID, singleton);
+ loadBalancerPoolInterface.updateNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID, singleton);
if (instances != null) {
for (Object instance : instances) {
/**
* Remove the member from the neutron load balancer pool
*/
- NeutronLoadBalancerPool singletonPool = loadBalancerPoolInterface.getNeutronLoadBalancerPool(loadBalancerPoolUUID);
- singletonPool.removeLoadBalancerPoolMember(singleton);
+ loadBalancerPoolInterface.removeNeutronLoadBalancerPoolMember(loadBalancerPoolUUID, loadBalancerPoolMemberUUID);
return Response.status(HttpURLConnection.HTTP_NO_CONTENT).build();
}
NeutronLoadBalancerPoolInterface.registerNewInterface(context, providerContext, registrations);
NeutronLoadBalancerListenerInterface.registerNewInterface(context, providerContext, registrations);
NeutronLoadBalancerHealthMonitorInterface.registerNewInterface(context, providerContext, registrations);
- NeutronLoadBalancerPoolMemberInterface.registerNewInterface(context, providerContext, registrations);
NeutronMeteringLabelInterface.registerNewInterface(context, providerContext, registrations);
NeutronMeteringLabelRuleInterface.registerNewInterface(context, providerContext, registrations);
NeutronVPNServiceInterface.registerNewInterface(context, providerContext, registrations);
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProbeHttps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProbeIcmp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProbeTcp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Healthmonitor;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.healthmonitor.Healthmonitors;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.healthmonitor.HealthmonitorsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Healthmonitors;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.healthmonitors.Healthmonitor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.healthmonitors.HealthmonitorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.framework.BundleContext;
import com.google.common.collect.ImmutableBiMap;
-public class NeutronLoadBalancerHealthMonitorInterface extends AbstractNeutronInterface<Healthmonitors, NeutronLoadBalancerHealthMonitor> implements INeutronLoadBalancerHealthMonitorCRUD {
+public class NeutronLoadBalancerHealthMonitorInterface extends AbstractNeutronInterface<Healthmonitor, NeutronLoadBalancerHealthMonitor> implements INeutronLoadBalancerHealthMonitorCRUD {
private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerHealthMonitorInterface.class);
private ConcurrentMap<String, NeutronLoadBalancerHealthMonitor> loadBalancerHealthMonitorDB = new ConcurrentHashMap<String, NeutronLoadBalancerHealthMonitor>();
@Override
public boolean neutronLoadBalancerHealthMonitorExists(String uuid) {
- return loadBalancerHealthMonitorDB.containsKey(uuid);
+ Healthmonitor healthMonitor = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (healthMonitor == null) {
+ return false;
+ }
+ return true;
}
@Override
public NeutronLoadBalancerHealthMonitor getNeutronLoadBalancerHealthMonitor(String uuid) {
- if (!neutronLoadBalancerHealthMonitorExists(uuid)) {
- LOGGER.debug("No LoadBalancerHealthMonitor has Been Defined");
+ Healthmonitor healthMonitor = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (healthMonitor == null) {
return null;
}
- return loadBalancerHealthMonitorDB.get(uuid);
+ return fromMd(healthMonitor);
}
@Override
public List<NeutronLoadBalancerHealthMonitor> getAllNeutronLoadBalancerHealthMonitors() {
Set<NeutronLoadBalancerHealthMonitor> allLoadBalancerHealthMonitors = new HashSet<NeutronLoadBalancerHealthMonitor>();
- for (Entry<String, NeutronLoadBalancerHealthMonitor> entry : loadBalancerHealthMonitorDB.entrySet()) {
- NeutronLoadBalancerHealthMonitor loadBalancerHealthMonitor = entry.getValue();
- allLoadBalancerHealthMonitors.add(loadBalancerHealthMonitor);
+ Healthmonitors healthMonitors = readMd(createInstanceIdentifier());
+ if (healthMonitors != null) {
+ for (Healthmonitor healthMonitor : healthMonitors.getHealthmonitor()) {
+ allLoadBalancerHealthMonitors.add(fromMd(healthMonitor));
+ }
}
LOGGER.debug("Exiting getLoadBalancerHealthMonitors, Found {} OpenStackLoadBalancerHealthMonitor", allLoadBalancerHealthMonitors.size());
List<NeutronLoadBalancerHealthMonitor> ans = new ArrayList<NeutronLoadBalancerHealthMonitor>();
if (neutronLoadBalancerHealthMonitorExists(input.getID())) {
return false;
}
- loadBalancerHealthMonitorDB.putIfAbsent(input.getID(), input);
- //TODO: add code to find INeutronLoadBalancerHealthMonitorAware services and call newtorkCreated on them
+ addMd(input);
return true;
}
if (!neutronLoadBalancerHealthMonitorExists(uuid)) {
return false;
}
- loadBalancerHealthMonitorDB.remove(uuid);
- //TODO: add code to find INeutronLoadBalancerHealthMonitorAware services and call newtorkDeleted on them
- return true;
+ return removeMd(toMd(uuid));
}
@Override
if (!neutronLoadBalancerHealthMonitorExists(uuid)) {
return false;
}
- NeutronLoadBalancerHealthMonitor target = loadBalancerHealthMonitorDB.get(uuid);
- return overwrite(target, delta);
+ updateMd(delta);
+ return true;
}
@Override
}
@Override
- protected Healthmonitors toMd(String uuid) {
- HealthmonitorsBuilder healthmonitorsBuilder = new HealthmonitorsBuilder();
- healthmonitorsBuilder.setUuid(toUuid(uuid));
- return healthmonitorsBuilder.build();
+ protected Healthmonitor toMd(String uuid) {
+ HealthmonitorBuilder healthmonitorBuilder = new HealthmonitorBuilder();
+ healthmonitorBuilder.setUuid(toUuid(uuid));
+ return healthmonitorBuilder.build();
}
@Override
- protected InstanceIdentifier<Healthmonitors> createInstanceIdentifier(
- Healthmonitors healthMonitors) {
+ protected InstanceIdentifier<Healthmonitor> createInstanceIdentifier(
+ Healthmonitor healthMonitor) {
return InstanceIdentifier.create(Neutron.class)
- .child(Healthmonitor.class )
- .child(Healthmonitors.class, healthMonitors.getKey());
+ .child(Healthmonitors.class )
+ .child(Healthmonitor.class, healthMonitor.getKey());
+ }
+
+ protected InstanceIdentifier<Healthmonitors> createInstanceIdentifier() {
+ return InstanceIdentifier.create(Neutron.class)
+ .child(Healthmonitors.class);
}
@Override
- protected Healthmonitors toMd(NeutronLoadBalancerHealthMonitor healthMonitor) {
- HealthmonitorsBuilder healthmonitorsBuilder = new HealthmonitorsBuilder();
- healthmonitorsBuilder.setAdminStateUp(healthMonitor.getLoadBalancerHealthMonitorAdminStateIsUp());
+ protected Healthmonitor toMd(NeutronLoadBalancerHealthMonitor healthMonitor) {
+ HealthmonitorBuilder healthmonitorBuilder = new HealthmonitorBuilder();
+ healthmonitorBuilder.setAdminStateUp(healthMonitor.getLoadBalancerHealthMonitorAdminStateIsUp());
if (healthMonitor.getLoadBalancerHealthMonitorDelay() != null) {
- healthmonitorsBuilder.setDelay(Long.valueOf(healthMonitor.getLoadBalancerHealthMonitorDelay()));
+ healthmonitorBuilder.setDelay(Long.valueOf(healthMonitor.getLoadBalancerHealthMonitorDelay()));
}
if (healthMonitor.getLoadBalancerHealthMonitorExpectedCodes() != null) {
- healthmonitorsBuilder.setExpectedCodes(healthMonitor.getLoadBalancerHealthMonitorExpectedCodes());
+ healthmonitorBuilder.setExpectedCodes(healthMonitor.getLoadBalancerHealthMonitorExpectedCodes());
}
if (healthMonitor.getLoadBalancerHealthMonitorHttpMethod() != null) {
- healthmonitorsBuilder.setHttpMethod(healthMonitor.getLoadBalancerHealthMonitorHttpMethod());
+ healthmonitorBuilder.setHttpMethod(healthMonitor.getLoadBalancerHealthMonitorHttpMethod());
}
if (healthMonitor.getLoadBalancerHealthMonitorMaxRetries() != null) {
- healthmonitorsBuilder.setMaxRetries(Integer.valueOf(healthMonitor.getLoadBalancerHealthMonitorMaxRetries()));
+ healthmonitorBuilder.setMaxRetries(Integer.valueOf(healthMonitor.getLoadBalancerHealthMonitorMaxRetries()));
}
if (healthMonitor.getLoadBalancerHealthMonitorPools() != null) {
List<Uuid> listUuid = new ArrayList<Uuid>();
for (Neutron_ID neutron_id : healthMonitor.getLoadBalancerHealthMonitorPools()) {
listUuid.add(toUuid(neutron_id.getID()));
}
- healthmonitorsBuilder.setPools(listUuid);
+ healthmonitorBuilder.setPools(listUuid);
}
if (healthMonitor.getLoadBalancerHealthMonitorTenantID() != null) {
- healthmonitorsBuilder.setTenantId(toUuid(healthMonitor.getLoadBalancerHealthMonitorTenantID()));
+ healthmonitorBuilder.setTenantId(toUuid(healthMonitor.getLoadBalancerHealthMonitorTenantID()));
}
if (healthMonitor.getLoadBalancerHealthMonitorTimeout() != null) {
- healthmonitorsBuilder.setTimeout(Long.valueOf(healthMonitor.getLoadBalancerHealthMonitorTimeout()));
+ healthmonitorBuilder.setTimeout(Long.valueOf(healthMonitor.getLoadBalancerHealthMonitorTimeout()));
}
if (healthMonitor.getLoadBalancerHealthMonitorType() != null) {
ImmutableBiMap<String, Class<? extends ProbeBase>> mapper =
PROBE_MAP.inverse();
- healthmonitorsBuilder.setType((Class<? extends ProbeBase>) mapper.get(healthMonitor.getLoadBalancerHealthMonitorType()));
+ healthmonitorBuilder.setType((Class<? extends ProbeBase>) mapper.get(healthMonitor.getLoadBalancerHealthMonitorType()));
}
if (healthMonitor.getLoadBalancerHealthMonitorUrlPath() != null) {
- healthmonitorsBuilder.setUrlPath(healthMonitor.getLoadBalancerHealthMonitorUrlPath());
+ healthmonitorBuilder.setUrlPath(healthMonitor.getLoadBalancerHealthMonitorUrlPath());
}
if (healthMonitor.getID() != null) {
- healthmonitorsBuilder.setUuid(toUuid(healthMonitor.getID()));
+ healthmonitorBuilder.setUuid(toUuid(healthMonitor.getID()));
+ } else {
+ LOGGER.warn("Attempting to write neutron laod balancer health monitor without UUID");
+ }
+ return healthmonitorBuilder.build();
+ }
+
+ protected NeutronLoadBalancerHealthMonitor fromMd(Healthmonitor healthMonitor) {
+ NeutronLoadBalancerHealthMonitor answer = new NeutronLoadBalancerHealthMonitor();
+ if (healthMonitor.isAdminStateUp() != null) {
+ answer.setLoadBalancerHealthMonitorAdminStateIsUp(healthMonitor.isAdminStateUp());
+ }
+ if (healthMonitor.getDelay() != null) {
+ answer.setLoadBalancerHealthMonitorDelay(healthMonitor.getDelay().intValue());
+ }
+ if (healthMonitor.getExpectedCodes() != null) {
+ answer.setLoadBalancerHealthMonitorExpectedCodes(healthMonitor.getExpectedCodes());
+ }
+ if (healthMonitor.getHttpMethod() != null) {
+ answer.setLoadBalancerHealthMonitorHttpMethod(healthMonitor.getHttpMethod());
+ }
+ if (healthMonitor.getMaxRetries() != null) {
+ answer.setLoadBalancerHealthMonitorMaxRetries(Integer.valueOf(healthMonitor.getMaxRetries()));
+ }
+ if (healthMonitor.getPools() != null) {
+ List<Neutron_ID> list = new ArrayList<Neutron_ID>();
+ for (Uuid id : healthMonitor.getPools()) {
+ list.add(new Neutron_ID(id.getValue()));
+ }
+ answer.setLoadBalancerHealthMonitorPools(list);
+ }
+ if (healthMonitor.getTenantId() != null) {
+ answer.setLoadBalancerHealthMonitorTenantID(healthMonitor.getTenantId().getValue().replace("-",""));
+ }
+ if (healthMonitor.getTimeout() != null) {
+ answer.setLoadBalancerHealthMonitorTimeout(healthMonitor.getTimeout().intValue());
+ }
+ if (healthMonitor.getType() != null) {
+ answer.setLoadBalancerHealthMonitorType(PROBE_MAP.get(healthMonitor.getType()));
+ }
+ if (healthMonitor.getUrlPath() != null) {
+ answer.setLoadBalancerHealthMonitorUrlPath(healthMonitor.getUrlPath());
+ }
+ if (healthMonitor.getUuid() != null) {
+ answer.setID(healthMonitor.getUuid().getValue());
} else {
LOGGER.warn("Attempting to write neutron laod balancer health monitor without UUID");
}
- return healthmonitorsBuilder.build();
+ return answer;
}
public static void registerNewInterface(BundleContext context,
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 org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
import org.opendaylight.neutron.spi.NeutronLoadBalancer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Loadbalancer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.loadbalancer.Loadbalancers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.loadbalancer.LoadbalancersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Loadbalancers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.loadbalancers.Loadbalancer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.loadbalancers.LoadbalancerBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronLoadBalancerInterface extends AbstractNeutronInterface<Loadbalancers, NeutronLoadBalancer> implements INeutronLoadBalancerCRUD {
+public class NeutronLoadBalancerInterface extends AbstractNeutronInterface<Loadbalancer, NeutronLoadBalancer> implements INeutronLoadBalancerCRUD {
private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerInterface.class);
- private ConcurrentMap<String, NeutronLoadBalancer> loadBalancerDB = new ConcurrentHashMap<String, NeutronLoadBalancer>();
NeutronLoadBalancerInterface(ProviderContext providerContext) {
@Override
public boolean neutronLoadBalancerExists(String uuid) {
- return loadBalancerDB.containsKey(uuid);
+ Loadbalancer lb = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (lb == null) {
+ return false;
+ }
+ return true;
}
@Override
public NeutronLoadBalancer getNeutronLoadBalancer(String uuid) {
- if (!neutronLoadBalancerExists(uuid)) {
- LOGGER.debug("No LoadBalancer Have Been Defined");
+ Loadbalancer lb = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (lb == null) {
return null;
}
- return loadBalancerDB.get(uuid);
+ return fromMd(lb);
}
@Override
public List<NeutronLoadBalancer> getAllNeutronLoadBalancers() {
Set<NeutronLoadBalancer> allLoadBalancers = new HashSet<NeutronLoadBalancer>();
- for (Entry<String, NeutronLoadBalancer> entry : loadBalancerDB.entrySet()) {
- NeutronLoadBalancer loadBalancer = entry.getValue();
- allLoadBalancers.add(loadBalancer);
+ Loadbalancers lbs = readMd(createInstanceIdentifier());
+ if (lbs != null) {
+ for (Loadbalancer lb: lbs.getLoadbalancer()) {
+ allLoadBalancers.add(fromMd(lb));
+ }
}
LOGGER.debug("Exiting getLoadBalancers, Found {} OpenStackLoadBalancer", allLoadBalancers.size());
List<NeutronLoadBalancer> ans = new ArrayList<NeutronLoadBalancer>();
if (neutronLoadBalancerExists(input.getID())) {
return false;
}
- loadBalancerDB.putIfAbsent(input.getID(), input);
- //TODO: add code to find INeutronLoadBalancerAware services and call newtorkCreated on them
+ addMd(input);
return true;
}
if (!neutronLoadBalancerExists(uuid)) {
return false;
}
- loadBalancerDB.remove(uuid);
- //TODO: add code to find INeutronLoadBalancerAware services and call newtorkDeleted on them
- return true;
+ return removeMd(toMd(uuid));
}
@Override
if (!neutronLoadBalancerExists(uuid)) {
return false;
}
- NeutronLoadBalancer target = loadBalancerDB.get(uuid);
- return overwrite(target, delta);
+ updateMd(delta);
+ return true;
}
@Override
}
@Override
- protected Loadbalancers toMd(String uuid) {
- LoadbalancersBuilder loadBalancersBuilder = new LoadbalancersBuilder();
- loadBalancersBuilder.setUuid(toUuid(uuid));
- return loadBalancersBuilder.build();
+ protected Loadbalancer toMd(String uuid) {
+ LoadbalancerBuilder loadBalancerBuilder = new LoadbalancerBuilder();
+ loadBalancerBuilder.setUuid(toUuid(uuid));
+ return loadBalancerBuilder.build();
}
@Override
- protected InstanceIdentifier<Loadbalancers> createInstanceIdentifier(
- Loadbalancers loadBalancers) {
+ protected InstanceIdentifier<Loadbalancer> createInstanceIdentifier(
+ Loadbalancer loadBalancer) {
return InstanceIdentifier.create(Neutron.class)
- .child(Loadbalancer.class)
- .child(Loadbalancers.class, loadBalancers.getKey());
+ .child(Loadbalancers.class)
+ .child(Loadbalancer.class, loadBalancer.getKey());
+ }
+
+ protected InstanceIdentifier<Loadbalancers> createInstanceIdentifier() {
+ return InstanceIdentifier.create(Neutron.class)
+ .child(Loadbalancers.class);
+ }
+
+ protected NeutronLoadBalancer fromMd(Loadbalancer loadBalancer) {
+ NeutronLoadBalancer answer = new NeutronLoadBalancer();
+ if (loadBalancer.isAdminStateUp() != null) {
+ answer.setLoadBalancerAdminStateUp(loadBalancer.isAdminStateUp());
+ }
+ if (loadBalancer.getDescr() != null) {
+ answer.setLoadBalancerDescription(loadBalancer.getDescr());
+ }
+ if (loadBalancer.getName() != null) {
+ answer.setLoadBalancerName(loadBalancer.getName());
+ }
+ if (loadBalancer.getStatus() != null) {
+ answer.setLoadBalancerStatus(loadBalancer.getStatus());
+ }
+ if (loadBalancer.getTenantId() != null) {
+ answer.setLoadBalancerTenantID(loadBalancer.getTenantId().getValue().replace("-",""));
+ }
+ if (loadBalancer.getVipAddress() != null) {
+ answer.setLoadBalancerVipAddress(String.valueOf(loadBalancer.getVipAddress().getValue()));
+ }
+ if (loadBalancer.getVipSubnetId() != null) {
+ answer.setLoadBalancerVipSubnetID(loadBalancer.getVipSubnetId().getValue());
+ }
+ if (loadBalancer.getUuid() != null) {
+ answer.setID(loadBalancer.getUuid().getValue());
+ }
+ return answer;
}
@Override
- protected Loadbalancers toMd(NeutronLoadBalancer loadBalancer) {
- LoadbalancersBuilder loadBalancersBuilder = new LoadbalancersBuilder();
- loadBalancersBuilder.setAdminStateUp(loadBalancer.getLoadBalancerAdminStateUp());
+ protected Loadbalancer toMd(NeutronLoadBalancer loadBalancer) {
+ LoadbalancerBuilder loadBalancerBuilder = new LoadbalancerBuilder();
+ loadBalancerBuilder.setAdminStateUp(loadBalancer.getLoadBalancerAdminStateUp());
if (loadBalancer.getLoadBalancerDescription() != null) {
- loadBalancersBuilder.setDescr(loadBalancer.getLoadBalancerDescription());
+ loadBalancerBuilder.setDescr(loadBalancer.getLoadBalancerDescription());
}
if (loadBalancer.getLoadBalancerName() != null) {
- loadBalancersBuilder.setName(loadBalancer.getLoadBalancerName());
+ loadBalancerBuilder.setName(loadBalancer.getLoadBalancerName());
}
if (loadBalancer.getLoadBalancerStatus() != null) {
- loadBalancersBuilder.setStatus(loadBalancer.getLoadBalancerStatus());
+ loadBalancerBuilder.setStatus(loadBalancer.getLoadBalancerStatus());
}
if (loadBalancer.getLoadBalancerTenantID() != null) {
- loadBalancersBuilder.setTenantId(toUuid(loadBalancer.getLoadBalancerTenantID()));
+ loadBalancerBuilder.setTenantId(toUuid(loadBalancer.getLoadBalancerTenantID()));
}
if (loadBalancer.getLoadBalancerVipAddress() != null) {
- loadBalancersBuilder.setVipAddress(new IpAddress(loadBalancer.getLoadBalancerVipAddress().toCharArray()));
+ loadBalancerBuilder.setVipAddress(new IpAddress(loadBalancer.getLoadBalancerVipAddress().toCharArray()));
}
if (loadBalancer.getLoadBalancerVipSubnetID() != null) {
- loadBalancersBuilder.setVipSubnetId(toUuid(loadBalancer.getLoadBalancerVipSubnetID()));
+ loadBalancerBuilder.setVipSubnetId(toUuid(loadBalancer.getLoadBalancerVipSubnetID()));
}
if (loadBalancer.getID() != null) {
- loadBalancersBuilder.setUuid(toUuid(loadBalancer.getID()));
+ loadBalancerBuilder.setUuid(toUuid(loadBalancer.getID()));
} else {
LOGGER.warn("Attempting to write neutron load balancer without UUID");
}
- return loadBalancersBuilder.build();
+ return loadBalancerBuilder.build();
}
public static void registerNewInterface(BundleContext context,
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 org.opendaylight.neutron.spi.INeutronLoadBalancerListenerCRUD;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProtocolHttp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProtocolHttps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProtocolTcp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Listener;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.listener.Listeners;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.listener.ListenersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.Listeners;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.listeners.Listener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.listeners.ListenerBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.framework.BundleContext;
import com.google.common.collect.ImmutableBiMap;
-public class NeutronLoadBalancerListenerInterface extends AbstractNeutronInterface<Listeners, NeutronLoadBalancerListener> implements INeutronLoadBalancerListenerCRUD {
+public class NeutronLoadBalancerListenerInterface extends AbstractNeutronInterface<Listener, NeutronLoadBalancerListener> implements INeutronLoadBalancerListenerCRUD {
private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerListenerInterface.class);
- private ConcurrentMap<String, NeutronLoadBalancerListener> loadBalancerListenerDB = new ConcurrentHashMap<String, NeutronLoadBalancerListener>();
private static final ImmutableBiMap<Class<? extends ProtocolBase>,String> PROTOCOL_MAP
= new ImmutableBiMap.Builder<Class<? extends ProtocolBase>,String>()
@Override
public boolean neutronLoadBalancerListenerExists(String uuid) {
- return loadBalancerListenerDB.containsKey(uuid);
+ Listener listener = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (listener == null) {
+ return false;
+ }
+ return true;
}
@Override
public NeutronLoadBalancerListener getNeutronLoadBalancerListener(String uuid) {
- if (!neutronLoadBalancerListenerExists(uuid)) {
- LOGGER.debug("No LoadBalancerListener Have Been Defined");
+ Listener listener = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (listener == null) {
return null;
}
- return loadBalancerListenerDB.get(uuid);
+ return fromMd(listener);
}
@Override
public List<NeutronLoadBalancerListener> getAllNeutronLoadBalancerListeners() {
Set<NeutronLoadBalancerListener> allLoadBalancerListeners = new HashSet<NeutronLoadBalancerListener>();
- for (Entry<String, NeutronLoadBalancerListener> entry : loadBalancerListenerDB.entrySet()) {
- NeutronLoadBalancerListener loadBalancerListener = entry.getValue();
- allLoadBalancerListeners.add(loadBalancerListener);
+ Listeners listeners = readMd(createInstanceIdentifier());
+ if (listeners != null) {
+ for (Listener listener: listeners.getListener()) {
+ allLoadBalancerListeners.add(fromMd(listener));
+ }
}
LOGGER.debug("Exiting getLoadBalancerListeners, Found {} OpenStackLoadBalancerListener", allLoadBalancerListeners.size());
List<NeutronLoadBalancerListener> ans = new ArrayList<NeutronLoadBalancerListener>();
if (neutronLoadBalancerListenerExists(input.getID())) {
return false;
}
- loadBalancerListenerDB.putIfAbsent(input.getID(), input);
- //TODO: add code to find INeutronLoadBalancerListenerAware services and call newtorkCreated on them
+ addMd(input);
return true;
}
if (!neutronLoadBalancerListenerExists(uuid)) {
return false;
}
- loadBalancerListenerDB.remove(uuid);
- //TODO: add code to find INeutronLoadBalancerListenerAware services and call newtorkDeleted on them
- return true;
+ return removeMd(toMd(uuid));
}
@Override
if (!neutronLoadBalancerListenerExists(uuid)) {
return false;
}
- NeutronLoadBalancerListener target = loadBalancerListenerDB.get(uuid);
- return overwrite(target, delta);
+ updateMd(delta);
+ return true;
}
@Override
@Override
- protected Listeners toMd(String uuid) {
- ListenersBuilder listenersBuilder = new ListenersBuilder();
- listenersBuilder.setUuid(toUuid(uuid));
- return listenersBuilder.build();
+ protected Listener toMd(String uuid) {
+ ListenerBuilder listenerBuilder = new ListenerBuilder();
+ listenerBuilder.setUuid(toUuid(uuid));
+ return listenerBuilder.build();
}
@Override
- protected InstanceIdentifier<Listeners> createInstanceIdentifier(
- Listeners listeners) {
+ protected InstanceIdentifier<Listener> createInstanceIdentifier(
+ Listener listener) {
+ return InstanceIdentifier.create(Neutron.class)
+ .child(Listeners.class)
+ .child(Listener.class, listener.getKey());
+ }
+
+ protected InstanceIdentifier<Listeners> createInstanceIdentifier() {
return InstanceIdentifier.create(Neutron.class)
- .child(Listener.class)
- .child(Listeners.class, listeners.getKey());
+ .child(Listeners.class);
}
@Override
- protected Listeners toMd(NeutronLoadBalancerListener listeners) {
- ListenersBuilder listenersBuilder = new ListenersBuilder();
- listenersBuilder.setAdminStateUp(listeners.getLoadBalancerListenerAdminStateIsUp());
- if (listeners.getNeutronLoadBalancerListenerConnectionLimit() != null) {
- listenersBuilder.setConnectionLimit(listeners.getNeutronLoadBalancerListenerConnectionLimit());
+ protected Listener toMd(NeutronLoadBalancerListener listener) {
+ ListenerBuilder listenerBuilder = new ListenerBuilder();
+ listenerBuilder.setAdminStateUp(listener.getLoadBalancerListenerAdminStateIsUp());
+ if (listener.getNeutronLoadBalancerListenerConnectionLimit() != null) {
+ listenerBuilder.setConnectionLimit(listener.getNeutronLoadBalancerListenerConnectionLimit());
}
- if (listeners.getNeutronLoadBalancerListenerDefaultPoolID() != null) {
- listenersBuilder.setDefaultPoolD(toUuid(listeners.getNeutronLoadBalancerListenerDefaultPoolID()));
+ if (listener.getNeutronLoadBalancerListenerDefaultPoolID() != null) {
+ listenerBuilder.setDefaultPoolId(toUuid(listener.getNeutronLoadBalancerListenerDefaultPoolID()));
}
- if (listeners.getLoadBalancerListenerDescription() != null) {
- listenersBuilder.setDescr(listeners.getLoadBalancerListenerDescription());
+ if (listener.getLoadBalancerListenerDescription() != null) {
+ listenerBuilder.setDescr(listener.getLoadBalancerListenerDescription());
}
- if (listeners.getNeutronLoadBalancerListenerLoadBalancerIDs() != null) {
+ if (listener.getNeutronLoadBalancerListenerLoadBalancerIDs() != null) {
List<Uuid> listLoadBalancers = new ArrayList<Uuid>();
- for (Neutron_ID neutron_id : listeners.getNeutronLoadBalancerListenerLoadBalancerIDs()) {
+ for (Neutron_ID neutron_id : listener.getNeutronLoadBalancerListenerLoadBalancerIDs()) {
listLoadBalancers.add(toUuid(neutron_id.getID()));
}
- listenersBuilder.setLoadbalancers(listLoadBalancers);
+ listenerBuilder.setLoadbalancers(listLoadBalancers);
}
- if (listeners.getLoadBalancerListenerName() != null) {
- listenersBuilder.setName(listeners.getLoadBalancerListenerName());
+ if (listener.getLoadBalancerListenerName() != null) {
+ listenerBuilder.setName(listener.getLoadBalancerListenerName());
}
- if (listeners.getNeutronLoadBalancerListenerProtocol() != null) {
+ if (listener.getNeutronLoadBalancerListenerProtocol() != null) {
ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper =
PROTOCOL_MAP.inverse();
- listenersBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(listeners.getNeutronLoadBalancerListenerProtocol()));
+ listenerBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(listener.getNeutronLoadBalancerListenerProtocol()));
}
- if (listeners.getNeutronLoadBalancerListenerProtocolPort() != null) {
- listenersBuilder.setProtocolPort(Integer.valueOf(listeners.getNeutronLoadBalancerListenerProtocolPort()));
+ if (listener.getNeutronLoadBalancerListenerProtocolPort() != null) {
+ listenerBuilder.setProtocolPort(Integer.valueOf(listener.getNeutronLoadBalancerListenerProtocolPort()));
}
- if (listeners.getLoadBalancerListenerTenantID() != null) {
- listenersBuilder.setTenantId(toUuid(listeners.getLoadBalancerListenerTenantID()));
+ if (listener.getLoadBalancerListenerTenantID() != null) {
+ listenerBuilder.setTenantId(toUuid(listener.getLoadBalancerListenerTenantID()));
}
- if (listeners.getID() != null) {
- listenersBuilder.setUuid(toUuid(listeners.getID()));
+ if (listener.getID() != null) {
+ listenerBuilder.setUuid(toUuid(listener.getID()));
} else {
LOGGER.warn("Attempting to write neutron load balancer listener without UUID");
}
- return listenersBuilder.build();
+ return listenerBuilder.build();
+ }
+
+ protected NeutronLoadBalancerListener fromMd(Listener listener) {
+ NeutronLoadBalancerListener answer = new NeutronLoadBalancerListener();
+ if (listener.isAdminStateUp() != null) {
+ answer.setLoadBalancerListenerAdminStateIsUp(listener.isAdminStateUp());
+ }
+ if (listener.getConnectionLimit() != null) {
+ answer.setNeutronLoadBalancerListenerConnectionLimit(listener.getConnectionLimit());
+ }
+ if (listener.getDefaultPoolId() != null) {
+ answer.setNeutronLoadBalancerListenerDefaultPoolID(listener.getDefaultPoolId().getValue());
+ }
+ if (listener.getDescr() != null) {
+ answer.setLoadBalancerListenerDescription(listener.getDescr());
+ }
+ if (listener.getLoadbalancers() != null) {
+ List<Neutron_ID> list = new ArrayList<Neutron_ID>();
+ for (Uuid id : listener.getLoadbalancers()) {
+ list.add(new Neutron_ID(id.getValue()));
+ }
+ answer.setNeutronLoadBalancerListenerLoadBalancerIDs(list);
+ }
+ if (listener.getName() != null) {
+ answer.setLoadBalancerListenerName(listener.getName());
+ }
+ if (listener.getProtocol() != null) {
+ answer.setNeutronLoadBalancerListenerProtocol(PROTOCOL_MAP.get(listener.getProtocol()));
+ }
+ if (listener.getProtocolPort() != null) {
+ answer.setNeutronLoadBalancerListenerProtocolPort(String.valueOf(listener.getProtocolPort()));
+ }
+ if (listener.getTenantId() != null) {
+ answer.setLoadBalancerListenerTenantID(listener.getTenantId().getValue().replace("-",""));
+ }
+ if (listener.getUuid() != null) {
+ answer.setID(listener.getUuid().getValue());
+ }
+ return answer;
}
public static void registerNewInterface(BundleContext context,
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
+
+import java.util.concurrent.ExecutionException;
+
+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.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
+import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
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.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.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.constants.rev160807.ProtocolBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProtocolHttp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProtocolHttps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev160807.ProtocolTcp;
-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.lbaas.attributes.Pools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pools.Pool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pools.PoolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pools.pool.Members;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pools.pool.members.Member;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pools.pool.members.MemberBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.pool.attributes.SessionPersistenceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Optional;
import com.google.common.collect.ImmutableBiMap;
+import com.google.common.util.concurrent.CheckedFuture;
-public class NeutronLoadBalancerPoolInterface extends AbstractNeutronInterface<Pools, NeutronLoadBalancerPool> implements INeutronLoadBalancerPoolCRUD {
+public class NeutronLoadBalancerPoolInterface extends AbstractNeutronInterface<Pool, NeutronLoadBalancerPool> implements INeutronLoadBalancerPoolCRUD {
private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
- private ConcurrentMap<String, NeutronLoadBalancerPool> loadBalancerPoolDB = new ConcurrentHashMap<String, NeutronLoadBalancerPool>();
private static final ImmutableBiMap<Class<? extends ProtocolBase>,String> PROTOCOL_MAP
= new ImmutableBiMap.Builder<Class<? extends ProtocolBase>,String>()
.put(ProtocolTcp.class,"TCP")
.build();
+ private static final int DEDASHED_UUID_LENGTH = 32;
+ private static final int DEDASHED_UUID_START = 0;
+ private static final int DEDASHED_UUID_DIV1 = 8;
+ private static final int DEDASHED_UUID_DIV2 = 12;
+ private static final int DEDASHED_UUID_DIV3 = 16;
+ private static final int DEDASHED_UUID_DIV4 = 20;
+
NeutronLoadBalancerPoolInterface(ProviderContext providerContext) {
super(providerContext);
}
@Override
public boolean neutronLoadBalancerPoolExists(String uuid) {
- return loadBalancerPoolDB.containsKey(uuid);
+ Pool pool = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (pool == null) {
+ return false;
+ }
+ return true;
}
@Override
public NeutronLoadBalancerPool getNeutronLoadBalancerPool(String uuid) {
- if (!neutronLoadBalancerPoolExists(uuid)) {
- LOGGER.debug("No LoadBalancerPool has Been Defined");
+ Pool pool = readMd(createInstanceIdentifier(toMd(uuid)));
+ if (pool == null) {
return null;
}
- return loadBalancerPoolDB.get(uuid);
+ return fromMd(pool);
}
@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);
+ Pools pools = readMd(createInstanceIdentifier());
+ if (pools != null) {
+ for (Pool pool: pools.getPool()) {
+ allLoadBalancerPools.add(fromMd(pool));
+ }
}
LOGGER.debug("Exiting getLoadBalancerPools, Found {} OpenStackLoadBalancerPool", allLoadBalancerPools.size());
List<NeutronLoadBalancerPool> ans = new ArrayList<NeutronLoadBalancerPool>();
if (neutronLoadBalancerPoolExists(input.getID())) {
return false;
}
- loadBalancerPoolDB.putIfAbsent(input.getID(), input);
+ addMd(input);
//TODO: add code to find INeutronLoadBalancerPoolAware services and call newtorkCreated on them
return true;
}
if (!neutronLoadBalancerPoolExists(uuid)) {
return false;
}
- loadBalancerPoolDB.remove(uuid);
- return true;
+ return removeMd(toMd(uuid));
}
@Override
if (!neutronLoadBalancerPoolExists(uuid)) {
return false;
}
- loadBalancerPoolDB.putIfAbsent(uuid, delta);
+ updateMd(delta);
return true;
}
}
@Override
- protected Pools toMd(String uuid) {
- PoolsBuilder poolsBuilder = new PoolsBuilder();
- poolsBuilder.setUuid(toUuid(uuid));
- return poolsBuilder.build();
+ protected Pool toMd(String uuid) {
+ PoolBuilder poolBuilder = new PoolBuilder();
+ poolBuilder.setUuid(toUuid(uuid));
+ return poolBuilder.build();
}
@Override
- protected InstanceIdentifier<Pools> createInstanceIdentifier(Pools pools) {
+ protected InstanceIdentifier<Pool> createInstanceIdentifier(Pool pool) {
+ return InstanceIdentifier.create(Neutron.class)
+ .child(Pools.class)
+ .child(Pool.class, pool.getKey());
+ }
+
+ protected InstanceIdentifier<Pools> createInstanceIdentifier() {
return InstanceIdentifier.create(Neutron.class)
- .child(Pool.class)
- .child(Pools.class, pools.getKey());
+ .child(Pools.class);
}
@Override
- protected Pools toMd(NeutronLoadBalancerPool pools) {
- PoolsBuilder poolsBuilder = new PoolsBuilder();
- poolsBuilder.setAdminStateUp(pools.getLoadBalancerPoolAdminIsStateIsUp());
- if (pools.getLoadBalancerPoolDescription() != null) {
- poolsBuilder.setDescr(pools.getLoadBalancerPoolDescription());
+ protected Pool toMd(NeutronLoadBalancerPool pool) {
+ PoolBuilder poolBuilder = new PoolBuilder();
+ poolBuilder.setAdminStateUp(pool.getLoadBalancerPoolAdminIsStateIsUp());
+ if (pool.getLoadBalancerPoolDescription() != null) {
+ poolBuilder.setDescr(pool.getLoadBalancerPoolDescription());
}
- if (pools.getNeutronLoadBalancerPoolHealthMonitorID() != null) {
- List<Uuid> listHealthMonitor = new ArrayList<Uuid>();
- listHealthMonitor.add(toUuid(pools.getNeutronLoadBalancerPoolHealthMonitorID()));
- poolsBuilder.setHealthmonitorIds(listHealthMonitor);
+ if (pool.getNeutronLoadBalancerPoolHealthMonitorID() != null) {
+ poolBuilder.setHealthmonitorId(toUuid(pool.getNeutronLoadBalancerPoolHealthMonitorID()));
}
- if (pools.getLoadBalancerPoolLbAlgorithm() != null) {
- poolsBuilder.setLbAlgorithm(pools.getLoadBalancerPoolLbAlgorithm());
+ if (pool.getLoadBalancerPoolLbAlgorithm() != null) {
+ poolBuilder.setLbAlgorithm(pool.getLoadBalancerPoolLbAlgorithm());
}
- if (pools.getLoadBalancerPoolListeners() != null) {
+ if (pool.getLoadBalancerPoolListeners() != null) {
List<Uuid> listListener = new ArrayList<Uuid>();
- for (Neutron_ID neutron_id : pools.getLoadBalancerPoolListeners()) {
+ for (Neutron_ID neutron_id : pool.getLoadBalancerPoolListeners()) {
listListener.add(toUuid(neutron_id.getID()));
}
- poolsBuilder.setListeners(listListener);
- }
- if (pools.getLoadBalancerPoolMembers() != null) {
- List<Uuid> listMember = new ArrayList<Uuid>();
- for (NeutronLoadBalancerPoolMember laodBalancerPoolMember : pools.getLoadBalancerPoolMembers()) {
- listMember.add(toUuid(laodBalancerPoolMember.getID()));
-
- }
- poolsBuilder.setMembers(listMember);
+ poolBuilder.setListeners(listListener);
}
- if (pools.getLoadBalancerPoolName() != null) {
- poolsBuilder.setName(pools.getLoadBalancerPoolName());
+ // because members are another container, we don't want to copy
+ // it over, so just skip it here
+ if (pool.getLoadBalancerPoolName() != null) {
+ poolBuilder.setName(pool.getLoadBalancerPoolName());
}
- if (pools.getLoadBalancerPoolProtocol() != null) {
+ if (pool.getLoadBalancerPoolProtocol() != null) {
ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper =
PROTOCOL_MAP.inverse();
- poolsBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(pools.getLoadBalancerPoolProtocol()));
+ poolBuilder.setProtocol((Class<? extends ProtocolBase>) mapper.get(pool.getLoadBalancerPoolProtocol()));
}
- if (pools.getLoadBalancerPoolSessionPersistence() != null) {
- NeutronLoadBalancer_SessionPersistence sessionPersistence = pools.getLoadBalancerPoolSessionPersistence();
+ if (pool.getLoadBalancerPoolSessionPersistence() != null) {
+ NeutronLoadBalancer_SessionPersistence sessionPersistence = pool.getLoadBalancerPoolSessionPersistence();
SessionPersistenceBuilder sessionPersistenceBuilder = new SessionPersistenceBuilder();
sessionPersistenceBuilder.setCookieName(sessionPersistence.getCookieName());
sessionPersistenceBuilder.setType(sessionPersistence.getType());
- poolsBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
+ poolBuilder.setSessionPersistence(sessionPersistenceBuilder.build());
}
- if (pools.getLoadBalancerPoolTenantID() != null) {
- poolsBuilder.setTenantId(toUuid(pools.getLoadBalancerPoolTenantID()));
+ if (pool.getLoadBalancerPoolTenantID() != null) {
+ poolBuilder.setTenantId(toUuid(pool.getLoadBalancerPoolTenantID()));
}
- if (pools.getID() != null) {
- poolsBuilder.setUuid(toUuid(pools.getID()));
+ if (pool.getID() != null) {
+ poolBuilder.setUuid(toUuid(pool.getID()));
} else {
LOGGER.warn("Attempting to write neutron load balancer pool without UUID");
}
- return poolsBuilder.build();
+ return poolBuilder.build();
+ }
+
+ protected NeutronLoadBalancerPool fromMd(Pool pool) {
+ NeutronLoadBalancerPool answer = new NeutronLoadBalancerPool();
+ if (pool.isAdminStateUp() != null) {
+ answer.setLoadBalancerPoolAdminStateIsUp(pool.isAdminStateUp());
+ }
+ if (pool.getDescr() != null) {
+ answer.setLoadBalancerPoolDescription(pool.getDescr());
+ }
+ if (pool.getHealthmonitorId() != null) {
+ answer.setNeutronLoadBalancerPoolHealthMonitorID(pool.getHealthmonitorId().getValue());
+ }
+ if (pool.getLbAlgorithm() != null) {
+ answer.setLoadBalancerPoolLbAlgorithm(pool.getLbAlgorithm());
+ }
+ if (pool.getListeners() != null) {
+ List<Neutron_ID> ids = new ArrayList<Neutron_ID>();
+ for (Uuid id : pool.getListeners()) {
+ ids.add(new Neutron_ID(id.getValue()));
+ }
+ answer.setLoadBalancerPoolListeners(ids);
+ }
+ if (pool.getMembers() != null) {
+ List<NeutronLoadBalancerPoolMember> members = new ArrayList<NeutronLoadBalancerPoolMember>();
+ for (Member member: pool.getMembers().getMember()) {
+ members.add(fromMemberMd(member));
+ }
+ answer.setLoadBalancerPoolMembers(members);
+ }
+ if (pool.getName() != null) {
+ answer.setLoadBalancerPoolName(pool.getName());
+ }
+ if (pool.getProtocol() != null) {
+ answer.setLoadBalancerPoolProtocol(PROTOCOL_MAP.get(pool.getProtocol()));
+ }
+ if (pool.getSessionPersistence() != null) {
+ NeutronLoadBalancer_SessionPersistence sessionPersistence = new NeutronLoadBalancer_SessionPersistence();
+ sessionPersistence.setCookieName(pool.getSessionPersistence().getCookieName());
+ sessionPersistence.setType(pool.getSessionPersistence().getType());
+
+ answer.setLoadBalancerSessionPersistence(sessionPersistence);
+ }
+ if (pool.getTenantId() != null) {
+ answer.setLoadBalancerPoolTenantID(pool.getTenantId().getValue().replace("-",""));
+ }
+ if (pool.getUuid() != null) {
+ answer.setID(pool.getUuid().getValue());
+ }
+ return answer;
}
public static void registerNewInterface(BundleContext context,
registrations.add(neutronLoadBalancerPoolInterfaceRegistration);
}
}
+
+ public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) {
+ Member member = readMemberMd(
+ createMemberInstanceIdentifier(toMd(poolUuid),
+ toMemberMd(uuid)));
+ if (member == null) {
+ return false;
+ }
+ return true;
+ }
+
+ public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(
+ String poolUuid, String uuid) {
+ Member member = readMemberMd(
+ createMemberInstanceIdentifier(toMd(poolUuid),
+ toMemberMd(uuid)));
+ if (member == null) {
+ return null;
+ }
+ return fromMemberMd(member);
+ }
+
+ public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers(String poolUuid) {
+ Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<NeutronLoadBalancerPoolMember>();
+ Members members = readMd(createMembersInstanceIdentifier(toMd(poolUuid)));
+ if (members != null) {
+ for (Member member: members.getMember()) {
+ allLoadBalancerPoolMembers.add(fromMemberMd(member));
+ }
+ }
+ LOGGER.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
+ allLoadBalancerPoolMembers.size());
+ List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
+ ans.addAll(allLoadBalancerPoolMembers);
+ return ans;
+ }
+
+ public boolean addNeutronLoadBalancerPoolMember(String poolUuid, NeutronLoadBalancerPoolMember input) {
+ if (neutronLoadBalancerPoolMemberExists(poolUuid, input.getID())) {
+ return false;
+ }
+ addMemberMd(toMd(poolUuid), input);
+ return true;
+ }
+
+ public boolean removeNeutronLoadBalancerPoolMember(String poolUuid, String uuid) {
+ if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
+ return false;
+ }
+ return removeMemberMd(toMd(poolUuid), toMemberMd(uuid));
+ }
+
+ public boolean updateNeutronLoadBalancerPoolMember(String poolUuid,
+ String uuid, NeutronLoadBalancerPoolMember delta) {
+ if (!neutronLoadBalancerPoolMemberExists(poolUuid, uuid)) {
+ return false;
+ }
+ updateMemberMd(toMd(poolUuid), delta);
+ return true;
+ }
+
+ public boolean neutronLoadBalancerPoolMemberInUse(String poolUuid,
+ String loadBalancerPoolMemberID) {
+ return !neutronLoadBalancerPoolMemberExists(poolUuid,
+ loadBalancerPoolMemberID);
+ }
+
+ protected InstanceIdentifier<Member> createMemberInstanceIdentifier(Pool pool,
+ Member item) {
+ return InstanceIdentifier.create(Neutron.class)
+ .child(Pools.class)
+ .child(Pool.class, pool.getKey())
+ .child(Members.class)
+ .child(Member.class, item.getKey());
+ }
+
+ protected InstanceIdentifier<Members> createMembersInstanceIdentifier(Pool pool) {
+ return InstanceIdentifier.create(Neutron.class)
+ .child(Pools.class)
+ .child(Pool.class, pool.getKey())
+ .child(Members.class);
+ }
+
+ static NeutronLoadBalancerPoolMember fromMemberMd(Member member) {
+ NeutronLoadBalancerPoolMember answer = new NeutronLoadBalancerPoolMember();
+ if (member.isAdminStateUp() != null) {
+ answer.setPoolMemberAdminStateIsUp(member.isAdminStateUp());
+ }
+ if (member.getAddress() != null) {
+ answer.setPoolMemberAddress(String.valueOf(member.getAddress().getValue()));
+ }
+ if (member.getProtocolPort() != null) {
+ answer.setPoolMemberProtoPort(member.getProtocolPort());
+ }
+ if (member.getUuid() != null) {
+ answer.setID(member.getUuid().getValue());
+ answer.setPoolID(member.getUuid().getValue());
+ }
+ if (member.getSubnetId() != null) {
+ answer.setPoolMemberSubnetID(member.getSubnetId().getValue());
+ }
+ if (member.getTenantId() != null) {
+ answer.setPoolMemberTenantID(member.getTenantId().getValue().replace("-",""));
+ }
+ if (member.getWeight() != null) {
+ answer.setPoolMemberWeight(member.getWeight());
+ }
+ return answer;
+ }
+
+ protected Member toMemberMd(NeutronLoadBalancerPoolMember member) {
+ MemberBuilder memberBuilder = new MemberBuilder();
+ memberBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
+ if (member.getPoolMemberAddress() != null) {
+ IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
+ memberBuilder.setAddress(ipAddress);
+ }
+ if (member.getPoolMemberProtoPort() != null) {
+ memberBuilder.setProtocolPort(member.getPoolMemberProtoPort());
+ }
+ if (member.getID() != null) {
+ memberBuilder.setUuid(toUuid(member.getID()));
+ }
+ if (member.getPoolMemberSubnetID() != null) {
+ memberBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
+ }
+ if (member.getPoolMemberTenantID() != null) {
+ memberBuilder.setTenantId(toUuid(member.getPoolMemberTenantID()));
+ }
+ if (member.getPoolMemberWeight() != null) {
+ memberBuilder.setWeight(member.getPoolMemberWeight());
+ }
+ return memberBuilder.build();
+ }
+
+ protected Member toMemberMd(String uuid) {
+ MemberBuilder memberBuilder = new MemberBuilder();
+ memberBuilder.setUuid(toUuid(uuid));
+ return memberBuilder.build();
+ }
+
+ protected <T extends org.opendaylight.yangtools.yang.binding.DataObject> T readMemberMd(InstanceIdentifier<T> path) {
+ T result = null;
+ final ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction();
+ CheckedFuture<Optional<T>, ReadFailedException> future = transaction.read(LogicalDatastoreType.CONFIGURATION, path);
+ if (future != null) {
+ Optional<T> optional;
+ try {
+ optional = future.checkedGet();
+ if (optional.isPresent()) {
+ result = optional.get();
+ }
+ } catch (ReadFailedException e) {
+ LOGGER.warn("Failed to read {}", path, e);
+ }
+ }
+ transaction.close();
+ return result;
+ }
+
+ protected boolean addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
+ // TODO think about adding existence logic
+ return updateMemberMd(pool, neutronObject);
+ }
+
+ protected boolean updateMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject) {
+ WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
+ Member item = toMemberMd(neutronObject);
+ InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
+ transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item,true);
+ CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ try {
+ future.get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOGGER.warn("Transation failed ",e);
+ return false;
+ }
+ return true;
+ }
+
+ protected boolean removeMemberMd(Pool pool, Member item) {
+ WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
+ InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
+ transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
+ CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
+ try {
+ future.get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOGGER.warn("Transation failed ",e);
+ return false;
+ }
+ return true;
+ }
}
+++ /dev/null
-/*
- * 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.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberCRUD;
-import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pool.pools.Member;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pool.pools.member.Members;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev141002.lbaas.attributes.pool.pools.member.MembersBuilder;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.ServiceRegistration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class NeutronLoadBalancerPoolMemberInterface extends
- AbstractNeutronInterface<Members, NeutronLoadBalancerPoolMember> implements INeutronLoadBalancerPoolMemberCRUD {
- private static final Logger LOGGER = LoggerFactory.getLogger(NeutronLoadBalancerPoolMemberInterface.class);
- private ConcurrentMap<String, NeutronLoadBalancerPoolMember> loadBalancerPoolMemberDB = new ConcurrentHashMap<String, NeutronLoadBalancerPoolMember>();
-
- NeutronLoadBalancerPoolMemberInterface(ProviderContext providerContext) {
- super(providerContext);
- }
-
- @Override
- public boolean neutronLoadBalancerPoolMemberExists(String uuid) {
- return loadBalancerPoolMemberDB.containsKey(uuid);
- }
-
- @Override
- public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String uuid) {
- if (!neutronLoadBalancerPoolMemberExists(uuid)) {
- LOGGER.debug("No LoadBalancerPoolMember Have Been Defined");
- return null;
- }
- return loadBalancerPoolMemberDB.get(uuid);
- }
-
- @Override
- public List<NeutronLoadBalancerPoolMember> getAllNeutronLoadBalancerPoolMembers() {
- Set<NeutronLoadBalancerPoolMember> allLoadBalancerPoolMembers = new HashSet<NeutronLoadBalancerPoolMember>();
- for (Map.Entry<String, NeutronLoadBalancerPoolMember> entry : loadBalancerPoolMemberDB.entrySet()) {
- NeutronLoadBalancerPoolMember loadBalancerPoolMember = entry.getValue();
- allLoadBalancerPoolMembers.add(loadBalancerPoolMember);
- }
- LOGGER.debug("Exiting getLoadBalancerPoolMembers, Found {} OpenStackLoadBalancerPoolMember",
- allLoadBalancerPoolMembers.size());
- List<NeutronLoadBalancerPoolMember> ans = new ArrayList<NeutronLoadBalancerPoolMember>();
- ans.addAll(allLoadBalancerPoolMembers);
- return ans;
- }
-
- @Override
- public boolean addNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember input) {
- if (neutronLoadBalancerPoolMemberExists(input.getID())) {
- return false;
- }
- loadBalancerPoolMemberDB.putIfAbsent(input.getID(), input);
- return true;
- }
-
- @Override
- public boolean removeNeutronLoadBalancerPoolMember(String uuid) {
- if (!neutronLoadBalancerPoolMemberExists(uuid)) {
- return false;
- }
- loadBalancerPoolMemberDB.remove(uuid);
- return true;
- }
-
- @Override
- public boolean updateNeutronLoadBalancerPoolMember(String uuid, NeutronLoadBalancerPoolMember delta) {
- if (!neutronLoadBalancerPoolMemberExists(uuid)) {
- return false;
- }
- NeutronLoadBalancerPoolMember target = loadBalancerPoolMemberDB.get(uuid);
- return overwrite(target, delta);
- }
-
- @Override
- public boolean neutronLoadBalancerPoolMemberInUse(String loadBalancerPoolMemberID) {
- return !neutronLoadBalancerPoolMemberExists(loadBalancerPoolMemberID);
- }
-
- @Override
- protected InstanceIdentifier<Members> createInstanceIdentifier(Members item) {
- return InstanceIdentifier.create(Member.class).child(Members.class);
- }
-
- @Override
- protected Members toMd(NeutronLoadBalancerPoolMember member) {
- MembersBuilder membersBuilder = new MembersBuilder();
- membersBuilder.setAdminStateUp(member.getPoolMemberAdminStateIsUp());
- if (member.getPoolID() != null) {
- membersBuilder.setUuid(toUuid(member.getPoolID()));
- }
- if (member.getPoolMemberAddress() != null) {
- IpAddress ipAddress = new IpAddress(member.getPoolMemberAddress().toCharArray());
- membersBuilder.setAddress(ipAddress);
- }
- if (member.getPoolMemberProtoPort() != null) {
- membersBuilder.setProtocolPort(member.getPoolMemberProtoPort());
- }
- if (member.getID() != null) {
- membersBuilder.setUuid(toUuid(member.getID()));
- }
- if (member.getPoolMemberSubnetID() != null) {
- membersBuilder.setSubnetId(toUuid(member.getPoolMemberSubnetID()));
- }
- if (member.getPoolMemberTenantID() != null) {
- membersBuilder.setTenantId(toUuid(member.getPoolMemberTenantID()));
- }
- if (member.getPoolMemberWeight() != null) {
- membersBuilder.setWeight(member.getPoolMemberWeight());
- }
- return membersBuilder.build();
- }
-
- @Override
- protected Members toMd(String uuid) {
- MembersBuilder membersBuilder = new MembersBuilder();
- membersBuilder.setUuid(toUuid(uuid));
- return membersBuilder.build();
- }
-
- public static void registerNewInterface(BundleContext context,
- ProviderContext providerContext,
- List<ServiceRegistration<?>> registrations) {
- NeutronLoadBalancerPoolMemberInterface neutronLoadBalancerPoolMemberInterface = new NeutronLoadBalancerPoolMemberInterface(providerContext);
- ServiceRegistration<INeutronLoadBalancerPoolMemberCRUD> neutronLoadBalancerPoolMemberInterfaceRegistration = context.registerService(INeutronLoadBalancerPoolMemberCRUD.class, neutronLoadBalancerPoolMemberInterface, null);
- if(neutronLoadBalancerPoolMemberInterfaceRegistration != null) {
- registrations.add(neutronLoadBalancerPoolMemberInterfaceRegistration);
- }
- }
-}
Code Review / neutron.git / commitdiff