- Change current logic where read/save config is completely managed by each bundle,
with moving it to configuration manager. This decoupling will allow configuration
manager to decide how to persist the bundles' configurations to disk, withouth
necessarely depend on java serialization as today controlelr does.
Also now file names can be static and each bundle does not need to track the container
context in the file name (which was lame). This allow controller to erase container
startup files on container removal, which was not possible today.
- Global and in container configuration services to expose
two APIs for the other bundles to retrieve and save their config
- Per container startup files organized in directories (directory name = container name)
- Container startup directory removed on container removal, and created on container creation if not present
Change-Id: I58c283eb796cf2a60466a97162428a8c2ae478ae
Signed-off-by: Alessandro Boch <aboch@cisco.com>
<groupId>org.opendaylight.controller</groupId>
<artifactId>usermanager</artifactId>
</dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- </dependency>
- <dependency>
- <groupId>equinoxSDK381</groupId>
- <artifactId>javax.servlet</artifactId>
- </dependency>
- <!-- Spring security -->
- <dependency>
- <groupId>org.springframework.security</groupId>
- <artifactId>spring-security-config</artifactId>
- </dependency>
- <dependency>
- <groupId>org.springframework.security</groupId>
- <artifactId>spring-security-core</artifactId>
- </dependency>
- <dependency>
- <groupId>org.springframework.security</groupId>
- <artifactId>spring-security-web</artifactId>
- </dependency>
- <dependency>
- <groupId>org.springframework.security</groupId>
- <artifactId>spring-security-taglibs</artifactId>
- </dependency>
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>org.springframework.transaction</artifactId>
- </dependency>
</dependencies>
</project>
</plugins>
</build>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>clustering.services</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>switchmanager</artifactId>
<configuration>
<instructions>
<Import-Package>
- org.opendaylight.controller.sal.utils,
- org.apache.commons.lang3.builder
+ org.opendaylight.controller.sal.utils
</Import-Package>
<Export-Package>
org.opendaylight.controller.configuration
package org.opendaylight.controller.configuration;
+import java.util.List;
+
+import org.opendaylight.controller.sal.utils.IObjectReader;
import org.opendaylight.controller.sal.utils.Status;
/**
* @return the Status object representing the result of the saving request
*/
Status saveConfigurations();
+
+ /**
+ * Bundle will call this function to ask Configuration Manager to persist
+ * their configurations. It is up to the Configuration Manager to decide
+ * how the configuration will be persisted
+ *
+ * @param config
+ * The bundle configuration as a collection of
+ * ConfigurationObject
+ * @param storeName
+ * The identifier for this configuration
+ * @return The Status of the operation
+ */
+ Status persistConfiguration(List<ConfigurationObject> config, String storeName);
+
+ /**
+ * Bundle will call this function to ask Configuration Manager to retrieve
+ * the configuration identified by the passed store name
+ *
+ * @param reader
+ * The reader object for parsing the configuration provided by
+ * the caller
+ * @param storeName
+ * The identifier for the configuration
+ * @return The retrieved configuration as a collection of
+ * ConfigurationObject
+ */
+ List<ConfigurationObject> retrieveConfiguration(IObjectReader reader, String storeName);
}
// export the service
c.setInterface(
new String[] { IConfigurationService.class.getName(),
- ICacheUpdateAware.class.getName()},
- props);
+ ICacheUpdateAware.class.getName() }, props);
c.add(createServiceDependency().setService(
IClusterGlobalServices.class).setCallbacks(
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
import org.opendaylight.controller.configuration.ConfigurationEvent;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationAware;
import org.opendaylight.controller.configuration.IConfigurationService;
-import org.opendaylight.controller.sal.utils.StatusCode;
+import org.opendaylight.controller.sal.utils.GlobalConstants;
+import org.opendaylight.controller.sal.utils.IObjectReader;
+import org.opendaylight.controller.sal.utils.ObjectReader;
+import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
+import org.opendaylight.controller.sal.utils.StatusCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger logger = LoggerFactory
.getLogger(ConfigurationService.class);
public static final String SAVE_EVENT_CACHE = "config.event.save";
+ private static final Object ROOT = GlobalConstants.STARTUPHOME.toString();
private IClusterGlobalServices clusterServices;
private ConcurrentMap <ConfigurationEvent, String> configEvent;
private Set<IConfigurationAware> configurationAwareList = Collections
.synchronizedSet(new HashSet<IConfigurationAware>());
+ private ObjectReader objReader;
+ private ObjectWriter objWriter;
public int getConfigurationAwareListSize() {
public void start() {
allocateCache();
retrieveCache();
+ objReader = new ObjectReader();
+ objWriter = new ObjectWriter();
}
public void destroy() {
logger.error("Failed to retrieve configuration Cache");
}
}
+
+ @Override
+ public Status persistConfiguration(List<ConfigurationObject> config, String fileName) {
+ String destination = String.format("%s%s", ROOT, fileName);
+ return objWriter.write(config, destination);
+ }
+
+ @Override
+ public List<ConfigurationObject> retrieveConfiguration(IObjectReader reader, String fileName) {
+ if (!clusterServices.amICoordinator()) {
+ return Collections.emptyList();
+ }
+ String source = String.format("%s%s", ROOT, fileName);
+ Object obj = objReader.read(reader, source);
+ return (obj == null || !(obj instanceof List)) ? Collections.<ConfigurationObject> emptyList()
+ : (List<ConfigurationObject>) obj;
+ }
}
package org.opendaylight.controller.configuration.internal;
+import java.io.File;
import java.util.Collections;
+import java.util.Dictionary;
import java.util.EnumSet;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
+import org.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.CacheConfigException;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
import org.opendaylight.controller.configuration.ConfigurationEvent;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationAware;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
import org.opendaylight.controller.configuration.IConfigurationContainerService;
+import org.opendaylight.controller.sal.utils.GlobalConstants;
+import org.opendaylight.controller.sal.utils.IObjectReader;
+import org.opendaylight.controller.sal.utils.ObjectReader;
+import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.slf4j.Logger;
*
* @brief Backend functionality for all ConfigurationService related tasks.
*
- *
*/
-public class ContainerConfigurationService implements IConfigurationContainerService, IConfigurationAware,
- ICacheUpdateAware<ConfigurationEvent, String> {
+public class ContainerConfigurationService implements IConfigurationContainerService,
+ IConfigurationAware, ICacheUpdateAware<ConfigurationEvent, String> {
public static final String CONTAINER_SAVE_EVENT_CACHE = "config.container.event.save";
private static final Logger logger = LoggerFactory.getLogger(ContainerConfigurationService.class);
private IClusterContainerServices clusterServices;
*/
private Set<IConfigurationContainerAware> configurationAwareList = Collections
.synchronizedSet(new HashSet<IConfigurationContainerAware>());
+ private String root;
+ private ObjectReader objReader;
+ private ObjectWriter objWriter;
public void addConfigurationContainerAware(
IConfigurationContainerAware configurationAware) {
}
}
- public void init() {
+ void init(Component c) {
+ Dictionary<?, ?> props = c.getServiceProperties();
+ String containerName = (props != null) ? (String) props.get("containerName") : GlobalConstants.DEFAULT.toString();
+ root = String.format("%s%s/", GlobalConstants.STARTUPHOME.toString(), containerName);
+ if (!new File(root).exists()) {
+ boolean created = new File(root).mkdir();
+ if (!created) {
+ logger.error("Failed to create startup config directory for container {}", containerName);
+ }
+ }
}
public void start() {
allocateCache();
retrieveCache();
+ objReader = new ObjectReader();
+ objWriter = new ObjectWriter();
}
public void destroy() {
this.configurationAwareList.clear();
}
+ /**
+ * Function called by the dependency manager before Container is Stopped and Destroyed.
+ */
+ public void containerStop() {
+ // Remove container directory along with its startup files
+ File[] files = new File(root).listFiles();
+ for (File file : files) {
+ file.delete();
+ }
+ new File(root).delete();
+ }
+
@Override
public Status saveConfiguration() {
boolean success = true;
logger.error("Failed to retrieve configuration Cache");
}
}
+
+ @Override
+ public Status persistConfiguration(List<ConfigurationObject> config, String fileName) {
+ String destination = String.format("%s%s", root, fileName);
+ return objWriter.write(config, destination);
+ }
+
+ @Override
+ public List<ConfigurationObject> retrieveConfiguration(IObjectReader reader, String fileName) {
+ if (!clusterServices.amICoordinator()) {
+ return Collections.emptyList();
+ }
+ String source = String.format("%s%s", root, fileName);
+ Object obj = objReader.read(reader, source);
+ return (obj == null || !(obj instanceof List)) ? Collections.<ConfigurationObject> emptyList()
+ : (List<ConfigurationObject>) obj;
+ }
}
org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.action,
- org.opendaylight.controller.sal.flowprogrammer,
org.opendaylight.controller.sal.match,
org.opendaylight.controller.sal.packet,
org.opendaylight.controller.sal.reader,
- org.apache.commons.lang3.builder,
org.slf4j,
javax.xml.bind.annotation,
javax.xml.bind
<Import-Package>
org.opendaylight.controller.containermanager,
org.opendaylight.controller.appauth.authorization,
- org.opendaylight.controller.usermanager,
org.opendaylight.controller.configuration,
org.opendaylight.controller.clustering.services,
org.opendaylight.controller.sal.authorization,
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>usermanager</artifactId>
- </dependency>
</dependencies>
</project>
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.opendaylight.controller.configuration.IConfigurationAware;
+import org.opendaylight.controller.configuration.IConfigurationService;
import org.opendaylight.controller.containermanager.IContainerAuthorization;
import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
import org.opendaylight.controller.sal.core.IContainer;
.setCallbacks("setClusterServices", "unsetClusterServices")
.setRequired(true));
+ c.add(createServiceDependency().setService(
+ IConfigurationService.class).setCallbacks(
+ "setConfigurationService",
+ "unsetConfigurationService").setRequired(true));
+
// Key kick-starter for container creation in each component
c.add(createServiceDependency().setService(IContainerAware.class)
.setCallbacks("setIContainerAware", "unsetIContainerAware")
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArrayList;
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationAware;
import org.opendaylight.controller.configuration.IConfigurationService;
import org.opendaylight.controller.containermanager.ContainerChangeEvent;
import org.opendaylight.controller.sal.utils.IObjectReader;
import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
import org.opendaylight.controller.sal.utils.NodeCreator;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.ServiceHelper;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
CommandProvider, ICacheUpdateAware<String, Object>, IContainerInternal, IContainerAuthorization,
IConfigurationAware {
private static final Logger logger = LoggerFactory.getLogger(ContainerManager.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static String containersFileName = ROOT + "containers.conf";
+ private static String CONTAINERS_FILE_NAME = "containers.conf";
private static final String allContainersGroup = "allContainers";
private IClusterGlobalServices clusterServices;
+ private IConfigurationService configurationService;
/*
* Collection containing the configuration objects. This is configuration
* world: container names (also the map key) are maintained as they were
}
}
+ public void setConfigurationService(IConfigurationService service) {
+ logger.trace("Got configuration service set request {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationService(IConfigurationService service) {
+ logger.trace("Got configuration service UNset request");
+ this.configurationService = null;
+ }
+
private void allocateCaches() {
logger.debug("Container Manager allocating caches");
createDefaultAuthorizationGroups();
// Read startup configuration and create local database
- loadConfigurations();
+ loadContainerConfig();
}
public void destroy() {
return flowSpecConfig;
}
- private void loadConfigurations() {
- /*
- * Read containers, container flows and finally containers' entries from file
- * and program the database accordingly
- */
- if ((clusterServices != null) && (clusterServices.amICoordinator())) {
- loadContainerConfig();
- }
- }
-
private Status saveContainerConfig() {
return saveContainerConfigLocal();
}
public Status saveContainerConfigLocal() {
- ObjectWriter objWriter = new ObjectWriter();
+ Status status = configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(containerConfigs.values()), CONTAINERS_FILE_NAME);
- Status status = objWriter.write(new ConcurrentHashMap<String, ContainerConfig>(containerConfigs), containersFileName);
if (!status.isSuccess()) {
return new Status(StatusCode.INTERNALERROR, "Failed to save container configurations: "
+ status.getDescription());
}
- return new Status(StatusCode.SUCCESS);
+ return status;
}
private void removeComponentsStartUpfiles(String containerName) {
return ois.readObject();
}
- @SuppressWarnings("unchecked")
private void loadContainerConfig() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, ContainerConfig> configMap = (ConcurrentMap<String, ContainerConfig>) objReader.read(this,
- containersFileName);
-
- if (configMap == null) {
- return;
- }
-
- for (Map.Entry<String, ContainerConfig> configEntry : configMap.entrySet()) {
- addContainer(configEntry.getValue());
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, CONTAINERS_FILE_NAME)) {
+ addContainer((ContainerConfig) conf);
}
}
org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.configuration,
- org.opendaylight.controller.forwardingrulesmanager,
org.opendaylight.controller.hosttracker,
org.opendaylight.controller.hosttracker.hostAware,
org.opendaylight.controller.clustering.services,
org.opendaylight.controller.sal.packet,
org.opendaylight.controller.sal.routing,
- org.opendaylight.controller.topologymanager,
org.eclipse.osgi.framework.console,
org.osgi.framework,
org.slf4j,
- org.apache.felix.dm,
- org.apache.commons.lang3.builder
+ org.apache.felix.dm
</Import-Package>
<Export-Package>
org.opendaylight.controller.forwarding.staticrouting
<dependencies>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>topologymanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>forwardingrulesmanager</artifactId>
+ <artifactId>clustering.services</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.hosttracker.IfIptoHost;
import org.opendaylight.controller.hosttracker.IfNewHostNotify;
* instantiated in order to get an fully working implementation
* Object
*/
+ @Override
public Object[] getImplementations() {
Object[] res = { StaticRoutingImplementation.class };
return res;
* also optional per-container different behavior if needed, usually
* should not be the case though.
*/
+ @Override
public void configureInstance(Component c, Object imp, String containerName) {
if (imp.equals(StaticRoutingImplementation.class)) {
c.setInterface(new String[] {
IStaticRoutingAware.class).setCallbacks(
"setStaticRoutingAware", "unsetStaticRoutingAware")
.setRequired(false));
+
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
}
}
import java.net.Inet4Address;
import java.net.InetAddress;
import java.nio.ByteBuffer;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.Dictionary;
import java.util.EnumSet;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.forwarding.staticrouting.IForwardingStaticRouting;
import org.opendaylight.controller.forwarding.staticrouting.IStaticRoutingAware;
import org.opendaylight.controller.forwarding.staticrouting.StaticRoute;
import org.opendaylight.controller.hosttracker.IfIptoHost;
import org.opendaylight.controller.hosttracker.IfNewHostNotify;
import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.slf4j.Logger;
public class StaticRoutingImplementation implements IfNewHostNotify, IForwardingStaticRouting, IObjectReader,
IConfigurationContainerAware {
private static Logger log = LoggerFactory.getLogger(StaticRoutingImplementation.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
+ private static final String STATIC_ROUTES_FILE_NAME = "staticRouting.conf";
ConcurrentMap<String, StaticRoute> staticRoutes;
ConcurrentMap<String, StaticRouteConfig> staticRouteConfigs;
private IfIptoHost hostTracker;
private Timer gatewayProbeTimer;
- private String staticRoutesFileName = null;
private IClusterContainerServices clusterContainerService = null;
+ private IConfigurationContainerService configurationService;
private Set<IStaticRoutingAware> staticRoutingAware = Collections
.synchronizedSet(new HashSet<IStaticRoutingAware>());
private ExecutorService executor;
}
}
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service set request {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service UNset request");
+ this.configurationService = null;
+ }
+
@Override
public ConcurrentMap<String, StaticRouteConfig> getStaticRouteConfigs() {
return staticRouteConfigs;
return ois.readObject();
}
- @SuppressWarnings("unchecked")
- private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, StaticRouteConfig> confList = (ConcurrentMap<String, StaticRouteConfig>) objReader.read(
- this, staticRoutesFileName);
-
- if (confList == null) {
- return;
- }
- for (StaticRouteConfig conf : confList.values()) {
- addStaticRoute(conf);
+ private void loadConfiguration() {
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, STATIC_ROUTES_FILE_NAME)) {
+ addStaticRoute((StaticRouteConfig) conf);
}
}
}
public Status saveConfigInternal() {
- Status status;
- ObjectWriter objWriter = new ObjectWriter();
-
- status = objWriter.write(new ConcurrentHashMap<String, StaticRouteConfig>(staticRouteConfigs),
- staticRoutesFileName);
+ Status status = configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(staticRouteConfigs.values()), STATIC_ROUTES_FILE_NAME);
if (status.isSuccess()) {
return status;
}
}
- @SuppressWarnings("deprecation")
private void allocateCaches() {
if (this.clusterContainerService == null) {
log.trace("un-initialized clusterContainerService, can't create cache");
}
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCaches() {
if (this.clusterContainerService == null) {
log.warn("un-initialized clusterContainerService, can't retrieve cache");
containerName = "";
}
- staticRoutesFileName = ROOT + "staticRouting_" + containerName + ".conf";
-
log.debug("forwarding.staticrouting starting on container {}", containerName);
allocateCaches();
retrieveCaches();
this.executor = Executors.newFixedThreadPool(1);
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
+ loadConfiguration();
/*
* Slow probe to identify any gateway that might have silently appeared
org.opendaylight.controller.forwardingrulesmanager
</Export-Package>
<Import-Package>
- org.opendaylight.controller.clustering.services,
org.opendaylight.controller.configuration,
- org.opendaylight.controller.hosttracker,
- org.opendaylight.controller.hosttracker.hostAware,
org.opendaylight.controller.switchmanager,
org.opendaylight.controller.sal.action,
org.opendaylight.controller.sal.core,
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>hosttracker</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>configuration</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>clustering.services</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>switchmanager</artifactId>
import java.util.ArrayList;
import java.util.List;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
/**
* PortGroupConfig class represents the User's Configuration with a Opaque
* Regular Expression String that is parsed and handled by PortGroupProvider.
*
*
*/
-public class PortGroupConfig implements Serializable {
+public class PortGroupConfig extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
private static final String prettyFields[] = { "Name", "Match Criteria" };
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
PortGroupConfig other = (PortGroupConfig) obj;
if (matchString == null) {
- if (other.matchString != null)
+ if (other.matchString != null) {
return false;
- } else if (!matchString.equals(other.matchString))
+ }
+ } else if (!matchString.equals(other.matchString)) {
return false;
+ }
if (name == null) {
- if (other.name != null)
+ if (other.name != null) {
return false;
- } else if (!name.equals(other.name))
+ }
+ } else if (!name.equals(other.name)) {
return false;
+ }
return true;
}
org.opendaylight.controller.clustering.services,
org.opendaylight.controller.configuration,
org.opendaylight.controller.containermanager,
- org.opendaylight.controller.hosttracker,
- org.opendaylight.controller.hosttracker.hostAware,
org.opendaylight.controller.switchmanager,
org.opendaylight.controller.sal.action,
org.opendaylight.controller.sal.core,
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>hosttracker</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>configuration</artifactId>
<groupId>equinoxSDK381</groupId>
<artifactId>org.apache.felix.gogo.runtime</artifactId>
</dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>connectionmanager</artifactId>
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.connectionmanager.IConnectionManager;
import org.opendaylight.controller.containermanager.IContainerManager;
import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
.setCallbacks("setIContainer", "unsetIContainer").setRequired(true));
c.add(createServiceDependency().setService(IConnectionManager.class)
.setCallbacks("setIConnectionManager", "unsetIConnectionManager").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
if (GlobalConstants.DEFAULT.toString().equals(containerName)) {
c.add(createServiceDependency().setService(IContainerManager.class)
.setCallbacks("setIContainerManager", "unsetIContainerManager").setRequired(true));
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.connectionmanager.IConnectionManager;
import org.opendaylight.controller.containermanager.IContainerManager;
import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
import org.opendaylight.controller.sal.utils.EtherTypes;
import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.controller.switchmanager.IInventoryListener;
private static final String PORT_REMOVED = "Port removed";
private static final String NODE_DOWN = "Node is Down";
private static final String INVALID_FLOW_ENTRY = "Invalid FlowEntry";
- private String frmFileName;
- private String portGroupFileName;
+ private static final String STATIC_FLOWS_FILE_NAME = "frm_staticflows.conf";
+ private static final String PORT_GROUP_FILE_NAME = "portgroup.conf";
private ConcurrentMap<Integer, FlowConfig> staticFlows;
private ConcurrentMap<Integer, Integer> staticFlowsOrdinal;
private ConcurrentMap<String, PortGroupConfig> portGroupConfigs;
private ConcurrentMap<PortGroupConfig, Map<Node, PortGroup>> portGroupData;
private ConcurrentMap<String, Object> TSPolicies;
private IContainerManager containerManager;
+ private IConfigurationContainerService configurationService;
private boolean inContainerMode; // being used by global instance only
protected boolean stopping;
@Override
public List<FlowConfig> getStaticFlows() {
- return getStaticFlowsOrderedList(staticFlows, staticFlowsOrdinal.get(0).intValue());
- }
-
- // TODO: need to come out with a better algorithm for maintaining the order
- // of the configuration entries
- // with actual one, index associated to deleted entries cannot be reused and
- // map grows...
- private List<FlowConfig> getStaticFlowsOrderedList(ConcurrentMap<Integer, FlowConfig> flowMap, int maxKey) {
- List<FlowConfig> orderedList = new ArrayList<FlowConfig>();
- for (int i = 0; i <= maxKey; i++) {
- FlowConfig entry = flowMap.get(i);
- if (entry != null) {
- orderedList.add(entry);
- }
- }
- return orderedList;
+ return new ArrayList<FlowConfig>(staticFlows.values());
}
@Override
return new ArrayList<Node>(set);
}
- @SuppressWarnings("unchecked")
private void loadFlowConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<Integer, FlowConfig> confList = (ConcurrentMap<Integer, FlowConfig>) objReader.read(this,
- frmFileName);
-
- ConcurrentMap<String, PortGroupConfig> pgConfig = (ConcurrentMap<String, PortGroupConfig>) objReader.read(this,
- portGroupFileName);
-
- if (pgConfig != null) {
- for (ConcurrentMap.Entry<String, PortGroupConfig> entry : pgConfig.entrySet()) {
- addPortGroupConfig(entry.getKey(), entry.getValue().getMatchString(), true);
- }
- }
-
- if (confList == null) {
- return;
- }
-
- int maxKey = 0;
- for (Integer key : confList.keySet()) {
- if (key.intValue() > maxKey) {
- maxKey = key.intValue();
- }
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, PORT_GROUP_FILE_NAME)) {
+ addPortGroupConfig(((PortGroupConfig) conf).getName(), ((PortGroupConfig) conf).getMatchString(), true);
}
- for (FlowConfig conf : getStaticFlowsOrderedList(confList, maxKey)) {
- addStaticFlowInternal(conf, true);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, STATIC_FLOWS_FILE_NAME)) {
+ addStaticFlowInternal((FlowConfig) conf, true);
}
}
}
private Status saveConfigInternal() {
- ObjectWriter objWriter = new ObjectWriter();
- ConcurrentMap<Integer, FlowConfig> nonDynamicFlows = new ConcurrentHashMap<Integer, FlowConfig>();
+ List<ConfigurationObject> nonDynamicFlows = new ArrayList<ConfigurationObject>();
+
for (Integer ordinal : staticFlows.keySet()) {
FlowConfig config = staticFlows.get(ordinal);
// Do not save dynamic and controller generated static flows
if (config.isDynamic() || config.isInternalFlow()) {
continue;
}
- nonDynamicFlows.put(ordinal, config);
+ nonDynamicFlows.add(config);
}
- objWriter.write(nonDynamicFlows, frmFileName);
- objWriter.write(new ConcurrentHashMap<String, PortGroupConfig>(portGroupConfigs), portGroupFileName);
- return new Status(StatusCode.SUCCESS, null);
+
+ configurationService.persistConfiguration(nonDynamicFlows, STATIC_FLOWS_FILE_NAME);
+ configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(portGroupConfigs.values()),
+ PORT_GROUP_FILE_NAME);
+
+ return new Status(StatusCode.SUCCESS);
}
@Override
}
}
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service set request {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service UNset request");
+ this.configurationService = null;
+ }
+
@Override
public PortGroupProvider getPortGroupProvider() {
return portGroupProvider;
*
*/
void init() {
- frmFileName = GlobalConstants.STARTUPHOME.toString() + "frm_staticflows_" + this.getContainerName() + ".conf";
- portGroupFileName = GlobalConstants.STARTUPHOME.toString() + "portgroup_" + this.getContainerName() + ".conf";
inContainerMode = false;
/*
* Read startup and build database if we are the coordinator
*/
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadFlowConfiguration();
- }
+ loadFlowConfiguration();
}
/**
<Import-Package>
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.utils,
- org.opendaylight.controller.topologymanager,
org.opendaylight.controller.sal.packet.address,
- org.opendaylight.controller.switchmanager,
- org.opendaylight.controller.clustering.services,
javax.xml.bind.annotation,
javax.xml.bind,
org.apache.felix.dm,
- org.apache.commons.lang3.builder,
org.osgi.service.component,
org.slf4j,
org.eclipse.osgi.framework.console,
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>topologymanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>switchmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>clustering.services</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>connectionmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>connectionmanager.implementation</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal.connection</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal.connection.implementation</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>topologymanager</artifactId>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>commons.logback_settings</artifactId>
- </dependency>
</dependencies>
</project>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal.implementation</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection.implementation</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>connectionmanager.implementation</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>containermanager</artifactId>
import org.slf4j.LoggerFactory;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.networkconfig.neutron.INeutronFloatingIPCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronPortCRUD;
.setService(IClusterContainerServices.class)
.setCallbacks("setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
if (imp.equals(NeutronRouterInterface.class)) {
// export the service
.setService(IClusterContainerServices.class)
.setCallbacks("setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
if (imp.equals(NeutronPortInterface.class)) {
// export the service
.setService(IClusterContainerServices.class)
.setCallbacks("setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
if (imp.equals(NeutronSubnetInterface.class)) {
// export the service
.setService(IClusterContainerServices.class)
.setCallbacks("setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
if (imp.equals(NeutronNetworkInterface.class)) {
// export the service
.setService(IClusterContainerServices.class)
.setCallbacks("setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
}
}
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.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.networkconfig.neutron.INeutronFloatingIPCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronPortCRUD;
import org.opendaylight.controller.networkconfig.neutron.NeutronFloatingIP;
import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NeutronFloatingIPInterface implements INeutronFloatingIPCRUD, IConfigurationContainerAware,
IObjectReader {
private static final Logger logger = LoggerFactory.getLogger(NeutronFloatingIPInterface.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static final String FILENAME ="neutron.floatingip";
- private static String fileName;
+ private static final String FILE_NAME = "neutron.floatingip.conf";
private String containerName = null;
private IClusterContainerServices clusterContainerService = null;
+ private IConfigurationContainerService configurationService;
private ConcurrentMap<String, NeutronFloatingIP> floatingIPDB;
// methods needed for creating caches
}
}
- @SuppressWarnings("deprecation")
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service set: {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service removed: {}", service);
+ this.configurationService = null;
+ }
+
private void allocateCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't create cache");
logger.debug("Cache successfully created for NeutronFloatingIps");
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't retrieve cache");
logger.debug("Cache was successfully retrieved for Neutron FloatingIPs");
}
- @SuppressWarnings("deprecation")
private void destroyCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterMger, can't destroy cache");
private void startUp() {
allocateCache();
retrieveCache();
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
+ loadConfiguration();
}
/**
// In the Global instance case the containerName is empty
this.containerName = "";
}
- fileName = ROOT + FILENAME + "_" + containerName + ".conf";
startUp();
}
// this method uses reflection to update an object from it's delta.
+ @SuppressWarnings("unused")
private boolean overwrite(Object target, Object delta) {
Method[] methods = target.getClass().getMethods();
@Override
public NeutronFloatingIP getFloatingIP(String uuid) {
- if (!floatingIPExists(uuid))
+ if (!floatingIPExists(uuid)) {
return null;
+ }
return floatingIPDB.get(uuid);
}
INeutronSubnetCRUD subnetCRUD = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
INeutronPortCRUD portCRUD = NeutronCRUDInterfaces.getINeutronPortCRUD(this);
- if (floatingIPExists(input.getID()))
+ if (floatingIPExists(input.getID())) {
return false;
+ }
//if floating_ip_address isn't there, allocate from the subnet pool
NeutronSubnet subnet = subnetCRUD.getSubnet(networkCRUD.getNetwork(input.getFloatingNetworkUUID()).getSubnets().get(0));
- if (input.getFloatingIPAddress() == null)
+ if (input.getFloatingIPAddress() == null) {
input.setFloatingIPAddress(subnet.getLowAddr());
+ }
subnet.allocateIP(input.getFloatingIPAddress());
//if port_id is there, bind port to this floating ip
INeutronSubnetCRUD subnetCRUD = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
INeutronPortCRUD portCRUD = NeutronCRUDInterfaces.getINeutronPortCRUD(this);
- if (!floatingIPExists(uuid))
+ if (!floatingIPExists(uuid)) {
return false;
+ }
NeutronFloatingIP floatIP = getFloatingIP(uuid);
//if floating_ip_address isn't there, allocate from the subnet pool
NeutronSubnet subnet = subnetCRUD.getSubnet(networkCRUD.getNetwork(floatIP.getFloatingNetworkUUID()).getSubnets().get(0));
public boolean updateFloatingIP(String uuid, NeutronFloatingIP delta) {
INeutronPortCRUD portCRUD = NeutronCRUDInterfaces.getINeutronPortCRUD(this);
- if (!floatingIPExists(uuid))
+ if (!floatingIPExists(uuid)) {
return false;
+ }
NeutronFloatingIP target = floatingIPDB.get(uuid);
if (target.getPortUUID() != null) {
NeutronPort port = portCRUD.getPort(target.getPortUUID());
return true;
}
- @SuppressWarnings("unchecked")
private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, NeutronFloatingIP> confList = (ConcurrentMap<String, NeutronFloatingIP>)
- objReader.read(this, fileName);
-
- if (confList == null) {
- return;
- }
-
- for (String key : confList.keySet()) {
- floatingIPDB.put(key, confList.get(key));
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, FILE_NAME)) {
+ NeutronFloatingIP nfIP = (NeutronFloatingIP) conf;
+ floatingIPDB.put(nfIP.getID(), nfIP);
}
}
@Override
public Status saveConfiguration() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, NeutronFloatingIP>(floatingIPDB), fileName);
+ return configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(floatingIPDB.values()),
+ FILE_NAME);
}
@Override
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.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NeutronNetworkInterface implements INeutronNetworkCRUD, IConfigurationContainerAware,
IObjectReader {
private static final Logger logger = LoggerFactory.getLogger(NeutronNetworkInterface.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static final String FILENAME ="neutron.network";
- private static String fileName;
+ private static final String FILE_NAME ="neutron.network.conf";
private String containerName = null;
private ConcurrentMap<String, NeutronNetwork> networkDB;
private IClusterContainerServices clusterContainerService = null;
+ private IConfigurationContainerService configurationService;
// methods needed for creating caches
}
}
- @SuppressWarnings("deprecation")
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service set: {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service removed: {}", service);
+ this.configurationService = null;
+ }
+
private void allocateCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't create cache");
logger.debug("Cache successfully created for Neutron Networks");
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't retrieve cache");
private void startUp() {
allocateCache();
retrieveCache();
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
+ loadConfiguration();
}
/**
// In the Global instance case the containerName is empty
this.containerName = "";
}
- fileName = ROOT + FILENAME + "_" + containerName + ".conf";
startUp();
}
- @SuppressWarnings("deprecation")
private void destroyCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterMger, can't destroy cache");
@Override
public NeutronNetwork getNetwork(String uuid) {
- if (!networkExists(uuid))
+ if (!networkExists(uuid)) {
return null;
+ }
return networkDB.get(uuid);
}
@Override
public boolean addNetwork(NeutronNetwork input) {
- if (networkExists(input.getID()))
+ if (networkExists(input.getID())) {
return false;
+ }
networkDB.putIfAbsent(input.getID(), input);
//TODO: add code to find INeutronNetworkAware services and call newtorkCreated on them
return true;
@Override
public boolean removeNetwork(String uuid) {
- if (!networkExists(uuid))
+ if (!networkExists(uuid)) {
return false;
+ }
networkDB.remove(uuid);
//TODO: add code to find INeutronNetworkAware services and call newtorkDeleted on them
return true;
@Override
public boolean updateNetwork(String uuid, NeutronNetwork delta) {
- if (!networkExists(uuid))
+ if (!networkExists(uuid)) {
return false;
+ }
NeutronNetwork target = networkDB.get(uuid);
return overwrite(target, delta);
}
@Override
public boolean networkInUse(String netUUID) {
- if (!networkExists(netUUID))
+ if (!networkExists(netUUID)) {
return true;
+ }
NeutronNetwork target = networkDB.get(netUUID);
- if (target.getPortsOnNetwork().size() > 0)
+ if (target.getPortsOnNetwork().size() > 0) {
return true;
+ }
return false;
}
- @SuppressWarnings("unchecked")
private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, NeutronNetwork> confList = (ConcurrentMap<String, NeutronNetwork>)
- objReader.read(this, fileName);
-
- if (confList == null) {
- return;
- }
-
- for (String key : confList.keySet()) {
- networkDB.put(key, confList.get(key));
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, FILE_NAME)) {
+ NeutronNetwork nn = (NeutronNetwork) conf;
+ networkDB.put(nn.getID(), nn);
}
}
@Override
public Status saveConfiguration() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, NeutronNetwork>(networkDB), fileName);
+ return configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(networkDB.values()),
+ FILE_NAME);
}
@Override
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.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronPortCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;
import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
import org.opendaylight.controller.networkconfig.neutron.Neutron_IPs;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NeutronPortInterface implements INeutronPortCRUD, IConfigurationContainerAware,
IObjectReader {
private static final Logger logger = LoggerFactory.getLogger(NeutronPortInterface.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static final String FILENAME ="neutron.port";
- private static String fileName;
+ private static final String FILE_NAME ="neutron.port.conf";
private String containerName = null;
private IClusterContainerServices clusterContainerService = null;
+ private IConfigurationContainerService configurationService;
private ConcurrentMap<String, NeutronPort> portDB;
// methods needed for creating caches
}
}
- @SuppressWarnings("deprecation")
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service set: {}", service);
+ configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service removed: {}", service);
+ configurationService = null;
+ }
+
private void allocateCache() {
if (clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't create cache");
logger.debug("Cache successfully created for OpenDOVE");
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCache() {
if (clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't retrieve cache");
logger.debug("Cache was successfully retrieved for Neutron Ports");
}
- @SuppressWarnings("deprecation")
private void destroyCache() {
if (clusterContainerService == null) {
logger.error("un-initialized clusterMger, can't destroy cache");
private void startUp() {
allocateCache();
retrieveCache();
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
-
+ loadConfiguration();
}
/**
// In the Global instance case the containerName is empty
containerName = "";
}
- fileName = ROOT + FILENAME + "_" + containerName + ".conf";
startUp();
}
return null;
}
- @SuppressWarnings("unchecked")
private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, NeutronPort> confList = (ConcurrentMap<String, NeutronPort>)
- objReader.read(this, fileName);
-
- if (confList == null) {
- return;
- }
-
- for (String key : confList.keySet()) {
- portDB.put(key, confList.get(key));
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, FILE_NAME)) {
+ NeutronPort nn = (NeutronPort) conf;
+ portDB.put(nn.getID(), nn);
}
}
@Override
public Status saveConfiguration() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, NeutronPort>(portDB), fileName);
+ return configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(portDB.values()),
+ FILE_NAME);
}
@Override
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.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.networkconfig.neutron.INeutronRouterCRUD;
import org.opendaylight.controller.networkconfig.neutron.NeutronRouter;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NeutronRouterInterface implements INeutronRouterCRUD, IConfigurationContainerAware,
IObjectReader {
private static final Logger logger = LoggerFactory.getLogger(NeutronRouterInterface.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static final String FILENAME ="neutron.router";
- private static String fileName;
+ private static final String FILE_NAME ="neutron.router.conf";
private String containerName = null;
private IClusterContainerServices clusterContainerService = null;
+ private IConfigurationContainerService configurationService;
private ConcurrentMap<String, NeutronRouter> routerDB;
// methods needed for creating caches
}
}
- @SuppressWarnings("deprecation")
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service set: {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service removed: {}", service);
+ this.configurationService = null;
+ }
+
private void allocateCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't create cache");
logger.debug("Cache successfully created for Neutron Routers");
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't retrieve cache");
logger.debug("Cache was successfully retrieved for Neutron Routers");
}
- @SuppressWarnings("deprecation")
private void destroyCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterMger, can't destroy cache");
private void startUp() {
allocateCache();
retrieveCache();
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
-
+ loadConfiguration();
}
/**
// In the Global instance case the containerName is empty
this.containerName = "";
}
- fileName = ROOT + FILENAME + "_" + containerName + ".conf";
startUp();
}
@Override
public NeutronRouter getRouter(String uuid) {
- if (!routerExists(uuid))
+ if (!routerExists(uuid)) {
return null;
+ }
return routerDB.get(uuid);
}
@Override
public boolean addRouter(NeutronRouter input) {
- if (routerExists(input.getID()))
+ if (routerExists(input.getID())) {
return false;
+ }
routerDB.putIfAbsent(input.getID(), input);
return true;
}
@Override
public boolean removeRouter(String uuid) {
- if (!routerExists(uuid))
+ if (!routerExists(uuid)) {
return false;
+ }
routerDB.remove(uuid);
return true;
}
@Override
public boolean updateRouter(String uuid, NeutronRouter delta) {
- if (!routerExists(uuid))
+ if (!routerExists(uuid)) {
return false;
+ }
NeutronRouter target = routerDB.get(uuid);
return overwrite(target, delta);
}
@Override
public boolean routerInUse(String routerUUID) {
- if (!routerExists(routerUUID))
+ if (!routerExists(routerUUID)) {
return true;
+ }
NeutronRouter target = routerDB.get(routerUUID);
return (target.getInterfaces().size() > 0);
}
- @SuppressWarnings("unchecked")
private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, NeutronRouter> confList = (ConcurrentMap<String, NeutronRouter>)
- objReader.read(this, fileName);
-
- if (confList == null) {
- return;
- }
-
- for (String key : confList.keySet()) {
- routerDB.put(key, confList.get(key));
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, FILE_NAME)) {
+ NeutronRouter nr = (NeutronRouter) conf;
+ routerDB.put(nr.getID(), nr);
}
}
@Override
public Status saveConfiguration() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, NeutronRouter>(routerDB), fileName);
+ return configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(routerDB.values()),
+ FILE_NAME);
}
@Override
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.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.networkconfig.neutron.INeutronNetworkCRUD;
import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;
import org.opendaylight.controller.networkconfig.neutron.NeutronCRUDInterfaces;
import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NeutronSubnetInterface implements INeutronSubnetCRUD, IConfigurationContainerAware,
IObjectReader {
private static final Logger logger = LoggerFactory.getLogger(NeutronSubnetInterface.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static final String FILENAME ="neutron.subnet";
- private static String fileName;
+ private static final String FILE_NAME ="neutron.subnet.conf";
private String containerName = null;
private IClusterContainerServices clusterContainerService = null;
+ private IConfigurationContainerService configurationService;
private ConcurrentMap<String, NeutronSubnet> subnetDB;
// methods needed for creating caches
}
}
- @SuppressWarnings("deprecation")
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service set: {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ logger.trace("Configuration service removed: {}", service);
+ this.configurationService = null;
+ }
+
private void allocateCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't create cache");
logger.debug("Cache successfully created for Neutron Subnets");
}
- @SuppressWarnings({ "unchecked", "deprecation" })
+ @SuppressWarnings({ "unchecked" })
private void retrieveCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterContainerService, can't retrieve cache");
logger.debug("Cache was successfully retrieved for Neutron Subnets");
}
- @SuppressWarnings("deprecation")
private void destroyCache() {
if (this.clusterContainerService == null) {
logger.error("un-initialized clusterMger, can't destroy cache");
private void startUp() {
allocateCache();
retrieveCache();
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
-
+ loadConfiguration();
}
/**
// In the Global instance case the containerName is empty
this.containerName = "";
}
- fileName = ROOT + FILENAME + "_" + containerName + ".conf";
startUp();
}
@Override
public NeutronSubnet getSubnet(String uuid) {
- if (!subnetExists(uuid))
+ if (!subnetExists(uuid)) {
return null;
+ }
return subnetDB.get(uuid);
}
@Override
public boolean addSubnet(NeutronSubnet input) {
String id = input.getID();
- if (subnetExists(id))
+ if (subnetExists(id)) {
return false;
+ }
subnetDB.putIfAbsent(id, input);
INeutronNetworkCRUD networkIf = NeutronCRUDInterfaces.getINeutronNetworkCRUD(this);
@Override
public boolean removeSubnet(String uuid) {
- if (!subnetExists(uuid))
+ if (!subnetExists(uuid)) {
return false;
+ }
NeutronSubnet target = subnetDB.get(uuid);
INeutronNetworkCRUD networkIf = NeutronCRUDInterfaces.getINeutronNetworkCRUD(this);
@Override
public boolean updateSubnet(String uuid, NeutronSubnet delta) {
- if (!subnetExists(uuid))
+ if (!subnetExists(uuid)) {
return false;
+ }
NeutronSubnet target = subnetDB.get(uuid);
return overwrite(target, delta);
}
@Override
public boolean subnetInUse(String subnetUUID) {
- if (!subnetExists(subnetUUID))
+ if (!subnetExists(subnetUUID)) {
return true;
+ }
NeutronSubnet target = subnetDB.get(subnetUUID);
return (target.getPortsInSubnet().size() > 0);
}
- @SuppressWarnings("unchecked")
private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, NeutronSubnet> confList = (ConcurrentMap<String, NeutronSubnet>)
- objReader.read(this, fileName);
-
- if (confList == null) {
- return;
- }
-
- for (String key : confList.keySet()) {
- subnetDB.put(key, confList.get(key));
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, FILE_NAME)) {
+ NeutronSubnet ns = (NeutronSubnet) conf;
+ subnetDB.put(ns.getID(), ns);
}
}
@Override
public Status saveConfiguration() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, NeutronSubnet>(subnetDB), fileName);
+ return configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(subnetDB.values()),
+ FILE_NAME);
}
@Override
<configuration>
<instructions>
<Import-Package>
+ org.opendaylight.controller.configuration,
org.opendaylight.controller.clustering.services,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.utils,
<groupId>org.opendaylight.controller</groupId>
<artifactId>clustering.services</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>configuration</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronFloatingIP implements Serializable {
+public class NeutronFloatingIP extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
// See OpenStack Network API v2.0 Reference for description of
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
@XmlRootElement(name = "network")
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronNetwork implements Serializable {
+public class NeutronNetwork extends ConfigurationObject implements Serializable {
// See OpenStack Network API v2.0 Reference for description of
// annotated attributes
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronPort implements Serializable {
+public class NeutronPort extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
// See OpenStack Network API v2.0 Reference for description of
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronRouter implements Serializable {
+public class NeutronRouter extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
// See OpenStack Network API v2.0 Reference for description of
import org.apache.commons.net.util.SubnetUtils;
import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
+import org.opendaylight.controller.configuration.ConfigurationObject;
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronSubnet implements Serializable {
+public class NeutronSubnet extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
// See OpenStack Network API v2.0 Reference for description of
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class Neutron_IPs implements Serializable {
+public class Neutron_IPs extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
// See OpenStack Network API v2.0 Reference for description of
</plugins>
</build>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>containermanager</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>switchmanager</artifactId>
<artifactId>bundlescanner</artifactId>
</dependency>
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-annotations</artifactId>
- </dependency>
-
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-core</artifactId>
- </dependency>
-
- <dependency>
+ <dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
</plugins>
</build>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>clustering.services</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
<instructions>
<Import-Package>
org.opendaylight.controller.forwardingrulesmanager,
- org.opendaylight.controller.containermanager,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.flowprogrammer, org.slf4j,
org.opendaylight.controller.sal.reader,
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>containermanager</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>forwardingrulesmanager</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>clustering.services</artifactId>
- </dependency>
</dependencies>
</project>
<instructions>
<Import-Package>
org.opendaylight.controller.clustering.services,
- org.opendaylight.controller.containermanager,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.flowprogrammer,
org.opendaylight.controller.sal.reader,
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>containermanager</artifactId>
+ <artifactId>sal.connection</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>switchmanager</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>commons.logback_settings</artifactId>
- </dependency>
</dependencies>
</project>
org.opendaylight.controller.switchmanager
</Export-Package>
<Import-Package>
- org.opendaylight.controller.clustering.services,
org.opendaylight.controller.configuration,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.packet,
org.opendaylight.controller.sal.inventory,
org.slf4j,
- org.apache.felix.dm,
- org.eclipse.osgi.framework.console,
- org.osgi.framework,
- javax.xml.bind.annotation,
- org.apache.commons.lang3.builder
+ javax.xml.bind.annotation
</Import-Package>
</instructions>
<manifestLocation>${project.basedir}/META-INF</manifestLocation>
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>clustering.services</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>configuration</artifactId>
import java.util.ArrayList;
import java.util.List;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.utils.GUIField;
/**
* The class represents a Span Port configuration for a network node.
*/
-public class SpanConfig implements Serializable {
+public class SpanConfig extends ConfigurationObject implements Serializable {
protected static final Logger logger = LoggerFactory
.getLogger(SpanConfig.class);
private static final long serialVersionUID = 1L;
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
SpanConfig other = (SpanConfig) obj;
if (nodeId == null) {
- if (other.nodeId != null)
+ if (other.nodeId != null) {
return false;
- } else if (!nodeId.equals(other.nodeId))
+ }
+ } else if (!nodeId.equals(other.nodeId)) {
return false;
+ }
if (spanPort == null) {
- if (other.spanPort != null)
+ if (other.spanPort != null) {
return false;
- } else if (!spanPort.equals(other.spanPort))
+ }
+ } else if (!spanPort.equals(other.spanPort)) {
return false;
+ }
return true;
}
import java.util.HashMap;
import java.util.Map;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.sal.core.Description;
import org.opendaylight.controller.sal.core.ForwardingMode;
import org.opendaylight.controller.sal.core.Property;
/**
* The class describes a switch configuration
*/
-public class SwitchConfig implements Cloneable, Serializable {
+public class SwitchConfig extends ConfigurationObject implements Cloneable, Serializable {
private static final long serialVersionUID = 1L;
private final String nodeId;
private final Map<String, Property> nodeProperties;
<Export-Package>
</Export-Package>
<Import-Package>
+ org.opendaylight.controller.configuration,
org.opendaylight.controller.switchmanager,
org.opendaylight.controller.clustering.services,
- org.opendaylight.controller.configuration,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.packet,
<dependencies>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>clustering.services</artifactId>
+ <artifactId>configuration</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>configuration</artifactId>
+ <artifactId>clustering.services</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
</dependency>
<dependency>
<groupId>equinoxSDK381</groupId>
- <artifactId>org.apache.felix.gogo.runtime</artifactId>
+ <artifactId>org.eclipse.osgi</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>commons.logback_settings</artifactId>
+ <groupId>equinoxSDK381</groupId>
+ <artifactId>org.apache.felix.gogo.runtime</artifactId>
</dependency>
</dependencies>
</project>
import org.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
import org.opendaylight.controller.sal.inventory.IInventoryService;
import org.opendaylight.controller.sal.inventory.IListenInventoryUpdates;
IClusterContainerServices.class).setCallbacks(
"setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
}
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.sal.core.Bandwidth;
import org.opendaylight.controller.sal.core.Config;
import org.opendaylight.controller.sal.core.ConstructionException;
import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.HexEncode;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.controller.statisticsmanager.IStatisticsManager;
public class SwitchManager implements ISwitchManager, IConfigurationContainerAware,
IObjectReader, IListenInventoryUpdates, CommandProvider {
private static Logger log = LoggerFactory.getLogger(SwitchManager.class);
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private String subnetFileName, spanFileName, switchConfigFileName;
+ private static final String SUBNETS_FILE_NAME = "subnets.conf";
+ private static final String SPAN_FILE_NAME = "spanPorts.conf";
+ private static final String SWITCH_CONFIG_FILE_NAME = "switchConfig.conf";
private final List<NodeConnector> spanNodeConnectors = new CopyOnWriteArrayList<NodeConnector>();
// Collection of Subnets keyed by the InetAddress
private ConcurrentMap<InetAddress, Subnet> subnets;
private ConcurrentMap<String, Property> controllerProps;
private IInventoryService inventoryService;
private IStatisticsManager statisticsManager;
+ private IConfigurationContainerService configurationService;
private final Set<ISwitchManagerAware> switchManagerAware = Collections
.synchronizedSet(new HashSet<ISwitchManagerAware>());
private final Set<IInventoryListener> inventoryListeners = Collections
* only subnet returned. As soon as a user-configured subnet is created this one will
* vanish.
*/
- protected static SubnetConfig DEFAULT_SUBNETCONFIG;
- protected static Subnet DEFAULT_SUBNET;
- protected static String DEFAULT_SUBNET_NAME = "default (cannot be modifed)";
+ protected static final SubnetConfig DEFAULT_SUBNETCONFIG;
+ protected static final Subnet DEFAULT_SUBNET;
+ protected static final String DEFAULT_SUBNET_NAME = "default (cannot be modifed)";
static{
DEFAULT_SUBNETCONFIG = new SubnetConfig(DEFAULT_SUBNET_NAME, "0.0.0.0/0", new ArrayList<String>());
DEFAULT_SUBNET = new Subnet(DEFAULT_SUBNETCONFIG);
}
public void startUp() {
- String container = this.getContainerName();
- // Initialize configuration file names
- subnetFileName = ROOT + "subnets_" + container + ".conf";
- spanFileName = ROOT + "spanPorts_" + container + ".conf";
- switchConfigFileName = ROOT + "switchConfig_" + container + ".conf";
-
// Instantiate cluster synced variables
allocateCaches();
retrieveCaches();
- /*
- * Read startup and build database if we are the coordinator
- */
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadSubnetConfiguration();
- loadSpanConfiguration();
- loadSwitchConfiguration();
- }
-
// Add controller MAC, if first node in the cluster
if (!controllerProps.containsKey(MacAddress.name)) {
byte controllerMac[] = getHardwareMAC();
if (controllerMac != null) {
Property existing = controllerProps.putIfAbsent(MacAddress.name, new MacAddress(controllerMac));
if (existing == null && log.isTraceEnabled()) {
- log.trace("Container {}: Setting controller MAC address in the cluster: {}", container,
+ log.trace("Container {}: Setting controller MAC address in the cluster: {}", getContainerName(),
HexEncode.bytesToHexStringFormat(controllerMac));
}
}
@Override
public List<Switch> getNetworkDevices() {
- Set<Node> nodeSet = getNodes();
List<Switch> swList = new ArrayList<Switch>();
- if (nodeSet != null) {
- for (Node node : nodeSet) {
- swList.add(getSwitchByNode(node));
- }
+ for (Node node : getNodes()) {
+ swList.add(getSwitchByNode(node));
}
-
return swList;
}
return ois.readObject();
}
- @SuppressWarnings("unchecked")
private void loadSubnetConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, SubnetConfig> confList = (ConcurrentMap<String, SubnetConfig>) objReader
- .read(this, subnetFileName);
-
- if (confList == null) {
- return;
- }
-
- for (SubnetConfig conf : confList.values()) {
- addSubnet(conf);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, SUBNETS_FILE_NAME)) {
+ addSubnet((SubnetConfig) conf);
}
}
- @SuppressWarnings("unchecked")
private void loadSpanConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<Integer, SpanConfig> confList = (ConcurrentMap<Integer, SpanConfig>) objReader
- .read(this, spanFileName);
-
- if (confList == null) {
- return;
- }
-
- for (SpanConfig conf : confList.values()) {
- addSpanConfig(conf);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, SPAN_FILE_NAME)) {
+ addSpanConfig((SpanConfig) conf);
}
}
- @SuppressWarnings("unchecked")
private void loadSwitchConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, SwitchConfig> confList = (ConcurrentMap<String, SwitchConfig>) objReader
- .read(this, switchConfigFileName);
-
- if (confList == null) {
- return;
- }
-
- for (SwitchConfig conf : confList.values()) {
- updateNodeConfig(conf);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, SWITCH_CONFIG_FILE_NAME)) {
+ updateNodeConfig((SwitchConfig) conf);
}
}
}
public Status saveSwitchConfigInternal() {
- Status retS = null, retP = null;
- ObjectWriter objWriter = new ObjectWriter();
-
- retS = objWriter.write(new ConcurrentHashMap<String, SubnetConfig>(
- subnetsConfigList), subnetFileName);
- retP = objWriter.write(new ConcurrentHashMap<SpanConfig, SpanConfig>(
- spanConfigList), spanFileName);
- retS = objWriter.write(new ConcurrentHashMap<String, SwitchConfig>(
- nodeConfigList), switchConfigFileName);
- if (retS.equals(retP)) {
- if (retS.isSuccess()) {
- return retS;
- } else {
- return new Status(StatusCode.INTERNALERROR, "Save failed");
- }
+ Status status;
+ short number = 0;
+ status = configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(subnetsConfigList.values()), SUBNETS_FILE_NAME);
+ if (status.isSuccess()) {
+ number++;
+ } else {
+ log.warn("Failed to save subnet gateway configurations: " + status.getDescription());
+ }
+ status = configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(spanConfigList.values()),
+ SPAN_FILE_NAME);
+ if (status.isSuccess()) {
+ number++;
} else {
+ log.warn("Failed to save span port configurations: " + status.getDescription());
+ }
+ status = configurationService.persistConfiguration(new ArrayList<ConfigurationObject>(nodeConfigList.values()),
+ SWITCH_CONFIG_FILE_NAME);
+ if (status.isSuccess()) {
+ number++;
+ } else {
+ log.warn("Failed to save node configurations: " + status.getDescription());
+ }
+ if (number == 0) {
+ return new Status(StatusCode.INTERNALERROR, "Save failed");
+ }
+ if (number < 3) {
return new Status(StatusCode.INTERNALERROR, "Partial save failure");
}
+ return status;
}
@Override
if (macAddress == null) {
log.warn("Failed to acquire controller MAC: No physical interface found");
// This happens when running controller on windows VM, for example
- // TODO: Try parsing the OS command output
- // For now provide a quick fix for the release
- macAddress = new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x0c, (byte) 0x60, (byte) 0x0D, (byte) 0x10 };
- log.debug("Assigning custom MAC address to controller");
+ // Try parsing the OS command output
}
return macAddress;
}
isDefaultContainer = containerName.equals(GlobalConstants.DEFAULT
.toString());
- startUp();
}
/**
*
*/
void start() {
+ startUp();
+
+ /*
+ * Read startup and build database if we are the coordinator
+ */
+ loadSubnetConfiguration();
+ loadSpanConfiguration();
+ loadSwitchConfiguration();
+
// OSGI console
registerWithOSGIConsole();
}
void stop() {
}
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service set request {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service UNset request");
+ this.configurationService = null;
+ }
+
public void setInventoryService(IInventoryService service) {
log.trace("Got inventory service set request {}", service);
this.inventoryService = service;
if (configuredNotConnectedNodes != null) {
for (Node node : configuredNotConnectedNodes) {
Switch sw = getSwitchByNode(node);
- if (sw != null) {
- configuredNotConnectedSwitches.add(sw);
- }
+ configuredNotConnectedSwitches.add(sw);
}
}
return configuredNotConnectedSwitches;
<groupId>org.opendaylight.controller</groupId>
<artifactId>configuration.implementation</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>hosttracker</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>hosttracker.implementation</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>topologymanager</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>protocol_plugins.stub</artifactId>
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class TopologyUserLinkConfig implements Serializable {
+public class TopologyUserLinkConfig extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
private static final Logger logger = LoggerFactory.getLogger(TopologyUserLinkConfig.class);
private String name;
+ @Override
public String toString() {
return name;
}
public static STATUS fromString(String str) {
- if (str == null)
+ if (str == null) {
return LINKDOWN;
- if (str.equals(SUCCESS.toString()))
+ }
+ if (str.equals(SUCCESS.toString())) {
return SUCCESS;
- if (str.equals(LINKDOWN.toString()))
+ }
+ if (str.equals(LINKDOWN.toString())) {
return LINKDOWN;
- if (str.equals(INCORRECT.toString()))
+ }
+ if (str.equals(INCORRECT.toString())) {
return INCORRECT;
+ }
return LINKDOWN;
}
}
}
public boolean isValidNodeConnector(String nodeConnectorStr) {
- NodeConnector nc = NodeConnector.fromString(nodeConnectorStr);
- if (nc == null) return false;
- return true;
+ return (NodeConnector.fromString(nodeConnectorStr) != null);
}
public boolean isValid() {
- if (name == null || srcNodeConnector == null || dstNodeConnector == null) {
+ if (!isValidResourceName(name)) {
+ logger.debug("Invalid name in user link: {}", name);
return false;
}
if (!isValidNodeConnector(srcNodeConnector) ||
!isValidNodeConnector(dstNodeConnector)) {
- logger.debug("Invalid NodeConnector in user link: {}", this);
+ logger.debug("Invalid NodeConnector in user link: {}", name);
return false;
}
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
TopologyUserLinkConfig other = (TopologyUserLinkConfig) obj;
if (dstNodeConnector == null) {
- if (other.dstNodeConnector != null)
+ if (other.dstNodeConnector != null) {
return false;
- } else if (!dstNodeConnector.equals(other.dstNodeConnector))
+ }
+ } else if (!dstNodeConnector.equals(other.dstNodeConnector)) {
return false;
+ }
if (srcNodeConnector == null) {
- if (other.srcNodeConnector != null)
+ if (other.srcNodeConnector != null) {
return false;
- } else if (!srcNodeConnector.equals(other.srcNodeConnector))
+ }
+ } else if (!srcNodeConnector.equals(other.srcNodeConnector)) {
return false;
+ }
return true;
}
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
import org.opendaylight.controller.sal.topology.IListenTopoUpdates;
import org.opendaylight.controller.sal.topology.ITopologyService;
IClusterContainerServices.class).setCallbacks(
"setClusterContainerService",
"unsetClusterContainerService").setRequired(true));
+
+ c.add(createContainerServiceDependency(containerName).setService(
+ IConfigurationContainerService.class).setCallbacks(
+ "setConfigurationContainerService",
+ "unsetConfigurationContainerService").setRequired(true));
}
}
}
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationContainerAware;
+import org.opendaylight.controller.configuration.IConfigurationContainerService;
import org.opendaylight.controller.sal.core.Edge;
import org.opendaylight.controller.sal.core.Host;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.topology.IListenTopoUpdates;
import org.opendaylight.controller.sal.topology.ITopologyService;
import org.opendaylight.controller.sal.topology.TopoEdgeUpdate;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.controller.switchmanager.ISwitchManager;
protected static final String TOPOHOSTSDB = "topologymanager.hostsDB";
protected static final String TOPONODECONNECTORDB = "topologymanager.nodeConnectorDB";
protected static final String TOPOUSERLINKSDB = "topologymanager.userLinksDB";
+ private static final String USER_LINKS_FILE_NAME = "userTopology.conf";
private static final Logger log = LoggerFactory.getLogger(TopologyManagerImpl.class);
private ITopologyService topoService;
private IClusterContainerServices clusterContainerService;
+ private IConfigurationContainerService configurationService;
private ISwitchManager switchManager;
// DB of all the Edges with properties which constitute our topology
private ConcurrentMap<Edge, Set<Property>> edgesDB;
// Topology Manager Aware listeners - for clusterwide updates
private Set<ITopologyManagerClusterWideAware> topologyManagerClusterWideAware =
new CopyOnWriteArraySet<ITopologyManagerClusterWideAware>();
- private static String ROOT = GlobalConstants.STARTUPHOME.toString();
- private String userLinksFileName;
private ConcurrentMap<String, TopologyUserLinkConfig> userLinksDB;
private BlockingQueue<TopoEdgeUpdate> notifyQ = new LinkedBlockingQueue<TopoEdgeUpdate>();
private volatile Boolean shuttingDown = false;
}
}
+ public void setConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service set request {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationContainerService(IConfigurationContainerService service) {
+ log.trace("Got configuration service UNset request");
+ this.configurationService = null;
+ }
+
void setSwitchManager(ISwitchManager s) {
log.debug("Adding ISwitchManager: {}", s);
this.switchManager = s;
containerName = "UNKNOWN";
}
- userLinksFileName = ROOT + "userTopology_" + containerName + ".conf";
registerWithOSGIConsole();
- if ((clusterContainerService != null) && (clusterContainerService.amICoordinator())) {
- loadConfiguration();
- }
+ loadConfiguration();
+
// Restore the shuttingDown status on init of the component
shuttingDown = false;
notifyThread = new Thread(new TopologyNotify(notifyQ));
notifyThread = null;
}
- @SuppressWarnings("unchecked")
private void loadConfiguration() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, TopologyUserLinkConfig> confList =
- (ConcurrentMap<String, TopologyUserLinkConfig>) objReader.read(this, userLinksFileName);
-
- if (confList != null) {
- for (TopologyUserLinkConfig conf : confList.values()) {
- addUserLink(conf);
- }
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, USER_LINKS_FILE_NAME)) {
+ addUserLink((TopologyUserLinkConfig) conf);
}
}
}
public Status saveConfigInternal() {
- ObjectWriter objWriter = new ObjectWriter();
-
- Status saveStatus = objWriter.write(
- new ConcurrentHashMap<String, TopologyUserLinkConfig>(userLinksDB), userLinksFileName);
+ Status saveStatus = configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(userLinksDB.values()), USER_LINKS_FILE_NAME);
- if (! saveStatus.isSuccess()) {
+ if (!saveStatus.isSuccess()) {
return new Status(StatusCode.INTERNALERROR, "Topology save failed: " + saveStatus.getDescription());
}
return saveStatus;
<configuration>
<instructions>
<Import-Package>
- org.opendaylight.controller.clustering.services,
org.opendaylight.controller.configuration,
org.opendaylight.controller.sal.authorization,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.packet,
org.opendaylight.controller.sal.utils,
- org.opendaylight.controller.containermanager,
org.slf4j,
org.eclipse.osgi.framework.console,
org.osgi.framework,
org.apache.felix.dm,
- org.apache.commons.lang3.builder,
org.apache.commons.logging,
javax.servlet,
javax.servlet.http,
org.springframework.security.web.context,
org.springframework.security.core,
org.springframework.security.core.context,
- org.apache.commons.lang3,
org.springframework.security.authentication,
org.springframework.security.core.authority,
org.springframework.security.core.userdetails,
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>containermanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>clustering.services</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>configuration</artifactId>
<artifactId>javax.servlet</artifactId>
</dependency>
<!-- Spring security -->
- <dependency>
- <groupId>org.springframework.security</groupId>
- <artifactId>spring-security-config</artifactId>
- </dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-core</artifactId>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-web</artifactId>
</dependency>
- <dependency>
- <groupId>org.springframework.security</groupId>
- <artifactId>spring-security-taglibs</artifactId>
- </dependency>
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>org.springframework.transaction</artifactId>
- </dependency>
</dependencies>
</project>
import java.io.Serializable;
+import org.opendaylight.controller.configuration.ConfigurationObject;
+
/**
* Configuration Java Object which represents a Remote AAA server configuration
* information for User Manager.
*/
-public class ServerConfig implements Serializable {
+public class ServerConfig extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
// Order matters: JSP file expects following fields in the following order
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
ServerConfig other = (ServerConfig) obj;
if (ip == null) {
- if (other.ip != null)
+ if (other.ip != null) {
return false;
- } else if (!ip.equals(other.ip))
+ }
+ } else if (!ip.equals(other.ip)) {
return false;
+ }
if (protocol == null) {
- if (other.protocol != null)
+ if (other.protocol != null) {
return false;
- } else if (!protocol.equals(other.protocol))
+ }
+ } else if (!protocol.equals(other.protocol)) {
return false;
+ }
if (secret == null) {
- if (other.secret != null)
+ if (other.secret != null) {
return false;
- } else if (!secret.equals(other.secret))
+ }
+ } else if (!secret.equals(other.secret)) {
return false;
+ }
return true;
}
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.sal.authorization.AuthResultEnum;
import org.opendaylight.controller.sal.packet.BitBufferHelper;
import org.opendaylight.controller.sal.utils.HexEncode;
*/
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class UserConfig implements Serializable {
+public class UserConfig extends ConfigurationObject implements Serializable {
private static final long serialVersionUID = 1L;
private static Logger log = LoggerFactory.getLogger(UserConfig.class);
private static final boolean strongPasswordCheck = Boolean.getBoolean("enableStrongPasswordCheck");
<configuration>
<instructions>
<Import-Package>
- org.opendaylight.controller.clustering.services,
org.opendaylight.controller.configuration,
+ org.opendaylight.controller.clustering.services,
org.opendaylight.controller.sal.authorization,
org.opendaylight.controller.sal.core,
org.opendaylight.controller.sal.packet,
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
</dependency>
+
</dependencies>
</project>
import org.apache.felix.dm.Component;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.opendaylight.controller.configuration.IConfigurationAware;
+import org.opendaylight.controller.configuration.IConfigurationService;
import org.opendaylight.controller.containermanager.IContainerAuthorization;
import org.opendaylight.controller.sal.authorization.IResourceAuthorization;
import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
"setClusterGlobalService", "unsetClusterGlobalService")
.setRequired(true));
+ c.add(createServiceDependency().setService(
+ IConfigurationService.class).setCallbacks(
+ "setConfigurationService",
+ "unsetConfigurationService").setRequired(true));
+
c.add(createServiceDependency().setService(IAAAProvider.class)
.setCallbacks("addAAAProvider", "removeAAAProvider")
.setRequired(false));
import org.opendaylight.controller.clustering.services.CacheExistException;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.opendaylight.controller.clustering.services.IClusterServices;
+import org.opendaylight.controller.configuration.ConfigurationObject;
import org.opendaylight.controller.configuration.IConfigurationAware;
+import org.opendaylight.controller.configuration.IConfigurationService;
import org.opendaylight.controller.containermanager.IContainerAuthorization;
import org.opendaylight.controller.sal.authorization.AuthResultEnum;
import org.opendaylight.controller.sal.authorization.IResourceAuthorization;
import org.opendaylight.controller.sal.authorization.UserLevel;
-import org.opendaylight.controller.sal.utils.GlobalConstants;
import org.opendaylight.controller.sal.utils.IObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectReader;
-import org.opendaylight.controller.sal.utils.ObjectWriter;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.controller.usermanager.AuthResponse;
private static final String DEFAULT_ADMIN = "admin";
private static final String DEFAULT_ADMIN_PASSWORD = "admin";
private static final String DEFAULT_ADMIN_ROLE = UserLevel.NETWORKADMIN.toString();
- private static final String ROOT = GlobalConstants.STARTUPHOME.toString();
- private static final String USERS_FILE_NAME = ROOT + "users.conf";
- private static final String SERVERS_FILE_NAME = ROOT + "servers.conf";
- private static final String AUTH_FILE_NAME = ROOT + "authorization.conf";
- private static final String RECOVERY_FILE = ROOT + "NETWORK_ADMIN_PASSWORD_RECOVERY";
+ private static final String USERS_FILE_NAME = "users.conf";
+ private static final String SERVERS_FILE_NAME = "servers.conf";
+ private static final String AUTH_FILE_NAME = "authorization.conf";
+ private static final String RECOVERY_FILE = "NETWORK_ADMIN_PASSWORD_RECOVERY";
private ConcurrentMap<String, UserConfig> localUserConfigList;
private ConcurrentMap<String, ServerConfig> remoteServerConfigList;
// local authorization info for remotely authenticated users
private ConcurrentMap<String, AuthenticatedUser> activeUsers;
private ConcurrentMap<String, IAAAProvider> authProviders;
private IClusterGlobalServices clusterGlobalService = null;
+ private IConfigurationService configurationService;
private SecurityContextRepository securityContextRepo = new UserSecurityContextRepository();
private IContainerAuthorization containerAuthorizationClient;
private Set<IResourceAuthorization> applicationAuthorizationClients;
/*
* Do not load local startup file if we are not the coordinator
*/
- if ((clusterGlobalService != null) && (clusterGlobalService.amICoordinator())) {
- loadUserConfig();
- loadServerConfig();
- loadAuthConfig();
- }
+ loadUserConfig();
+ loadServerConfig();
+ loadAuthConfig();
}
private void loadSecurityKeys() {
}
private Status saveLocalUserListInternal() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, UserConfig>(
- localUserConfigList), USERS_FILE_NAME);
+ return configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(localUserConfigList.values()), USERS_FILE_NAME);
}
@Override
}
private Status saveAAAServerListInternal() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(new ConcurrentHashMap<String, ServerConfig>(
- remoteServerConfigList), SERVERS_FILE_NAME);
+ return configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(remoteServerConfigList.values()), SERVERS_FILE_NAME);
}
@Override
}
private Status saveAuthorizationListInternal() {
- ObjectWriter objWriter = new ObjectWriter();
- return objWriter.write(
- new ConcurrentHashMap<String, AuthorizationConfig>(
- authorizationConfList), AUTH_FILE_NAME);
+ return configurationService.persistConfiguration(
+ new ArrayList<ConfigurationObject>(authorizationConfList.values()), AUTH_FILE_NAME);
}
@Override
return ois.readObject();
}
- @SuppressWarnings("unchecked")
private void loadUserConfig() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, UserConfig> confList = (ConcurrentMap<String, UserConfig>) objReader
- .read(this, USERS_FILE_NAME);
-
- if (confList == null) {
- return;
- }
-
- for (UserConfig conf : confList.values()) {
- addRemoveLocalUserInternal(conf, false);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, USERS_FILE_NAME)) {
+ addRemoveLocalUserInternal((UserConfig) conf, false);
}
}
- @SuppressWarnings("unchecked")
private void loadServerConfig() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, ServerConfig> confList = (ConcurrentMap<String, ServerConfig>) objReader
- .read(this, SERVERS_FILE_NAME);
-
- if (confList == null) {
- return;
- }
-
- for (ServerConfig conf : confList.values()) {
- addAAAServer(conf);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, SERVERS_FILE_NAME)) {
+ addAAAServer((ServerConfig) conf);
}
}
- @SuppressWarnings("unchecked")
private void loadAuthConfig() {
- ObjectReader objReader = new ObjectReader();
- ConcurrentMap<String, AuthorizationConfig> confList = (ConcurrentMap<String, AuthorizationConfig>) objReader
- .read(this, AUTH_FILE_NAME);
-
- if (confList == null) {
- return;
- }
-
- for (AuthorizationConfig conf : confList.values()) {
- addAuthInfo(conf);
+ for (ConfigurationObject conf : configurationService.retrieveConfiguration(this, AUTH_FILE_NAME)) {
+ addAuthInfo((AuthorizationConfig) conf);
}
}
}
}
+ public void setConfigurationService(IConfigurationService service) {
+ logger.trace("Got configuration service set request {}", service);
+ this.configurationService = service;
+ }
+
+ public void unsetConfigurationService(IConfigurationService service) {
+ logger.trace("Got configuration service UNset request");
+ this.configurationService = null;
+ }
+
void unsetContainerAuthClient(IContainerAuthorization s) {
if (this.containerAuthorizationClient == s) {
this.containerAuthorizationClient = null;