With so many changes, am finding it hard to maintain it in my local repo and hence am pushing
it into the the topic/netty branch.
NOTE TO COMMITTERS : PLEASE DONT USE THIS YET. I have some more major cleanup and development
to be done to make this branch useful.
Signed-off-by: Madhu Venugopal <mavenugo@gmail.com>
Change-Id: I70a43dcecee002199d38ffd46a43ca5b20174df4
-<?xml version="1.0" encoding="UTF-8"?>\r
-<classpath>\r
- <classpathentry kind="src" output="target/classes" path="src/main/java">\r
- <attributes>\r
- <attribute name="optional" value="true"/>\r
- <attribute name="maven.pomderived" value="true"/>\r
- </attributes>\r
- </classpathentry>\r
- <classpathentry kind="src" output="target/test-classes" path="src/test/java">\r
- <attributes>\r
- <attribute name="optional" value="true"/>\r
- <attribute name="maven.pomderived" value="true"/>\r
- </attributes>\r
- </classpathentry>\r
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">\r
- <attributes>\r
- <attribute name="maven.pomderived" value="true"/>\r
- </attributes>\r
- </classpathentry>\r
- <classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">\r
- <attributes>\r
- <attribute name="maven.pomderived" value="true"/>\r
- </attributes>\r
- </classpathentry>\r
- <classpathentry kind="output" path="target/classes"/>\r
-</classpath>\r
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" output="target/classes" path="src/main/java">
+ <attributes>
+ <attribute name="optional" value="true"/>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="src" output="target/test-classes" path="src/test/java">
+ <attributes>
+ <attribute name="optional" value="true"/>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+ <attributes>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+ <attributes>
+ <attribute name="maven.pomderived" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="output" path="target/classes"/>
+</classpath>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.opendaylight.ovsdb</groupId>
- <artifactId>commons.ovsdb</artifactId>
- <version>1.0.0-SNAPSHOT</version>
- <relativePath>../commons/parent/</relativePath>
- </parent>
- <artifactId>ovsdb</artifactId>
- <version>0.4.0-SNAPSHOT</version>
- <packaging>bundle</packaging>
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.opendaylight.ovsdb</groupId>
+
<artifactId>commons.ovsdb</artifactId>
+ <version>1.0.0-SNAPSHOT</version>
+ <relativePath>../commons/parent/</relativePath>
+ </parent>
+
<artifactId>ovsdb</artifactId>
+ <version>0.4.0-SNAPSHOT</version>
+
<packaging>bundle</packaging>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <version>2.3.6</version>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Import-Package>
- org.opendaylight.controller.sal.packet,
- org.opendaylight.controller.sal.action,
- org.opendaylight.controller.sal.discovery,
- org.opendaylight.controller.sal.topology,
- org.opendaylight.controller.sal.core,
- org.opendaylight.controller.sal.flowprogrammer,
- org.opendaylight.controller.sal.reader,
- org.opendaylight.controller.sal.inventory,
- org.opendaylight.controller.sal.match,
- org.opendaylight.controller.sal.utils,
- org.opendaylight.controller.sal.connection,
- org.opendaylight.controller.sal.networkconfig.bridgedomain,
- org.apache.commons.lang3.builder,
- org.apache.commons.lang3.tuple,
- org.apache.felix.dm,
- org.slf4j,
- org.eclipse.osgi.framework.console,
- org.osgi.framework,
- javax.net.ssl,
- *
- </Import-Package>
- <Embed-Dependency>jsonrpc4j,httpclient,commons-codec,httpcore-nio,javax.servlet-api,jackson-annotations,jackson-core,jackson-databind,portlet-api;type=!pom;inline=false</Embed-Dependency>
- <Embed-Transitive>
- true
- </Embed-Transitive>
- <Bundle-Activator>
- org.opendaylight.ovsdb.internal.Activator
- </Bundle-Activator>
- </instructions>
- <manifestLocation>${project.basedir}/META-INF</manifestLocation>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <repositories>
- <repository>
- <id>jsonrpc4j-webdav-maven-repo</id>
- <name>jsonrpc4j maven repository</name>
- <url>http://jsonrpc4j.googlecode.com/svn/maven/repo/</url>
- <layout>default</layout>
- </repository>
- </repositories>
- <dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal</artifactId>
- <version>0.5.0-SNAPSHOT</version>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal.connection</artifactId>
- <version>0.1.0-SNAPSHOT</version>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal.networkconfiguration</artifactId>
- <version>0.0.1-SNAPSHOT</version>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.thirdparty</groupId>
- <artifactId>org.openflow.openflowj</artifactId>
- <version>1.0.2-SNAPSHOT</version>
- </dependency>
- <dependency>
- <groupId>com.googlecode</groupId>
- <artifactId>jsonrpc4j</artifactId>
- <version>0.28</version>
- </dependency>
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-annotations</artifactId>
- <version>2.0.2</version>
- </dependency>
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-core</artifactId>
- <version>2.0.2</version>
- </dependency>
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-databind</artifactId>
- <version>2.0.2</version>
- </dependency>
- <dependency>
- <groupId>javax.portlet</groupId>
- <artifactId>portlet-api</artifactId>
- <version>2.0</version>
- </dependency>
- <dependency>
- <groupId>commons-codec</groupId>
- <artifactId>commons-codec</artifactId>
- <version>1.4</version>
- <optional>true</optional>
- </dependency>
- <dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpcore-nio</artifactId>
- <version>4.2.1</version>
- <optional>true</optional>
- </dependency>
- </dependencies>
-</project>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <version>2.3.6</version>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Import-Package>
+ org.opendaylight.controller.sal.packet,
+ org.opendaylight.controller.sal.action,
+ org.opendaylight.controller.sal.discovery,
+ org.opendaylight.controller.sal.topology,
+ org.opendaylight.controller.sal.core,
+ org.opendaylight.controller.sal.flowprogrammer,
+ org.opendaylight.controller.sal.reader,
+ org.opendaylight.controller.sal.inventory,
+ org.opendaylight.controller.sal.match,
+ org.opendaylight.controller.sal.utils,
+ org.opendaylight.controller.sal.connection,
+ org.opendaylight.controller.clustering.services,
+ org.opendaylight.controller.sal.networkconfig.bridgedomain,
+ org.apache.commons.lang3.builder,
+ org.apache.commons.lang3.tuple,
+ org.apache.felix.dm,
+ org.slf4j,
+ org.eclipse.osgi.framework.console,
+ org.osgi.framework,
+ javax.net.ssl,
+ *
+ </Import-Package>
+ <Embed-Dependency>jsonrpc4j,httpclient,commons-codec,httpcore-nio,javax.servlet-api,jackson-annotations,jackson-core,jackson-databind,portlet-api;type=!pom;inline=false</Embed-Dependency>
+ <Embed-Transitive>
+ true
+ </Embed-Transitive>
+ <Bundle-Activator>
+ org.opendaylight.ovsdb.internal.Activator
+ </Bundle-Activator>
+ </instructions>
+ <manifestLocation>${project.basedir}/META-INF</manifestLocation>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <repositories>
+ <repository>
+ <id>jsonrpc4j-webdav-maven-repo</id>
+ <name>jsonrpc4j maven repository</name>
+ <url>http://jsonrpc4j.googlecode.com/svn/maven/repo/</url>
+ <layout>default</layout>
+ </repository>
+ </repositories>
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>clustering.services</artifactId>
+ <version>0.4.1-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal</artifactId>
+ <version>0.5.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.connection</artifactId>
+ <version>0.1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal.networkconfiguration</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller.thirdparty</groupId>
+ <artifactId>org.openflow.openflowj</artifactId>
+ <version>1.0.2-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.core</groupId>
+ <artifactId>jackson-annotations</artifactId>
+ <version>2.2.2</version>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.core</groupId>
+ <artifactId>jackson-core</artifactId>
+ <version>2.2.2</version>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.core</groupId>
+ <artifactId>jackson-databind</artifactId>
+ <version>2.2.2</version>
+ </dependency>
+ <dependency>
+ <groupId>javax.portlet</groupId>
+ <artifactId>portlet-api</artifactId>
+ <version>2.0</version>
+ </dependency>
+ <dependency>
+ <groupId>commons-codec</groupId>
+ <artifactId>commons-codec</artifactId>
+ <version>1.4</version>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.httpcomponents</groupId>
+ <artifactId>httpcore-nio</artifactId>
+ <version>4.2.1</version>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>io.netty</groupId>
+ <artifactId>netty-all</artifactId>
+ <version>4.0.8.Final</version>
+ </dependency>
+ <dependency>
+ <groupId>commons-lang</groupId>
+ <artifactId>commons-lang</artifactId>
+ <version>2.3</version>
+ </dependency>
+
+ </dependencies>
+</project>
\ No newline at end of file
\r
OvsdbMessage msg = new OvsdbMessage("monitor", params);\r
Map<String, Object> monitorResponse = new HashMap<String, Object>();\r
-\r
+/*\r
try{\r
connection.sendMessage(msg);\r
monitorResponse = (Map<String, Object>) connection.readResponse(Map.class);\r
} catch (Throwable e){\r
e.printStackTrace();\r
}\r
-\r
+*/\r
Map<String, Object> bridgeTable = (Map) monitorResponse.get("Bridge");\r
\r
Object[] uuidObjects = bridgeTable.keySet().toArray();\r
\r
OvsdbMessage msg = new OvsdbMessage("monitor", params);\r
Map<String, Object> monitorResponse = new HashMap<String, Object>();\r
-\r
+/*\r
try{\r
connection.sendMessage(msg);\r
monitorResponse = (Map<String, Object>) connection.readResponse(Map.class);\r
} catch (Throwable e){\r
e.printStackTrace();\r
}\r
-\r
+*/\r
Map<String, Object> vSwitchTable = (Map) monitorResponse.get("Open_vSwitch");\r
if(vSwitchTable != null){\r
String uuid = (String) vSwitchTable.keySet().toArray()[0];\r
--- /dev/null
+package org.opendaylight.ovsdb.datatype;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.google.common.collect.ForwardingMap;
+import com.google.common.collect.Maps;
+
+import org.opendaylight.ovsdb.datatype.json.Converter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+//@JsonTypeIdResolver(OVSDBTypesIDResolver.class)
+//@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM, include = JsonTypeInfo.As.WRAPPER_ARRAY)
+@JsonDeserialize(converter = Converter.MapConverter.class)
+public class OvsDBMap<K, V> extends ForwardingMap<K, V> {
+
+ HashMap<K, V> target = Maps.newHashMap();
+
+ @Override
+ protected Map<K, V> delegate() {
+ return target;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.datatype;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.google.common.collect.ForwardingSet;
+import com.google.common.collect.Sets;
+
+import org.opendaylight.ovsdb.datatype.json.Converter;
+
+import java.util.Set;
+
+/*This class exists just to aid in specifying annotations at type level*/
+
+//@JsonTypeIdResolver(OVSDBTypesIDResolver.class)
+//@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM, include = JsonTypeInfo.As.WRAPPER_ARRAY)
+//@JsonDeserialize(converter = ObjectToSetConverter.class)
+@JsonDeserialize(converter = Converter.SetConverter.class)
+public class OvsDBSet<T> extends ForwardingSet<T> {
+
+ Set<T> target = Sets.newHashSet();
+
+ @Override
+ protected Set<T> delegate() {
+ return target;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.datatype;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonTypeIdResolver;
+
+import org.opendaylight.ovsdb.datatype.json.OVSDBTypesIDResolver;
+import org.opendaylight.ovsdb.datatype.json.UUIDStringConverter;
+
+@JsonTypeIdResolver(OVSDBTypesIDResolver.class)
+@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM, include = JsonTypeInfo.As.WRAPPER_ARRAY)
+@JsonDeserialize(contentConverter = UUIDStringConverter.class)
+public class UUID {
+ String val;
+
+ public UUID(String value) {
+ this.val = value;
+ }
+
+ public String toString() {
+ return val;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.datatype.json;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.util.StdConverter;
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+
+public class Converter {
+
+ static AtomDeser atomDeser = new AtomDeser();
+ static MapDeser mapDeser = new MapDeser();
+ static SetDeser setDeser = new SetDeser();
+
+ public static class MapConverter extends StdConverter<JsonNode, OvsDBMap<Object, Object>> {
+ @Override
+ public OvsDBMap<Object, Object> convert(JsonNode value) {
+ return mapDeser.deserialize(value);
+ }
+ }
+
+ public static class SetConverter extends StdConverter<JsonNode, OvsDBSet<Object>> {
+ @Override
+ public OvsDBSet<Object> convert(JsonNode value) {
+ return setDeser.deserialize(value);
+ }
+ }
+
+ static class MapDeser {
+ public OvsDBMap<Object, Object> deserialize(JsonNode node) {
+ if (node.isArray()) {
+ if (node.size() == 2) {
+ if (node.get(0).isTextual() && "map".equals(node.get(0).asText())) {
+ OvsDBMap<Object, Object> map = new OvsDBMap<Object, Object>();
+ for (JsonNode pairNode : node.get(1)) {
+ if (pairNode.isArray() && node.size() == 2) {
+ Object key = atomDeser.deserialize(pairNode.get(0));
+ Object value = atomDeser.deserialize(pairNode.get(1));
+ map.put(key, value);
+ }
+ }
+ return map.isEmpty() ? null : map;
+ } else if (node.size() == 0) {
+ return null;
+ }
+ }
+ }
+ throw new RuntimeException("not a map type");
+ }
+ }
+
+ static class SetDeser {
+ public OvsDBSet<Object> deserialize(JsonNode node) {
+ OvsDBSet<Object> set = new OvsDBSet<Object>();
+ if (node.isArray()) {
+ if (node.size() == 2) {
+ if (node.get(0).isTextual() && "set".equals(node.get(0).asText())) {
+ for (JsonNode atomNode : node.get(1)) {
+ set.add(atomDeser.deserialize(atomNode));
+ }
+ return set;
+ }
+ } else if (node.size() == 0) {
+ return null;
+ }
+ }
+ //treat the whole thing as a single Atom
+ Object atom = atomDeser.deserialize(node);
+ if (null != atom) {
+ set.add(atom);
+ }
+ return set;
+ }
+ }
+
+
+ static class AtomDeser {
+
+ public Object deserialize(JsonNode node) {
+ if (!node.isArray()) {
+ switch (node.getNodeType()) {
+ case BOOLEAN:
+ return node.asBoolean();
+ case NUMBER:
+ if (node.isFloatingPointNumber()) {
+ return node.decimalValue();
+ } else {
+ return node.bigIntegerValue();
+ }
+ case STRING:
+ return node.asText();
+ }
+ }
+
+ if (node.isArray() && node.get(0).isTextual()) {
+ if ("uuid".equals(node.get(0).asText())) {
+ return new UUID(node.get(1).asText());
+ }
+ }
+
+ throw new RuntimeException("not an atom node");
+ }
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.datatype.json;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.jsontype.TypeIdResolver;
+import com.fasterxml.jackson.databind.type.TypeFactory;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+
+public class OVSDBTypesIDResolver implements TypeIdResolver {
+
+ private JavaType baseType;
+
+ @Override
+ public void init(JavaType bt) {
+ this.baseType = bt;
+ }
+
+ @Override
+ public String idFromValue(Object value) {
+ throw new UnsupportedOperationException("not yet done");
+ }
+
+ @Override
+ public String idFromValueAndType(Object value, Class<?> suggestedType) {
+ throw new UnsupportedOperationException("not yet done");
+ }
+
+ @Override
+ public String idFromBaseType() {
+ throw new UnsupportedOperationException("not yet done");
+ }
+
+ @Override
+ public JavaType typeFromId(String id) {
+ if ("set".equals(id)) {
+ return TypeFactory.defaultInstance().constructCollectionType(OvsDBSet.class, Object.class);
+ } else if ("uuid".equals(id)) {
+ return TypeFactory.defaultInstance().constructType(UUID.class);
+ }
+ return null;
+ }
+
+ @Override
+ public JsonTypeInfo.Id getMechanism() {
+ throw new UnsupportedOperationException("not yet done");
+ }
+ }
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.datatype.json;
+
+import com.fasterxml.jackson.databind.util.StdConverter;
+import org.opendaylight.ovsdb.datatype.UUID;
+
+public class UUIDStringConverter extends StdConverter<String, UUID> {
+
+ @Override
+ public UUID convert(String value) {
+ return new UUID(value);
+ }
+
+}
}
private Connection getConnection (Node node) {
-
Connection connection = connectionService.getConnection(node);
- if (connection == null || connection.getSocket() == null) {
+ if (connection == null || !connection.getChannel().isActive()) {
return null;
}
- /*
- * This is possible only when the connection is disconnected due to any reason.
- * But, we have to implement ECHO handling else, it results in timeout and the
- * connection being partially closed from the server side and the client Socket
- * seems to be up. Hence forcing the issue for now till we implement the ECHO.
- */
- if (connection.getSocket().isClosed() || forceConnect) {
- String address = connection.getSocket().getInetAddress().getHostAddress();
- Map<ConnectionConstants, String> params = new HashMap<ConnectionConstants, String>();
- params.put(ConnectionConstants.ADDRESS, address);
- params.put(ConnectionConstants.PORT, connection.getSocket().getPort()+"");
- node = connectionService.connect(connection.getIdentifier(), params);
- connection = connectionService.getConnection(node);
- }
- if (connection == null || connection.getSocket() == null || connection.getSocket().isClosed()) {
- return null;
- }
return connection;
}
/**
}
Connection connection = this.getConnection(node);
- if (connection == null || connection.getSocket() == null) {
+ if (connection == null) {
return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
}
Object[] params = {"Open_vSwitch", addSwitchRequest, addIntfRequest, addPortRequest, addBridgeRequest};
OvsdbMessage msg = new OvsdbMessage("transact", params);
- connection.sendMessage(msg);
+ //connection.sendMessage(msg);
}
}catch(Exception e){
e.printStackTrace();
return new Status(StatusCode.NOSERVICE);
}
Connection connection = this.getConnection(node);
- if (connection == null || connection.getSocket() == null) {
+ if (connection == null) {
return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
}
Object[] params = {"Open_vSwitch", mutateBridgeRequest, addIntfRequest, addPortRequest};
OvsdbMessage msg = new OvsdbMessage("transact", params);
- connection.sendMessage(msg);
+ //connection.sendMessage(msg);
}
}catch(Exception e){
e.printStackTrace();
return false;
}
Connection connection = this.getConnection(node);
- if (connection == null || connection.getSocket() == null) {
+ if (connection == null) {
return false;
}
Object[] params = {"Open_vSwitch", ovsoutter, mgroutside};
OvsdbMessage msg = new OvsdbMessage("transact", params);
- connection.sendMessage(msg);
+ //connection.sendMessage(msg);
}
}catch(Exception e){
package org.opendaylight.ovsdb.internal;
-import java.io.IOException;
-import java.net.Socket;
-import java.util.Map;
+import io.netty.channel.Channel;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import com.googlecode.jsonrpc4j.JsonRpcClient;
-import com.googlecode.jsonrpc4j.JsonRpcClient.RequestListener;
+import java.io.IOException;
-public class Connection implements RequestListener {
+public class Connection {
private Node node;
private String identifier;
- private Socket socket;
- private JsonRpcClient rpcClient;
+ private Channel channel;
+
+ public Long getIdCounter() {
+ return idCounter;
+ }
+
+ public void setIdCounter(Long idCounter) {
+ this.idCounter = idCounter;
+ }
+
+ private Long idCounter;
+
private static final Logger logger = LoggerFactory.getLogger(Connection.class);
- public Connection(String identifier, Socket socket, JsonRpcClient rpcClient) {
+ public Connection(String identifier, Channel channel) {
+
super();
+
this.identifier = identifier;
- this.socket = socket;
- this.rpcClient = rpcClient;
- rpcClient.setRequestListener(this);
+ this.channel = channel;
+ this.idCounter = 0L;
try {
- node = new Node("OVS", identifier);
+ node = new Node("OVS", identifier);
} catch (Exception e) {
e.printStackTrace();
- logger.error("Error creating Node {}", e.getMessage());
+ logger.error("Error creating Node {}", e);
}
}
this.identifier = identifier;
}
- public Socket getSocket() {
- return socket;
+ public Channel getChannel() {
+ return this.channel;
}
- public void setSocket(Socket socket) {
- this.socket = socket;
- }
-
- public JsonRpcClient getRpcClient() {
- return rpcClient;
- }
- public void setRpcClient(JsonRpcClient rpcClient) {
- this.rpcClient = rpcClient;
+ public void setChannel(Channel channel) {
+ this.channel = channel;
}
public Node getNode() {
this.node = node;
}
- @Override
- public void onBeforeRequestSent(JsonRpcClient client, ObjectNode request) {
- request.remove("jsonrpc"); //ovsdb-server expects JSON-RPC v1.0
- }
-
- @Override
- public void onBeforeResponseProcessed(JsonRpcClient client,
- ObjectNode response) {
-
- }
-
- public void sendMessage(OvsdbMessage message) throws IOException{
- try{
- rpcClient.invoke(message.methodName, message.argument, socket.getOutputStream(), message.id);
- }catch(Exception e){
- logger.warn("Could not send RPC for {} ({})", message.methodName, e.getMessage());
- }
- }
-
- public Object readResponse(Class<?> clazz) throws Throwable{
- try{
- if(clazz.equals(String[].class)){
- String[] result = this.rpcClient.readResponse(String[].class, socket.getInputStream());
- for (String res : result) logger.info(res);
- return result;
- }
- else if(clazz.equals(Map.class)){
- Map result = this.rpcClient.readResponse(Map.class, socket.getInputStream());
- return result;
- }
- else{
- ObjectNode jsonObject = this.rpcClient.readResponse(ObjectNode.class, socket.getInputStream());
- ObjectMapper mapper = new ObjectMapper();
- JsonParser parser = mapper.treeAsTokens(jsonObject);
- Object result = mapper.readValue(parser, clazz);
- return result;
- }
-
- }catch(Exception e){
- logger.warn("Could not receive RPC response: {}", e.getMessage());
+ public void sendMessage(String message) throws IOException {
+ try {
+ channel.writeAndFlush(message);
+ this.idCounter++;
+ } catch (Exception e) {
+ e.printStackTrace();
}
- return null;
}
public Status disconnect() {
try {
- socket.close();
- } catch (IOException e) {
+ channel.pipeline().get("messageHandler");
+ channel.close();
+ } catch (Exception e) {
e.printStackTrace();
return new Status(StatusCode.INTERNALERROR, e.getMessage());
}
@Override
public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
+ if (this == obj) return true;
+ if (obj == null) return false;
+ if (getClass() != obj.getClass()) return false;
Connection other = (Connection) obj;
if (identifier == null) {
- if (other.identifier != null)
- return false;
- } else if (!identifier.equals(other.identifier))
- return false;
+ if (other.identifier != null) return false;
+ } else if (!identifier.equals(other.identifier)) return false;
return true;
}
}
package org.opendaylight.ovsdb.internal;
-import java.net.InetAddress;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import javax.net.ServerSocketFactory;
-
-import com.googlecode.jsonrpc4j.JsonRpcClient;
-import com.googlecode.jsonrpc4j.JsonRpcServer;
-import com.googlecode.jsonrpc4j.StreamServer;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.string.StringEncoder;
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
+import io.netty.util.CharsetUtil;
import org.opendaylight.controller.sal.connection.ConnectionConstants;
import org.opendaylight.controller.sal.connection.IPluginInConnectionService;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
+import org.opendaylight.ovsdb.internal.jsonrpc.JsonRpcDecoder;
+import org.opendaylight.ovsdb.internal.jsonrpc.JsonRpcEndpoint;
+import org.opendaylight.ovsdb.internal.jsonrpc.JsonRpcServiceBinderHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.Lists;
+
+import java.net.InetAddress;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+
/**
* Represents the openflow plugin component in charge of programming the flows
* the flow programming and relay them to functional modules above SAL.
*/
-public class ConnectionService implements IPluginInConnectionService, IConnectionServiceInternal
-{
- protected static final Logger logger = LoggerFactory
- .getLogger(ConnectionService.class);
+public class ConnectionService implements IPluginInConnectionService, IConnectionServiceInternal {
+ protected static final Logger logger = LoggerFactory.getLogger(ConnectionService.class);
private static final Integer defaultOvsdbPort = 6632;
- ConcurrentMap <String, Connection> ovsdbConnections;
+ ConcurrentMap<String, Connection> ovsdbConnections;
+ List<ChannelHandler> handlers = null;
+
public void init() {
ovsdbConnections = new ConcurrentHashMap<String, Connection>();
+
+ //backward compatability with other tests and stuff
+ if (handlers == null) {
+ List<ChannelHandler> _handlers = Lists.newArrayList();
+ _handlers.add(new LoggingHandler(LogLevel.INFO));
+ _handlers.add(new JsonRpcDecoder(100000));
+ _handlers.add(new StringEncoder(CharsetUtil.UTF_8));
+ _handlers.add(new MessageHandler());
+ }
}
/**
* Function called by the dependency manager when at least one dependency
* become unsatisfied or when the component is shutting down because for
* example bundle is being stopped.
- *
*/
void destroy() {
}
/**
* Function called by dependency manager after "init ()" is called and after
* the services provided by the class are registered in the service registry
- *
*/
void start() {
}
* Function called by the dependency manager before the services exported by
* the component are unregistered, this will be followed by a "destroy ()"
* calls
- *
*/
void stop() {
}
@Override
public Status disconnect(Node node) {
- String identifier = (String)node.getID();
+ String identifier = (String) node.getID();
Connection connection = ovsdbConnections.get(identifier);
if (connection != null) {
ovsdbConnections.remove(identifier);
try {
address = InetAddress.getByName(params.get(ConnectionConstants.ADDRESS));
} catch (Exception e) {
- address = null;
- }
-
- if (address == null) {
+ e.printStackTrace();
return null;
}
- try {
+ try {
port = Integer.parseInt(params.get(ConnectionConstants.PORT));
if (port == 0) port = defaultOvsdbPort;
} catch (Exception e) {
port = defaultOvsdbPort;
}
+
try {
- Socket clientSocket = new Socket(address, port);
- Connection connection = new Connection(identifier, clientSocket, new JsonRpcClient());
+ Bootstrap bootstrap = new Bootstrap();
+ bootstrap.group(new NioEventLoopGroup());
+ bootstrap.channel(NioSocketChannel.class);
+ bootstrap.option(ChannelOption.TCP_NODELAY, true);
+ bootstrap.option(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(65535, 65535, 65535));
+ bootstrap.handler(new ChannelInitializer<SocketChannel>() {
+ @Override
+ public void initChannel(SocketChannel channel) throws Exception {
+// ObjectMapper objectMapper = new ObjectMapper();
+// JsonRpcEndpoint factory = new JsonRpcEndpoint(objectMapper, ConnectionService.this);
+ /*Add new Handlers here.
+ Break out into todo break out into channel Init Class*/
+ if (handlers == null) {
+ channel.pipeline().addLast(
+ new LoggingHandler(LogLevel.INFO),
+ new JsonRpcDecoder(100000),
+ new StringEncoder(CharsetUtil.UTF_8),
+ // new JsonRpcServiceBinderHandler(factory),
+ new MessageHandler());
+ } else {
+ for (ChannelHandler handler : handlers) {
+ channel.pipeline().addLast(handler);
+ }
+ }
+ }
+ });
+ ChannelFuture future = bootstrap.connect(address, port).sync();
+
+ Channel channel = future.channel();
+ Connection connection = new Connection(identifier, channel);
+
+ ovsdbConnections.put(identifier, connection);
+ return connection.getNode();
- if (connection != null) {
- ovsdbConnections.put(identifier, connection);
- return connection.getNode();
- }
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
+
+ public List<ChannelHandler> getHandlers() {
+ return handlers;
+ }
+
+ public void setHandlers(List<ChannelHandler> handlers) {
+ this.handlers = handlers;
+ }
+
@Override
public Connection getConnection(Node node) {
- String identifier = (String)node.getID();
+ String identifier = (String) node.getID();
return ovsdbConnections.get(identifier);
}
@Override
public void notifyNodeDisconnectFromMaster(Node arg0) {
}
- }
\ No newline at end of file
+}
*
*
*/
-public class InventoryService implements IPluginInInventoryService {
+public class InventoryService implements IPluginInInventoryService, InventoryServiceInternal {
private static final Logger logger = LoggerFactory
.getLogger(InventoryService.class);
- private ConcurrentMap<Node, Map<String, Property>> nodeProps; // properties
- // are
- // maintained
- // in global
- // container
- // only
- private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps; // properties
- // are
- // maintained
- // in
- // global
- // container
- // only
+ private ConcurrentMap<Node, Map<String, Property>> nodeProps;
+ private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps;
/**
* Function called by the dependency manager when all the required
void init() {
nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
- Node.NodeIDType.registerIDType("STUB", Integer.class);
- NodeConnector.NodeConnectorIDType.registerIDType("STUB", Integer.class,
- "STUB");
-
- setupNodeProps();
- setupNodeConnectorProps();
- }
-
- private void setupNodeConnectorProps() {
- Map<String, Property> ncPropMap = new HashMap<String, Property>();
- Capabilities cap = new Capabilities(
- CapabilitiesType.FLOW_STATS_CAPABILITY.getValue());
- ncPropMap.put(Capabilities.CapabilitiesPropName, cap);
- Bandwidth bw = new Bandwidth(Bandwidth.BW1Gbps);
- ncPropMap.put(Bandwidth.BandwidthPropName, bw);
- State st = new State(State.EDGE_UP);
- ncPropMap.put(State.StatePropName, st);
-
- // setup property map for all node connectors
- NodeConnector nc;
- Node node;
- try {
- node = new Node("STUB", new Integer(0xCAFE));
- nc = new NodeConnector("STUB", 0xCAFE, node);
- } catch (ConstructionException e) {
- nc = null;
- node = null;
- }
- nodeConnectorProps.put(nc, ncPropMap);
-
- try {
- node = new Node("STUB", 3366);
- nc = new NodeConnector("STUB", 12, node);
- } catch (ConstructionException e) {
- nc = null;
- node = null;
- }
- nodeConnectorProps.put(nc, ncPropMap);
-
- try {
- node = new Node("STUB", 4477);
- nc = new NodeConnector("STUB", 34, node);
- } catch (ConstructionException e) {
- nc = null;
- node = null;
- }
- nodeConnectorProps.put(nc, ncPropMap);
-
+ Node.NodeIDType.registerIDType("OVS", String.class);
+ NodeConnector.NodeConnectorIDType.registerIDType("OVS", String.class, "OVS");
}
- private void setupNodeProps() {
- Map<String, Property> propMap = new HashMap<String, Property>();
-
- Tables t = new Tables((byte) 1);
- propMap.put(Tables.TablesPropName, t);
- Capabilities c = new Capabilities((int) 3);
- propMap.put(Capabilities.CapabilitiesPropName, c);
- Actions a = new Actions((int) 2);
- propMap.put(Actions.ActionsPropName, a);
- Buffers b = new Buffers((int) 1);
- propMap.put(Buffers.BuffersPropName, b);
- Long connectedSinceTime = 100000L;
- TimeStamp timeStamp = new TimeStamp(connectedSinceTime,
- "connectedSince");
- propMap.put(TimeStamp.TimeStampPropName, timeStamp);
-
- // setup property map for all nodes
- Node node;
- try {
- node = new Node("STUB", new Integer(0xCAFE));
- } catch (ConstructionException e) {
- node = null;
- }
-
- nodeProps.put(node, propMap);
-
- try {
- node = new Node("STUB", 3366);
- } catch (ConstructionException e) {
- node = null;
- }
- nodeProps.put(node, propMap);
-
- try {
- node = new Node("STUB", 4477);
- } catch (ConstructionException e) {
- node = null;
- }
- nodeProps.put(node, propMap);
-
- }
/**
* Function called by the dependency manager when at least one dependency
--- /dev/null
+package org.opendaylight.ovsdb.internal;
+
+public interface InventoryServiceInternal {
+
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal;\r
+\r
+import com.fasterxml.jackson.databind.JsonNode;\r
+import com.fasterxml.jackson.databind.ObjectMapper;\r
+\r
+import io.netty.channel.ChannelHandlerContext;\r
+import io.netty.channel.ChannelInboundHandlerAdapter;\r
+\r
+import org.opendaylight.ovsdb.message.EchoResponse;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import java.io.IOException;\r
+import java.util.HashMap;\r
+import java.util.Map;\r
+import java.util.concurrent.Future;\r
+\r
+public class MessageHandler extends ChannelInboundHandlerAdapter {\r
+ protected static final Logger logger = LoggerFactory.getLogger(MessageHandler.class);\r
+\r
+ private Map<Long, MessageHandlerFuture> responseFutures = new HashMap<Long, MessageHandlerFuture>();\r
+\r
+ public Future<Object> getResponse(long id) {\r
+ MessageHandlerFuture responseFuture = new MessageHandlerFuture(Long.valueOf(id));\r
+ responseFutures.put(Long.valueOf(id), responseFuture);\r
+ return responseFuture;\r
+ }\r
+\r
+ @Override\r
+ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {\r
+ // logger.debug(ctx.channel().alloc().buffer().alloc().directBuffer().toString());\r
+\r
+ logger.info("ChannRead ==> " + msg.toString());\r
+ JsonNode jsonNode;\r
+ ObjectMapper mapper = new ObjectMapper();\r
+ String strmsg = msg.toString();\r
+ try {\r
+ jsonNode = mapper.readTree(strmsg);\r
+ } catch (IOException e) {\r
+ e.printStackTrace();\r
+ return;\r
+ }\r
+\r
+ if (jsonNode.has("method")) {\r
+ String method = jsonNode.get("method").toString();\r
+ // if (method.contains("echo")) {\r
+ EchoResponse echoreply = new EchoResponse();\r
+ JsonNode echoReplyJnode = mapper.valueToTree(echoreply);\r
+ logger.debug("Echo Reply DP ==>" + msg);\r
+ ctx.writeAndFlush(echoReplyJnode.toString());\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {\r
+ ctx.flush();\r
+ }\r
+}
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.internal;\r
+\r
+import org.opendaylight.controller.sal.utils.Status;\r
+import org.opendaylight.controller.sal.utils.StatusCode;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import java.util.concurrent.*;\r
+\r
+/**\r
+ * Class which will monitor the completion of a FlowEntryDistributionOrder it\r
+ * implements a Future interface so it can be inspected by who is waiting for\r
+ * it.\r
+ */\r
+final class MessageHandlerFuture implements Future<Object> {\r
+ private final Long id;\r
+ private Object response;\r
+ private boolean amICancelled;\r
+ private CountDownLatch waitingLatch;\r
+ private Status retStatus;\r
+ private static final Logger logger = LoggerFactory.getLogger(MessageHandlerFuture.class);\r
+\r
+\r
+ /**\r
+ * @param order for which we are monitoring the execution\r
+ */\r
+ public MessageHandlerFuture(Long id) {\r
+ // Order being monitored\r
+ this.id = id;\r
+ this.response = null;\r
+ this.amICancelled = false;\r
+ // We need to wait for one completion to happen\r
+ this.waitingLatch = new CountDownLatch(1);\r
+ // No return status yet!\r
+ this.retStatus = new Status(StatusCode.UNDEFINED);\r
+ }\r
+\r
+ @Override\r
+ public boolean cancel(boolean mayInterruptIfRunning) {\r
+ return false;\r
+ }\r
+\r
+ @Override\r
+ public Object get() throws InterruptedException, ExecutionException {\r
+ // If i'm done lets return the status as many times as caller wants\r
+ if (this.waitingLatch.getCount() == 0L) {\r
+ return response;\r
+ }\r
+\r
+ // Wait till someone signal that we are done\r
+ this.waitingLatch.await();\r
+\r
+ // Return the known status\r
+ return response;\r
+ }\r
+\r
+ @Override\r
+ public Object get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {\r
+ // If i'm done lets return the status as many times as caller wants\r
+ if (this.waitingLatch.getCount() == 0L) {\r
+ return response;\r
+ }\r
+\r
+ // Wait till someone signal that we are done\r
+ this.waitingLatch.await(timeout, unit);\r
+\r
+ // Return the known status, could also be null if didn't return\r
+ return response;\r
+ }\r
+\r
+ @Override\r
+ public boolean isCancelled() {\r
+ return this.amICancelled;\r
+ }\r
+\r
+ @Override\r
+ public boolean isDone() {\r
+ return (this.waitingLatch.getCount() == 0L);\r
+ }\r
+\r
+ /**\r
+ * Used by the thread that gets back the status for the order so can unblock\r
+ * an eventual caller waiting on the result to comes back\r
+ *\r
+ * @param order\r
+ * @param retStatus\r
+ */\r
+ void gotResponse(Long id, Object response) {\r
+ if (id != this.id) {\r
+ // Weird we got a call for an order we didn't make\r
+ return;\r
+ }\r
+ this.response = response;\r
+ // Now we are not waiting any longer\r
+ this.waitingLatch.countDown();\r
+ }\r
+}\r
--- /dev/null
+package org.opendaylight.ovsdb.internal;\r
+\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import java.util.HashMap;\r
+import java.util.Map;\r
+\r
+public class MessageMapper {\r
+\r
+ private static final Logger logger = LoggerFactory.getLogger(MessageMapper.class);\r
+\r
+ private static MessageMapper mapper = null;\r
+ Map<Long, Class<?>> responseMapper = new HashMap<Long, Class<?>>();\r
+ Map<String, Class<?>> requestMapper = new HashMap<String, Class<?>>();\r
+\r
+ private MessageMapper() {\r
+ }\r
+\r
+ public static MessageMapper getMapper() {\r
+ if (mapper == null) mapper = new MessageMapper();\r
+ return mapper;\r
+ }\r
+\r
+ public void map(long id, Class<?> rClass) {\r
+ responseMapper.put(Long.valueOf(id), rClass);\r
+ }\r
+\r
+ public Class<?> pop(long id) {\r
+ return responseMapper.remove(id);\r
+ }\r
+\r
+ public void map(String type, Class<?> rClass) {\r
+ requestMapper.put(type, rClass);\r
+ }\r
+\r
+ public Class<?> get(String type) {\r
+ return requestMapper.get(type);\r
+ }\r
+}\r
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import io.netty.channel.ChannelHandlerAdapter;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.TooLongFrameException;
+
+public class ExceptionHandler extends ChannelHandlerAdapter {
+
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+ if ((cause instanceof InvalidEncodingException)
+ || (cause instanceof TooLongFrameException)) {
+
+ ctx.channel().disconnect();
+ }
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+public class InvalidEncodingException extends RuntimeException {
+
+ private final String actual;
+
+ public InvalidEncodingException(String actual, String message) {
+ super(message);
+ this.actual = actual;
+ }
+
+ public String getActual() {
+ return actual;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import com.google.common.collect.Lists;
+
+import java.util.List;
+import java.util.UUID;
+
+public class JsonRpc10Request {
+
+ String id;
+ String method;
+ List<Object> params = Lists.newArrayList();
+
+ public JsonRpc10Request(String id) {
+ setId(id);
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public String getMethod() {
+ return method;
+ }
+
+ public void setMethod(String method) {
+ this.method = method;
+ }
+
+ public List<Object> getParams() {
+ return params;
+ }
+
+ public void setParams(List<Object> params) {
+ this.params = params;
+ }
+
+ public void setParams(Object[] pararms) {
+ this.params = Lists.newArrayList(pararms);
+ }
+
+ @Override
+ public String toString() {
+ return "JsonRpc10Request [id=" + id + ", method=" + method
+ + ", params=" + params + "]";
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import java.util.List;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.collect.Lists;
+
+public class JsonRpc10Response {
+
+ String id;
+ String error;
+ List<Object> result = Lists.newArrayList();
+
+ public JsonRpc10Response(String id) {
+ setId(id);
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public String getError() {
+ return error;
+ }
+
+ public void setError(String error) {
+ this.error = error;
+ }
+
+ public List<Object> getResult() {
+ return result;
+ }
+
+ public void setResult(List<Object> result) {
+ this.result = result;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+
+import com.fasterxml.jackson.core.JsonEncoding;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.io.IOContext;
+import com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper;
+import com.fasterxml.jackson.core.util.BufferRecycler;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.MappingJsonFactory;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import io.netty.handler.codec.TooLongFrameException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * JSON RPC 1.0 compatible decoder capable of decoding JSON messages from a TCP stream.
+ * The stream is framed first by inspecting the json for valid end marker (left curly)
+ * and is passed to a Json parser (jackson) for converting into an object model.
+ *
+ * There are no JSON parsers that I am aware of that does non blocking parsing.
+ * This approach avoids having to run json parser over and over again on the entire
+ * stream waiting for input. Parser is invoked only when we know of a full JSON message
+ * in the stream.
+ */
+public class JsonRpcDecoder extends ByteToMessageDecoder {
+
+ protected static final Logger logger = LoggerFactory.getLogger(JsonRpcDecoder.class);
+
+ private int maxFrameLength;
+
+ private JsonFactory jacksonJsonFactory = new MappingJsonFactory();
+
+ private IOContext jacksonIOContext = new IOContext(new BufferRecycler(), null, false);
+
+ // context for the previously read incomplete records
+ private int lastRecordBytes = 0;
+ private int leftCurlies = 0;
+ private int rightCurlies = 0;
+ private boolean inS = false;
+
+ private int recordsRead;
+
+ public JsonRpcDecoder(int maxFrameLength) {
+ this.maxFrameLength = maxFrameLength;
+ }
+
+ @Override
+ protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) throws Exception {
+
+ logger.debug("readable bytes {}, records read {}, incomplete record bytes {}",
+ buf.readableBytes(), recordsRead, lastRecordBytes);
+
+ if (lastRecordBytes == 0) {
+ if (buf.readableBytes() < 4) {
+ return; //wait for more data
+ }
+
+ skipSpaces(buf);
+
+ byte[] buff = new byte[4];
+ buf.getBytes(buf.readerIndex(), buff);
+ ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(jacksonIOContext, buff, 0, 4);
+ JsonEncoding jsonEncoding = strapper.detectEncoding();
+ if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
+ throw new InvalidEncodingException(jsonEncoding.getJavaName(), "currently only UTF-8 is supported");
+ }
+ }
+
+ int i = lastRecordBytes + buf.readerIndex();
+
+ for (; i < buf.writerIndex(); i++) {
+ switch (buf.getByte(i)) {
+ case '{':
+ if (!inS) leftCurlies++;
+ break;
+ case '}':
+ if (!inS) rightCurlies++;
+ break;
+ case '"': {
+ if (buf.getByte(i - 1) != '\\') inS = !inS;
+ break;
+ }
+ }
+
+ if (leftCurlies != 0 && leftCurlies == rightCurlies && !inS) {
+ ByteBuf slice = buf.readSlice(1 + i - buf.readerIndex());
+ JsonParser jp = jacksonJsonFactory.createParser(new ByteBufInputStream(slice));
+ JsonNode root = jp.readValueAsTree();
+ out.add(root);
+ leftCurlies = rightCurlies = lastRecordBytes = 0;
+ recordsRead++;
+ break;
+ }
+
+ if (i - buf.readerIndex() >= maxFrameLength) {
+ fail(ctx, i - buf.readerIndex());
+ }
+ }
+
+ // end of stream, save the incomplete record index to avoid reexamining the whole on next run
+ if (i >= buf.writerIndex()) {
+ lastRecordBytes = buf.readableBytes();
+ return;
+ }
+ }
+
+ public int getRecordsRead() {
+ return recordsRead;
+ }
+
+ private static void skipSpaces(ByteBuf b) throws IOException {
+ while (b.isReadable()) {
+ int ch = (int) b.getByte(b.readerIndex()) & 0xFF;
+ if (!(ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t')) {
+ return;
+ } else {
+ b.readByte(); //move the read index
+ }
+ }
+ }
+
+
+ private void print(ByteBuf buf, String message) {
+ print(buf, buf.readerIndex(), buf.readableBytes(), message == null ? "buff" : message);
+ }
+
+ private void print(ByteBuf buf, int startPos, int chars, String message) {
+ if (null == message) message = "";
+ if (startPos > buf.writerIndex()) {
+ logger.debug("startPos out of bounds");
+ }
+ byte[] b = new byte[startPos + chars <= buf.writerIndex() ? chars : buf.writerIndex() - startPos];
+ buf.getBytes(startPos, b);
+ logger.debug("{} ={}", message, new String(b));
+ }
+
+ // copied from Netty decoder
+ private void fail(ChannelHandlerContext ctx, long frameLength) {
+ if (frameLength > 0) {
+ ctx.fireExceptionCaught(
+ new TooLongFrameException(
+ "frame length exceeds " + maxFrameLength +
+ ": " + frameLength + " - discarded"));
+ } else {
+ ctx.fireExceptionCaught(
+ new TooLongFrameException(
+ "frame length exceeds " + maxFrameLength +
+ " - discarding"));
+ }
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageEncoder;
+
+import java.util.List;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: araveendrann
+ * Date: 10/6/13
+ * Time: 11:19 PM
+ * To change this template use File | Settings | File Templates.
+ */
+public class JsonRpcEncoder extends MessageToMessageEncoder<Object> {
+ @Override
+ protected void encode(ChannelHandlerContext ctx, Object msg, List<Object> out) throws Exception {
+
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.google.common.collect.Maps;
+import com.google.common.reflect.Reflection;
+import com.google.common.reflect.TypeToken;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.ovsdb.internal.Connection;
+import org.opendaylight.ovsdb.internal.ConnectionService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class JsonRpcEndpoint {
+
+ protected static final Logger logger = LoggerFactory.getLogger(JsonRpcEndpoint.class);
+
+ public class CallContext {
+ Method method;
+ JsonRpc10Request request;
+ SettableFuture<Object> future;
+
+ public CallContext(JsonRpc10Request request, Method method, SettableFuture<Object> future) {
+ this.method = method;
+ this.request = request;
+ this.future = future;
+ }
+
+ public Method getMethod() {
+ return method;
+ }
+
+ public JsonRpc10Request getRequest() {
+ return request;
+ }
+
+ public SettableFuture<Object> getFuture() {
+ return future;
+ }
+ }
+
+ ObjectMapper objectMapper;
+ ConnectionService service;
+ Map<String, CallContext> methodContext = Maps.newHashMap();
+
+ public JsonRpcEndpoint(ObjectMapper objectMapper, ConnectionService service) {
+ this.objectMapper = objectMapper;
+ this.service = service;
+ }
+
+ public <T> T getClient(final Node node, Class<T> klazz) {
+
+ return Reflection.newProxy(klazz, new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+
+ JsonRpc10Request request = new JsonRpc10Request(UUID.randomUUID().toString());
+ request.setMethod(method.getName());
+
+
+ if (args != null && args.length != 0) {
+ List<Object> params = null;
+
+ if (args.length == 1) {
+ if (args[0] instanceof Params) {
+ params = ((Params) args[0]).params();
+ } else if (args[0] instanceof List) {
+ params = (List<Object>) args[0];
+ }
+
+ if (params == null) {
+ throw new RuntimeException("do not understand this argument yet");
+ }
+ request.setParams(params);
+ }
+ }
+
+ String s = objectMapper.writeValueAsString(request);
+ logger.debug("{}", s);
+
+ SettableFuture<Object> sf = SettableFuture.create();
+ methodContext.put(request.getId(), new CallContext(request, method, sf));
+
+ Connection connection = service.getConnection(node);
+ connection.getChannel().writeAndFlush(s);
+
+ return sf;
+ }
+ }
+ );
+ }
+
+ public void processResult(JsonNode response) throws NoSuchMethodException {
+
+ CallContext returnCtxt = methodContext.get(response.get("id").asText());
+
+ Class<?> returnType = null;
+
+ if (ListenableFuture.class == returnCtxt.getMethod().getReturnType()) {
+ TypeToken<?> retType = TypeToken.of(
+ returnCtxt.getMethod().getGenericReturnType())
+ .resolveType(ListenableFuture.class.getMethod("get").getGenericReturnType());
+
+ JsonNode result = response.get("result");
+ Object result1 = objectMapper.convertValue(result, retType.getRawType());
+ returnCtxt.getFuture().set(result1);
+
+ } else {
+ throw new RuntimeException("donno how to deal with this");
+ }
+ }
+
+ public void processRequest(Node node, JsonNode requestJson) {
+ JsonRpc10Request request = new JsonRpc10Request(requestJson.get("id").asText());
+ request.setMethod(requestJson.get("method").asText());
+
+ // TODO : Take care of listener interested in the async message from ovsdb-server
+ // and return a result to be sent back.
+ // The following piece of code will help with ECHO handling as is.
+ JsonRpc10Response response = new JsonRpc10Response(request.getId());
+ response.setError(null);
+ try {
+ String s = objectMapper.writeValueAsString(response);
+ Connection connection = service.getConnection(node);
+ connection.getChannel().writeAndFlush(s);
+ } catch (JsonProcessingException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public Map<String, CallContext> getMethodContext() {
+ return methodContext;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;\r
+\r
+import com.fasterxml.jackson.databind.JsonNode;\r
+import com.google.common.base.Strings;\r
+import com.google.common.collect.Maps;\r
+import com.google.common.util.concurrent.SettableFuture;\r
+\r
+import io.netty.channel.ChannelHandlerContext;\r
+import io.netty.channel.ChannelInboundHandlerAdapter;\r
+\r
+import org.opendaylight.controller.sal.core.Node;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import java.util.Map;\r
+\r
+public class JsonRpcServiceBinderHandler extends ChannelInboundHandlerAdapter {\r
+ protected static final Logger logger = LoggerFactory.getLogger(JsonRpcServiceBinderHandler.class);\r
+ Map<Object, SettableFuture<Object>> waitingForReply = Maps.newHashMap();\r
+ JsonRpcEndpoint factory = null;\r
+ Node node = null;\r
+\r
+ public Node getNode() {\r
+ return node;\r
+ }\r
+\r
+ public void setNode(Node node) {\r
+ this.node = node;\r
+ }\r
+\r
+ public JsonRpcServiceBinderHandler(JsonRpcEndpoint factory) {\r
+ this.factory = factory;\r
+ }\r
+\r
+ @Override\r
+ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {\r
+\r
+ if (msg instanceof JsonNode) {\r
+ JsonNode jsonNode = (JsonNode) msg;\r
+\r
+ if (jsonNode.has("result")) {\r
+ factory.processResult(jsonNode);\r
+ } else if (jsonNode.hasNonNull("method")) {\r
+ if (jsonNode.has("id") && !Strings.isNullOrEmpty(jsonNode.get("id").asText())) {\r
+ factory.processRequest(node, jsonNode);\r
+ }\r
+ }\r
+\r
+ return;\r
+ }\r
+\r
+ ctx.channel().close();\r
+ }\r
+\r
+ @Override\r
+ public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {\r
+ ctx.flush();\r
+ }\r
+}
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import java.util.List;
+
+public interface Params {
+ List<Object> params();
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.ovsdb;
+
+import java.util.List;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+import org.opendaylight.ovsdb.database.DatabaseSchema;
+import org.opendaylight.ovsdb.message.EchoResponse;
+import org.opendaylight.ovsdb.message.MonitorRequestBuilder;
+import org.opendaylight.ovsdb.message.TableUpdates;
+
+
+public interface OVSDB {
+
+ public ListenableFuture<DatabaseSchema> get_schema(List<String> db_names);
+
+ public ListenableFuture<List<String>> echo();
+
+ public ListenableFuture<TableUpdates> monitor(MonitorRequestBuilder request);
+
+ public ListenableFuture<List<String>> list_dbs();
+
+ public ListenableFuture<List<Object>> transact();
+ /*
+ public void registerListener(Callback callback);
+
+ public static interface Callback {
+ public void monitorResponse(TableUpdates upadate);
+ }
+ */
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+
+public class EchoResponse {
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.google.common.collect.Lists;
+
+import java.util.List;
+
+import org.opendaylight.ovsdb.table.internal.Column;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class MonitorRequest<E> {
+
+ //@JsonSerialize(contentAs = ToStringSerializer.class)
+ List<Column<E>> columns;
+
+ MonitorSelect select;
+
+ public List<? extends Column> getColumns() {
+ return columns;
+ }
+
+ public void setColumns(List<Column<E>> columns) {
+ this.columns = columns;
+ }
+
+
+ public MonitorSelect getSelect() {
+ return select;
+ }
+
+ public void setSelect(MonitorSelect select) {
+ this.select = select;
+ }
+
+ public MonitorRequest<E> column(Column<E> column) {
+ if (null == columns) {
+ columns = Lists.newArrayList();
+ }
+ columns.add(column);
+ return this;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import org.opendaylight.ovsdb.internal.jsonrpc.Params;
+import org.opendaylight.ovsdb.table.Bridge;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+import java.util.List;
+import java.util.Map;
+
+public class MonitorRequestBuilder implements Params {
+
+ Map<String, MonitorRequest> requests = Maps.newLinkedHashMap();
+
+ @Override
+ public List<Object> params() {
+ requests.put("Bridge", new MonitorRequest<Bridge>());
+ return Lists.newArrayList("Open_vSwitch", null, requests);
+ }
+
+
+ public <T extends Table> MonitorRequest<T> monitor(T table) {
+ MonitorRequest<T> req = new MonitorRequest<T>();
+ requests.put(table.getTableName().getName(), req);
+ return req;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+public class MonitorSelect {
+
+ boolean inital;
+ boolean insert;
+ boolean delete;
+ boolean modify;
+
+ public boolean isInital() {
+ return inital;
+ }
+
+ public void setInital(boolean inital) {
+ this.inital = inital;
+ }
+
+ public boolean isInsert() {
+ return insert;
+ }
+
+ public void setInsert(boolean insert) {
+ this.insert = insert;
+ }
+
+ public boolean isDelete() {
+ return delete;
+ }
+
+ public void setDelete(boolean delete) {
+ this.delete = delete;
+ }
+
+ public boolean isModify() {
+ return modify;
+ }
+
+ public void setModify(boolean modify) {
+ this.modify = modify;
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.Maps;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.ovsdb.table.internal.Table;
+
+
+public class TableUpdate<T extends Table> {
+ /*This could have been done as a map, but doing so would expose the inner wrapper class in type signature*/
+
+ Map<String, Row<T>> map = Maps.newHashMap();
+
+ @JsonAnyGetter
+ public Row<T> get(String rowId) {
+ return map.get(rowId);
+ }
+
+ @JsonAnySetter
+ public void set(String rowId, Row<T> value) {
+ map.put(rowId, value);
+ value.setId(rowId);
+ }
+
+ public Collection<Row<T>> getRows() {
+ return map.values();
+ }
+
+ @Override
+ public String toString() {
+ return "TableUpdate [map=" + map + "]";
+ }
+
+ static class Row<T> {
+
+ @JsonIgnore
+ String id;
+
+ @JsonProperty("new")
+ T _new;
+ T old;
+
+ public String getId() {
+ return id;
+ }
+
+ public T getNew() {
+ return _new;
+ }
+
+ public void setNew(T neww) {
+ this._new = neww;
+ }
+
+ public T getOld() {
+ return old;
+ }
+
+ public void setOld(T old) {
+ this.old = old;
+ }
+
+ void setId(String id) {
+ this.id = id;
+ }
+
+ @Override
+ public String toString() {
+ return "Row{" +
+ "id='" + id + '\'' +
+ ", _new=" + _new.toString() +
+ '}';
+ }
+
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.Maps;
+
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.ovsdb.table.*;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+
+public class TableUpdates {
+
+ Map<Table.Name, TableUpdate> map = Maps.newHashMap();
+
+ public Set<Table.Name> availableUpdates() {
+ return map.keySet();
+ }
+
+ @SuppressWarnings("unchecked")
+ public <T extends Table> TableUpdate<T> getUpdate(Table.Name<T> name) {
+ return map.get(name);
+ }
+
+
+ private <T extends Table> void put(Table.Name<T> name, TableUpdate<T> update) {
+ map.put(name, update);
+ }
+
+
+ @JsonProperty("Interface")
+ public TableUpdate<Interface> getInterfaceUpdate() {
+ return getUpdate(Interface.NAME);
+ }
+
+ public void setInterfaceUpdate(TableUpdate<Interface> interfaceUpdate) {
+ put(Interface.NAME, interfaceUpdate);
+ }
+
+ @JsonProperty("Bridge")
+ TableUpdate<Bridge> getBridgeUpdate() {
+ return getUpdate(Bridge.NAME);
+ }
+
+ public void setBridgeUpdate(TableUpdate<Bridge> bridgeUpdate) {
+ put(Bridge.NAME, bridgeUpdate);
+ }
+
+ @JsonProperty("Port")
+ TableUpdate<Port> getPortUpdate() {
+ return getUpdate(Port.NAME);
+ }
+
+ void setPortUpdate(TableUpdate<Port> portUpdate) {
+ put(Port.NAME, portUpdate);
+ }
+
+ @JsonProperty("Capability")
+ public TableUpdate<Capability> getCapabilityUpdate() {
+ return getUpdate(Capability.NAME);
+ }
+
+ public void setCapabilityUpdate(TableUpdate<Capability> capabilityUpdate) {
+ put(Capability.NAME, capabilityUpdate);
+ }
+
+ @JsonProperty("Controller")
+ public TableUpdate<Controller> getControllerUpdate() {
+ return getUpdate(Controller.NAME);
+ }
+
+ public void setControllerUpdate(TableUpdate<Controller> controllerUpdate) {
+ put(Controller.NAME, controllerUpdate);
+ }
+
+ @JsonProperty("Manager")
+ public TableUpdate<Manager> getManagerUpdate() {
+ return getUpdate(Manager.NAME);
+ }
+
+ public void setManagerUpdate(TableUpdate<Manager> managerUpdate) {
+ put(Manager.NAME, managerUpdate);
+ }
+
+ @JsonProperty("Mirror")
+ public TableUpdate<Mirror> getMirrorUpdate() {
+ return getUpdate(Mirror.NAME);
+ }
+
+ public void setMirrorUpdate(TableUpdate<Mirror> mirrorUpdate) {
+ put(Mirror.NAME, mirrorUpdate);
+ }
+
+ @JsonProperty("NetFlow")
+ public TableUpdate<NetFlow> getNetFlowUpdate() {
+ return getUpdate(NetFlow.NAME);
+ }
+
+ public void setNetFlowUpdate(TableUpdate<NetFlow> netFlowUpdate) {
+ put(NetFlow.NAME, netFlowUpdate);
+ }
+
+ @JsonProperty("Open_vSwitch")
+ public TableUpdate<Open_vSwitch> getOpen_vSwitchUpdate() {
+ return getUpdate(Open_vSwitch.NAME);
+ }
+
+ public void setOpen_vSwitchUpdate(TableUpdate<Open_vSwitch> openVSwitchUpdate) {
+ put(Open_vSwitch.NAME, openVSwitchUpdate);
+ }
+
+ @JsonProperty("QoS")
+ public TableUpdate<Qos> getQosUpdate() {
+ return getUpdate(Qos.NAME);
+ }
+
+ public void setQosUpdate(TableUpdate<Qos> qosUpdate) {
+ put(Qos.NAME, qosUpdate);
+ }
+
+ @JsonProperty("Queue")
+ public TableUpdate<Queue> getQueueUpdate() {
+ return getUpdate(Queue.NAME);
+ }
+
+ public void setQueueUpdate(TableUpdate<Queue> queueUpdate) {
+ put(Queue.NAME, queueUpdate);
+ }
+
+ @JsonProperty("sFlow")
+ public TableUpdate<SFlow> getSFlowUpdate() {
+ return getUpdate(SFlow.NAME);
+ }
+
+ public void setSFlowUpdate(TableUpdate<SFlow> sFlowUpdate) {
+ put(SFlow.NAME, sFlowUpdate);
+ }
+
+ @JsonProperty("SSL")
+ public TableUpdate<SSL> getSSLUpdate() {
+ return getUpdate(SSL.NAME);
+ }
+
+ public void setSSLUpdate(TableUpdate<SSL> sslUpdate) {
+ put(SSL.NAME, sslUpdate);
+ }
+}
package org.opendaylight.ovsdb.table;
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.internal.Table;
-import java.util.HashMap;
-import java.util.Map;
+public class Bridge extends Table<Bridge> {
+ public static final Name<Bridge> NAME = new Name<Bridge>("Bridge"){};
+ public enum Column implements org.opendaylight.ovsdb.table.internal.Column<Bridge>{ controller, fail_mode, name, ports}
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class Bridge {
+ private String name;
+ private OvsDBSet<UUID> ports;
+ private OvsDBSet<UUID> controller;
+ private OvsDBSet<String> datapath_id;
+ private String datapath_type;
+ private OvsDBSet<String> fail_mode;
+ private OvsDBMap<String, String> status;
+ private Boolean stp_enable;
+ private OvsDBMap<String, String> other_config;
+ private OvsDBMap<String, String> external_ids;
- Map<String, BridgeInfo> bridgeInfo = new HashMap<String, BridgeInfo>();
+ public Bridge() {
+ }
- private Map<String, BridgeInfo> getBridgeInfo() {
- return bridgeInfo;
+ @Override
+ public Name<Bridge> getTableName() {
+ return NAME;
}
- private void setBridgeInfo(Map<String, BridgeInfo> bridgeInfo) {
- this.bridgeInfo = bridgeInfo;
+
+ public String getName() {
+ return name;
}
- @JsonAnySetter
- private void add(String key, BridgeInfo value) {
- bridgeInfo.put(key, value);
+ public void setName(String name) {
+ this.name = name;
}
- @JsonAnyGetter
- private Map<String, BridgeInfo> getProperties() {
- return bridgeInfo;
+ public OvsDBSet<UUID> getPorts() {
+ return ports;
}
- @Override
- public String toString() {
- return "Bridge [bridgeInfo=" + bridgeInfo + "]";
+ public void setPorts(OvsDBSet<UUID> ports) {
+ this.ports = ports;
}
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((bridgeInfo == null) ? 0 : bridgeInfo.hashCode());
- return result;
+ public OvsDBSet<UUID> getController() {
+ return controller;
+ }
+
+ public void setController(OvsDBSet<UUID> controller) {
+ this.controller = controller;
+ }
+
+ public OvsDBSet<String> getDatapath_id() {
+ return datapath_id;
+ }
+
+ public void setDatapath_id(OvsDBSet<String> datapath_id) {
+ this.datapath_id = datapath_id;
+ }
+
+ public String getDatapath_type() {
+ return datapath_type;
+ }
+
+ public void setDatapath_type(String datapath_type) {
+ this.datapath_type = datapath_type;
+ }
+
+ public OvsDBSet<String> getFail_mode() {
+ return fail_mode;
+ }
+
+ public void setFail_mode(OvsDBSet<String> fail_mode) {
+ this.fail_mode = fail_mode;
+ }
+
+ public OvsDBMap<String, String> getStatus() {
+ return status;
+ }
+
+ public void setStatus(OvsDBMap<String, String> status) {
+ this.status = status;
+ }
+
+ public Boolean getStp_enable() {
+ return stp_enable;
+ }
+
+ public void setStp_enable(Boolean stp_enable) {
+ this.stp_enable = stp_enable;
+ }
+
+ public OvsDBMap<String, String> getOther_config() {
+ return other_config;
+ }
+
+ public void setOther_config(OvsDBMap<String, String> other_config) {
+ this.other_config = other_config;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Bridge other = (Bridge) obj;
- if (bridgeInfo == null) {
- if (other.bridgeInfo != null)
- return false;
- } else if (!bridgeInfo.equals(other.bridgeInfo))
- return false;
- return true;
- }
-}
\ No newline at end of file
+ public String toString() {
+ return "Bridge [name=" + name + ", ports=" + ports + ", controller="
+ + controller + ", datapath_id=" + datapath_id
+ + ", datapath_type=" + datapath_type + ", fail_mode="
+ + fail_mode + ", status=" + status + ", stp_enable="
+ + stp_enable + ", other_config=" + other_config
+ + ", external_ids=" + external_ids + "]";
+ }
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class BridgeInfo {
- @JsonProperty("new")
- private New unique;
-
- private New getKey() {
- return unique;
- }
-
- private void setNew(New unique) {
- this.unique = unique;
- }
-
- @Override
- public String toString() {
- return "BridgeInfo [new=" + unique + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((unique == null) ? 0 : unique.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- BridgeInfo other = (BridgeInfo) obj;
- if (unique == null) {
- if (other.unique != null)
- return false;
- } else if (!unique.equals(other.unique))
- return false;
- return true;
- }
-}
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class Capability extends Table<Capability> {
+
+ public static final Name<Capability> NAME = new Name<Capability>("Capability") {};
+ private OvsDBMap<String, String> details;
+
+
+ public OvsDBMap<String, String> getDetails() {
+ return details;
+ }
+
+ public void setDetails(OvsDBMap<String, String> details) {
+ this.details = details;
+ }
+
+ @Override
+ public Name<Capability> getTableName() {
+ return NAME;
+ }
+
+ @Override
+ public String toString() {
+ return "Capability [details=" + details + "]";
+ }
+}
package org.opendaylight.ovsdb.table;
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
+import org.opendaylight.ovsdb.table.internal.Table;
-import java.util.HashMap;
-import java.util.Map;
+public class Controller extends Table<Controller> {
-public class Controller {
+ public static final Name<Controller> NAME = new Name<Controller>("Controller") {};
+ private String target;
- Map<String, ControllerInfo> controllerInfo = new HashMap<String, ControllerInfo>();
-
- private Map<String, ControllerInfo> getControllerInfo() {
- return controllerInfo;
- }
-
- private void setControllerInfo(Map<String, ControllerInfo> controllerInfo) {
- this.controllerInfo = controllerInfo;
- }
-
- @JsonAnySetter
- private void add(String key, ControllerInfo value) {
- controllerInfo.put(key, value);
+ public String getTarget() {
+ return target;
}
- @JsonAnyGetter
- private Map<String, ControllerInfo> getProperties() {
- return controllerInfo;
+ public void setTarget(String target) {
+ this.target = target;
}
@Override
- public String toString() {
- return "Controller [controllerInfo=" + controllerInfo + "]";
+ public Name<Controller> getTableName() {
+ return NAME;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((controllerInfo == null) ? 0 : controllerInfo.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Controller other = (Controller) obj;
- if (controllerInfo == null) {
- if (other.controllerInfo != null)
- return false;
- } else if (!controllerInfo.equals(other.controllerInfo))
- return false;
- return true;
+ public String toString() {
+ return "Controller [target=" + target + "]";
}
-}
\ No newline at end of file
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class ControllerInfo {
-
- @JsonProperty("new")
- private New unique;
-
- private New getNew() {
- return unique;
- }
-
- private void setNew(New unique) {
- this.unique = unique;
- }
-
- @Override
- public String toString() {
- return "ControllerInfo [new="
- + unique + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((unique == null) ? 0 : unique.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- ControllerInfo other = (ControllerInfo) obj;
- if (unique == null) {
- if (other.unique != null)
- return false;
- } else if (!unique.equals(other.unique))
- return false;
- return true;
- }
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JsonInclude(JsonInclude.Include.NON_NULL)
-/*
- * Adding as a root reference,table
- * POJOs will likely be called individually
-*/
-
-public class Data {
-
- @JsonProperty("Port")
- private Port Port;
- @JsonProperty("Controller")
- private Controller Controller;
- @JsonProperty("Interface")
- private Interface Interface;
- @JsonProperty("OpenvSwitch")
- private OvsTable OvsTable;
- @JsonProperty("Manager")
- private Manager Manager;
- @JsonProperty("Bridge")
- private Bridge Bridge;
-
- private Port getPort() {
- return Port;
- }
-
- private void setPort(Port port) {
- Port = port;
- }
-
- private Controller getController() {
- return Controller;
- }
-
- private void setController(Controller controller) {
- Controller = controller;
- }
-
- private Interface getInterface() {
- return Interface;
- }
-
- private void setInterface(Interface anInterface) {
- Interface = anInterface;
- }
-
- private OvsTable getOvsTable() {
- return OvsTable;
- }
-
- private void setOvsTable(OvsTable ovsTable) {
- OvsTable = ovsTable;
- }
-
- private Manager getManager() {
- return Manager;
- }
-
- private void setManager(Manager manager) {
- Manager = manager;
- }
-
- private Bridge getBridge() {
- return Bridge;
- }
-
- private void setBridge(Bridge bridge) {
- Bridge = bridge;
- }
-
- @Override
- public String toString() {
- return "Data{" +
- "port=" + Port +
- ", Bridge=" + Bridge +
- ", Interface=" + Interface +
- ", OvsTable=" + OvsTable +
- ", Controller=" + Controller +
- ", Manager=" + Manager +
- '}';
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((Bridge == null) ? 0 : Bridge.hashCode());
- result = prime * result
- + ((Controller == null) ? 0 : Controller.hashCode());
- result = prime * result
- + ((Interface == null) ? 0 : Interface.hashCode());
- result = prime * result + ((Manager == null) ? 0 : Manager.hashCode());
- result = prime * result
- + ((OvsTable == null) ? 0 : OvsTable.hashCode());
- result = prime * result + ((Port == null) ? 0 : Port.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Data other = (Data) obj;
- if (Bridge == null) {
- if (other.Bridge != null)
- return false;
- } else if (!Bridge.equals(other.Bridge))
- return false;
- if (Controller == null) {
- if (other.Controller != null)
- return false;
- } else if (!Controller.equals(other.Controller))
- return false;
- if (Interface == null) {
- if (other.Interface != null)
- return false;
- } else if (!Interface.equals(other.Interface))
- return false;
- if (Manager == null) {
- if (other.Manager != null)
- return false;
- } else if (!Manager.equals(other.Manager))
- return false;
- if (OvsTable == null) {
- if (other.OvsTable != null)
- return false;
- } else if (!OvsTable.equals(other.OvsTable))
- return false;
- if (Port == null) {
- if (other.Port != null)
- return false;
- } else if (!Port.equals(other.Port))
- return false;
- return true;
- }
-
-}
\ No newline at end of file
package org.opendaylight.ovsdb.table;
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.table.internal.Table;
-import java.util.HashMap;
-import java.util.Map;
+public class Interface extends Table<Interface> {
-public class Interface {
+ public static Name<Interface> NAME = new Name<Interface>("Interface") {};
- Map<String, InterfaceInfo> interfaceInfo = new HashMap<String, InterfaceInfo>();
+ private String name;
+ private OvsDBMap<String, String> options;
+ private String type;
+ private OvsDBSet<Integer> ofport;
+ private OvsDBSet<String> mac;
+ private OvsDBMap<String, Integer> statistics;
+ private OvsDBMap<String, String> status;
+ private OvsDBMap<String, String> other_config;
+ private OvsDBMap<String, String> external_ids;
- private Map<String, InterfaceInfo> getInterfaceInfo() {
- return interfaceInfo;
+ public String getName() {
+ return name;
}
- private void setInterfaceInfo(Map<String, InterfaceInfo> interfaceInfo) {
- this.interfaceInfo = interfaceInfo;
+ public void setName(String name) {
+ this.name = name;
}
- @JsonAnySetter
- private void add(String key, InterfaceInfo value) {
- interfaceInfo.put(key, value);
+ public OvsDBMap<String, String> getOptions() {
+ return options;
}
- @JsonAnyGetter
- private Map<String, InterfaceInfo> getProperties() {
- return interfaceInfo;
+ public void setOptions(OvsDBMap<String, String> options) {
+ this.options = options;
}
- @Override
- public String toString() {
- return "Interface [interfaceInfo=" + interfaceInfo + "]";
+ public String getType() {
+ return type;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public OvsDBSet<Integer> getOfport() {
+ return ofport;
+ }
+
+ public void setOfport(OvsDBSet<Integer> ofport) {
+ this.ofport = ofport;
+ }
+
+ public OvsDBSet<String> getMac() {
+ return mac;
+ }
+
+ public void setMac(OvsDBSet<String> mac) {
+ this.mac = mac;
+ }
+
+ public OvsDBMap<String, Integer> getStatistics() {
+ return statistics;
+ }
+
+ public void setStatistics(OvsDBMap<String, Integer> statistics) {
+ this.statistics = statistics;
+ }
+
+ public OvsDBMap<String, String> getStatus() {
+ return status;
+ }
+
+ public void setStatus(OvsDBMap<String, String> status) {
+ this.status = status;
+ }
+
+ public OvsDBMap<String, String> getOther_config() {
+ return other_config;
+ }
+
+ public void setOther_config(OvsDBMap<String, String> other_config) {
+ this.other_config = other_config;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((interfaceInfo == null) ? 0 : interfaceInfo.hashCode());
- return result;
+ public Name<Interface> getTableName() {
+ return NAME;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Interface other = (Interface) obj;
- if (interfaceInfo == null) {
- if (other.interfaceInfo != null)
- return false;
- } else if (!interfaceInfo.equals(other.interfaceInfo))
- return false;
- return true;
- }
-
-}
\ No newline at end of file
+ public String toString() {
+ return "Interface [name=" + name + ", options=" + options + ", type="
+ + type + ", ofport=" + ofport + ", mac=" + mac
+ + ", statistics=" + statistics + ", status=" + status
+ + ", other_config=" + other_config + ", external_ids="
+ + external_ids + "]";
+ }
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class InterfaceInfo {
-
- @JsonProperty("new")
- private New unique;
-
- private New getNew() {
- return unique;
- }
-
- private void setNew(New unique) {
- this.unique = unique;
- }
-
- @Override
- public String toString() {
- return "InterfaceInfo [new=" + unique + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((unique == null) ? 0 : unique.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- InterfaceInfo other = (InterfaceInfo) obj;
- if (unique == null) {
- if (other.unique != null)
- return false;
- } else if (!unique.equals(other.unique))
- return false;
- return true;
- }
-}
\ No newline at end of file
package org.opendaylight.ovsdb.table;
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
+import org.opendaylight.ovsdb.table.internal.Table;
-import java.util.HashMap;
-import java.util.Map;
+public class Manager extends Table<Manager> {
-public class Manager {
+ public static final Name<Manager> NAME = new Name<Manager>("Manager") {};
+ private String target;
- Map<String, ManagerInfo> managerInfo = new HashMap<String, ManagerInfo>();
-
- private Map<String, ManagerInfo> getManagerInfo() {
- return managerInfo;
- }
-
- private void setManagerInfo(Map<String, ManagerInfo> managerInfo) {
- this.managerInfo = managerInfo;
- }
-
- @JsonAnySetter
- private void add(String key, ManagerInfo value) {
- managerInfo.put(key, value);
+ public String getTarget() {
+ return target;
}
- @JsonAnyGetter
- private Map<String, ManagerInfo> getProperties() {
- return managerInfo;
+ public void setTarget(String target) {
+ this.target = target;
}
@Override
- public String toString() {
- return "Manager [managerInfo=" + managerInfo + "]";
+ public Name<Manager> getTableName() {
+ return NAME;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((managerInfo == null) ? 0 : managerInfo.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Manager other = (Manager) obj;
- if (managerInfo == null) {
- if (other.managerInfo != null)
- return false;
- } else if (!managerInfo.equals(other.managerInfo))
- return false;
- return true;
+ public String toString() {
+ return "Manager [target=" + target + "]";
}
-}
\ No newline at end of file
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class ManagerInfo {
- @JsonProperty("new")
- private New unique;
-
- private New getNew() {
- return unique;
- }
-
- private void setNew(New unique) {
- this.unique = unique;
- }
-
- @Override
- public String toString() {
- return "ManagerInfo [new=" + unique + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((unique == null) ? 0 : unique.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- ManagerInfo other = (ManagerInfo) obj;
- if (unique == null) {
- if (other.unique != null)
- return false;
- } else if (!unique.equals(other.unique))
- return false;
- return true;
- }
-}
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class Mirror extends Table<Mirror> {
+
+ public static final Name<Mirror> NAME = new Name<Mirror>("Mirror") {};
+ private String name;
+ private OvsDBSet<UUID> select_src_port;
+ private OvsDBSet<UUID> select_dst_port;
+ private OvsDBSet<Integer> select_vlan;
+ private OvsDBSet<UUID> output_port;
+ private OvsDBSet<Integer> output_vlan;
+ private OvsDBMap<String, Integer> statistics;
+ private OvsDBMap<String, String> external_ids;
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public OvsDBSet<UUID> getSelect_src_port() {
+ return select_src_port;
+ }
+
+ public void setSelect_src_port(OvsDBSet<UUID> select_src_port) {
+ this.select_src_port = select_src_port;
+ }
+
+ public OvsDBSet<UUID> getSelect_dst_port() {
+ return select_dst_port;
+ }
+
+ public void setSelect_dst_port(OvsDBSet<UUID> select_dst_port) {
+ this.select_dst_port = select_dst_port;
+ }
+
+ public OvsDBSet<Integer> getSelect_vlan() {
+ return select_vlan;
+ }
+
+ public void setSelect_vlan(OvsDBSet<Integer> select_vlan) {
+ this.select_vlan = select_vlan;
+ }
+
+ public OvsDBSet<UUID> getOutput_port() {
+ return output_port;
+ }
+
+ public void setOutput_port(OvsDBSet<UUID> output_port) {
+ this.output_port = output_port;
+ }
+
+ public OvsDBSet<Integer> getOutput_vlan() {
+ return output_vlan;
+ }
+
+ public void setOutput_vlan(OvsDBSet<Integer> output_vlan) {
+ this.output_vlan = output_vlan;
+ }
+
+ public OvsDBMap<String, Integer> getStatistics() {
+ return statistics;
+ }
+
+ public void setStatistics(OvsDBMap<String, Integer> statistics) {
+ this.statistics = statistics;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
+ }
+
+ @Override
+ public Name<Mirror> getTableName() {
+ return NAME;
+ }
+
+ @Override
+ public String toString() {
+ return "Mirror [name=" + name + ", select_src_port=" + select_src_port
+ + ", select_dst_port=" + select_dst_port + ", select_vlan="
+ + select_vlan + ", output_port=" + output_port
+ + ", output_vlan=" + output_vlan + ", statistics=" + statistics
+ + ", external_ids=" + external_ids + "]";
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class NetFlow extends Table<NetFlow> {
+
+ public static final Name<NetFlow> NAME = new Name<NetFlow>("NetFlow") {};
+ private OvsDBSet<String> targets;
+
+ public OvsDBSet<String> getTargets() {
+ return targets;
+ }
+
+ public void setTargets(OvsDBSet<String> targets) {
+ this.targets = targets;
+ }
+
+ @Override
+ public Name<NetFlow> getTableName() {
+ return NAME;
+ }
+
+ @Override
+ public String toString() {
+ return "NetFlow [targets=" + targets + "]";
+ }
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-import java.util.List;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JsonInclude(JsonInclude.Include.NON_NULL)
-
-public class New {
-
- @JsonProperty("interfaces")
- private List<String> interfaces;
- @JsonProperty("name")
- private String name;
- @JsonProperty("fake_bridge")
- private boolean fake_bridge;
- @JsonProperty("type")
- private String type;
- @JsonProperty("ovs_version")
- private String ovs_version;
- @JsonProperty("uuid")
- private String uuid;
- @JsonProperty("target")
- private String target;
- @JsonProperty("is_connected")
- private boolean is_connected;
-
- private List<String> getInterfaces() {
- return interfaces;
- }
-
- private void setInterfaces(List<String> interfaces) {
- this.interfaces = interfaces;
- }
-
- private String getName() {
- return name;
- }
-
- private void setName(String name) {
- this.name = name;
- }
-
- private boolean isFake_bridge() {
- return fake_bridge;
- }
-
- private void setFake_bridge(boolean fake_bridge) {
- this.fake_bridge = fake_bridge;
- }
-
- private String getType() {
- return type;
- }
-
- private void setType(String type) {
- this.type = type;
- }
-
- private String getOvs_version() {
- return ovs_version;
- }
-
- private void setOvs_version(String ovs_version) {
- this.ovs_version = ovs_version;
- }
-
- private String getUuid() {
- return uuid;
- }
-
- private void setUuid(String uuid) {
- this.uuid = uuid;
- }
-
- private String getTarget() {
- return target;
- }
-
- private void setTarget(String target) {
- this.target = target;
- }
-
- private boolean isIs_connected() {
- return is_connected;
- }
-
- private void setIs_connected(boolean is_connected) {
- this.is_connected = is_connected;
- }
-
- @Override
- public String toString() {
- return "New{" +
- "interfaces=" + interfaces +
- ", name='" + name + '\'' +
- ", fake_bridge=" + fake_bridge +
- ", type='" + type + '\'' +
- ", ovs_version='" + ovs_version + '\'' +
- ", uuid='" + uuid + '\'' +
- ", target='" + target + '\'' +
- ", is_connected=" + is_connected +
- '}';
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + (fake_bridge ? 1231 : 1237);
- result = prime * result
- + ((interfaces == null) ? 0 : interfaces.hashCode());
- result = prime * result + (is_connected ? 1231 : 1237);
- result = prime * result + ((name == null) ? 0 : name.hashCode());
- result = prime * result
- + ((ovs_version == null) ? 0 : ovs_version.hashCode());
- result = prime * result + ((target == null) ? 0 : target.hashCode());
- result = prime * result + ((type == null) ? 0 : type.hashCode());
- result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- New other = (New) obj;
- if (fake_bridge != other.fake_bridge)
- return false;
- if (interfaces == null) {
- if (other.interfaces != null)
- return false;
- } else if (!interfaces.equals(other.interfaces))
- return false;
- if (is_connected != other.is_connected)
- return false;
- if (name == null) {
- if (other.name != null)
- return false;
- } else if (!name.equals(other.name))
- return false;
- if (ovs_version == null) {
- if (other.ovs_version != null)
- return false;
- } else if (!ovs_version.equals(other.ovs_version))
- return false;
- if (target == null) {
- if (other.target != null)
- return false;
- } else if (!target.equals(other.target))
- return false;
- if (type == null) {
- if (other.type != null)
- return false;
- } else if (!type.equals(other.type))
- return false;
- if (uuid == null) {
- if (other.uuid != null)
- return false;
- } else if (!uuid.equals(other.uuid))
- return false;
- return true;
- }
-}
-
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class Open_vSwitch extends Table<Open_vSwitch> {
+
+ public static final Name<Open_vSwitch> NAME = new Name<Open_vSwitch>("Open_vSwitch"){};
+
+ private OvsDBSet<UUID> bridges;
+ private Integer curr_cfg;
+ private OvsDBSet<String> db_version;
+ private OvsDBSet<UUID> manager_options;
+ private OvsDBMap<String, String> status;
+ private Integer next_cfg;
+ private OvsDBSet<String> ovs_version;
+ private OvsDBSet<UUID> ssl;
+ private OvsDBSet<String> system_type;
+ private OvsDBSet<String> system_version;
+ private OvsDBMap<String, UUID> capabilities;
+ private OvsDBMap<String, String> other_config;
+ private OvsDBMap<String, String> external_ids;
+ private OvsDBMap<String, Integer> statistics;
+
+ public Open_vSwitch() {
+ }
+
+ @Override
+ public Name<Open_vSwitch> getTableName() {
+ return NAME;
+ }
+
+ public OvsDBSet<UUID> getBridges() {
+ return bridges;
+ }
+
+ public void setBridges(OvsDBSet<UUID> bridges) {
+ this.bridges = bridges;
+ }
+
+ public Integer getCurr_cfg() {
+ return curr_cfg;
+ }
+
+ public void setCurr_cfg(Integer curr_cfg) {
+ this.curr_cfg = curr_cfg;
+ }
+
+ public OvsDBSet<String> getDb_version() {
+ return db_version;
+ }
+
+ public void setDb_version(OvsDBSet<String> db_version) {
+ this.db_version = db_version;
+ }
+
+ public OvsDBSet<UUID> getManager_options() {
+ return manager_options;
+ }
+
+ public void setManager_options(OvsDBSet<UUID> manager_options) {
+ this.manager_options = manager_options;
+ }
+
+ public OvsDBMap<String, String> getStatus() {
+ return status;
+ }
+
+ public void setStatus(OvsDBMap<String, String> status) {
+ this.status = status;
+ }
+
+ public Integer getNext_cfg() {
+ return next_cfg;
+ }
+
+ public void setNext_cfg(Integer next_cfg) {
+ this.next_cfg = next_cfg;
+ }
+
+ public OvsDBSet<String> getOvs_version() {
+ return ovs_version;
+ }
+
+ public void setOvs_version(OvsDBSet<String> ovs_version) {
+ this.ovs_version = ovs_version;
+ }
+
+ public OvsDBSet<UUID> getSsl() {
+ return ssl;
+ }
+
+ public void setSsl(OvsDBSet<UUID> ssl) {
+ this.ssl = ssl;
+ }
+
+ public OvsDBSet<String> getSystem_type() {
+ return system_type;
+ }
+
+ public void setSystem_type(OvsDBSet<String> system_type) {
+ this.system_type = system_type;
+ }
+
+ public OvsDBSet<String> getSystem_version() {
+ return system_version;
+ }
+
+ public void setSystem_version(OvsDBSet<String> system_version) {
+ this.system_version = system_version;
+ }
+
+ public OvsDBMap<String, UUID> getCapabilities() {
+ return capabilities;
+ }
+
+ public void setCapabilities(OvsDBMap<String, UUID> capabilities) {
+ this.capabilities = capabilities;
+ }
+
+ public OvsDBMap<String, String> getOther_config() {
+ return other_config;
+ }
+
+ public void setOther_config(OvsDBMap<String, String> other_config) {
+ this.other_config = other_config;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
+ }
+
+ public OvsDBMap<String, Integer> getStatistics() {
+ return statistics;
+ }
+
+ public void setStatistics(OvsDBMap<String, Integer> statistics) {
+ this.statistics = statistics;
+ }
+
+ @Override
+ public String toString() {
+ return "Open_vSwitch [bridges=" + bridges + ", curr_cfg=" + curr_cfg
+ + ", db_version=" + db_version + ", manager_options="
+ + manager_options + ", status=" + status + ", next_cfg="
+ + next_cfg + ", ovs_version=" + ovs_version + ", ssl=" + ssl
+ + ", system_type=" + system_type + ", system_version="
+ + system_version + ", capabilities=" + capabilities
+ + ", other_config=" + other_config + ", external_ids="
+ + external_ids + ", statistics=" + statistics + "]";
+ }
+
+ public enum Column implements org.opendaylight.ovsdb.table.internal.Column<Open_vSwitch>{ controller, fail_mode, name, ports}
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
-
-import java.util.HashMap;
-import java.util.Map;
-
-
-public class OvsTable {
-
- Map<String, OvsTableInfo> ovstableInfo = new HashMap<String, OvsTableInfo>();
-
- private Map<String, OvsTableInfo> getOvstableInfo() {
- return ovstableInfo;
- }
-
- private void setOvstableInfo(Map<String, OvsTableInfo> ovstableInfo) {
- this.ovstableInfo = ovstableInfo;
- }
-
- @JsonAnySetter
- private void add(String key, OvsTableInfo value) {
- ovstableInfo.put(key, value);
- }
-
- @JsonAnyGetter
- private Map<String, OvsTableInfo> getProperties() {
- return ovstableInfo;
- }
-
- @Override
- public String toString() {
- return "OvsTable [ovstableInfo=" + ovstableInfo + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((ovstableInfo == null) ? 0 : ovstableInfo.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- OvsTable other = (OvsTable) obj;
- if (ovstableInfo == null) {
- if (other.ovstableInfo != null)
- return false;
- } else if (!ovstableInfo.equals(other.ovstableInfo))
- return false;
- return true;
- }
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class OvsTableInfo {
-
- @JsonProperty("new")
- private New unique;
-
- private New getNew() {
- return unique;
- }
-
- private void setNew(New unique) {
- this.unique = unique;
- }
-
- @Override
- public String toString() {
- return "OvsTableInfo [new=" + unique + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((unique == null) ? 0 : unique.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- OvsTableInfo other = (OvsTableInfo) obj;
- if (unique == null) {
- if (other.unique != null)
- return false;
- } else if (!unique.equals(other.unique))
- return false;
- return true;
- }
-
-}
\ No newline at end of file
package org.opendaylight.ovsdb.table;
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
+import java.math.BigInteger;
-import java.util.HashMap;
-import java.util.Map;
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.internal.Table;
-public class Port {
+public class Port extends Table<Port> {
- Map<String, PortInfo> portInfo = new HashMap<String, PortInfo>();
+ public static final Name<Port> NAME = new Name<Port>("Port") {};
- private Map<String, PortInfo> getPortInfo() {
- return portInfo;
+ private String name;
+ private OvsDBSet<BigInteger> tag;
+ private OvsDBSet<BigInteger> trunks;
+ private OvsDBSet<UUID> interfaces;
+ private OvsDBSet<String> mac;
+ private OvsDBSet<UUID> qos;
+ private OvsDBMap<String, String> other_config;
+ private OvsDBMap<String, String> external_ids;
+
+ public Port() {
}
- private void setPortInfo(Map<String, PortInfo> portInfo) {
- this.portInfo = portInfo;
+ public String getName() {
+ return name;
}
- @JsonAnySetter
- private void add(String key, PortInfo value) {
- portInfo.put(key, value);
+ public void setName(String name) {
+ this.name = name;
}
- @JsonAnyGetter
- private Map<String, PortInfo> getProperties() {
- return portInfo;
+ public OvsDBSet<BigInteger> getTag() {
+ return tag;
}
- @Override
- public String toString() {
- return "Port [portInfo=" + portInfo + "]";
+ public void setTag(OvsDBSet<BigInteger> tag) {
+ this.tag = tag;
+ }
+
+ public OvsDBSet<BigInteger> getTrunks() {
+ return trunks;
+ }
+
+ public void setTrunks(OvsDBSet<BigInteger> trunks) {
+ this.trunks = trunks;
+ }
+
+ public OvsDBSet<UUID> getInterfaces() {
+ return interfaces;
+ }
+
+ public void setInterfaces(OvsDBSet<UUID> interfaces) {
+ this.interfaces = interfaces;
+ }
+
+ public OvsDBSet<String> getMac() {
+ return mac;
+ }
+
+ public void setMac(OvsDBSet<String> mac) {
+ this.mac = mac;
+ }
+
+ public OvsDBSet<UUID> getQos() {
+ return qos;
+ }
+
+ public void setQos(OvsDBSet<UUID> qos) {
+ this.qos = qos;
+ }
+
+ public OvsDBMap<String, String> getOther_config() {
+ return other_config;
+ }
+
+ public void setOther_config(OvsDBMap<String, String> other_config) {
+ this.other_config = other_config;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((portInfo == null) ? 0 : portInfo.hashCode());
- return result;
+ public Name<Port> getTableName() {
+ return NAME;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Port other = (Port) obj;
- if (portInfo == null) {
- if (other.portInfo != null)
- return false;
- } else if (!portInfo.equals(other.portInfo))
- return false;
- return true;
- }
-}
\ No newline at end of file
+ public String toString() {
+ return "Port [name=" + name + ", tag=" + tag + ", trunks=" + trunks
+ + ", interfaces=" + interfaces + ", mac=" + mac + ", qos="
+ + qos + ", other_config=" + other_config + ", external_ids="
+ + external_ids + "]";
+ }
+
+ public enum Column implements org.opendaylight.ovsdb.table.internal.Column<Port> {
+ interfaces,
+ name,
+ tag,
+ trunks,
+ mac,
+ qos,
+ statistics,
+ other_config,
+ external_ids}
+}
+++ /dev/null
-package org.opendaylight.ovsdb.table;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class PortInfo {
-
- @JsonProperty("new")
- private New unique;
-
- private New getNew() {
- return unique;
- }
-
- private void setNew(New unique) {
- this.unique = unique;
- }
-
- @Override
- public String toString() {
- return "PortInfo [new=" + unique + "]";
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((unique == null) ? 0 : unique.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- PortInfo other = (PortInfo) obj;
- if (unique == null) {
- if (other.unique != null)
- return false;
- } else if (!unique.equals(other.unique))
- return false;
- return true;
- }
-}
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import java.math.BigInteger;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class Qos extends Table<Qos> {
+
+ public static final Name<Qos> NAME = new Name<Qos>("QoS") {};
+
+ private OvsDBMap<Integer, UUID> queues;
+ private Integer type;
+ private OvsDBMap<String, String> other_config;
+ private OvsDBMap<String, String> external_ids;
+
+ public Qos() {
+ }
+
+ public OvsDBMap<Integer, UUID> getQueues() {
+ return queues;
+ }
+
+ public void setQueues(OvsDBMap<Integer, UUID> queues) {
+ this.queues = queues;
+ }
+
+ public Integer getType() {
+ return type;
+ }
+
+ public void setType(Integer type) {
+ this.type = type;
+ }
+
+ public OvsDBMap<String, String> getOther_config() {
+ return other_config;
+ }
+
+ public void setOther_config(OvsDBMap<String, String> other_config) {
+ this.other_config = other_config;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
+ }
+
+ @Override
+ public Name<Qos> getTableName() {
+ return NAME;
+ }
+
+ @Override
+ public String toString() {
+ return "Qos [queues=" + queues + ", type=" + type + ", other_config="
+ + other_config + ", external_ids=" + external_ids + "]";
+ }
+
+ public enum Column implements org.opendaylight.ovsdb.table.internal.Column<Qos> {
+ queues,
+ type,
+ other_config,
+ external_ids}
+}
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import java.math.BigInteger;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class Queue extends Table<Queue> {
+
+ public static final Name<Queue> NAME = new Name<Queue>("Queue") {};
+
+ private OvsDBSet<Integer> dscp;
+ private OvsDBMap<String, String> other_config;
+ private OvsDBMap<String, String> external_ids;
+
+ public Queue() {
+ }
+
+ public OvsDBSet<Integer> getDscp() {
+ return dscp;
+ }
+
+ public void setDscp(OvsDBSet<Integer> dscp) {
+ this.dscp = dscp;
+ }
+
+ public OvsDBMap<String, String> getOther_config() {
+ return other_config;
+ }
+
+ public void setOther_config(OvsDBMap<String, String> other_config) {
+ this.other_config = other_config;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
+ }
+
+ @Override
+ public Name<Queue> getTableName() {
+ return NAME;
+ }
+
+ @Override
+ public String toString() {
+ return "Queue [dscp=" + dscp + ", other_config=" + other_config
+ + ", external_ids=" + external_ids + "]";
+ }
+
+ public enum Column implements org.opendaylight.ovsdb.table.internal.Column<Queue> {
+ dscp,
+ other_config,
+ external_ids}
+}
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.table.internal.Table;
+
+public class SFlow extends Table<SFlow> {
+
+ public static final Name<SFlow> NAME = new Name<SFlow>("sFlow") {};
+ private OvsDBSet<String> agent;
+ private OvsDBSet<String> targets;
+ private OvsDBMap<String, String> external_ids;
+ private OvsDBSet<Integer> header;
+ private OvsDBSet<Integer> polling;
+ private OvsDBSet<Integer> sampling;
+
+ public OvsDBSet<String> getTargets() {
+ return targets;
+ }
+
+ public void setTargets(OvsDBSet<String> targets) {
+ this.targets = targets;
+ }
+
+ @Override
+ public Name<SFlow> getTableName() {
+ return NAME;
+ }
+
+ public OvsDBSet<String> getAgent() {
+ return agent;
+ }
+
+ public void setAgent(OvsDBSet<String> agent) {
+ this.agent = agent;
+ }
+
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
+ }
+
+ public OvsDBSet<Integer> getHeader() {
+ return header;
+ }
+
+ public void setHeader(OvsDBSet<Integer> header) {
+ this.header = header;
+ }
+
+ public OvsDBSet<Integer> getPolling() {
+ return polling;
+ }
+
+ public void setPolling(OvsDBSet<Integer> polling) {
+ this.polling = polling;
+ }
+
+ public OvsDBSet<Integer> getSampling() {
+ return sampling;
+ }
+
+ public void setSampling(OvsDBSet<Integer> sampling) {
+ this.sampling = sampling;
+ }
+
+ @Override
+ public String toString() {
+ return "SFlow [agent=" + agent + ", targets=" + targets
+ + ", external_ids=" + external_ids + ", header=" + header
+ + ", polling=" + polling + ", sampling=" + sampling + "]";
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.table;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.table.internal.Table;
+import org.opendaylight.ovsdb.table.internal.Table.Name;
+
+public class SSL extends Table<SSL> {
+
+ public static final Name<SSL> NAME = new Name<SSL>("SSL") {};
+ private String ca_cert;
+ private Boolean bootstrap_ca_cert;
+ private String certificate;
+ private String private_key;
+ private OvsDBMap<String, String> external_ids;
+
+ public String getCa_cert() {
+ return ca_cert;
+ }
+ public void setCa_cert(String ca_cert) {
+ this.ca_cert = ca_cert;
+ }
+ public OvsDBMap<String, String> getExternal_ids() {
+ return external_ids;
+ }
+ public void setExternal_ids(OvsDBMap<String, String> external_ids) {
+ this.external_ids = external_ids;
+ }
+ public Boolean getBootstrap_ca_cert() {
+ return bootstrap_ca_cert;
+ }
+ public void setBootstrap_ca_cert(Boolean bootstrap_ca_cert) {
+ this.bootstrap_ca_cert = bootstrap_ca_cert;
+ }
+ public String getCertificate() {
+ return certificate;
+ }
+ public void setCertificate(String certificate) {
+ this.certificate = certificate;
+ }
+ public String getPrivate_key() {
+ return private_key;
+ }
+ public void setPrivate_key(String private_key) {
+ this.private_key = private_key;
+ }
+
+ @Override
+ public Name<SSL> getTableName() {
+ return NAME;
+ }
+
+ @Override
+ public String toString() {
+ return "SSL [ca_cert=" + ca_cert + ", bootstrap_ca_cert="
+ + bootstrap_ca_cert + ", certificate=" + certificate
+ + ", private_key=" + private_key + ", external_ids="
+ + external_ids + "]";
+ }
+
+ public enum Column implements org.opendaylight.ovsdb.table.internal.Column<SSL> {
+ ca_cert,
+ bootstrap_ca_cert,
+ certificate,
+ private_key,
+ external_ids}
+}
--- /dev/null
+package org.opendaylight.ovsdb.table.internal;
+
+
+public interface Column<E> {
+}
--- /dev/null
+package org.opendaylight.ovsdb.table.internal;
+
+public abstract class Table<E extends Table> {
+
+ public abstract Name<E> getTableName();
+ public abstract String toString();
+
+ public static abstract class Name<E extends Table> {
+ String name;
+
+ protected Name(String name) {
+ this.name = name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public String toString() {
+ return "Table:" + name;
+ }
+ }
+}
--- /dev/null
+package org.opendaylight.ovsdb.table.internal;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.opendaylight.ovsdb.table.*;
+
+public class Tables {
+ public static List<Table> tables = new ArrayList<Table>();
+ static {
+ tables.add(new Bridge());
+ tables.add(new Port());
+ tables.add(new Capability());
+ tables.add(new Interface());
+ tables.add(new Controller());
+ tables.add(new Manager());
+ tables.add(new Mirror());
+ tables.add(new NetFlow());
+ tables.add(new Open_vSwitch());
+ tables.add(new Qos());
+ tables.add(new Queue());
+ tables.add(new SFlow());
+ tables.add(new SSL());
+ }
+ public static List<Table> getTables() {
+ return tables;
+ }
+}
--- /dev/null
+[
+ "Open_vSwitch",
+ null,
+ {
+ "Bridge": {
+ "columns": [
+ "controller",
+ "fail_mode",
+ "name",
+ "ports"
+ ]
+ },
+ "Controller": {
+ "columns": [
+ "is_connected",
+ "target"
+ ]
+ },
+ "Interface": {
+ "columns": [
+ "name",
+ "options",
+ "type"
+ ]
+ },
+ "Manager": {
+ "columns": [
+ "is_connected",
+ "target"
+ ]
+ },
+ "Open_vSwitch": {
+ "columns": [
+ "bridges",
+ "cur_cfg",
+ "manager_options",
+ "ovs_version"
+ ]
+ },
+ "Port": {
+ "columns": [
+ "interfaces",
+ "name",
+ "tag",
+ "trunks"
+ ]
+ }
+ }
+]
\ No newline at end of file
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+
+import java.util.concurrent.TimeUnit;
+
+public class NettyBootStrapper {
+
+ EventLoopGroup bossGroup = null;
+ EventLoopGroup workerGroup = null;
+ ChannelFuture f = null;
+
+ public ChannelFuture startServer(int localPort, final ChannelHandler... handlers) throws Exception {
+ // Configure the server.
+ bossGroup = new NioEventLoopGroup();
+ workerGroup = new NioEventLoopGroup();
+ ServerBootstrap b = new ServerBootstrap();
+ b.group(bossGroup, workerGroup)
+ .channel(NioServerSocketChannel.class)
+ .option(ChannelOption.SO_BACKLOG, 100)
+ .localAddress(localPort)
+ .childOption(ChannelOption.TCP_NODELAY, true)
+ .childHandler(new ChannelInitializer<SocketChannel>() {
+
+ @Override
+ public void initChannel(SocketChannel ch) throws Exception {
+ for (ChannelHandler handler : handlers) {
+ ch.pipeline().addLast(handler);
+ }
+ }
+ });
+
+ // Start the server.
+ f = b.bind().sync();
+ return f;
+ }
+
+ public void stopServer() throws InterruptedException {
+ try {
+
+ ChannelFuture channelFuture = f.channel().closeFuture();
+ channelFuture.get(1000, TimeUnit.MILLISECONDS);
+ if (!channelFuture.isDone()) {
+ f.channel().unsafe().closeForcibly();
+ }
+
+ bossGroup.shutdownGracefully();
+ workerGroup.shutdownGracefully();
+
+ // Wait until all threads are terminated.
+ bossGroup.terminationFuture().sync();
+ workerGroup.terminationFuture().sync();
+ } catch (Exception e) {
+ //ignore
+ }
+ }
+
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.ListenableFuture;
+
+import io.netty.channel.ChannelHandler;
+import io.netty.handler.codec.string.StringEncoder;
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
+import io.netty.util.CharsetUtil;
+import junit.framework.TestCase;
+
+import org.junit.Test;
+import org.opendaylight.controller.sal.connection.ConnectionConstants;
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.ovsdb.database.DatabaseSchema;
+import org.opendaylight.ovsdb.internal.ConnectionService;
+import org.opendaylight.ovsdb.internal.MessageHandler;
+import org.opendaylight.ovsdb.internal.jsonrpc.JsonRpcEndpoint;
+import org.opendaylight.ovsdb.internal.ovsdb.OVSDB;
+import org.opendaylight.ovsdb.message.EchoResponse;
+import org.opendaylight.ovsdb.message.MonitorRequestBuilder;
+import org.opendaylight.ovsdb.message.TableUpdates;
+import org.opendaylight.ovsdb.table.internal.Table;
+import org.opendaylight.ovsdb.table.internal.Tables;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+
+public class OVSDBNettyFactoryTest {
+
+ @Test
+ public void testSome() throws InterruptedException, ExecutionException {
+
+ //todo(ashwin): this is a big mess without a bean factory like spring or guice
+ ConnectionService service = new ConnectionService();
+ ObjectMapper objectMapper = new ObjectMapper();
+ objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+ JsonRpcEndpoint factory = new JsonRpcEndpoint(objectMapper, service);
+ JsonRpcServiceBinderHandler binderHandler = new JsonRpcServiceBinderHandler(factory);
+
+ List<ChannelHandler> _handlers = Lists.newArrayList();
+ _handlers.add(new LoggingHandler(LogLevel.INFO));
+ _handlers.add(new JsonRpcDecoder(100000));
+ _handlers.add(new StringEncoder(CharsetUtil.UTF_8));
+ _handlers.add(binderHandler);
+
+ service.init();
+ service.setHandlers(_handlers);
+ String identifier = "TEST";
+ Node.NodeIDType.registerIDType("OVS", String.class);
+ Map<ConnectionConstants, String> params = new HashMap<ConnectionConstants, String>();
+ params.put(ConnectionConstants.ADDRESS, "192.168.56.101");
+ params.put(ConnectionConstants.PORT, "6634");
+ Node node = service.connect(identifier, params);
+ if (node != null) {
+ binderHandler.setNode(node);
+ }
+
+ OVSDB ovsdb = factory.getClient(node, OVSDB.class);
+
+ //GET DB-SCHEMA
+ List<String> dbNames = Arrays.asList("Open_vSwitch");
+ ListenableFuture<DatabaseSchema> dbSchemaF = ovsdb.get_schema(dbNames);
+ DatabaseSchema databaseSchema = dbSchemaF.get();
+ System.out.println(databaseSchema);
+
+ //TEST MONITOR
+ MonitorRequestBuilder monitorReq = new MonitorRequestBuilder();
+ for (Table table : Tables.getTables()) {
+ monitorReq.monitor(table);
+ }
+
+ ListenableFuture<TableUpdates> monResponse = ovsdb.monitor(monitorReq);
+ System.out.println("Monitor Request sent :");
+ TableUpdates updates = monResponse.get();
+
+ Set<Table.Name> available = updates.availableUpdates();
+ for (Table.Name name : available) {
+ System.out.println(name.getName() +":"+ updates.getUpdate(name).toString());
+ }
+
+ // TEST ECHO
+ ListenableFuture<List<String>> some = ovsdb.echo();
+ Object s = some.get();
+ System.out.printf("Result of echo is %s \n", s);
+
+ // TEST ECHO REQUEST/REPLY
+
+ Thread.sleep(10);
+ service.disconnect(node);
+ }
+
+}
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
+import junit.framework.TestCase;
+import org.codehaus.jackson.map.ObjectMapper;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.*;
+import java.net.Socket;
+
+public class TestClient extends TestCase {
+
+ String serverurl = "127.0.0.1";
+ int serverport = 8080;
+
+ NettyBootStrapper bootstrapper = new NettyBootStrapper();
+ JsonRpcDecoder jsonRpcDecoder = new JsonRpcDecoder(100000);
+
+ public void setupServer() throws Exception {
+ bootstrapper.startServer(serverport,
+ jsonRpcDecoder,
+ new LoggingHandler(LogLevel.DEBUG));
+ }
+
+ public void shutDownServer() throws InterruptedException {
+ bootstrapper.stopServer();
+ }
+
+ @Test
+ public void testBasicFlow() throws Exception {
+ setupServer();
+ Socket socket = socket = new Socket(serverurl, serverport);
+
+ OutputStream outputStream = socket.getOutputStream();
+
+ int records = 20;
+
+ for (int i = 0; i < records; i++) {
+ writeJson(outputStream, 1);
+ writePartialFirst(outputStream);
+ outputStream.flush();
+ Thread.sleep(10);
+ writePartialLast(outputStream);
+ }
+ socket.close();
+ shutDownServer();
+
+ assertEquals("mismatch in records processed", records * 2, jsonRpcDecoder.getRecordsRead());
+ }
+
+ static int counter = 0;
+
+ /*
+ create and a json of specified size
+ */
+ private void writeJson(OutputStream outputStream, int times) throws IOException {
+ outputStream.write("{".getBytes("UTF-8"));
+ for (int i = 0 ; i < times; i ++) {
+ counter++;
+ String s = ",\"key1"+ counter +"\":\"planet of apes" + counter +
+ "\", \"key2"+ counter +"\":{\"k1\":\"ovs-db rocks the world\"}";
+ outputStream.write(s.substring(i == 0 ? 1 : 0).getBytes("UTF-8"));
+ System.out.println("data counter = " + counter);
+ }
+ outputStream.write("}".getBytes("UTF-8"));
+ }
+
+ /*
+ writes a partial json and flush to simulate the case where netty gets half the message and
+ has to frame it accordingly.
+ */
+ private void writePartialFirst(OutputStream outputStream) throws IOException {
+ counter++;
+ String s = " {\"part"+ counter+"\":";
+ outputStream.write(s.getBytes("UTF-8"));
+ System.out.println("partial first half counter = " + counter);
+ }
+
+ /*
+ finishes the json started by writePartialFirst
+ */
+ private void writePartialLast(OutputStream outputStream) throws IOException {
+ String s = "\"val"+ counter+"\"}";
+ outputStream.write(s.getBytes("UTF-8"));
+ System.out.println("partial second half counter = " + counter);
+ }
+
+}
+
--- /dev/null
+package org.opendaylight.ovsdb.internal.jsonrpc;
+
+import com.google.common.reflect.Invokable;
+import com.google.common.reflect.TypeToken;
+import com.google.common.util.concurrent.ListenableFuture;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+
+public class TestTokens {
+
+ public ListenableFuture<String> getString() {
+ return null;
+ }
+
+
+ public static void main(String[] args) throws NoSuchMethodException {
+ Method getString = TestTokens.class.getMethod("getString");
+ Invokable<?, Object> from = Invokable.from(getString);
+ //TypeToken<?> get = from.getReturnType().resolveType(ListenableFuture.class.getMethod("get").getGenericReturnType());
+ TypeToken<?> get = from.getReturnType().resolveType(ListenableFuture.class.getMethod("get").getGenericReturnType());
+ System.out.println(get.getRawType());
+
+
+ TypeToken<?> get1 = TypeToken.of(getString.getGenericReturnType()).resolveType(ListenableFuture.class.getMethod("get").getGenericReturnType());
+ System.out.println("get1 = " + get1);
+ }
+
+}
--- /dev/null
+package org.opendaylight.ovsdb.message;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Function;
+import com.google.common.collect.Ordering;
+import com.google.common.io.InputSupplier;
+import com.google.common.io.Resources;
+
+import junit.framework.TestCase;
+
+import org.opendaylight.ovsdb.datatype.OvsDBMap;
+import org.opendaylight.ovsdb.datatype.OvsDBSet;
+import org.opendaylight.ovsdb.datatype.UUID;
+import org.opendaylight.ovsdb.table.Bridge;
+import org.opendaylight.ovsdb.table.Interface;
+import org.opendaylight.ovsdb.table.Port;
+import org.opendaylight.ovsdb.table.internal.Table;
+import org.sonatype.inject.Nullable;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class MonitorResponseTest extends TestCase {
+
+ public void testDeser() throws IOException {
+ URL resource = Resources.getResource(MonitorResponseTest.class, "monitor_response1.json");
+ InputSupplier<InputStream> inputStreamInputSupplier = Resources.newInputStreamSupplier(resource);
+ InputStream input = inputStreamInputSupplier.getInput();
+ ObjectMapper mapper = new ObjectMapper();
+ mapper.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.ANY);
+ TableUpdates updates = mapper.readValue(input, TableUpdates.class);
+
+ Set<Table.Name> available = updates.availableUpdates();
+ for (Table.Name name : available) {
+ if (Bridge.NAME.equals(name)) {
+ verifyBridge(updates);
+ } else if (Port.NAME.equals(name)) {
+ veriftyPort(updates);
+ } else if (Interface.NAME.equals(name)) {
+ verifyInterface(updates);
+ }
+ }
+ }
+
+ private void verifyInterface(TableUpdates updates) {
+ TableUpdate<Interface> update = updates.getUpdate(Interface.NAME);
+ for (TableUpdate.Row<Interface> interfaceRow : update.getRows()) {
+ System.out.println("interfaceRow = " + interfaceRow);
+ Interface aNew = interfaceRow.getNew();
+ if (null != aNew) {
+ OvsDBMap<String, String> options = aNew.getOptions();
+ if (options != null) {
+ for (Map.Entry<String, String> optE : options.entrySet()) {
+ System.out.println("optE.getKey() = " + optE.getKey());
+ System.out.println("optE.getValue() = " + optE.getValue());
+ }
+ }
+ }
+ }
+ }
+
+ private void verifyBridge(TableUpdates updates) {
+ TableUpdate<Bridge> update = updates.getUpdate(Bridge.NAME);
+ for (TableUpdate.Row<Bridge> row : update.getRows()) {
+ assertEquals("788de61c-0e4f-43d8-a068-259e75aabbba", row.getId());
+ Bridge bridge = row.getNew();
+ assertNotNull(bridge);
+ OvsDBSet<UUID> ports = bridge.getPorts();
+ assertEquals(2, ports.size());
+ List<UUID> uuids = Ordering.usingToString().sortedCopy(ports);
+ assertEquals("f6018e7a-7ca5-4e72-a744-a9b434f47011", uuids.get(0).toString());
+ assertEquals("fe3c89fd-2ff3-44d8-9f27-f9c7ac2a693d", uuids.get(1).toString());
+ bridge = row.getOld();
+ assertNull(bridge);
+ }
+ }
+
+ private void veriftyPort(TableUpdates updates) {
+ TableUpdate<Port> update = updates.getUpdate(Port.NAME);
+ Collection<TableUpdate.Row<Port>> rows = update.getRows();
+ assertEquals(2, rows.size());
+ List<TableUpdate.Row<Port>> sorted = Ordering.natural().onResultOf(new Function<TableUpdate.Row<Port>, String>() {
+ @Override
+ public String apply(@Nullable org.opendaylight.ovsdb.message.TableUpdate.Row<Port> input) {
+ return input.getId();
+ }
+ }).sortedCopy(rows);
+
+ TableUpdate.Row<Port> portRow = sorted.get(0);
+ assertEquals("f6018e7a-7ca5-4e72-a744-a9b434f47011", portRow.getId());
+ Port port = portRow.getNew();
+ assertNotNull(port);
+ List<UUID> interfaces = Ordering.usingToString().sortedCopy(port.getInterfaces());
+ assertEquals("13548b08-dca3-4d4b-9e9b-f50c237dcb9e", interfaces.get(0).toString());
+ port = portRow.getOld();
+ assertNull(port);
+
+ portRow = sorted.get(1);
+ assertEquals("fe3c89fd-2ff3-44d8-9f27-f9c7ac2a693d", portRow.getId());
+ port = portRow.getNew();
+ assertNotNull(port);
+ interfaces = Ordering.usingToString().sortedCopy(port.getInterfaces());
+ assertEquals("88ae29fb-8c91-41a9-a14f-a74126e790c0", interfaces.get(0).toString());
+ port = portRow.getOld();
+ assertNull(port);
+ }
+
+}
--- /dev/null
+{
+ "Bridge": {
+ "788de61c-0e4f-43d8-a068-259e75aabbba": {
+ "new": {
+ "controller": [
+ "set",
+ []
+ ],
+ "fail_mode": [
+ "set",
+ []
+ ],
+ "name": "br0",
+ "ports": [
+ "set",
+ [
+ [
+ "uuid",
+ "f6018e7a-7ca5-4e72-a744-a9b434f47011"
+ ],
+ [
+ "uuid",
+ "fe3c89fd-2ff3-44d8-9f27-f9c7ac2a693d"
+ ]
+ ]
+ ]
+ }
+ }
+ },
+ "Port": {
+ "f6018e7a-7ca5-4e72-a744-a9b434f47011": {
+ "new": {
+ "interfaces": [
+ "uuid",
+ "13548b08-dca3-4d4b-9e9b-f50c237dcb9e"
+ ],
+ "name": "vif0",
+ "tag": [
+ "set",
+ []
+ ],
+ "trunks": [
+ "set",
+ []
+ ]
+ }
+ },
+ "fe3c89fd-2ff3-44d8-9f27-f9c7ac2a693d": {
+ "new": {
+ "interfaces": [
+ "uuid",
+ "88ae29fb-8c91-41a9-a14f-a74126e790c0"
+ ],
+ "name": "br0",
+ "tag": [
+ "set",
+ []
+ ],
+ "trunks": [
+ "set",
+ []
+ ]
+ }
+ }
+ },
+ "Interface": {
+ "13548b08-dca3-4d4b-9e9b-f50c237dcb9e": {
+ "new": {
+ "name": "vif0",
+ "options": [
+ "map",
+ [["remote_ip","192.168.1.165"]]
+ ],
+ "type": ""
+ }
+ },
+ "88ae29fb-8c91-41a9-a14f-a74126e790c0": {
+ "new": {
+ "name": "br0",
+ "options": [
+ "map",
+ []
+ ],
+ "type": "internal"
+ }
+ }
+ }
+
+}
--- /dev/null
+{
+ "Bridge": {
+ "788de61c-0e4f-43d8-a068-259e75aabbba": {
+ "new": {
+ "controller": [
+ "set",
+ []
+ ],
+ "fail_mode": [
+ "set",
+ []
+ ],
+ "name": "br0",
+ "ports": [
+ "set",
+ [
+ [
+ "uuid",
+ "f6018e7a-7ca5-4e72-a744-a9b434f47011"
+ ],
+ [
+ "uuid",
+ "fe3c89fd-2ff3-44d8-9f27-f9c7ac2a693d"
+ ]
+ ]
+ ]
+ }
+ }
+ },
+ "Interface": {
+ "13548b08-dca3-4d4b-9e9b-f50c237dcb9e": {
+ "new": {
+ "name": "vif0",
+ "options": [
+ "map",
+ []
+ ],
+ "type": ""
+ }
+ },
+ "88ae29fb-8c91-41a9-a14f-a74126e790c0": {
+ "new": {
+ "name": "br0",
+ "options": [
+ "map",
+ []
+ ],
+ "type": "internal"
+ }
+ }
+ },
+ "Open_vSwitch": {
+ "987c42d0-eab0-43d9-a32b-4246973706c2": {
+ "new": {
+ "bridges": [
+ "uuid",
+ "788de61c-0e4f-43d8-a068-259e75aabbba"
+ ],
+ "cur_cfg": 7,
+ "manager_options": [
+ "set",
+ []
+ ],
+ "ovs_version": "1.4.3"
+ }
+ }
+ },
+ "Port": {
+ "f6018e7a-7ca5-4e72-a744-a9b434f47011": {
+ "new": {
+ "interfaces": [
+ "uuid",
+ "13548b08-dca3-4d4b-9e9b-f50c237dcb9e"
+ ],
+ "name": "vif0",
+ "tag": [
+ "set",
+ []
+ ],
+ "trunks": [
+ "set",
+ []
+ ]
+ }
+ },
+ "fe3c89fd-2ff3-44d8-9f27-f9c7ac2a693d": {
+ "new": {
+ "interfaces": [
+ "uuid",
+ "88ae29fb-8c91-41a9-a14f-a74126e790c0"
+ ],
+ "name": "br0",
+ "tag": [
+ "set",
+ []
+ ],
+ "trunks": [
+ "set",
+ []
+ ]
+ }
+ }
+ }
+}
Code Review / ovsdb.git / commitdiff