From 13d05bc8458758ee39cb829098241e89616717ee Mon Sep 17 00:00:00 2001 From: Ashlee Young Date: Wed, 9 Sep 2015 22:15:21 -0700 Subject: ONOS checkin based on commit tag e796610b1f721d02f9b0e213cf6f7790c10ecd60 Change-Id: Ife8810491034fe7becdba75dda20de4267bd15cd --- framework/src/onos/ovsdb/api/pom.xml | 56 + .../ovsdb/controller/DefaultEventSubject.java | 126 +++ .../onosproject/ovsdb/controller/EventSubject.java | 23 + .../onosproject/ovsdb/controller/OvsdbBridge.java | 87 ++ .../ovsdb/controller/OvsdbBridgeName.java | 71 ++ .../ovsdb/controller/OvsdbClientService.java | 231 ++++ .../ovsdb/controller/OvsdbConstant.java | 68 ++ .../ovsdb/controller/OvsdbController.java | 68 ++ .../ovsdb/controller/OvsdbDatapathId.java | 68 ++ .../onosproject/ovsdb/controller/OvsdbEvent.java | 74 ++ .../ovsdb/controller/OvsdbEventListener.java | 28 + .../ovsdb/controller/OvsdbEventSubject.java | 75 ++ .../onosproject/ovsdb/controller/OvsdbIfaceId.java | 68 ++ .../onosproject/ovsdb/controller/OvsdbNodeId.java | 83 ++ .../ovsdb/controller/OvsdbNodeListener.java | 36 + .../onosproject/ovsdb/controller/OvsdbPort.java | 86 ++ .../ovsdb/controller/OvsdbPortName.java | 70 ++ .../ovsdb/controller/OvsdbPortNumber.java | 68 ++ .../ovsdb/controller/OvsdbPortType.java | 70 ++ .../ovsdb/controller/OvsdbRowStore.java | 69 ++ .../onosproject/ovsdb/controller/OvsdbStore.java | 71 ++ .../ovsdb/controller/OvsdbTableStore.java | 67 ++ .../onosproject/ovsdb/controller/OvsdbTunnel.java | 125 ++ .../ovsdb/controller/OvsdbTunnelName.java | 69 ++ .../controller/driver/DefaultOvsdbClient.java | 1188 ++++++++++++++++++++ .../ovsdb/controller/driver/OvsdbAgent.java | 42 + .../controller/driver/OvsdbProviderService.java | 81 ++ .../ovsdb/controller/driver/package-info.java | 20 + .../onosproject/ovsdb/controller/package-info.java | 20 + 29 files changed, 3208 insertions(+) create mode 100644 framework/src/onos/ovsdb/api/pom.xml create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/DefaultEventSubject.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/EventSubject.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbController.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbDatapathId.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEvent.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventListener.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventSubject.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbIfaceId.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeId.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeListener.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPort.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortName.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortNumber.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortType.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbRowStore.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbStore.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTableStore.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnel.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnelName.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbAgent.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbProviderService.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/package-info.java create mode 100644 framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/package-info.java (limited to 'framework/src/onos/ovsdb/api') diff --git a/framework/src/onos/ovsdb/api/pom.xml b/framework/src/onos/ovsdb/api/pom.xml new file mode 100644 index 00000000..c1808794 --- /dev/null +++ b/framework/src/onos/ovsdb/api/pom.xml @@ -0,0 +1,56 @@ + + + + 4.0.0 + + org.onosproject + onos-ovsdb + 1.3.0-SNAPSHOT + + onos-ovsdb-api + bundle + + ONOS OVSDB plugin API + + + junit + junit + test + + + commons-pool + commons-pool + + + io.netty + netty-transport + + + io.netty + netty-transport-native-epoll + ${netty4.version} + + + org.onosproject + onos-ovsdb-rfc + ${project.version} + + + + diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/DefaultEventSubject.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/DefaultEventSubject.java new file mode 100644 index 00000000..5d9134b4 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/DefaultEventSubject.java @@ -0,0 +1,126 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; + +import java.util.Objects; +import java.util.Set; + +import org.onlab.packet.IpAddress; +import org.onlab.packet.MacAddress; + +/** + * This class is default event subject that implements OvsdbEventSubject. + */ +public class DefaultEventSubject implements OvsdbEventSubject { + private final MacAddress mac; + private final Set ips; + private final OvsdbPortName portname; + private final OvsdbPortNumber portnumber; + private final OvsdbDatapathId dpid; + private final OvsdbPortType portType; + private final OvsdbIfaceId ifaceid; + + /** + * Creates an end-station event subject using the supplied information. + * + * @param mac host MAC address + * @param ips host MAC ips + * @param portname port name + * @param portnumber port number + * @param dpid ovs dpid + * @param portType port type + * @param ifaceid vm ifaceid + */ + public DefaultEventSubject(MacAddress mac, Set ips, + OvsdbPortName portname, OvsdbPortNumber portnumber, OvsdbDatapathId dpid, + OvsdbPortType portType, OvsdbIfaceId ifaceid) { + super(); + this.mac = mac; + this.ips = ips; + this.portname = portname; + this.portnumber = portnumber; + this.dpid = dpid; + this.portType = portType; + this.ifaceid = ifaceid; + } + + @Override + public MacAddress hwAddress() { + return mac; + } + + @Override + public Set ipAddress() { + return ips; + } + + @Override + public OvsdbPortName portName() { + return portname; + } + + @Override + public OvsdbPortNumber portNumber() { + return portnumber; + } + + @Override + public OvsdbPortType portType() { + return portType; + } + + @Override + public OvsdbDatapathId dpid() { + return dpid; + } + + @Override + public OvsdbIfaceId ifaceid() { + return ifaceid; + } + + @Override + public int hashCode() { + return Objects.hash(mac, portname, portnumber, dpid, portType, ifaceid); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof DefaultEventSubject) { + final DefaultEventSubject other = (DefaultEventSubject) obj; + return Objects.equals(this.mac, other.mac) + && Objects.equals(this.portname, other.portname) + && Objects.equals(this.portnumber, other.portnumber) + && Objects.equals(this.dpid, other.dpid) + && Objects.equals(this.portType, other.portType) + && Objects.equals(this.ifaceid, other.ifaceid); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("mac", mac).add("portname", portname) + .add("portnumber", portnumber).add("portType", portType) + .add("ipAddresses", ips).add("dpid", dpid).add("ifaceid", ifaceid) + .toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/EventSubject.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/EventSubject.java new file mode 100644 index 00000000..6a067244 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/EventSubject.java @@ -0,0 +1,23 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +/** + * Represents for a entity that carry important information for listener. + */ +public interface EventSubject { + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java new file mode 100644 index 00000000..1ee0a367 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java @@ -0,0 +1,87 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +/** + * The class representing a ovsdb bridge. This class is immutable. + */ +public final class OvsdbBridge { + + private final OvsdbBridgeName bridgeName; + private final OvsdbDatapathId datapathId; + + /** + * Constructor from a OvsdbBridgeName bridgeName and a OvsdbDatapathId + * datapathId. + * + * @param bridgeName the bridgeName to use + * @param datapathId the datapathId to use + */ + public OvsdbBridge(OvsdbBridgeName bridgeName, OvsdbDatapathId datapathId) { + checkNotNull(bridgeName, "bridgeName is not null"); + checkNotNull(datapathId, "datapathId is not null"); + this.bridgeName = bridgeName; + this.datapathId = datapathId; + } + + /** + * Gets the bridge name of the bridge. + * + * @return the bridge name of the bridge + */ + public OvsdbBridgeName bridgeName() { + return bridgeName; + } + + /** + * Gets the datapathId of the bridge. + * + * @return datapathId the datapathId to use + */ + public OvsdbDatapathId datapathId() { + return datapathId; + } + + @Override + public int hashCode() { + return Objects.hash(bridgeName, datapathId); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbBridge) { + final OvsdbBridge otherOvsdbBridge = (OvsdbBridge) obj; + return Objects.equals(this.bridgeName, otherOvsdbBridge.bridgeName) + && Objects.equals(this.datapathId, + otherOvsdbBridge.datapathId); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("bridgeName", bridgeName.value()) + .add("datapathId", datapathId.value()).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java new file mode 100644 index 00000000..daedff5f --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java @@ -0,0 +1,71 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +/** + * The class representing a bridge name. This class is immutable. + */ +public final class OvsdbBridgeName { + + private final String value; + + /** + * Constructor from a String bridge name. + * + * @param value the bridge name to use + */ + public OvsdbBridgeName(String value) { + checkNotNull(value, "value is not null"); + this.value = value; + } + + /** + * Gets the value of the bridge name. + * + * @return the value of the bridge name + */ + public String value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbBridgeName) { + final OvsdbBridgeName otherBridgeName = (OvsdbBridgeName) obj; + return Objects.equals(this.value, otherBridgeName.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java new file mode 100644 index 00000000..ab88a24e --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java @@ -0,0 +1,231 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import java.util.List; +import java.util.Set; + +import org.onlab.packet.IpAddress; + +import org.onosproject.ovsdb.rfc.jsonrpc.OvsdbRPC; +import org.onosproject.ovsdb.rfc.message.OperationResult; +import org.onosproject.ovsdb.rfc.message.TableUpdates; +import org.onosproject.ovsdb.rfc.notation.Row; +import org.onosproject.ovsdb.rfc.operations.Operation; +import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; + +import com.google.common.util.concurrent.ListenableFuture; + +/** + * Represents to provider facing side of a node. + */ +public interface OvsdbClientService extends OvsdbRPC { + /** + * Gets the node identifier. + * + * @return node identifier + */ + OvsdbNodeId nodeId(); + + /** + * Creates the configuration for the tunnel. + * + * @param srcIp source IP address + * @param dstIp destination IP address + */ + void createTunnel(IpAddress srcIp, IpAddress dstIp); + + /** + * Drops the configuration for the tunnel. + * + * @param srcIp source IP address + * @param dstIp destination IP address + */ + void dropTunnel(IpAddress srcIp, IpAddress dstIp); + + /** + * Gets tunnels of the node. + * + * @return set of tunnels; empty if no tunnel is find + */ + Set getTunnels(); + + /** + * Creates a bridge. + * + * @param bridgeName bridge name + */ + void createBridge(String bridgeName); + + /** + * Drops a bridge. + * + * @param bridgeName bridge name + */ + void dropBridge(String bridgeName); + + /** + * Gets bridges of the node. + * + * @return set of bridges; empty if no bridge is find + */ + Set getBridges(); + + /** + * Creates a port. + * + * @param bridgeName bridge name + * @param portName port name + */ + void createPort(String bridgeName, String portName); + + /** + * Drops a port. + * + * @param bridgeName bridge name + * @param portName port name + */ + void dropPort(String bridgeName, String portName); + + /** + * Gets ports of the bridge. + * + * @return set of ports; empty if no ports is find + */ + Set getPorts(); + + /** + * Checks if the node is still connected. + * + * @return true if the node is still connected + */ + boolean isConnected(); + + /** + * Gets the Bridge uuid. + * + * @param bridgeName bridge name + * @return bridge uuid, empty if no uuid is find + */ + String getBridgeUuid(String bridgeName); + + /** + * Gets the Port uuid. + * + * @param portName port name + * @param bridgeUuid bridge uuid + * @return port uuid, empty if no uuid is find + */ + String getPortUuid(String portName, String bridgeUuid); + + /** + * Gets the Interface uuid. + * + * @param portUuid port uuid + * @param portName port name + * @return interface uuid, empty if no uuid is find + */ + String getInterfaceUuid(String portUuid, String portName); + + /** + * Gets the Controller uuid. + * + * @param controllerName controller name + * @param controllerTarget controller target + * @return controller uuid, empty if no uuid is find + */ + String getControllerUuid(String controllerName, String controllerTarget); + + /** + * Gets the Ovs uuid. + * + * @param dbName database name + * @return ovs uuid, empty if no uuid is find + */ + String getOvsUuid(String dbName); + + /** + * Gets the ovsdb database schema. + * + * @param dbName database name + * @return database schema + */ + ListenableFuture getOvsdbSchema(String dbName); + + /** + * Gets the ovsdb table updates. + * + * @param dbName database name + * @param id random uuid + * @return table updates + */ + ListenableFuture monitorTables(String dbName, String id); + + /** + * Gets the ovsdb config operation result. + * + * @param dbName database name + * @param operations the list of operations + * @return operation results + */ + ListenableFuture> transactConfig(String dbName, + List operations); + + /** + * Gets the ovsdb database schema from local. + * + * @param dbName database name + * @return database schema + */ + DatabaseSchema getDatabaseSchema(String dbName); + + /** + * Gets the ovsdb row from the local ovsdb store. + * + * @param dbName database name + * @param tableName table name + * @param uuid row uuid + * @return row ovsdb row + */ + Row getRow(String dbName, String tableName, String uuid); + + /** + * Removes the ovsdb row from the local ovsdb store. + * + * @param dbName database name + * @param tableName table name + * @param uuid row uuid + */ + void removeRow(String dbName, String tableName, String uuid); + + /** + * Updates the local ovsdb store. + * + * @param dbName database name + * @param tableName table name + * @param uuid row uuid + * @param row ovsdb row + */ + void updateOvsdbStore(String dbName, String tableName, String uuid, Row row); + + /** + * Gets ovsdb local ports. + * + * @param ifaceids the ifaceid that needed + * @return ovsdb ports + */ + Set getLocalPorts(Iterable ifaceids); +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java new file mode 100644 index 00000000..c1133bbd --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java @@ -0,0 +1,68 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +/** + * Ovsdb related constants. + */ +public final class OvsdbConstant { + + /** + * Default constructor. + * + * The constructor is private to prevent creating an instance of this + * utility class. + */ + private OvsdbConstant() { + } + + /** Ovsdb database Open_vSwitch. */ + public static final String DATABASENAME = "Open_vSwitch"; + + /** Ovsdb table Bridge. */ + public static final String BRIDGE = "Bridge"; + + /** Ovsdb table Interface. */ + public static final String INTERFACE = "Interface"; + + /** Ovsdb table Controller. */ + public static final String CONTROLLER = "Controller"; + + /** Ovsdb table Port. */ + public static final String PORT = "Port"; + + /** Ovsdb bridge name. */ + public static final String INTEGRATION_BRIDGE = "br-int"; + + /** Ovsdb vxlan tunnel type. */ + public static final String TYPEVXLAN = "vxlan"; + + /** Openflow version. */ + public static final String OPENFLOW13 = "OpenFlow13"; + + /** Ovsdb external_id_interface_id.. */ + public static final String EXTERNAL_ID_INTERFACE_ID = "iface-id"; + + /** Ovsdb external_id_vm_mac. */ + public static final String EXTERNAL_ID_VM_MAC = "attached-mac"; + + /** Openflow port. */ + public static final int OFPORT = 6633; + + /** Ovsdb port. */ + public static final int OVSDBPORT = 6640; + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbController.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbController.java new file mode 100644 index 00000000..9e245240 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbController.java @@ -0,0 +1,68 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import java.util.List; + +/** + * Abstraction of an ovsdb controller. Serves as a one stop shop for obtaining + * OvsdbNode and (un)register listeners on ovsdb events and ovsdb node events. + */ +public interface OvsdbController { + + /** + * Adds Node Event Listener. + * + * @param listener node listener + */ + void addNodeListener(OvsdbNodeListener listener); + + /** + * Removes Node Event Listener. + * + * @param listener node listener + */ + void removeNodeListener(OvsdbNodeListener listener); + + /** + * Adds ovsdb event listener. + * + * @param listener event listener + */ + void addOvsdbEventListener(OvsdbEventListener listener); + + /** + * Removes ovsdb event listener. + * + * @param listener event listener + */ + void removeOvsdbEventListener(OvsdbEventListener listener); + + /** + * Gets all the nodes information. + * + * @return the list of node id + */ + List getNodeIds(); + + /** + * Gets a ovsdb client by node identifier. + * + * @param nodeId node identifier + * @return OvsdbClient ovsdb node information + */ + OvsdbClientService getOvsdbClient(OvsdbNodeId nodeId); +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbDatapathId.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbDatapathId.java new file mode 100644 index 00000000..1a2d8366 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbDatapathId.java @@ -0,0 +1,68 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; +import java.util.Objects; + +/** + * The class representing a datapathid. This class is immutable. + */ +public final class OvsdbDatapathId { + private final String value; + + /** + * Constructor from a String datapathid. + * + * @param value the datapathid to use + */ + public OvsdbDatapathId(String value) { + checkNotNull(value, "value is not null"); + this.value = value; + } + + /** + * Gets the value of the datapathid. + * + * @return the value of the datapathid + */ + public String value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbDatapathId) { + final OvsdbDatapathId otherDatapathId = (OvsdbDatapathId) obj; + return Objects.equals(this.value, otherDatapathId.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEvent.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEvent.java new file mode 100644 index 00000000..35fac7bc --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEvent.java @@ -0,0 +1,74 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; + +/** + * The abstract event of ovsdb. + */ +public final class OvsdbEvent { + + public enum Type { + /** + * Signifies that a new ovs port update has been detected. + */ + PORT_ADDED, + /** + * Signifies that a ovs port has been removed. + */ + PORT_REMOVED + } + + private final Type type; + private final S subject; + + /** + * Creates an event of a given type and for the specified event subject. + * + * @param type event type + * @param subject event subject + */ + public OvsdbEvent(Type type, S subject) { + this.type = type; + this.subject = subject; + } + + /** + * Returns the type of the event. + * + * @return event type + */ + public Type type() { + return type; + } + + /** + * Returns the subject of the event. + * + * @return subject to which this event pertains + */ + public S subject() { + return subject; + } + + @Override + public String toString() { + return toStringHelper(this).add("type", type()) + .add("subject", subject()).toString(); + } + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventListener.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventListener.java new file mode 100644 index 00000000..b7bf2b55 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventListener.java @@ -0,0 +1,28 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +/** + * Allows for providers interested in ovsdb events to be notified. + */ +public interface OvsdbEventListener { + /** + * Handles the ovsdb event. + * + * @param event ovsdb event + */ + void handle(OvsdbEvent event); +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventSubject.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventSubject.java new file mode 100644 index 00000000..263027f2 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbEventSubject.java @@ -0,0 +1,75 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import java.util.Set; + +import org.onlab.packet.IpAddress; +import org.onlab.packet.MacAddress; + +/** + * Represents for a entity that carry important information for listener. + */ +public interface OvsdbEventSubject extends EventSubject { + /** + * Returns the MAC address associated with this host (NIC). + * + * @return the MAC address of this host + */ + MacAddress hwAddress(); + + /** + * Returns the IP address associated with this host's MAC. + * + * @return host IP address + */ + Set ipAddress(); + + /** + * Returns the Port name associated with the host. + * + * @return port name + */ + OvsdbPortName portName(); + + /** + * Returns the Port number associated with the host. + * + * @return port number + */ + OvsdbPortNumber portNumber(); + + /** + * Returns the Port type associated with the host. + * + * @return port type + */ + OvsdbPortType portType(); + + /** + * Returns the Ovs dpid associated with the host. + * + * @return Ovs dpid + */ + OvsdbDatapathId dpid(); + + /** + * Returns the vm ifaceid associated with the host. + * + * @return vm ifaceid + */ + OvsdbIfaceId ifaceid(); +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbIfaceId.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbIfaceId.java new file mode 100644 index 00000000..b0535d21 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbIfaceId.java @@ -0,0 +1,68 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; +import java.util.Objects; + +/** + * The class representing a ifaceid. This class is immutable. + */ +public class OvsdbIfaceId { + private final String value; + + /** + * Constructor from a String ifaceid. + * + * @param value the ifaceid to use + */ + public OvsdbIfaceId(String value) { + checkNotNull(value, "value is not null"); + this.value = value; + } + + /** + * Gets the value of the ifaceid. + * + * @return the value of the ifaceid + */ + public String value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbIfaceId) { + final OvsdbIfaceId otherIfaceId = (OvsdbIfaceId) obj; + return Objects.equals(this.value, otherIfaceId.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeId.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeId.java new file mode 100644 index 00000000..2c1a440b --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeId.java @@ -0,0 +1,83 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +import org.onlab.packet.IpAddress; + +/** + * The class representing a OpenStack Compute or Network nodeId. This class is + * immutable. + */ +public final class OvsdbNodeId { + private static final String SCHEME = "ovsdb"; + private final String nodeId; + private final String ipAddress; + + /** + * Creates a new node identifier from a IpAddress ipAddress, a long port. + * + * @param ipAddress node IP address + * @param port node port + */ + public OvsdbNodeId(IpAddress ipAddress, long port) { + checkNotNull(ipAddress, "ipAddress is not null"); + this.ipAddress = ipAddress.toString(); + this.nodeId = ipAddress + ":" + port; + } + + @Override + public int hashCode() { + return Objects.hash(nodeId); + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof OvsdbNodeId)) { + return false; + } + + OvsdbNodeId otherNodeId = (OvsdbNodeId) other; + + return Objects.equals(otherNodeId.nodeId, this.nodeId); + } + + @Override + public String toString() { + return SCHEME + ":" + nodeId; + } + + /** + * Gets the value of the NodeId. + * + * @return the value of the NodeId. + */ + public String nodeId() { + return SCHEME + ":" + nodeId; + } + + /** + * Get the IP address of the node. + * + * @return the IP address of the node + */ + public String getIpAddress() { + return ipAddress; + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeListener.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeListener.java new file mode 100644 index 00000000..ca732ef9 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbNodeListener.java @@ -0,0 +1,36 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +/** + * Allows for providers interested in node events to be notified. + */ +public interface OvsdbNodeListener { + + /** + * Notifies that the node was added. + * + * @param nodeId the node where the event occurred + */ + void nodeAdded(OvsdbNodeId nodeId); + + /** + * Notifies that the node was removed. + * + * @param nodeId the node where the event occurred + */ + void nodeRemoved(OvsdbNodeId nodeId); +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPort.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPort.java new file mode 100644 index 00000000..3c04f6a5 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPort.java @@ -0,0 +1,86 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +/** + * The class representing a ovsdb port. This class is immutable. + */ +public final class OvsdbPort { + + private final OvsdbPortNumber portNumber; + private final OvsdbPortName portName; + + /** + * Constructor from a OvsdbPortNumber portNumber, OvsdbPortName portName. + * + * @param portNumber the portNumber to use + * @param portName the portName to use + */ + public OvsdbPort(OvsdbPortNumber portNumber, OvsdbPortName portName) { + checkNotNull(portNumber, "portNumber is not null"); + checkNotNull(portName, "portName is not null"); + this.portNumber = portNumber; + this.portName = portName; + } + + /** + * Gets the port number of the port. + * + * @return the port number of the port + */ + public OvsdbPortNumber portNumber() { + return portNumber; + } + + /** + * Gets the port name of the port. + * + * @return the port name of the port + */ + public OvsdbPortName portName() { + return portName; + } + + @Override + public int hashCode() { + return Objects.hash(portNumber, portName); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbPort) { + final OvsdbPort otherOvsdbPort = (OvsdbPort) obj; + return Objects.equals(this.portNumber, otherOvsdbPort.portNumber) + && Objects.equals(this.portName, otherOvsdbPort.portName); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this) + .add("portNumber", String.valueOf(portNumber.value())) + .add("portName", portName.value()).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortName.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortName.java new file mode 100644 index 00000000..aa0f55b0 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortName.java @@ -0,0 +1,70 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +/** + * The class representing a port number. This class is immutable. + */ +public final class OvsdbPortName { + + private final String value; + + /** + * Constructor from a String port name. + * + * @param value the port name to use + */ + public OvsdbPortName(String value) { + checkNotNull(value, "value is not null"); + this.value = value; + } + + /** + * Gets the value of the port name. + * + * @return the value of the port name + */ + public String value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbPortName) { + final OvsdbPortName otherOvsdbPortName = (OvsdbPortName) obj; + return Objects.equals(this.value, otherOvsdbPortName.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortNumber.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortNumber.java new file mode 100644 index 00000000..9c57b5df --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortNumber.java @@ -0,0 +1,68 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; + +import java.util.Objects; + +/** + * The class representing a port number. This class is immutable. + */ +public final class OvsdbPortNumber { + + private final long value; + + /** + * Constructor from a long port number. + * + * @param value the port number to use + */ + public OvsdbPortNumber(long value) { + this.value = value; + } + + /** + * Gets the value of the port number. + * + * @return the value of the port number + */ + public long value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbPortNumber) { + final OvsdbPortNumber ovsdbPortNumber = (OvsdbPortNumber) obj; + return Objects.equals(this.value, ovsdbPortNumber.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortType.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortType.java new file mode 100644 index 00000000..bf05fc73 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbPortType.java @@ -0,0 +1,70 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +/** + * The class representing a port type. This class is immutable. + */ +public class OvsdbPortType { + + private final String value; + + /** + * Constructor from a String port type. + * + * @param value the port type to use + */ + public OvsdbPortType(String value) { + checkNotNull(value, "value is not null"); + this.value = value; + } + + /** + * Gets the value of the port type. + * + * @return the value of the port type + */ + public String value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbPortType) { + final OvsdbPortType otherOvsdbPortType = (OvsdbPortType) obj; + return Objects.equals(this.value, otherOvsdbPortType.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbRowStore.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbRowStore.java new file mode 100644 index 00000000..bec0e2e9 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbRowStore.java @@ -0,0 +1,69 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import java.util.concurrent.ConcurrentMap; + +import org.onosproject.ovsdb.rfc.notation.Row; + +import com.google.common.collect.Maps; + +/** + * The class representing a table data. + */ +public class OvsdbRowStore { + + private final ConcurrentMap rowStore = Maps.newConcurrentMap(); + + /** + * Gets the row. + * + * @param uuid the key of the rowStore + * @return row the row of the rowStore + */ + public Row getRow(String uuid) { + return rowStore.get(uuid); + } + + /** + * Inserts a row to rowStore. + * + * @param uuid key of the row + * @param row a row of the table + */ + public void insertRow(String uuid, Row row) { + rowStore.put(uuid, row); + } + + /** + * Deletes a row to rowStore. + * + * @param uuid key of the row + */ + public void deleteRow(String uuid) { + rowStore.remove(uuid); + } + + /** + * Gets the rowStore. + * + * @return rowStore + */ + public ConcurrentMap getRowStore() { + return rowStore; + } + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbStore.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbStore.java new file mode 100644 index 00000000..56704908 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbStore.java @@ -0,0 +1,71 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import java.util.concurrent.ConcurrentMap; + +import com.google.common.collect.Maps; + +/** + * The cache for local ovsdb database. + */ +public class OvsdbStore { + + private final ConcurrentMap ovsdbStore = Maps.newConcurrentMap(); + + /** + * Gets the OvsdbTableStore. + * + * @param dbName ovsdb database name + * @return tableStore OvsdbTableStore + */ + public OvsdbTableStore getOvsdbTableStore(String dbName) { + OvsdbTableStore tableStore = ovsdbStore.get(dbName); + if (tableStore == null) { + return null; + } + return tableStore; + } + + /** + * Create or Update a value to ovsdbStore. + * + * @param dbName ovsdb database name + * @param tableStore a database tableStore. + */ + public void createOrUpdateOvsdbStore(String dbName, OvsdbTableStore tableStore) { + ovsdbStore.put(dbName, tableStore); + } + + /** + * Drops a value to rowStore. + * + * @param dbName ovsdb database name + */ + public void dropOvsdbStore(String dbName) { + ovsdbStore.remove(dbName); + } + + /** + * Gets the ovsdbStore. + * + * @return ovsdbStore + */ + public ConcurrentMap getOvsdbStore() { + return ovsdbStore; + } + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTableStore.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTableStore.java new file mode 100644 index 00000000..1d9146eb --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTableStore.java @@ -0,0 +1,67 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import java.util.concurrent.ConcurrentMap; + +import com.google.common.collect.Maps; + +/** + * The class representing a database data. + */ +public class OvsdbTableStore { + + private final ConcurrentMap tableStore = Maps.newConcurrentMap(); + + /** + * Gets the ovsdbRowStore. + * + * @param tableName a ovsdb table name + * @return OvsdbRowStore the data of the table + */ + public OvsdbRowStore getRows(String tableName) { + return tableStore.get(tableName); + } + + /** + * Create or update a value to tableStore. + * + * @param tableName key of the tableName + * @param rowStore a row of the table + */ + public void createOrUpdateTable(String tableName, OvsdbRowStore rowStore) { + tableStore.put(tableName, rowStore); + } + + /** + * Drops a value to table data. + * + * @param tableName key of the tableName + */ + public void dropTable(String tableName) { + tableStore.remove(tableName); + } + + /** + * Gets the tableStore. + * + * @return tableStore + */ + public ConcurrentMap getTableStore() { + return tableStore; + } + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnel.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnel.java new file mode 100644 index 00000000..e1c5c7fd --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnel.java @@ -0,0 +1,125 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +import org.onlab.packet.IpAddress; + +/** + * The class representing a ovsdb tunnel. This class is immutable. + */ +public final class OvsdbTunnel { + + private final IpAddress localIp; + private final IpAddress remoteIp; + + public enum Type { + VXLAN, GRE + } + + private final Type tunnelType; + private final OvsdbTunnelName tunnelName; + + /** + * Constructor from a IpAddress localIp, IpAddress remoteIp Type tunnelType, + * OvsdbTunnelName tunnelName. + * + * @param localIp the localIp to use + * @param remoteIp the remoteIp to use + * @param tunnelType the tunnelType to use + * @param tunnelName the tunnelName to use + */ + public OvsdbTunnel(IpAddress localIp, IpAddress remoteIp, Type tunnelType, + OvsdbTunnelName tunnelName) { + checkNotNull(localIp, "portName is not null"); + checkNotNull(remoteIp, "portName is not null"); + checkNotNull(tunnelName, "portName is not null"); + this.localIp = localIp; + this.remoteIp = remoteIp; + this.tunnelType = tunnelType; + this.tunnelName = tunnelName; + } + + /** + * Gets the local IP of the tunnel. + * + * @return the local IP of the tunnel + */ + public IpAddress localIp() { + return localIp; + } + + /** + * Gets the remote IP of the tunnel. + * + * @return the remote IP of the tunnel + */ + public IpAddress remoteIp() { + return remoteIp; + } + + /** + * Gets the tunnel type of the tunnel. + * + * @return the tunnel type of the tunnel + */ + public Type tunnelType() { + return tunnelType; + } + + /** + * Gets the tunnel name of the tunnel. + * + * @return the tunnel name of the tunnel + */ + public OvsdbTunnelName tunnelName() { + return tunnelName; + } + + @Override + public int hashCode() { + return Objects.hash(localIp, remoteIp, tunnelType, tunnelName); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbTunnel) { + final OvsdbTunnel otherOvsdbTunnel = (OvsdbTunnel) obj; + return Objects.equals(this.localIp, otherOvsdbTunnel.localIp) + && Objects.equals(this.remoteIp, otherOvsdbTunnel.remoteIp) + && Objects.equals(this.tunnelType, + otherOvsdbTunnel.tunnelType) + && Objects.equals(this.tunnelName, + otherOvsdbTunnel.tunnelName); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("localIp", localIp.toString()) + .add("remoteIp", remoteIp.toString()) + .add("tunnelType", tunnelType).add("tunnelName", tunnelName) + .toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnelName.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnelName.java new file mode 100644 index 00000000..116f6217 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbTunnelName.java @@ -0,0 +1,69 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller; + +import static com.google.common.base.MoreObjects.toStringHelper; +import static com.google.common.base.Preconditions.checkNotNull; + +import java.util.Objects; + +/** + * The class representing a tunnel name. This class is immutable. + */ +public final class OvsdbTunnelName { + private final String value; + + /** + * Constructor from a String tunnel name. + * + * @param value the tunnel name to use + */ + public OvsdbTunnelName(String value) { + checkNotNull(value, "value is not null"); + this.value = value; + } + + /** + * Gets the value of the tunnel name. + * + * @return the value of the tunnel name + */ + public String value() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof OvsdbTunnelName) { + final OvsdbTunnelName otherOvsdbTunnelName = (OvsdbTunnelName) obj; + return Objects.equals(this.value, otherOvsdbTunnelName.value); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("value", value).toString(); + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java new file mode 100644 index 00000000..0c64cc0e --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java @@ -0,0 +1,1188 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller.driver; + +import io.netty.channel.Channel; + +import java.net.InetSocketAddress; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.ExecutionException; + +import org.onlab.packet.IpAddress; +import org.onosproject.ovsdb.controller.OvsdbBridge; +import org.onosproject.ovsdb.controller.OvsdbBridgeName; +import org.onosproject.ovsdb.controller.OvsdbClientService; +import org.onosproject.ovsdb.controller.OvsdbConstant; +import org.onosproject.ovsdb.controller.OvsdbDatapathId; +import org.onosproject.ovsdb.controller.OvsdbNodeId; +import org.onosproject.ovsdb.controller.OvsdbPort; +import org.onosproject.ovsdb.controller.OvsdbPortName; +import org.onosproject.ovsdb.controller.OvsdbPortNumber; +import org.onosproject.ovsdb.controller.OvsdbRowStore; +import org.onosproject.ovsdb.controller.OvsdbStore; +import org.onosproject.ovsdb.controller.OvsdbTableStore; +import org.onosproject.ovsdb.controller.OvsdbTunnel; +import org.onosproject.ovsdb.rfc.jsonrpc.Callback; +import org.onosproject.ovsdb.rfc.message.OperationResult; +import org.onosproject.ovsdb.rfc.message.TableUpdates; +import org.onosproject.ovsdb.rfc.notation.Condition; +import org.onosproject.ovsdb.rfc.notation.Mutation; +import org.onosproject.ovsdb.rfc.notation.OvsdbMap; +import org.onosproject.ovsdb.rfc.notation.OvsdbSet; +import org.onosproject.ovsdb.rfc.notation.Row; +import org.onosproject.ovsdb.rfc.notation.UUID; +import org.onosproject.ovsdb.rfc.operations.Delete; +import org.onosproject.ovsdb.rfc.operations.Insert; +import org.onosproject.ovsdb.rfc.operations.Mutate; +import org.onosproject.ovsdb.rfc.operations.Operation; +import org.onosproject.ovsdb.rfc.operations.Update; +import org.onosproject.ovsdb.rfc.schema.ColumnSchema; +import org.onosproject.ovsdb.rfc.schema.DatabaseSchema; +import org.onosproject.ovsdb.rfc.schema.TableSchema; +import org.onosproject.ovsdb.rfc.table.Bridge; +import org.onosproject.ovsdb.rfc.table.Controller; +import org.onosproject.ovsdb.rfc.table.Interface; +import org.onosproject.ovsdb.rfc.table.OvsdbTable; +import org.onosproject.ovsdb.rfc.table.Port; +import org.onosproject.ovsdb.rfc.table.TableGenerator; +import org.onosproject.ovsdb.rfc.utils.ConditionUtil; +import org.onosproject.ovsdb.rfc.utils.FromJsonUtil; +import org.onosproject.ovsdb.rfc.utils.JsonRpcWriterUtil; +import org.onosproject.ovsdb.rfc.utils.MutationUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.databind.JsonNode; +import com.google.common.base.Function; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.SettableFuture; + +/** + * An representation of an ovsdb client. + */ +public class DefaultOvsdbClient + implements OvsdbProviderService, OvsdbClientService { + + private final Logger log = LoggerFactory + .getLogger(DefaultOvsdbClient.class); + + private Channel channel; + + private OvsdbAgent agent; + private boolean connected; + private OvsdbNodeId nodeId; + private Callback monitorCallBack; + + private OvsdbStore ovsdbStore = new OvsdbStore(); + + private final Map requestMethod = Maps.newHashMap(); + private final Map> requestResult = Maps + .newHashMap(); + + private final Map schema = Maps.newHashMap(); + private final Set ovsdbTunnels = new HashSet(); + + /** + * Creates an OvsdbClient. + * + * @param nodeId ovsdb node id + */ + public DefaultOvsdbClient(OvsdbNodeId nodeId) { + this.nodeId = nodeId; + } + + @Override + public OvsdbNodeId nodeId() { + return nodeId; + } + + @Override + public void setAgent(OvsdbAgent agent) { + if (this.agent == null) { + this.agent = agent; + } + } + + @Override + public void setChannel(Channel channel) { + this.channel = channel; + } + + @Override + public void setConnection(boolean connected) { + this.connected = connected; + } + + @Override + public boolean isConnected() { + return this.connected; + } + + @Override + public void nodeAdded() { + this.agent.addConnectedNode(nodeId, this); + } + + @Override + public void nodeRemoved() { + this.agent.removeConnectedNode(nodeId); + channel.disconnect(); + } + + /** + * Gets the ovsdb table store. + * + * @param dbName the ovsdb database name + * @return ovsTableStore, empty if table store is find + */ + private OvsdbTableStore getTableStore(String dbName) { + if (ovsdbStore == null) { + return null; + } + return ovsdbStore.getOvsdbTableStore(dbName); + } + + /** + * Gets the ovsdb row store. + * + * @param dbName the ovsdb database name + * @param tableName the ovsdb table name + * + * @return ovsRowStore, empty if row store is find + */ + private OvsdbRowStore getRowStore(String dbName, String tableName) { + OvsdbTableStore tableStore = getTableStore(dbName); + if (tableStore == null) { + return null; + } + return tableStore.getRows(tableName); + } + + /** + * Gets the ovsdb row. + * + * @param dbName the ovsdb database name + * @param tableName the ovsdb table name + * @param uuid the key of the row + * @return row, empty if row is find + */ + @Override + public Row getRow(String dbName, String tableName, String uuid) { + OvsdbTableStore tableStore = getTableStore(dbName); + if (tableStore == null) { + return null; + } + OvsdbRowStore rowStore = tableStore.getRows(tableName); + if (rowStore == null) { + return null; + } + return rowStore.getRow(uuid); + } + + @Override + public void removeRow(String dbName, String tableName, String uuid) { + OvsdbTableStore tableStore = getTableStore(dbName); + if (tableStore == null) { + return; + } + OvsdbRowStore rowStore = tableStore.getRows(tableName); + if (rowStore == null) { + return; + } + rowStore.deleteRow(uuid); + } + + @Override + public void updateOvsdbStore(String dbName, String tableName, String uuid, + Row row) { + OvsdbTableStore tableStore = ovsdbStore.getOvsdbTableStore(dbName); + if (tableStore == null) { + tableStore = new OvsdbTableStore(); + } + OvsdbRowStore rowStore = tableStore.getRows(tableName); + if (rowStore == null) { + rowStore = new OvsdbRowStore(); + } + rowStore.insertRow(uuid, row); + tableStore.createOrUpdateTable(tableName, rowStore); + ovsdbStore.createOrUpdateOvsdbStore(dbName, tableStore); + } + + @Override + public String getPortUuid(String portName, String bridgeUuid) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + + Row bridgeRow = getRow(OvsdbConstant.DATABASENAME, + OvsdbConstant.BRIDGE, bridgeUuid); + + Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, bridgeRow, + OvsdbTable.BRIDGE); + if (bridge != null) { + OvsdbSet setPorts = (OvsdbSet) bridge.getPortsColumn().data(); + @SuppressWarnings("unchecked") + Set ports = setPorts.set(); + if (ports == null || ports.size() == 0) { + log.warn("The port uuid is null"); + return null; + } + + for (UUID uuid : ports) { + Row portRow = getRow(OvsdbConstant.DATABASENAME, + OvsdbConstant.PORT, uuid.value()); + Port port = (Port) TableGenerator.getTable(dbSchema, portRow, + OvsdbTable.PORT); + if (port != null && portName.equalsIgnoreCase(port.getName())) { + return uuid.value(); + } + } + + } + return null; + } + + @Override + public String getInterfaceUuid(String portUuid, String portName) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + + Row portRow = getRow(OvsdbConstant.DATABASENAME, OvsdbConstant.PORT, + portUuid); + Port port = (Port) TableGenerator.getTable(dbSchema, portRow, + OvsdbTable.PORT); + + if (port != null) { + OvsdbSet setInterfaces = (OvsdbSet) port.getInterfacesColumn().data(); + @SuppressWarnings("unchecked") + Set interfaces = setInterfaces.set(); + + if (interfaces == null || interfaces.size() == 0) { + log.warn("The interface uuid is null"); + return null; + } + + for (UUID uuid : interfaces) { + Row intfRow = getRow(OvsdbConstant.DATABASENAME, + OvsdbConstant.INTERFACE, uuid.value()); + Interface intf = (Interface) TableGenerator + .getTable(dbSchema, intfRow, OvsdbTable.INTERFACE); + if (intf != null && portName.equalsIgnoreCase(intf.getName())) { + return uuid.value(); + } + } + + } + + return null; + } + + @Override + public String getBridgeUuid(String bridgeName) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + + OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME, + OvsdbConstant.BRIDGE); + if (rowStore == null) { + log.debug("The bridge uuid is null"); + return null; + } + + ConcurrentMap bridgeTableRows = rowStore.getRowStore(); + if (bridgeTableRows == null) { + log.debug("The bridge uuid is null"); + return null; + } + + for (String uuid : bridgeTableRows.keySet()) { + Bridge bridge = (Bridge) TableGenerator + .getTable(dbSchema, bridgeTableRows.get(uuid), + OvsdbTable.BRIDGE); + + if (bridge.getName().equals(bridgeName)) { + return uuid; + } + + } + return null; + } + + @Override + public String getControllerUuid(String controllerName, + String controllerTarget) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME, + OvsdbConstant.CONTROLLER); + if (rowStore == null) { + log.debug("The controller uuid is null"); + return null; + } + + ConcurrentMap controllerTableRows = rowStore.getRowStore(); + if (controllerTableRows != null) { + for (String uuid : controllerTableRows.keySet()) { + + Controller controller = (Controller) TableGenerator + .getTable(dbSchema, controllerTableRows.get(uuid), + OvsdbTable.CONTROLLER); + String target = (String) controller.getTargetColumn().data(); + if (target.equalsIgnoreCase(controllerTarget)) { + return uuid; + } + + } + } + return null; + } + + @Override + public String getOvsUuid(String dbName) { + OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME, + OvsdbConstant.DATABASENAME); + if (rowStore == null) { + log.debug("The bridge uuid is null"); + return null; + } + ConcurrentMap ovsTableRows = rowStore.getRowStore(); + if (ovsTableRows != null) { + for (String uuid : ovsTableRows.keySet()) { + Row row = ovsTableRows.get(uuid); + String tableName = row.tableName(); + if (tableName.equals(dbName)) { + return uuid; + } + } + } + return null; + } + + @Override + public void createPort(String bridgeName, String portName) { + String bridgeUuid = getBridgeUuid(bridgeName); + if (bridgeUuid == null) { + log.error("Can't find bridge {} in {}", bridgeName, + nodeId.getIpAddress()); + return; + } + + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + String portUuid = getPortUuid(portName, bridgeUuid); + + Port port = (Port) TableGenerator + .createTable(dbSchema, OvsdbTable.PORT); + + port.setName(portName); + if (portUuid == null) { + insertConfig(OvsdbConstant.PORT, "_uuid", OvsdbConstant.BRIDGE, + "ports", bridgeUuid, port.getRow()); + } else { + updateConfig(OvsdbConstant.PORT, "_uuid", portUuid, port.getRow()); + } + + return; + } + + @Override + public void dropPort(String bridgeName, String portName) { + String bridgeUuid = getBridgeUuid(bridgeName); + if (bridgeUuid == null) { + log.error("Could not find Bridge {} in {}", bridgeName, nodeId); + return; + } + + String portUuid = getPortUuid(portName, bridgeUuid); + if (portUuid != null) { + log.info("Port {} delete", portName); + deleteConfig(OvsdbConstant.PORT, "_uuid", portUuid, + OvsdbConstant.BRIDGE, "ports"); + } + } + + @Override + public void createBridge(String bridgeName) { + log.debug("create bridge {}", bridgeName); + + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + if (dbSchema == null) { + log.warn("The schema is null"); + return; + } + + Bridge bridge = (Bridge) TableGenerator.createTable(dbSchema, + OvsdbTable.BRIDGE); + if (bridge == null) { + log.debug("Can not create bridge"); + return; + } + + Set failModes = new HashSet<>(); + failModes.add("secure"); + bridge.setFailMode(failModes); + + Set protocols = new HashSet<>(); + protocols.add(OvsdbConstant.OPENFLOW13); + bridge.setProtocols(protocols); + + String ovsUuid = getOvsUuid(OvsdbConstant.DATABASENAME); + if (ovsUuid == null) { + log.warn("The Open_vSwitch is null"); + return; + } + + String bridgeUuid = getBridgeUuid(bridgeName); + if (bridgeUuid == null) { + log.debug("Create a new bridge"); + + bridge.setName(bridgeName); + bridgeUuid = insertConfig(OvsdbConstant.BRIDGE, "_uuid", + OvsdbConstant.DATABASENAME, "bridges", + ovsUuid, bridge.getRow()); + + if (bridgeUuid != null) { + Port port = (Port) TableGenerator.createTable(dbSchema, + OvsdbTable.PORT); + if (port != null) { + log.debug("the port is not null"); + port.setName(bridgeName); + + insertConfig(OvsdbConstant.PORT, "_uuid", "Bridge", "ports", bridgeUuid, + port.getRow()); + } + } + + } else { + log.info("Update a bridge"); + updateConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUuid, bridge.getRow()); + } + + setController(bridgeUuid); + log.info("Create bridge success"); + } + + /** + * Sets the Controller. + * + * @param bridgeUuid bridge uuid + */ + private void setController(String bridgeUuid) { + String controllerUuid = null; + String iPAddress = IpAddress.valueOf(((InetSocketAddress) channel + .localAddress()) + .getAddress() + .getHostAddress()) + .toString(); + + String target = "tcp:" + iPAddress + ":" + OvsdbConstant.OFPORT; + log.debug("controller IP {}: port {}", iPAddress, OvsdbConstant.OFPORT); + + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + Controller controller = (Controller) TableGenerator + .createTable(dbSchema, OvsdbTable.CONTROLLER); + + if (controller != null) { + controller.setTarget(target); + controllerUuid = getControllerUuid(OvsdbConstant.CONTROLLER, target); + if (controllerUuid == null) { + + insertConfig(OvsdbConstant.CONTROLLER, "_uuid", + OvsdbConstant.BRIDGE, "controller", bridgeUuid, + controller.getRow()); + + } else { + + Bridge bridge = (Bridge) TableGenerator + .createTable(dbSchema, OvsdbTable.BRIDGE); + Set controllerUuids = new HashSet<>(); + controllerUuids.add(UUID.uuid(controllerUuid)); + bridge.setController(controllerUuids); + updateConfig(OvsdbConstant.CONTROLLER, "_uuid", bridgeUuid, bridge.getRow()); + + } + } + + } + + @Override + public void dropBridge(String bridgeName) { + String bridgeUUID = getBridgeUuid(bridgeName); + if (bridgeUUID == null) { + log.warn("Could not find bridge in node", nodeId.getIpAddress()); + return; + } + deleteConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUUID, + OvsdbConstant.DATABASENAME, "bridges"); + } + + @Override + public void createTunnel(IpAddress srcIp, IpAddress dstIp) { + String bridgeUuid = getBridgeUuid(OvsdbConstant.INTEGRATION_BRIDGE); + if (bridgeUuid == null) { + log.warn("Could not find bridge {} and Could not create tunnel. ", + OvsdbConstant.INTEGRATION_BRIDGE); + return; + } + + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + String portName = getTunnelName(OvsdbConstant.TYPEVXLAN, dstIp); + String portUuid = getPortUuid(portName, bridgeUuid); + + Port port = (Port) TableGenerator + .createTable(dbSchema, OvsdbTable.PORT); + if (port != null) { + port.setName(portName); + } + + if (portUuid == null) { + portUuid = insertConfig(OvsdbConstant.PORT, "_uuid", OvsdbConstant.BRIDGE, + "ports", bridgeUuid, port.getRow()); + } else { + updateConfig(OvsdbConstant.PORT, "_uuid", portUuid, port.getRow()); + } + + // When a tunnel is created, A row is inserted into port table and + // interface table of the ovsdb node. + // and the following step is to get the interface uuid from local store + // in controller node. + // but it need spend some time synchronising data between node and + // controller. + // so loop to judge if interfaceUUid is null is necessary. + String interfaceUuid = null; + for (int i = 0; i < 10; i++) { + interfaceUuid = getInterfaceUuid(portUuid, portName); + if (interfaceUuid == null) { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + log.warn("Interrupted while waiting to get interfaceUuid"); + Thread.currentThread().interrupt(); + } + } else { + break; + } + } + + if (interfaceUuid != null) { + + Interface tunInterface = (Interface) TableGenerator + .createTable(dbSchema, OvsdbTable.INTERFACE); + + if (tunInterface != null) { + + tunInterface.setType(OvsdbConstant.TYPEVXLAN); + Map options = Maps.newHashMap(); + options.put("key", "flow"); + options.put("local_ip", srcIp.toString()); + options.put("remote_ip", dstIp.toString()); + tunInterface.setOptions(options); + updateConfig(OvsdbConstant.INTERFACE, "_uuid", interfaceUuid, + tunInterface.getRow()); + log.info("Tunnel added success", tunInterface); + + } + } + + return; + } + + @Override + public void dropTunnel(IpAddress srcIp, IpAddress dstIp) { + String bridgeName = OvsdbConstant.INTEGRATION_BRIDGE; + String portName = getTunnelName(OvsdbConstant.TYPEVXLAN, dstIp); + String bridgeUuid = getBridgeUuid(OvsdbConstant.INTEGRATION_BRIDGE); + if (bridgeUuid == null) { + log.warn("Could not find bridge {} in {}", bridgeName, + nodeId.getIpAddress()); + return; + } + + String portUUID = getPortUuid(portName, bridgeUuid); + if (portUUID != null) { + log.info("Delete tunnel"); + deleteConfig(OvsdbConstant.PORT, "_uuid", portUUID, + OvsdbConstant.BRIDGE, "ports"); + } + + return; + } + + /** + * Delete transact config. + * + * @param childTableName child table name + * @param childColumnName child column name + * @param childUuid child row uuid + * @param parentTableName parent table name + * @param parentColumnName parent column + * + */ + private void deleteConfig(String childTableName, String childColumnName, + String childUuid, String parentTableName, + String parentColumnName) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + TableSchema childTableSchema = dbSchema.getTableSchema(childTableName); + + ArrayList operations = Lists.newArrayList(); + if (parentTableName != null && parentColumnName != null) { + TableSchema parentTableSchema = dbSchema + .getTableSchema(parentTableName); + ColumnSchema parentColumnSchema = parentTableSchema + .getColumnSchema(parentColumnName); + List mutations = Lists.newArrayList(); + Mutation mutation = MutationUtil.delete(parentColumnSchema.name(), + UUID.uuid(childUuid)); + mutations.add(mutation); + List conditions = Lists.newArrayList(); + Condition condition = ConditionUtil.includes(parentColumnName, + UUID.uuid(childUuid)); + conditions.add(condition); + Mutate op = new Mutate(parentTableSchema, conditions, mutations); + operations.add(op); + } + + List conditions = Lists.newArrayList(); + Condition condition = ConditionUtil.equals(childColumnName, UUID.uuid(childUuid)); + conditions.add(condition); + Delete del = new Delete(childTableSchema, conditions); + operations.add(del); + transactConfig(OvsdbConstant.DATABASENAME, operations); + + return; + } + + /** + * Update transact config. + * + * @param tableName table name + * @param columnName column name + * @param uuid uuid + * @param row the config data + * + */ + private void updateConfig(String tableName, String columnName, String uuid, + Row row) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + TableSchema tableSchema = dbSchema.getTableSchema(tableName); + + List conditions = Lists.newArrayList(); + Condition condition = ConditionUtil.equals(columnName, UUID.uuid(uuid)); + conditions.add(condition); + + Update update = new Update(tableSchema, row, conditions); + + ArrayList operations = Lists.newArrayList(); + operations.add(update); + + transactConfig(OvsdbConstant.DATABASENAME, operations); + } + + /** + * Insert transact config. + * + * @param childTableName child table name + * @param childColumnName child column name + * @param parentTableName parent table name + * @param parentColumnName parent column + * @param parentUuid parent uuid + * @param row the config data + * + * @return uuid, empty if no uuid is find + */ + private String insertConfig(String childTableName, String childColumnName, + String parentTableName, String parentColumnName, + String parentUuid, Row row) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + TableSchema tableSchema = dbSchema.getTableSchema(childTableName); + + String namedUuid = childTableName; + Insert insert = new Insert(tableSchema, namedUuid, row); + + ArrayList operations = Lists.newArrayList(); + operations.add(insert); + + if (parentTableName != null && parentColumnName != null) { + TableSchema parentTableSchema = dbSchema + .getTableSchema(parentTableName); + ColumnSchema parentColumnSchema = parentTableSchema + .getColumnSchema(parentColumnName); + + List mutations = Lists.newArrayList(); + Mutation mutation = MutationUtil.insert(parentColumnSchema.name(), + UUID.uuid(namedUuid)); + mutations.add(mutation); + + List conditions = Lists.newArrayList(); + Condition condition = ConditionUtil.equals("_uuid", + UUID.uuid(parentUuid)); + conditions.add(condition); + + Mutate op = new Mutate(parentTableSchema, conditions, mutations); + operations.add(op); + } + if (childTableName.equalsIgnoreCase(OvsdbConstant.PORT)) { + log.info("Handle port insert"); + Insert intfInsert = handlePortInsertTable(OvsdbConstant.INTERFACE, + row); + + if (intfInsert != null) { + operations.add(intfInsert); + } + + Insert ins = (Insert) operations.get(0); + ins.getRow().put("interfaces", + UUID.uuid(OvsdbConstant.INTERFACE)); + } + + List results; + try { + results = transactConfig(OvsdbConstant.DATABASENAME, operations) + .get(); + + return results.get(0).getUuid().value(); + } catch (InterruptedException e) { + log.warn("Interrupted while waiting to get result"); + Thread.currentThread().interrupt(); + } catch (ExecutionException e) { + log.error("Exception thrown while to get result"); + } + + return null; + } + + /** + * Handles port insert. + * + * @param tableName ovsdb table interface + * @param portRow row of port + * + * @return insert, empty if null + */ + private Insert handlePortInsertTable(String tableName, Row portRow) { + DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME); + + TableSchema portTableSchema = dbSchema + .getTableSchema(OvsdbConstant.PORT); + ColumnSchema portColumnSchema = portTableSchema.getColumnSchema("name"); + + String portName = (String) portRow.getColumn(portColumnSchema.name()).data(); + + Interface inf = (Interface) TableGenerator + .createTable(dbSchema, OvsdbTable.INTERFACE); + + inf.setName(portName); + + TableSchema intfTableSchema = dbSchema + .getTableSchema(OvsdbConstant.INTERFACE); + Insert insert = new Insert(intfTableSchema, OvsdbConstant.INTERFACE, + inf.getRow()); + return insert; + } + + /** + * Gets tunnel name. + * + * @param tunnelType + * @param dstIp the remote ip address + * + * @return tunnel name + */ + private String getTunnelName(String tunnelType, IpAddress dstIp) { + return tunnelType + "-" + dstIp.toString(); + } + + @Override + public ListenableFuture getOvsdbSchema(String dbName) { + if (dbName == null) { + return null; + } + DatabaseSchema databaseSchema = schema.get(dbName); + if (databaseSchema == null) { + List dbNames = new ArrayList(); + dbNames.add(dbName); + Function rowFunction = new Function() { + @Override + public DatabaseSchema apply(JsonNode input) { + log.info("Get ovsdb database schema", dbName); + DatabaseSchema dbSchema = FromJsonUtil + .jsonNodeToDbSchema(dbName, input); + if (dbSchema == null) { + log.debug("Get ovsdb database schema error"); + return null; + } + schema.put(dbName, dbSchema); + + return dbSchema; + } + }; + + ListenableFuture input = getSchema(dbNames); + if (input != null) { + return Futures.transform(input, rowFunction); + } + return null; + } else { + return Futures.immediateFuture(databaseSchema); + } + } + + @Override + public ListenableFuture monitorTables(String dbName, String id) { + if (dbName == null) { + return null; + } + DatabaseSchema dbSchema = schema.get(dbName); + if (dbSchema != null) { + Function rowFunction = new Function() { + @Override + public TableUpdates apply(JsonNode input) { + log.info("Get table updates"); + TableUpdates updates = FromJsonUtil + .jsonNodeToTableUpdates(input, dbSchema); + if (updates == null) { + log.debug("Get table updates error"); + return null; + } + return updates; + } + }; + return Futures.transform(monitor(dbSchema, id), rowFunction); + } + return null; + } + + @Override + public ListenableFuture> transactConfig(String dbName, + List operations) { + if (dbName == null) { + return null; + } + DatabaseSchema dbSchema = schema.get(dbName); + if (dbSchema != null) { + Function, List> rowFunction = + new Function, List>() { + @Override + public List apply(List input) { + log.info("Get ovsdb operation result"); + List result = FromJsonUtil + .jsonNodeToOperationResult(input, operations); + + if (result == null) { + log.debug("The operation result is null"); + return null; + } + return result; + } + }; + return Futures.transform(transact(dbSchema, operations), + rowFunction); + } + return null; + } + + @Override + public ListenableFuture getSchema(List dbnames) { + String id = java.util.UUID.randomUUID().toString(); + String getSchemaString = JsonRpcWriterUtil.getSchemaStr(id, dbnames); + + SettableFuture sf = SettableFuture.create(); + requestResult.put(id, sf); + requestMethod.put(id, "getSchema"); + + channel.writeAndFlush(getSchemaString); + return sf; + + } + + @Override + public ListenableFuture> echo() { + String id = java.util.UUID.randomUUID().toString(); + String echoString = JsonRpcWriterUtil.echoStr(id); + + SettableFuture> sf = SettableFuture.create(); + requestResult.put(id, sf); + requestMethod.put(id, "echo"); + + channel.writeAndFlush(echoString); + return sf; + + } + + @Override + public ListenableFuture monitor(DatabaseSchema dbSchema, + String monitorId) { + String id = java.util.UUID.randomUUID().toString(); + String monitorString = JsonRpcWriterUtil.monitorStr(id, monitorId, + dbSchema); + + SettableFuture sf = SettableFuture.create(); + requestResult.put(id, sf); + requestMethod.put(id, "monitor"); + + channel.writeAndFlush(monitorString); + return sf; + + } + + @Override + public ListenableFuture> listDbs() { + String id = java.util.UUID.randomUUID().toString(); + String listDbsString = JsonRpcWriterUtil.listDbsStr(id); + + SettableFuture> sf = SettableFuture.create(); + requestResult.put(id, sf); + requestMethod.put(id, "listDbs"); + + channel.writeAndFlush(listDbsString); + return sf; + + } + + @Override + public ListenableFuture> transact(DatabaseSchema dbSchema, + List operations) { + String id = java.util.UUID.randomUUID().toString(); + String transactString = JsonRpcWriterUtil.transactStr(id, dbSchema, + operations); + + SettableFuture> sf = SettableFuture.create(); + requestResult.put(id, sf); + requestMethod.put(id, "transact"); + + channel.writeAndFlush(transactString); + return sf; + + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public void processResult(JsonNode response) { + log.debug("Handle result"); + String requestId = response.get("id").asText(); + SettableFuture sf = requestResult.get(requestId); + if (sf == null) { + log.debug("No such future to process"); + return; + } + String methodName = requestMethod.get(requestId); + + Object result; + result = FromJsonUtil.jsonResultParser(response, methodName); + + sf.set(result); + return; + } + + @Override + public void processRequest(JsonNode requestJson) { + log.debug("Handle request"); + if (requestJson.get("method").asText().equalsIgnoreCase("echo")) { + log.debug("handle echo request"); + + String replyString = FromJsonUtil.getEchoRequestStr(requestJson); + channel.writeAndFlush(replyString); + + return; + } else { + FromJsonUtil + .jsonCallbackRequestParser(requestJson, monitorCallBack); + return; + } + } + + @Override + public void setCallback(Callback monitorCallback) { + this.monitorCallBack = monitorCallback; + } + + @Override + public Set getTunnels() { + return ovsdbTunnels; + } + + @Override + public Set getBridges() { + Set ovsdbBridges = new HashSet(); + OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME); + if (tableStore == null) { + return null; + } + OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.BRIDGE); + if (rowStore == null) { + return null; + } + ConcurrentMap rows = rowStore.getRowStore(); + for (String uuid : rows.keySet()) { + Row row = getRow(OvsdbConstant.DATABASENAME, OvsdbConstant.BRIDGE, + uuid); + OvsdbBridge ovsdbBridge = getOvsdbBridge(row); + if (ovsdbBridge != null) { + ovsdbBridges.add(ovsdbBridge); + } + } + return ovsdbBridges; + } + + @Override + public Set getPorts() { + Set ovsdbPorts = new HashSet(); + OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME); + if (tableStore == null) { + return null; + } + OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.INTERFACE); + if (rowStore == null) { + return null; + } + ConcurrentMap rows = rowStore.getRowStore(); + for (String uuid : rows.keySet()) { + Row row = getRow(OvsdbConstant.DATABASENAME, + OvsdbConstant.INTERFACE, uuid); + OvsdbPort ovsdbPort = getOvsdbPort(row); + if (ovsdbPort != null) { + ovsdbPorts.add(ovsdbPort); + } + } + return ovsdbPorts; + } + + @Override + public DatabaseSchema getDatabaseSchema(String dbName) { + return schema.get(dbName); + } + + //Gets ovsdb port. + private OvsdbPort getOvsdbPort(Row row) { + DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME); + Interface intf = (Interface) TableGenerator + .getTable(dbSchema, row, OvsdbTable.INTERFACE); + if (intf == null) { + return null; + } + long ofPort = getOfPort(intf); + String portName = intf.getName(); + if ((ofPort < 0) || (portName == null)) { + return null; + } + + OvsdbPort ovsdbPort = new OvsdbPort(new OvsdbPortNumber(ofPort), + new OvsdbPortName(portName)); + return ovsdbPort; + } + + ////Gets ovsdb bridge. + private OvsdbBridge getOvsdbBridge(Row row) { + DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME); + Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, row, + OvsdbTable.BRIDGE); + if (bridge == null) { + return null; + } + + OvsdbSet datapathIdSet = (OvsdbSet) bridge.getDatapathIdColumn().data(); + @SuppressWarnings("unchecked") + Set datapathIds = datapathIdSet.set(); + if (datapathIds == null || datapathIds.size() == 0) { + return null; + } + String datapathId = (String) datapathIds.toArray()[0]; + String bridgeName = bridge.getName(); + if ((datapathId == null) || (bridgeName == null)) { + return null; + } + + OvsdbBridge ovsdbBridge = new OvsdbBridge(new OvsdbBridgeName(bridgeName), + new OvsdbDatapathId(datapathId)); + return ovsdbBridge; + } + + //Gets ofPort in the interface. + private long getOfPort(Interface intf) { + OvsdbSet ofPortSet = (OvsdbSet) intf.getOpenFlowPortColumn().data(); + @SuppressWarnings("unchecked") + Set ofPorts = ofPortSet.set(); + while (ofPorts == null || ofPorts.size() <= 0) { + log.debug("The ofport is null in {}", intf.getName()); + return -1; + } + // return (long) ofPorts.toArray()[0]; + Iterator it = ofPorts.iterator(); + return Long.parseLong(it.next().toString()); + } + + @Override + public Set getLocalPorts(Iterable ifaceids) { + Set ovsdbPorts = new HashSet(); + OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME); + if (tableStore == null) { + return null; + } + OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.INTERFACE); + if (rowStore == null) { + return null; + } + ConcurrentMap rows = rowStore.getRowStore(); + for (String uuid : rows.keySet()) { + Row row = getRow(OvsdbConstant.DATABASENAME, + OvsdbConstant.INTERFACE, uuid); + DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME); + Interface intf = (Interface) TableGenerator + .getTable(dbSchema, row, OvsdbTable.INTERFACE); + if (intf == null || getIfaceid(intf) == null) { + continue; + } + String portName = intf.getName(); + Set ifaceidSet = Sets.newHashSet(ifaceids); + if (portName.startsWith("vxlan") + || !ifaceidSet.contains(getIfaceid(intf))) { + continue; + } + long ofPort = getOfPort(intf); + if ((ofPort < 0) || (portName == null)) { + continue; + } + + OvsdbPort ovsdbPort = new OvsdbPort(new OvsdbPortNumber(ofPort), + new OvsdbPortName(portName)); + if (ovsdbPort != null) { + ovsdbPorts.add(ovsdbPort); + } + } + return ovsdbPorts; + } + + private String getIfaceid(Interface intf) { + OvsdbMap ovsdbMap = (OvsdbMap) intf.getExternalIdsColumn().data(); + @SuppressWarnings("unchecked") + Map externalIds = ovsdbMap.map(); + if (externalIds.isEmpty()) { + log.warn("The external_ids is null"); + return null; + } + String ifaceid = externalIds + .get(OvsdbConstant.EXTERNAL_ID_INTERFACE_ID); + if (ifaceid == null) { + log.warn("The ifaceid is null"); + return null; + } + return ifaceid; + } +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbAgent.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbAgent.java new file mode 100644 index 00000000..70ffae8b --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbAgent.java @@ -0,0 +1,42 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller.driver; + +import org.onosproject.ovsdb.controller.OvsdbNodeId; +import org.onosproject.ovsdb.controller.OvsdbClientService; + +/** + * Responsible for keeping track of the current set of nodes connected to the + * system. + */ +public interface OvsdbAgent { + /** + * Add a node that has just connected to the system. + * + * @param nodeId the nodeId to add + * @param ovsdbClient the actual node object. + */ + void addConnectedNode(OvsdbNodeId nodeId, OvsdbClientService ovsdbClient); + + /** + * Clear all state in controller node maps for a node that has disconnected + * from the local controller. Also release control for that node from the + * global repository. Notify node listeners. + * + * @param nodeId the node id to be removed. + */ + void removeConnectedNode(OvsdbNodeId nodeId); +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbProviderService.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbProviderService.java new file mode 100644 index 00000000..48f58d02 --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/OvsdbProviderService.java @@ -0,0 +1,81 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.ovsdb.controller.driver; + +import io.netty.channel.Channel; + +import org.onosproject.ovsdb.rfc.jsonrpc.Callback; + +import com.fasterxml.jackson.databind.JsonNode; + +/** + * Represents the driver side of an ovsdb node. This interface should never be + * exposed to consumers. + */ +public interface OvsdbProviderService { + /** + * Sets the ovsdb agent to be used. This method can only be called once. + * + * @param agent the agent to set. + */ + void setAgent(OvsdbAgent agent); + + /** + * Sets the associated Netty channel for this node. + * + * @param channel the Netty channel + */ + void setChannel(Channel channel); + + /** + * Announces to the ovsdb agent that this node has added. + */ + void nodeAdded(); + + /** + * Announces to the ovsdb agent that this node has removed. + */ + void nodeRemoved(); + + /** + * Sets whether the node is connected. + * + * @param connected whether the node is connected + */ + void setConnection(boolean connected); + + /** + * Processes result from ovsdb. + * + * @param response JsonNode response from ovsdb + */ + void processResult(JsonNode response); + + /** + * processes request from ovsdb. + * + * @param request JsonNode request from ovsdb + */ + void processRequest(JsonNode request); + + /** + * Sets call back. + * + * @param monitorCallback the callback to set + */ + void setCallback(Callback monitorCallback); + +} diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/package-info.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/package-info.java new file mode 100644 index 00000000..b14afdfb --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/package-info.java @@ -0,0 +1,20 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Ovsdb controller node driver API. + */ +package org.onosproject.ovsdb.controller.driver; \ No newline at end of file diff --git a/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/package-info.java b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/package-info.java new file mode 100644 index 00000000..d6fb434c --- /dev/null +++ b/framework/src/onos/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/package-info.java @@ -0,0 +1,20 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Ovsdb controller API. + */ +package org.onosproject.ovsdb.controller; \ No newline at end of file -- cgit 1.2.3-korg