diff options
| author |   Ashlee Young <ashlee@wildernessvoice.com> | 2015-12-01 05:49:27 -0800 |
|---|---|---|
| committer | Ashlee Young <ashlee@wildernessvoice.com> | 2015-12-01 05:49:27 -0800 |
| commit | e63291850fd0795c5700e25e67e5dee89ba54c5f (patch) | |
| tree | 9707289536ad95bb739c9856761ad43275e07d8c /framework/src/onos/apps/openstackswitching | |
| parent | 671823e12bc13be9a8b87a5d7de33da1bb7a44e8 (diff) | |
onos commit hash c2999f30c69e50df905a9d175ef80b3f23a98514
Change-Id: I2bb8562c4942b6d6a6d60b663db2e17540477b81
Signed-off-by: Ashlee Young <ashlee@wildernessvoice.com>
Diffstat (limited to 'framework/src/onos/apps/openstackswitching')
27 files changed, 1471 insertions, 885 deletions
diff --git a/framework/src/onos/apps/openstackswitching/api/pom.xml b/framework/src/onos/apps/openstackswitching/api/pom.xml new file mode 100644 index 00000000..f5e6f94f --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/api/pom.xml @@ -0,0 +1,50 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ 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. + --> +<project xmlns="http://maven.apache.org/POM/4.0.0" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.onosproject</groupId> + <artifactId>onos-openstackswitching</artifactId> + <version>1.4.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>onos-app-openstackswitching-api</artifactId> + <packaging>bundle</packaging> + + <description>SONA Openstack Switching application API</description> + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-api</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>org.osgi</groupId> + <artifactId>org.osgi.compendium</artifactId> + </dependency> + <dependency> + <groupId>org.osgi</groupId> + <artifactId>org.osgi.core</artifactId> + </dependency> + </dependencies> + +</project> diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackNetwork.java b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackNetwork.java index 7bfdf290..1b28d0c4 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackNetwork.java +++ b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackNetwork.java @@ -77,6 +77,11 @@ public final class OpenstackNetwork { return this.networkType; } + @Override + protected Object clone() throws CloneNotSupportedException { + return super.clone(); + } + public static final class Builder { private String name; private String tenantId; diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackPort.java b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackPort.java index 4326b4fc..1613b597 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackPort.java +++ b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackPort.java @@ -19,6 +19,7 @@ import com.google.common.collect.Lists; import org.onlab.packet.Ip4Address; import org.onlab.packet.MacAddress; +import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -31,7 +32,8 @@ public final class OpenstackPort { public enum PortStatus { UP, - DOWN + DOWN, + ACTIVE } private PortStatus status; @@ -179,6 +181,16 @@ public final class OpenstackPort { // //} + @Override + public Object clone() { + OpenstackPort op = new OpenstackPort(this.status, this.name, this.adminStateUp, + this.networkId, this.tenantId, this.deviceOwner, this.macAddress, + (HashMap) this.fixedIps.clone(), this.id, + Collections.unmodifiableList(this.securityGroups), this.deviceId); + + return op; + } + /** * OpenstackPort Builder class. */ diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSubnet.java b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackSubnet.java index 39d783e3..bc536e88 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSubnet.java +++ b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackSubnet.java @@ -15,6 +15,10 @@ */ package org.onosproject.openstackswitching; +import org.onlab.packet.Ip4Address; + +import java.util.List; + import static com.google.common.base.Preconditions.checkNotNull; /** @@ -26,13 +30,13 @@ public final class OpenstackSubnet { private boolean enableHhcp; private String networkId; private String tenantId; - private String dnsNameservers; + private List<Ip4Address> dnsNameservers; private String gatewayIp; private String cidr; private String id; private OpenstackSubnet(String name, boolean enableHhcp, String networkId, - String tenantId, String dnsNameservers, String gatewayIp, + String tenantId, List<Ip4Address> dnsNameservers, String gatewayIp, String cidr, String id) { this.name = name; this.enableHhcp = enableHhcp; @@ -69,7 +73,7 @@ public final class OpenstackSubnet { return tenantId; } - public String dnsNameservers() { + public List<Ip4Address> dnsNameservers() { return dnsNameservers; } @@ -85,8 +89,6 @@ public final class OpenstackSubnet { return id; } - // TODO : Implement the following functions when necessary - /** * OpenstackSubnet Builder class. * @@ -96,7 +98,7 @@ public final class OpenstackSubnet { private boolean enableDhcp; private String networkId; private String tenantId; - private String dnsNameservers; + private List<Ip4Address> dnsNameservers; private String gatewayIp; private String cidr; private String id; @@ -127,7 +129,7 @@ public final class OpenstackSubnet { return this; } - public Builder setDnsNameservers(String dnsNameservers) { + public Builder setDnsNameservers(List<Ip4Address> dnsNameservers) { this.dnsNameservers = dnsNameservers; return this; diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingService.java b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingService.java index 3d40d51d..59b8db0c 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingService.java +++ b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingService.java @@ -15,8 +15,12 @@ */ package org.onosproject.openstackswitching; +import org.onosproject.net.Port; + +import java.util.Collection; + /** - * It handles port management REST API from Openstack for VMs. + * Handles port management REST API from Openstack for VMs. */ public interface OpenstackSwitchingService { @@ -40,16 +44,49 @@ public interface OpenstackSwitchingService { void updatePorts(); /** - * Store the network information created by openstack. + * Stores the network information created by openstack. * * @param openstackNetwork network information */ void createNetwork(OpenstackNetwork openstackNetwork); /** - * Store the subnet information created by openstack. + * Stores the subnet information created by openstack. * * @param openstackSubnet subnet information */ void createSubnet(OpenstackSubnet openstackSubnet); + + /** + * Returns port information list for the network ID given. + * + * @param networkId Network ID of the ports + * @return port information list + */ + Collection<OpenstackPort> ports(String networkId); + + /** + * Returns port information for the port given. + * + * @param port port reference + * @return port information + */ + OpenstackPort port(Port port); + + /** + * Returns port information for the port ID given. + * + * @param portId Port ID + * @return port information + */ + OpenstackPort port(String portId); + + /** + * Returns network information list for the network ID given. + * + * @param networkId Network ID + * @return network information list + */ + OpenstackNetwork network(String networkId); + } diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/package-info.java b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/package-info.java index cd50f912..cd50f912 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/package-info.java +++ b/framework/src/onos/apps/openstackswitching/api/src/main/java/org/onosproject/openstackswitching/package-info.java diff --git a/framework/src/onos/apps/openstackswitching/app/app.xml b/framework/src/onos/apps/openstackswitching/app/app.xml new file mode 100644 index 00000000..e982b90d --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/app.xml @@ -0,0 +1,24 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ 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. + --> +<app name="org.onosproject.openstackswitching" origin="ON.Lab" version="${project.version}" + featuresRepo="mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features" + features="${project.artifactId}"> + <description>${project.description}</description> + <artifact>mvn:${project.groupId}/onos-app-openstackswitching/${project.version}</artifact> + <artifact>mvn:${project.groupId}/onos-app-dhcp-api/${project.version}</artifact> + <artifact>mvn:${project.groupId}/onos-app-dhcp/${project.version}</artifact> +</app> diff --git a/framework/src/onos/apps/openstackswitching/app/features.xml b/framework/src/onos/apps/openstackswitching/app/features.xml new file mode 100644 index 00000000..acb07b62 --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/features.xml @@ -0,0 +1,28 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<!-- + ~ 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. + --> +<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="${project.artifactId}-${project.version}"> + <repository>mvn:${project.groupId}/${project.artifactId}/${project.version}/xml/features</repository> + <feature name="${project.artifactId}" version="${project.version}" + description="${project.description}"> + <feature>onos-api</feature> + <bundle>mvn:${project.groupId}/onos-app-openstackswitching/${project.version}</bundle> + <bundle>mvn:${project.groupId}/onos-app-dhcp-api/${project.version}</bundle> + <bundle>mvn:${project.groupId}/onos-app-dhcp/${project.version}</bundle> + <bundle>mvn:com.sun.jersey/jersey-client/1.19</bundle> + <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle> + </feature> +</features> diff --git a/framework/src/onos/apps/openstackswitching/app/pom.xml b/framework/src/onos/apps/openstackswitching/app/pom.xml new file mode 100644 index 00000000..5460faef --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/pom.xml @@ -0,0 +1,137 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ 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. + --> +<project xmlns="http://maven.apache.org/POM/4.0.0" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.onosproject</groupId> + <artifactId>onos-openstackswitching</artifactId> + <version>1.4.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>onos-app-openstackswitching</artifactId> + <packaging>bundle</packaging> + + <description>SONA Openstack Switching applications</description> + <properties> + <onos.version>1.4.0-SNAPSHOT</onos.version> + <onos.app.name>org.onosproject.openstackswitching</onos.app.name> + <web.context>/onos/openstackswitching</web.context> + <api.version>1.0.0</api.version> + <api.title>ONOS OpenStack Switching REST API</api.title> + <api.description> + APIs for receiving Neutron information. + </api.description> + <api.package>org.onosproject.openstackswitching.web</api.package> + <onos.app.origin>SKT, Inc.</onos.app.origin> + </properties> + + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-app-openstackswitching-api</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-rest</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-rest</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>javax.ws.rs</groupId> + <artifactId>jsr311-api</artifactId> + <version>1.1.1</version> + </dependency> + <dependency> + <groupId>com.sun.jersey</groupId> + <artifactId>jersey-servlet</artifactId> + </dependency> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-databind</artifactId> + </dependency> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-annotations</artifactId> + </dependency> + <dependency> + <groupId>org.osgi</groupId> + <artifactId>org.osgi.compendium</artifactId> + </dependency> + <dependency> + <groupId>org.osgi</groupId> + <artifactId>org.osgi.core</artifactId> + </dependency> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-app-dhcp-api</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>com.sun.jersey</groupId> + <artifactId>jersey-client</artifactId> + <version>1.19</version> + </dependency> + </dependencies> + + <build> + <plugins> + <plugin> + <groupId>org.apache.felix</groupId> + <artifactId>maven-bundle-plugin</artifactId> + <extensions>true</extensions> + <configuration> + <instructions> + <_wab>src/main/webapp/</_wab> + <Bundle-SymbolicName> + ${project.groupId}.${project.artifactId} + </Bundle-SymbolicName> + <Import-Package> + org.slf4j, + org.osgi.framework, + javax.ws.rs, + javax.ws.rs.core, + com.sun.jersey.api.core, + com.sun.jersey.api.client, + com.sun.jersey.spi.container.servlet, + com.sun.jersey.server.impl.container.servlet, + com.fasterxml.jackson.databind, + com.fasterxml.jackson.databind.node, + com.fasterxml.jackson.core, + org.apache.karaf.shell.commands, + com.google.common.*, + org.onlab.packet.*, + org.onosproject.* + </Import-Package> + <Web-ContextPath>${web.context}</Web-ContextPath> + </instructions> + </configuration> + </plugin> + </plugins> + </build> + + +</project> diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackArpHandler.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackArpHandler.java index 0c139d8d..944d12a1 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackArpHandler.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackArpHandler.java @@ -28,26 +28,27 @@ import org.onosproject.net.packet.PacketService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.nio.ByteBuffer; -import java.util.Map; + +import static com.google.common.base.Preconditions.checkNotNull; /** - * It handles ARP packet from VMs. + * Handles ARP packet from VMs. */ public class OpenstackArpHandler { private static Logger log = LoggerFactory .getLogger(OpenstackArpHandler.class); private PacketService packetService; - private Map<String, OpenstackPort> openstackPortMap; + private OpenstackRestHandler restHandler; /** * Returns OpenstackArpHandler reference. * - * @param openstackPortMap - * @param packetService + * @param restHandler rest API handler reference + * @param packetService PacketService reference */ - public OpenstackArpHandler(Map<String, OpenstackPort> openstackPortMap, PacketService packetService) { - this.openstackPortMap = openstackPortMap; + public OpenstackArpHandler(OpenstackRestHandler restHandler, PacketService packetService) { + this.restHandler = checkNotNull(restHandler); this.packetService = packetService; } @@ -68,8 +69,9 @@ public class OpenstackArpHandler { //Searches the Dst MAC Address based on openstackPortMap MacAddress macAddress = null; - OpenstackPort openstackPort = openstackPortMap.values().stream().filter(e -> e.fixedIps(). - containsValue(Ip4Address.valueOf(dstIPAddress))).findAny().orElse(null); + OpenstackPort openstackPort = restHandler.getPorts().stream(). + filter(e -> e.fixedIps().containsValue(Ip4Address.valueOf( + dstIPAddress))).findAny().orElse(null); if (openstackPort != null) { macAddress = openstackPort.macAddress(); diff --git a/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackRestHandler.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackRestHandler.java new file mode 100644 index 00000000..9065bc52 --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackRestHandler.java @@ -0,0 +1,179 @@ +/* + * 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.openstackswitching; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.google.common.collect.Lists; +import com.sun.jersey.api.client.Client; +import com.sun.jersey.api.client.WebResource; +import org.onosproject.openstackswitching.web.OpenstackNetworkCodec; +import org.onosproject.openstackswitching.web.OpenstackPortCodec; +import org.onosproject.openstackswitching.web.OpenstackSubnetCodec; +import org.slf4j.Logger; +import javax.ws.rs.core.MediaType; +import java.io.IOException; +import java.util.Collection; +import java.util.List; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.net.MediaType.JSON_UTF_8; +import static org.slf4j.LoggerFactory.getLogger; + +/** + * Handles REST Calls to Openstack Neutron. + * + */ +public class OpenstackRestHandler { + + private final Logger log = getLogger(getClass()); + private String neutronUrl; + private String keystoneUrl; + private String tokenId; + private String userName; + private String pass; + + /** + * Creates OpenstackRestHandler instance. + * + * @param cfg OpenstackSwitchingConfig reference + */ + public OpenstackRestHandler(OpenstackSwitchingConfig cfg) { + this.neutronUrl = checkNotNull(cfg.neutronServer()); + this.keystoneUrl = checkNotNull(cfg.keystoneServer()); + this.userName = checkNotNull(cfg.userName()); + this.pass = checkNotNull(cfg.password()); + } + + /** + * Returns network information stored in Neutron. + * + * @return List of OpenstackNetwork + */ + public Collection<OpenstackNetwork> getNetworks() { + + WebResource.Builder builder = getClientBuilder(neutronUrl + "networks"); + String response = builder.accept(MediaType.APPLICATION_JSON_TYPE). + header("X-Auth-Token", getToken()).get(String.class); + + ObjectMapper mapper = new ObjectMapper(); + List<OpenstackNetwork> openstackNetworks = Lists.newArrayList(); + try { + ObjectNode node = (ObjectNode) mapper.readTree(response); + ArrayNode networkList = (ArrayNode) node.path("networks"); + OpenstackNetworkCodec networkCodec = new OpenstackNetworkCodec(); + networkList.forEach(n -> openstackNetworks.add(networkCodec.decode((ObjectNode) n, null))); + } catch (IOException e) { + e.printStackTrace(); + } + + log.debug("networks response:" + response); + openstackNetworks.forEach(n -> log.debug("network ID: {}", n.id())); + + return openstackNetworks; + } + + /** + * Returns port information stored in Neutron. + * + * @return List of OpenstackPort + */ + public Collection<OpenstackPort> getPorts() { + + WebResource.Builder builder = getClientBuilder(neutronUrl + "ports"); + String response = builder.accept(MediaType.APPLICATION_JSON_TYPE). + header("X-Auth-Token", getToken()).get(String.class); + + ObjectMapper mapper = new ObjectMapper(); + List<OpenstackPort> openstackPorts = Lists.newArrayList(); + try { + ObjectNode node = (ObjectNode) mapper.readTree(response); + ArrayNode portList = (ArrayNode) node.path("ports"); + OpenstackPortCodec portCodec = new OpenstackPortCodec(); + portList.forEach(p -> openstackPorts.add(portCodec.decode((ObjectNode) p, null))); + } catch (IOException e) { + e.printStackTrace(); + } + + log.debug("port response:" + response); + openstackPorts.forEach(n -> log.debug("port ID: {}", n.id())); + + return openstackPorts; + } + + /** + * Returns Subnet information in Neutron. + * + * @return List of OpenstackSubnet + */ + public Collection<OpenstackSubnet> getSubnets() { + + WebResource.Builder builder = getClientBuilder(neutronUrl + "subnets"); + String response = builder.accept(MediaType.APPLICATION_JSON_TYPE). + header("X-Auth-Token", getToken()).get(String.class); + + ObjectMapper mapper = new ObjectMapper(); + List<OpenstackSubnet> subnets = Lists.newArrayList(); + try { + ObjectNode node = (ObjectNode) mapper.readTree(response); + ArrayNode subnetList = (ArrayNode) node.path("subnets"); + OpenstackSubnetCodec subnetCodec = new OpenstackSubnetCodec(); + subnetList.forEach(s -> subnets.add(subnetCodec.decode((ObjectNode) s, null))); + } catch (IOException e) { + e.printStackTrace(); + } + + log.debug("subnets response:" + response); + subnets.forEach(s -> log.debug("subnet ID: {}", s.id())); + + return subnets; + } + + private WebResource.Builder getClientBuilder(String uri) { + Client client = Client.create(); + WebResource resource = client.resource(uri); + return resource.accept(JSON_UTF_8.toString()) + .type(JSON_UTF_8.toString()); + } + + private String getToken() { + if (isTokenInvalid()) { + String request = "{\"auth\": {\"tenantName\": \"admin\", " + + "\"passwordCredentials\": {\"username\": \"" + + userName + "\",\"password\": \"" + pass + "\"}}}"; + WebResource.Builder builder = getClientBuilder(keystoneUrl + "tokens"); + String response = builder.accept(MediaType.APPLICATION_JSON).post(String.class, request); + + ObjectMapper mapper = new ObjectMapper(); + try { + ObjectNode node = (ObjectNode) mapper.readTree(response); + tokenId = node.path("access").path("token").path("id").asText(); + } catch (IOException e) { + e.printStackTrace(); + } + log.debug("token response:" + response); + } + + return tokenId; + } + + private boolean isTokenInvalid() { + //TODO: validation check for the existing token + return true; + } + +} diff --git a/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingConfig.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingConfig.java new file mode 100644 index 00000000..ba39ff66 --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingConfig.java @@ -0,0 +1,127 @@ +/* + * Copyright 2014 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.openstackswitching; + +import org.onosproject.core.ApplicationId; +import org.onosproject.net.config.Config; +import org.onosproject.net.config.basics.BasicElementConfig; + +/** + * Handles configuration for OpenstackSwitching app. + */ +public class OpenstackSwitchingConfig extends Config<ApplicationId> { + public static final String DONOTPUSH = "do_not_push_flows"; + public static final String NEUTRON_SERVER = "neutron_server"; + public static final String KEYSTONE_SERVER = "keystone_server"; + public static final String USER_NAME = "user_name"; + public static final String PASSWORD = "password"; + + /** + * Returns the flag whether the app pushes flows or not. + * + * @return the flag or false if not set + */ + public boolean doNotPushFlows() { + String flag = get(DONOTPUSH, "false"); + return Boolean.valueOf(flag); + } + + /** + * Returns the Neutron server IP address. + * + * @return Neutron server IP + */ + public String neutronServer() { + return get(NEUTRON_SERVER, ""); + } + + /** + * Returns the Keystone server IP address. + * + * @return Keystone server IP + */ + public String keystoneServer() { + return get(KEYSTONE_SERVER, ""); + } + + /** + * Returns the username for openstack. + * + * @return username for openstack + */ + public String userName() { + return get(USER_NAME, ""); + } + + /** + * Returns the password for openstack. + * + * @return password for openstack + */ + public String password() { + return get(PASSWORD, ""); + } + + /** + * Sets the flag whether the app pushes flows or not. + * + * @param flag the flag whether the app pushes flows or not + * @return self + */ + public BasicElementConfig doNotPushFlows(boolean flag) { + return (BasicElementConfig) setOrClear(DONOTPUSH, flag); + } + + /** + * Sets the neutron server IP address. + * + * @param url neutron server IP address + * @return itself + */ + public BasicElementConfig neutronServer(String url) { + return (BasicElementConfig) setOrClear(NEUTRON_SERVER, url); + } + + /** + * Sets the keystone server IP address. + * + * @param url keystone server IP address + * @return itself + */ + public BasicElementConfig keystoneServer(String url) { + return (BasicElementConfig) setOrClear(KEYSTONE_SERVER, url); + } + + /** + * Sets the username for openstack. + * + * @param username user name for openstack + * @return itself + */ + public BasicElementConfig userName(String username) { + return (BasicElementConfig) setOrClear(USER_NAME, username); + } + + /** + * Sets the password for openstack. + * + * @param password password for openstack + * @return itself + */ + public BasicElementConfig password(String password) { + return (BasicElementConfig) setOrClear(PASSWORD, password); + } +} diff --git a/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingManager.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingManager.java new file mode 100644 index 00000000..d881d81c --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingManager.java @@ -0,0 +1,374 @@ +/* + * 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.openstackswitching; + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Reference; +import org.apache.felix.scr.annotations.ReferenceCardinality; +import org.apache.felix.scr.annotations.Service; +import org.onlab.packet.Ethernet; +import org.onlab.packet.Ip4Address; +import org.onosproject.core.ApplicationId; +import org.onosproject.core.CoreService; +import org.onosproject.dhcp.DhcpService; +import org.onosproject.net.Device; +import org.onosproject.net.DeviceId; +import org.onosproject.net.Port; +import org.onosproject.net.config.ConfigFactory; +import org.onosproject.net.config.NetworkConfigEvent; +import org.onosproject.net.config.NetworkConfigListener; +import org.onosproject.net.config.NetworkConfigRegistry; +import org.onosproject.net.device.DeviceEvent; +import org.onosproject.net.device.DeviceListener; +import org.onosproject.net.device.DeviceService; +import org.onosproject.net.driver.DriverService; +import org.onosproject.net.flowobjective.FlowObjectiveService; +import org.onosproject.net.packet.InboundPacket; +import org.onosproject.net.packet.PacketContext; +import org.onosproject.net.packet.PacketProcessor; +import org.onosproject.net.packet.PacketService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import java.util.List; +import java.util.Collection; +import java.util.Set; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.stream.Collectors; + +import static org.onosproject.net.config.basics.SubjectFactories.APP_SUBJECT_FACTORY; + +@SuppressWarnings("ALL") +@Service +@Component(immediate = true) +/** + * Populates forwarding rules for VMs created by Openstack. + */ +public class OpenstackSwitchingManager implements OpenstackSwitchingService { + + private static Logger log = LoggerFactory + .getLogger(OpenstackSwitchingManager.class); + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected CoreService coreService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected PacketService packetService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected DeviceService deviceService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected FlowObjectiveService flowObjectiveService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected DhcpService dhcpService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected NetworkConfigRegistry cfgService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected DriverService driverService; + + private ApplicationId appId; + private boolean doNotPushFlows; + private Ip4Address neutronServer; + private Ip4Address keystoneServer; + private String userName; + private String password; + private OpenstackArpHandler arpHandler; + private OpenstackRestHandler restHandler; + + private ExecutorService deviceEventExcutorService = Executors.newFixedThreadPool(10); + + private InternalPacketProcessor internalPacketProcessor = new InternalPacketProcessor(); + private InternalDeviceListener internalDeviceListener = new InternalDeviceListener(); + private InternalConfigListener internalConfigListener = new InternalConfigListener(); + private final Set<ConfigFactory> factories = ImmutableSet.of( + new ConfigFactory<ApplicationId, OpenstackSwitchingConfig>(APP_SUBJECT_FACTORY, + OpenstackSwitchingConfig.class, + "openstackswitching") { + @Override + public OpenstackSwitchingConfig createConfig() { + return new OpenstackSwitchingConfig(); + } + } + ); + + @Activate + protected void activate() { + appId = coreService + .registerApplication("org.onosproject.openstackswitching"); + + factories.forEach(cfgService::registerConfigFactory); + packetService.addProcessor(internalPacketProcessor, PacketProcessor.director(1)); + deviceService.addListener(internalDeviceListener); + cfgService.addListener(internalConfigListener); + + internalConfigListener.configureNetwork(); + + log.info("Started"); + } + + @Deactivate + protected void deactivate() { + packetService.removeProcessor(internalPacketProcessor); + deviceService.removeListener(internalDeviceListener); + cfgService.removeListener(internalConfigListener); + + deviceEventExcutorService.shutdown(); + + log.info("Stopped"); + } + + @Override + public void createPorts(OpenstackPort openstackPort) { + registerDhcpInfo(openstackPort); + } + + @Override + public void deletePorts() { + + } + + @Override + public void updatePorts() { + + } + + @Override + public void createNetwork(OpenstackNetwork openstackNetwork) { + } + + @Override + public void createSubnet(OpenstackSubnet openstackSubnet) { + } + + @Override + public Collection<OpenstackPort> ports(String networkId) { + Collection<OpenstackPort> ports = restHandler.getPorts(); + List<OpenstackPort> portList = ports.stream() + .filter(p -> p.networkId().equals(networkId)) + .collect(Collectors.toList()); + + return portList; + } + + @Override + public OpenstackPort port(Port port) { + Collection<OpenstackPort> ports = restHandler.getPorts(); + String uuid = port.annotations().value("portName").substring(3); + return ports.stream() + .filter(p -> p.id().startsWith(uuid)) + .findFirst().orElse(null); + } + + @Override + public OpenstackPort port(String portId) { + Collection<OpenstackPort> ports = restHandler.getPorts(); + return ports.stream() + .filter(p -> p.id().equals(portId)) + .findFirst().orElse(null); + } + + @Override + public OpenstackNetwork network(String networkId) { + Collection<OpenstackNetwork> networks = restHandler.getNetworks(); + return networks.stream() + .filter(n -> n.id().equals(networkId)) + .findFirst().orElse(null); + } + + private void processDeviceAdded(Device device) { + log.debug("device {} is added", device.id()); + } + + private void processPortAdded(Device device, Port port) { + if (!port.annotations().value("portName").equals("vxlan")) { + OpenstackSwitchingRulePopulator rulePopulator = + new OpenstackSwitchingRulePopulator(appId, flowObjectiveService, + deviceService, restHandler, driverService); + rulePopulator.populateSwitchingRules(device, port); + } + } + + private void processPortRemoved(Device device, Port port) { + // TODO: Remove flow rules for the VM removed + log.debug("port {} is removed", port.toString()); + } + + private void registerDhcpInfo(OpenstackPort openstackPort) { + Ip4Address ip4Address; + Ip4Address subnetMask; + Ip4Address dhcpServer; + Ip4Address gatewayIPAddress; + Ip4Address domainServer; + OpenstackSubnet openstackSubnet; + + ip4Address = (Ip4Address) openstackPort.fixedIps().values().toArray()[0]; + + openstackSubnet = restHandler.getSubnets().stream() + .filter(n -> n.networkId().equals(openstackPort.networkId())) + .findFirst().get(); + + subnetMask = Ip4Address.valueOf(buildSubnetMask(openstackSubnet.cidr())); + gatewayIPAddress = Ip4Address.valueOf(openstackSubnet.gatewayIp()); + dhcpServer = gatewayIPAddress; + // TODO: supports multiple DNS servers + if (openstackSubnet.dnsNameservers().isEmpty()) { + domainServer = Ip4Address.valueOf("8.8.8.8"); + } else { + domainServer = openstackSubnet.dnsNameservers().get(0); + } + List<Ip4Address> options = Lists.newArrayList(); + options.add(subnetMask); + options.add(dhcpServer); + options.add(gatewayIPAddress); + options.add(domainServer); + + dhcpService.setStaticMapping(openstackPort.macAddress(), ip4Address, true, options); + } + + private byte[] buildSubnetMask(String cidr) { + int prefix; + String[] parts = cidr.split("/"); + prefix = Integer.parseInt(parts[1]); + int mask = 0xffffffff << (32 - prefix); + byte[] bytes = new byte[]{(byte) (mask >>> 24), + (byte) (mask >> 16 & 0xff), (byte) (mask >> 8 & 0xff), (byte) (mask & 0xff)}; + + return bytes; + } + + + + private class InternalPacketProcessor implements PacketProcessor { + + @Override + public void process(PacketContext context) { + + if (context.isHandled()) { + return; + } + + InboundPacket pkt = context.inPacket(); + Ethernet ethernet = pkt.parsed(); + + if (ethernet.getEtherType() == Ethernet.TYPE_ARP) { + arpHandler.processPacketIn(pkt); + } + } + } + + private class InternalDeviceListener implements DeviceListener { + + @Override + public void event(DeviceEvent deviceEvent) { + deviceEventExcutorService.execute(new InternalEventHandler(deviceEvent)); + } + } + + private class InternalEventHandler implements Runnable { + + volatile DeviceEvent deviceEvent; + + InternalEventHandler(DeviceEvent deviceEvent) { + this.deviceEvent = deviceEvent; + } + + @Override + public void run() { + + if (doNotPushFlows) { + return; + } + + switch (deviceEvent.type()) { + case DEVICE_ADDED: + processDeviceAdded((Device) deviceEvent.subject()); + break; + case DEVICE_UPDATED: + Port port = (Port) deviceEvent.subject(); + if (port.isEnabled()) { + processPortAdded((Device) deviceEvent.subject(), deviceEvent.port()); + } + break; + case DEVICE_AVAILABILITY_CHANGED: + Device device = (Device) deviceEvent.subject(); + if (deviceService.isAvailable(device.id())) { + processDeviceAdded(device); + } + break; + case PORT_ADDED: + processPortAdded((Device) deviceEvent.subject(), deviceEvent.port()); + break; + case PORT_UPDATED: + processPortAdded((Device) deviceEvent.subject(), deviceEvent.port()); + break; + case PORT_REMOVED: + processPortRemoved((Device) deviceEvent.subject(), deviceEvent.port()); + break; + default: + break; + } + } + } + + private class InternalConfigListener implements NetworkConfigListener { + + public void configureNetwork() { + OpenstackSwitchingConfig cfg = + cfgService.getConfig(appId, OpenstackSwitchingConfig.class); + if (cfg == null) { + log.error("There is no openstack server information in config."); + return; + } + doNotPushFlows = cfg.doNotPushFlows(); + restHandler = new OpenstackRestHandler(cfg); + arpHandler = new OpenstackArpHandler(restHandler, packetService); + } + + @Override + public void event(NetworkConfigEvent event) { + if (((event.type() == NetworkConfigEvent.Type.CONFIG_ADDED || + event.type() == NetworkConfigEvent.Type.CONFIG_UPDATED)) && + event.configClass().equals(OpenstackSwitchingConfig.class)) { + configureNetwork(); + } + } + + } + + private final class PortInfo { + DeviceId deviceId; + String portName; + Ip4Address fixedIp; + Ip4Address hostIp; + + private PortInfo(DeviceId deviceId, String portName, Ip4Address fixedIp, + Ip4Address hostIp) { + this.deviceId = deviceId; + this.portName = portName; + this.fixedIp = fixedIp; + this.hostIp = hostIp; + } + } + +}
\ No newline at end of file diff --git a/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingRulePopulator.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingRulePopulator.java new file mode 100644 index 00000000..38c03638 --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingRulePopulator.java @@ -0,0 +1,307 @@ +/* +* 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.openstackswitching; + +import org.onlab.packet.Ethernet; +import org.onlab.packet.Ip4Address; +import org.onlab.packet.MacAddress; +import org.onosproject.core.ApplicationId; +import org.onosproject.net.Device; +import org.onosproject.net.DeviceId; +import org.onosproject.net.Port; +import org.onosproject.net.PortNumber; +import org.onosproject.net.behaviour.ExtensionTreatmentResolver; +import org.onosproject.net.device.DeviceService; +import org.onosproject.net.driver.DefaultDriverData; +import org.onosproject.net.driver.DefaultDriverHandler; +import org.onosproject.net.driver.Driver; +import org.onosproject.net.driver.DriverHandler; +import org.onosproject.net.driver.DriverService; +import org.onosproject.net.flow.DefaultTrafficSelector; +import org.onosproject.net.flow.DefaultTrafficTreatment; +import org.onosproject.net.flow.TrafficSelector; +import org.onosproject.net.flow.TrafficTreatment; +import org.onosproject.net.flow.instructions.ExtensionTreatment; +import org.onosproject.net.flow.instructions.ExtensionPropertyException; +import org.onosproject.net.flow.instructions.ExtensionTreatmentType; +import org.onosproject.net.flowobjective.DefaultForwardingObjective; +import org.onosproject.net.flowobjective.FlowObjectiveService; +import org.onosproject.net.flowobjective.ForwardingObjective; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Collection; + +/** + * Populates switching flow rules. + */ +public class OpenstackSwitchingRulePopulator { + + private static Logger log = LoggerFactory + .getLogger(OpenstackSwitchingRulePopulator.class); + private static final int SWITCHING_RULE_PRIORITY = 50000; + + private FlowObjectiveService flowObjectiveService; + private DriverService driverService; + private DeviceService deviceService; + private OpenstackRestHandler restHandler; + private ApplicationId appId; + + private Collection<OpenstackNetwork> openstackNetworkList; + private Collection<OpenstackPort> openstackPortList; + + /** + * Creates OpenstackSwitchingRulPopulator. + * + * @param appId application id + * @param flowObjectiveService FlowObjectiveService reference + * @param deviceService DeviceService reference + * @param driverService DriverService reference + */ + public OpenstackSwitchingRulePopulator(ApplicationId appId, + FlowObjectiveService flowObjectiveService, + DeviceService deviceService, + OpenstackRestHandler restHandler, + DriverService driverService) { + this.flowObjectiveService = flowObjectiveService; + this.deviceService = deviceService; + this.driverService = driverService; + this.restHandler = restHandler; + this.appId = appId; + + openstackNetworkList = restHandler.getNetworks(); + openstackPortList = restHandler.getPorts(); + } + + /** + * Populates flow rules for the VM created. + * + * @param device device to populate rules to + * @param port port for the VM created + */ + public void populateSwitchingRules(Device device, Port port) { + populateFlowRulesForTrafficToSameCnode(device, port); + populateFlowRulesForTrafficToDifferentCnode(device, port); + } + + /** + * Populates the flow rules for traffic to VMs in the same Cnode as the sender. + * + * @param device device to put the rules + * @param port port info of the VM + */ + private void populateFlowRulesForTrafficToSameCnode(Device device, Port port) { + Ip4Address vmIp = getFixedIpAddressForPort(port.annotations().value("portName")); + if (vmIp != null) { + setFlowRuleForVMsInSameCnode(vmIp, device.id(), port); + } + } + + /** + * Populates the flow rules for traffic to VMs in different Cnode using + * Nicira extention. + * + * @param device device to put rules + * @param port port information of the VM + */ + private void populateFlowRulesForTrafficToDifferentCnode(Device device, Port port) { + String portName = port.annotations().value("portName"); + String channelId = device.annotations().value("channelId"); + Ip4Address hostIpAddress = Ip4Address.valueOf(channelId.split(":")[0]); + Ip4Address fixedIp = getFixedIpAddressForPort(portName); + MacAddress vmMac = getVmMacAddressForPort(portName); + String vni = getVniForPort(portName); + deviceService.getAvailableDevices().forEach(d -> { + if (!d.equals(device)) { + deviceService.getPorts(d.id()).forEach(p -> { + String pName = p.annotations().value("portName"); + if (!p.equals(port) && vni.equals(getVniForPort(pName))) { + String cidx = d.annotations().value("channelId"); + Ip4Address hostIpx = Ip4Address.valueOf(cidx.split(":")[0]); + MacAddress vmMacx = getVmMacAddressForPort(pName); + Ip4Address fixedIpx = getFixedIpAddressForPort(pName); + + setVxLanFlowRule(vni, device.id(), hostIpx, fixedIpx, vmMacx); + setVxLanFlowRule(vni, d.id(), hostIpAddress, fixedIp, vmMac); + } + }); + } + }); + } + + /** + * Returns the VNI of the VM of the port. + * + * @param portName VM port + * @return VNI + */ + private String getVniForPort(String portName) { + String uuid = portName.substring(3); + OpenstackPort port = openstackPortList.stream() + .filter(p -> p.id().startsWith(uuid)) + .findAny().orElse(null); + if (port == null) { + log.warn("No port information for port {}", portName); + return null; + } + + OpenstackNetwork network = openstackNetworkList.stream() + .filter(n -> n.id().equals(port.networkId())) + .findAny().orElse(null); + if (network == null) { + log.warn("No VNI information for network {}", port.networkId()); + return null; + } + + return network.segmentId(); + } + + /** + * Returns the Fixed IP address of the VM. + * + * @param portName VM port info + * @return IP address of the VM + */ + private Ip4Address getFixedIpAddressForPort(String portName) { + + String uuid = portName.substring(3); + OpenstackPort port = openstackPortList.stream() + .filter(p -> p.id().startsWith(uuid)) + .findFirst().orElse(null); + + if (port == null) { + log.error("There is no port information for port name {}", portName); + return null; + } + + if (port.fixedIps().isEmpty()) { + log.error("There is no fixed IP info in the port information"); + return null; + } + + return (Ip4Address) port.fixedIps().values().toArray()[0]; + } + + /** + * Returns the MAC address of the VM of the port. + * + * @param portName VM port + * @return MAC address of the VM + */ + private MacAddress getVmMacAddressForPort(String portName) { + + String uuid = portName.substring(3); + OpenstackPort port = openstackPortList.stream() + .filter(p -> p.id().startsWith(uuid)) + .findFirst().orElse(null); + + if (port == null) { + log.error("There is port information for port name {}", portName); + return null; + } + + return port.macAddress(); + } + + /** + * Sets the flow rules for traffic between VMs in the same Cnode. + * + * @param ip4Address VM IP address + * @param id device ID to put rules + * @param port VM port + */ + private void setFlowRuleForVMsInSameCnode(Ip4Address ip4Address, DeviceId id, + Port port) { + TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder(); + TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder(); + + sBuilder.matchEthType(Ethernet.TYPE_IPV4) + .matchIPDst(ip4Address.toIpPrefix()); + tBuilder.setOutput(port.number()); + + ForwardingObjective fo = DefaultForwardingObjective.builder() + .withSelector(sBuilder.build()) + .withTreatment(tBuilder.build()) + .withPriority(SWITCHING_RULE_PRIORITY) + .withFlag(ForwardingObjective.Flag.VERSATILE) + .fromApp(appId) + .add(); + + flowObjectiveService.forward(id, fo); + } + + /** + * Sets the flow rules between traffic from VMs in different Cnode. + * + * @param vni VNI + * @param id device ID + * @param hostIp host IP of the VM + * @param vmIp fixed IP of the VM + * @param vmMac MAC address of the VM + */ + private void setVxLanFlowRule(String vni, DeviceId id, Ip4Address hostIp, + Ip4Address vmIp, MacAddress vmMac) { + TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder(); + TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder(); + + sBuilder.matchEthType(Ethernet.TYPE_IPV4) + .matchIPDst(vmIp.toIpPrefix()); + tBuilder.setTunnelId(Long.parseLong(vni)) + .extension(buildNiciraExtenstion(id, hostIp), id) + .setOutput(getTunnelPort(id)); + + ForwardingObjective fo = DefaultForwardingObjective.builder() + .withSelector(sBuilder.build()) + .withTreatment(tBuilder.build()) + .withPriority(SWITCHING_RULE_PRIORITY) + .withFlag(ForwardingObjective.Flag.VERSATILE) + .fromApp(appId) + .add(); + + flowObjectiveService.forward(id, fo); + } + + private ExtensionTreatment buildNiciraExtenstion(DeviceId id, Ip4Address hostIp) { + Driver driver = driverService.getDriver(id); + DriverHandler driverHandler = new DefaultDriverHandler(new DefaultDriverData(driver, id)); + ExtensionTreatmentResolver resolver = driverHandler.behaviour(ExtensionTreatmentResolver.class); + + ExtensionTreatment extensionInstruction = + resolver.getExtensionInstruction( + ExtensionTreatmentType.ExtensionTreatmentTypes.NICIRA_SET_TUNNEL_DST.type()); + + try { + extensionInstruction.setPropertyValue("tunnelDst", hostIp); + } catch (ExtensionPropertyException e) { + log.error("Error setting Nicira extension setting {}", e); + } + + return extensionInstruction; + } + + private PortNumber getTunnelPort(DeviceId id) { + Port port = deviceService.getPorts(id).stream() + .filter(p -> p.annotations().value("portName").equals("vxlan")) + .findAny().orElse(null); + + if (port == null) { + log.error("No TunnelPort was created."); + return null; + } + return port.number(); + } +} diff --git a/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/package-info.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/package-info.java new file mode 100644 index 00000000..cd50f912 --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/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. + */ + +/** + * OpenStack switch interface. + */ +package org.onosproject.openstackswitching; diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkCodec.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkCodec.java index fc1509d4..0a0b5dce 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkCodec.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkCodec.java @@ -43,6 +43,9 @@ public class OpenstackNetworkCodec extends JsonCodec<OpenstackNetwork> { public OpenstackNetwork decode(ObjectNode json, CodecContext context) { JsonNode networkInfo = json.get(NETWORK); + if (networkInfo == null) { + networkInfo = json; + } String name = networkInfo.path(NAME).asText(); String tenantId = networkInfo.path(TENANT_ID).asText(); diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkWebResource.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkWebResource.java index f4c401fb..bf04cc4d 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkWebResource.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackNetworkWebResource.java @@ -15,48 +15,52 @@ */ package org.onosproject.openstackswitching.web; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.node.ObjectNode; -import org.onosproject.openstackswitching.OpenstackNetwork; -import org.onosproject.openstackswitching.OpenstackSwitchingService; import org.onosproject.rest.AbstractWebResource; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.ws.rs.Consumes; +import javax.ws.rs.DELETE; import javax.ws.rs.POST; +import javax.ws.rs.PUT; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import java.io.InputStream; +/** + * Handles REST API call of Neutron ML2 plugin. + */ @Path("networks") public class OpenstackNetworkWebResource extends AbstractWebResource { protected static final Logger log = LoggerFactory .getLogger(OpenstackNetworkWebResource.class); - private static final OpenstackNetworkCodec NETWORK_CODEC = new OpenstackNetworkCodec(); - @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response createNetwork(InputStream input) { - try { - ObjectMapper mapper = new ObjectMapper(); - ObjectNode networkNode = (ObjectNode) mapper.readTree(input); + log.debug("REST API networks is called {}", input.toString()); + return Response.status(Response.Status.OK).build(); + } - OpenstackNetwork openstackNetwork = NETWORK_CODEC.decode(networkNode, this); + @PUT + @Path("{id}") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public Response updateNetwork(InputStream input) { + log.debug("REST API networks is called {}", input.toString()); + return Response.status(Response.Status.OK).build(); + } - OpenstackSwitchingService switchingService = get(OpenstackSwitchingService.class); - switchingService.createNetwork(openstackNetwork); - return Response.status(Response.Status.OK).build(); - } catch (Exception e) { - log.error("Creates VirtualPort failed because of exception {}", - e.toString()); - return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.toString()) - .build(); - } + @DELETE + @Path("{id}") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public Response deleteNetwork(InputStream input) { + log.debug("REST API networks is called {}", input.toString()); + return Response.status(Response.Status.OK).build(); } } diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortCodec.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortCodec.java index 765b6901..63e6d2ea 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortCodec.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortCodec.java @@ -29,7 +29,7 @@ import org.slf4j.LoggerFactory; import java.util.HashMap; /** - * It encodes and decodes the OpenstackPort. + * Encodes and decodes the OpenstackPort. */ public class OpenstackPortCodec extends JsonCodec<OpenstackPort> { @@ -58,6 +58,9 @@ public class OpenstackPortCodec extends JsonCodec<OpenstackPort> { HashMap<String, Ip4Address> fixedIpMap = new HashMap<>(); JsonNode portInfo = json.get(PORT); + if (portInfo == null) { + portInfo = json; + } String status = portInfo.path(STATUS).asText(); String name = portInfo.path(NAME).asText(); diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortWebResource.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortWebResource.java index 67a9cebb..faffa732 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortWebResource.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackPortWebResource.java @@ -33,6 +33,9 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import java.io.InputStream; +/** + * Handles Rest API call from Neutron ML2 plugin. + */ @Path("ports") public class OpenstackPortWebResource extends AbstractWebResource { @@ -50,13 +53,15 @@ public class OpenstackPortWebResource extends AbstractWebResource { ObjectNode portNode = (ObjectNode) mapper.readTree(input); OpenstackPort openstackPort = PORT_CODEC.decode(portNode, this); - - OpenstackSwitchingService switchingService = get(OpenstackSwitchingService.class); + OpenstackSwitchingService switchingService = + getService(OpenstackSwitchingService.class); switchingService.createPorts(openstackPort); - log.info("REST API ports is called with {}", portNode.toString()); + + log.debug("REST API ports is called with {}", portNode.toString()); return Response.status(Response.Status.OK).build(); + } catch (Exception e) { - log.error("Creates VirtualPort failed because of exception {}", + log.error("Creates Port failed because of exception {}", e.toString()); return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.toString()) .build(); @@ -64,23 +69,12 @@ public class OpenstackPortWebResource extends AbstractWebResource { } @DELETE + @Path("{id}") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response deletesPorts(InputStream input) { - try { - ObjectMapper mapper = new ObjectMapper(); - ObjectNode portNode = (ObjectNode) mapper.readTree(input); - - OpenstackSwitchingService switchingService = get(OpenstackSwitchingService.class); - switchingService.deletePorts(); - log.info("REST API ports is called with {}", portNode.toString()); - return Response.status(Response.Status.OK).build(); - } catch (Exception e) { - log.error("Delete VirtualPort failed because of exception {}", - e.toString()); - return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.toString()) - .build(); - } + log.debug("REST API ports is called with {}", input.toString()); + return Response.status(Response.Status.OK).build(); } @PUT @@ -88,19 +82,7 @@ public class OpenstackPortWebResource extends AbstractWebResource { @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response updatePorts(InputStream input) { - try { - ObjectMapper mapper = new ObjectMapper(); - ObjectNode portNode = (ObjectNode) mapper.readTree(input); - - OpenstackSwitchingService switchingService = get(OpenstackSwitchingService.class); - switchingService.updatePorts(); - log.info("REST API ports is called with {}", portNode.toString()); - return Response.status(Response.Status.OK).build(); - } catch (Exception e) { - log.error("Update VirtualPort failed because of exception {}", - e.toString()); - return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.toString()) - .build(); - } + log.info("REST API ports is called with {}", input.toString()); + return Response.status(Response.Status.OK).build(); } } diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetCodec.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetCodec.java index a643057a..2a7af82a 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetCodec.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetCodec.java @@ -18,17 +18,21 @@ package org.onosproject.openstackswitching.web; import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; +import com.google.common.collect.Lists; +import org.onlab.packet.Ip4Address; import org.onosproject.codec.CodecContext; import org.onosproject.codec.JsonCodec; import org.onosproject.openstackswitching.OpenstackSubnet; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.util.List; + /** - * It encodes and decodes the OpenstackSubnet. + * Encodes and decodes the OpenstackSubnet. */ - public class OpenstackSubnetCodec extends JsonCodec<OpenstackSubnet> { private static Logger log = LoggerFactory .getLogger(OpenstackSubnetCodec.class); @@ -47,12 +51,19 @@ public class OpenstackSubnetCodec extends JsonCodec<OpenstackSubnet> { @Override public OpenstackSubnet decode(ObjectNode json, CodecContext context) { JsonNode subnetInfo = json.get(SUBNET); + if (subnetInfo == null) { + subnetInfo = json; + } String name = subnetInfo.path(NAME).asText(); boolean enableDhcp = subnetInfo.path(ENABLE_DHCP).asBoolean(); String networkId = subnetInfo.path(NETWORK_ID).asText(); String tenantId = subnetInfo.path(TENANT_ID).asText(); - String dnsNameservsers = subnetInfo.path(DNS_NAMESERVERS).asText(); + ArrayNode dnsNameservsers = (ArrayNode) subnetInfo.path(DNS_NAMESERVERS); + List<Ip4Address> dnsList = Lists.newArrayList(); + if (dnsNameservsers != null && !dnsNameservsers.isMissingNode()) { + dnsNameservsers.forEach(dns -> dnsList.add(Ip4Address.valueOf(dns.asText()))); + } String gatewayIp = subnetInfo.path(GATEWAY_IP).asText(); String cidr = subnetInfo.path(CIDR).asText(); String id = subnetInfo.path(ID).asText(); @@ -62,7 +73,7 @@ public class OpenstackSubnetCodec extends JsonCodec<OpenstackSubnet> { .setEnableDhcp(enableDhcp) .setNetworkId(networkId) .setTenantId(tenantId) - .setDnsNameservers(dnsNameservsers) + .setDnsNameservers(dnsList) .setGatewayIp(gatewayIp) .setCidr(cidr) .setId(id) diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetWebResource.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetWebResource.java index af1ae9dd..43205eac 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetWebResource.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/OpenstackSubnetWebResource.java @@ -15,18 +15,19 @@ */ package org.onosproject.openstackswitching.web; - -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.node.ObjectNode; -import org.onosproject.openstackswitching.OpenstackSubnet; -import org.onosproject.openstackswitching.OpenstackSwitchingService; +/** + * Handles Rest API call from Neutron ML2 plugin. + */ import org.onosproject.rest.AbstractWebResource; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.ws.rs.Consumes; +import javax.ws.rs.DELETE; import javax.ws.rs.POST; +import javax.ws.rs.PUT; import javax.ws.rs.Path; +import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; @@ -37,28 +38,32 @@ public class OpenstackSubnetWebResource extends AbstractWebResource { protected static final Logger log = LoggerFactory .getLogger(OpenstackSubnetWebResource.class); - private static final OpenstackSubnetCodec SUBNET_CODEC = new OpenstackSubnetCodec(); - @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response createSubnet(InputStream input) { - try { - ObjectMapper mapper = new ObjectMapper(); - ObjectNode subnetNode = (ObjectNode) mapper.readTree(input); + return Response.status(Response.Status.OK).build(); + } + + + @PUT + @Path("{subnetUUID}") + @Produces(MediaType.APPLICATION_JSON) + @Consumes(MediaType.APPLICATION_JSON) + public Response updateSubnet(@PathParam("id") String id, + final InputStream input) { + return Response.status(Response.Status.OK).build(); - OpenstackSubnet openstackSubnet = SUBNET_CODEC.decode(subnetNode, this); + } - OpenstackSwitchingService switchingService = get(OpenstackSwitchingService.class); - switchingService.createSubnet(openstackSubnet); - log.info("REST API subnets is called with {}", subnetNode.toString()); - return Response.status(Response.Status.OK).build(); - } catch (Exception e) { - log.error("Creates VirtualSubnet failed because of exception {}", - e.toString()); - return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.toString()) - .build(); - } + @DELETE + @Path("{subnetUUID}") + @Produces(MediaType.APPLICATION_JSON) + @Consumes(MediaType.APPLICATION_JSON) + public Response deleteSubnet(@PathParam("id") String id, + final InputStream input) { + return Response.status(Response.Status.OK).build(); } + } diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/package-info.java b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/package-info.java index 91e19c62..91e19c62 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/web/package-info.java +++ b/framework/src/onos/apps/openstackswitching/app/src/main/java/org/onosproject/openstackswitching/web/package-info.java diff --git a/framework/src/onos/apps/openstackswitching/src/main/webapp/WEB-INF/web.xml b/framework/src/onos/apps/openstackswitching/app/src/main/webapp/WEB-INF/web.xml index 4f50ef72..4f50ef72 100644 --- a/framework/src/onos/apps/openstackswitching/src/main/webapp/WEB-INF/web.xml +++ b/framework/src/onos/apps/openstackswitching/app/src/main/webapp/WEB-INF/web.xml diff --git a/framework/src/onos/apps/openstackswitching/network-cfg.json b/framework/src/onos/apps/openstackswitching/network-cfg.json new file mode 100644 index 00000000..62c3a515 --- /dev/null +++ b/framework/src/onos/apps/openstackswitching/network-cfg.json @@ -0,0 +1,55 @@ +{ + "apps" : { + "org.onosproject.openstackswitching" : { + "openstackswitching" : { + "do_not_push_flows" : "false", + "neutron_server" : "http://127.0.0.1:9696/v2.0/", + "keystone_server" : "http://127.0.0.1:5000/v2.0/", + "user_name" : "admin", + "password" : "nova" + } + }, + "org.onosproject.dhcp" : { + "dhcp" : { + "ip": "10.0.0.1", + "mac": "1a:2b:3c:4e:5e:6f", + "subnet": "255.0.0.0", + "broadcast": "10.255.255.255", + "router": "10.0.0.1", + "domain": "10.0.0.1", + "ttl": "63", + "lease": "300", + "renew": "150", + "rebind": "200", + "delay": "3", + "timeout": "150", + "startip": "10.0.0.110", + "endip": "10.0.0.130" + } + }, + "org.onosproject.cordvtn" : { + "cordvtn" : { + "ovsdbNodes" : [ + { + "host" : "compute-01", + "ip" : "128.199.162.106", + "port" : "6640", + "bridgeId" : "of:0000000000000001" + }, + { + "host" : "compute-02", + "ip" : "103.253.145.133", + "port" : "6640", + "bridgeId" : "of:0000000000000002" + }, + { + "host" : "network", + "ip" : "128.199.125.11", + "port" : "6640", + "bridgeId" : "of:0000000000000003" + } + ] + } + } + } +} diff --git a/framework/src/onos/apps/openstackswitching/pom.xml b/framework/src/onos/apps/openstackswitching/pom.xml index 52129b6f..9dbdcf5f 100644 --- a/framework/src/onos/apps/openstackswitching/pom.xml +++ b/framework/src/onos/apps/openstackswitching/pom.xml @@ -26,101 +26,18 @@ <relativePath>../pom.xml</relativePath> </parent> - <artifactId>onos-app-openstackswitching</artifactId> - <packaging>bundle</packaging> + <artifactId>onos-openstackswitching</artifactId> + <packaging>pom</packaging> - <description>SONA Openstack Switching applications</description> - <properties> - <onos.version>1.4.0-SNAPSHOT</onos.version> - <onos.app.name>org.onosproject.openstackswitching</onos.app.name> - <web.context>/onos/openstackswitching</web.context> - <api.version>1.0.0</api.version> - <api.title>ONOS OpenStack Switching REST API</api.title> - <api.description> - APIs for receiving Neutron information. - </api.description> - <api.package>org.onosproject.openstackswitching.web</api.package> - <onos.app.origin>SKT, Inc.</onos.app.origin> - </properties> + <description>SONA Openstack Switching application</description> + <modules> + <module>api</module> + <module>app</module> + </modules> <dependencies> - <dependency> - <groupId>org.onosproject</groupId> - <artifactId>onos-rest</artifactId> - <version>${project.version}</version> - </dependency> - <dependency> - <groupId>org.onosproject</groupId> - <artifactId>onlab-rest</artifactId> - <version>${project.version}</version> - </dependency> - <dependency> - <groupId>javax.ws.rs</groupId> - <artifactId>jsr311-api</artifactId> - <version>1.1.1</version> - </dependency> - <dependency> - <groupId>com.sun.jersey</groupId> - <artifactId>jersey-servlet</artifactId> - </dependency> - <dependency> - <groupId>com.fasterxml.jackson.core</groupId> - <artifactId>jackson-databind</artifactId> - </dependency> - <dependency> - <groupId>com.fasterxml.jackson.core</groupId> - <artifactId>jackson-annotations</artifactId> - </dependency> - <dependency> - <groupId>org.osgi</groupId> - <artifactId>org.osgi.compendium</artifactId> - </dependency> - <dependency> - <groupId>org.osgi</groupId> - <artifactId>org.osgi.core</artifactId> - </dependency> - <dependency> - <groupId>org.onosproject</groupId> - <artifactId>onos-app-dhcp-api</artifactId> - <version>${project.version}</version> - </dependency> </dependencies> - <build> - <plugins> - <plugin> - <groupId>org.apache.felix</groupId> - <artifactId>maven-bundle-plugin</artifactId> - <extensions>true</extensions> - <configuration> - <instructions> - <_wab>src/main/webapp/</_wab> - <Bundle-SymbolicName> - ${project.groupId}.${project.artifactId} - </Bundle-SymbolicName> - <Import-Package> - org.slf4j, - org.osgi.framework, - javax.ws.rs, - javax.ws.rs.core, - com.sun.jersey.api.core, - com.sun.jersey.spi.container.servlet, - com.sun.jersey.server.impl.container.servlet, - com.fasterxml.jackson.databind, - com.fasterxml.jackson.databind.node, - com.fasterxml.jackson.core, - org.apache.karaf.shell.commands, - com.google.common.*, - org.onlab.packet.*, - org.onosproject.* - </Import-Package> - <Web-ContextPath>${web.context}</Web-ContextPath> - </instructions> - </configuration> - </plugin> - </plugins> - </build> - </project> diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingManager.java b/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingManager.java deleted file mode 100644 index 4be8a50d..00000000 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingManager.java +++ /dev/null @@ -1,471 +0,0 @@ -/* - * 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.openstackswitching; - -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import org.apache.felix.scr.annotations.Activate; -import org.apache.felix.scr.annotations.Component; -import org.apache.felix.scr.annotations.Deactivate; -import org.apache.felix.scr.annotations.Reference; -import org.apache.felix.scr.annotations.ReferenceCardinality; -import org.apache.felix.scr.annotations.Service; -import org.onlab.packet.Ethernet; -import org.onlab.packet.Ip4Address; -import org.onlab.packet.Ip4Prefix; -import org.onlab.packet.MacAddress; -import org.onosproject.core.ApplicationId; -import org.onosproject.core.CoreService; -import org.onosproject.dhcp.DhcpService; -import org.onosproject.net.Device; -import org.onosproject.net.DeviceId; -import org.onosproject.net.Port; -import org.onosproject.net.device.DeviceEvent; -import org.onosproject.net.device.DeviceListener; -import org.onosproject.net.device.DeviceService; -import org.onosproject.net.flowobjective.FlowObjectiveService; -import org.onosproject.net.packet.InboundPacket; -import org.onosproject.net.packet.PacketContext; -import org.onosproject.net.packet.PacketProcessor; -import org.onosproject.net.packet.PacketService; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.List; -import java.util.Map; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; - -@SuppressWarnings("ALL") -@Service -@Component(immediate = true) -/** - * It populates forwarding rules for VMs created by Openstack. - */ -public class OpenstackSwitchingManager implements OpenstackSwitchingService { - - private static Logger log = LoggerFactory - .getLogger(OpenstackSwitchingManager.class); - - @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) - protected CoreService coreService; - - @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) - protected PacketService packetService; - - @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) - protected DeviceService deviceService; - - @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) - protected FlowObjectiveService flowObjectiveService; - - @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) - protected DhcpService dhcpService; - - public static final int DHCP_PORT = 67; - - private ApplicationId appId; - private OpenstackArpHandler arpHandler; - - private OpenstackSwitchingRulePopulator rulePopulator; - private ExecutorService deviceEventExcutorService = Executors.newFixedThreadPool(10); - - private InternalPacketProcessor internalPacketProcessor = new InternalPacketProcessor(); - private InternalDeviceListener internalDeviceListener = new InternalDeviceListener(); - - // Map <port_id, OpenstackPort> - private Map<String, OpenstackPort> openstackPortMap; - // Map <network_id, OpenstackNetwork> - private Map<String, OpenstackNetwork> openstackNetworkMap; - // Map <subnet_id, OpenstackSubner> - private Map<String, OpenstackSubnet> openstackSubnetMap; - // Map <vni, List <Entry <portName, host ip>> - private Map<String, List<PortInfo>> vniPortMap; - private Map<Ip4Address, Port> tunnelPortMap; - - - @Activate - protected void activate() { - appId = coreService - .registerApplication("org.onosproject.openstackswitching"); - rulePopulator = new OpenstackSwitchingRulePopulator(appId, flowObjectiveService); - packetService.addProcessor(internalPacketProcessor, PacketProcessor.director(1)); - deviceService.addListener(internalDeviceListener); - - openstackPortMap = Maps.newHashMap(); - openstackNetworkMap = Maps.newHashMap(); - openstackSubnetMap = Maps.newHashMap(); - - vniPortMap = Maps.newHashMap(); - tunnelPortMap = Maps.newHashMap(); - arpHandler = new OpenstackArpHandler(openstackPortMap, packetService); - log.info("Started"); - } - - @Deactivate - protected void deactivate() { - packetService.removeProcessor(internalPacketProcessor); - deviceService.removeListener(internalDeviceListener); - - deviceEventExcutorService.shutdown(); - - log.info("Stopped"); - } - - @Override - public void createPorts(OpenstackPort openstackPort) { - //For DHCP purpose - //registerDhcpInfo(openstackPort); - openstackPortMap.put(openstackPort.id(), openstackPort); - } - - /* - private void registerDhcpInfo(OpenstackPort openstackPort) { - Ip4Address ip4Address; - Ip4Address subnetMask; - Ip4Address dhcpServer; - Ip4Address gatewayIPAddress; - Ip4Address domainServer; - OpenstackSubnet openstackSubnet; - - ip4Address = (Ip4Address) openstackPort.fixedIps().values().toArray()[0]; - - openstackSubnet = openstackSubnetMap.values().stream() - .filter(n -> n.networkId().equals(openstackPort.networkId())) - .findFirst().get(); - - int prefix; - String[] parts = openstackSubnet.cidr().split("/"); - prefix = Integer.parseInt(parts[1]); - int mask = 0xffffffff << (32 - prefix); - byte[] bytes = new byte[]{(byte) (mask >>> 24), - (byte) (mask >> 16 & 0xff), (byte) (mask >> 8 & 0xff), (byte) (mask & 0xff)}; - - subnetMask = Ip4Address.valueOf(bytes); - gatewayIPAddress = Ip4Address.valueOf(openstackSubnet.gatewayIp()); - dhcpServer = gatewayIPAddress; - domainServer = Ip4Address.valueOf("8.8.8.8"); - - dhcpService.setStaticMappingOpenstack(openstackPort.macAddress(), - ip4Address, subnetMask, dhcpServer, gatewayIPAddress, domainServer); - } - */ - - @Override - public void deletePorts() { - - } - - @Override - public void updatePorts() { - - } - - @Override - public void createNetwork(OpenstackNetwork openstackNetwork) { - openstackNetworkMap.put(openstackNetwork.id(), openstackNetwork); - } - - - @Override - public void createSubnet(OpenstackSubnet openstackSubnet) { - openstackSubnetMap.put(openstackSubnet.id(), openstackSubnet); - log.debug("Added Subnet Info {}", openstackNetworkMap.get(openstackSubnet.id())); - } - - private void processDeviceAdded(Device device) { - log.debug("device {} is added", device.id()); - rulePopulator.populateDefaultRules(device.id()); - } - - private void processPortAdded(Device device, Port port) { - // TODO: Simplify the data structure to store the network info - // TODO: Make it stateless - // TODO: All the logics need to be processed inside of the rulePopulator class - synchronized (vniPortMap) { - log.debug("port {} is updated", port.toString()); - - updatePortMaps(device, port); - if (!port.annotations().value("portName").equals("vxlan")) { - populateFlowRulesForTrafficToSameCnode(device, port); - populateFlowRulesForTrafficToDifferentCnode(device, port); - } - } - } - - private void processPortRemoved(Device device, Port port) { - log.debug("port {} is removed", port.toString()); - // TODO: need to update the vniPortMap - } - - /** - * Populates the flow rules for traffic to VMs in different Cnode using - * Nicira extention. - * - * @param device device to put rules - * @param port port information of the VM - */ - private void populateFlowRulesForTrafficToDifferentCnode(Device device, Port port) { - String portName = port.annotations().value("portName"); - String channelId = device.annotations().value("channelId"); - Ip4Address hostIpAddress = Ip4Address.valueOf(channelId.split(":")[0]); - Ip4Address fixedIp = getFixedIpAddressForPort(portName); - // TODO: Avoid duplicate flow rule set up for VMs in other Cnode - // (possibly avoided by flowrule subsystem?) - if (tunnelPortMap.get(hostIpAddress) == null) { - log.debug("There is no tunnel port information"); - return; - } - String vni = getVniForPort(portName); - MacAddress vmMac = getVmMacAddressForPort(portName); - if (!vniPortMap.isEmpty() && vniPortMap.get(vni) != null) { - for (PortInfo portInfo : vniPortMap.get(vni)) { - if (!portInfo.portName.equals(portName) && - !portInfo.hostIp.equals(hostIpAddress)) { - MacAddress vmMacx = getVmMacAddressForPort(portInfo.portName); - rulePopulator.populateForwardingRuleForOtherCnode(vni, - device.id(), portInfo.hostIp, portInfo.fixedIp, vmMacx, - tunnelPortMap.get(hostIpAddress).number(), - portInfo.deviceId, hostIpAddress, fixedIp, vmMac, - tunnelPortMap.get(portInfo.hostIp).number()); - } - } - } - } - - /** - * Populates the flow rules for traffic to VMs in the same Cnode as the sender. - * - * @param device device to put the rules - * @param port port info of the VM - */ - private void populateFlowRulesForTrafficToSameCnode(Device device, Port port) { - Ip4Prefix cidr = getCidrForPort(port.annotations().value("portName")); - Ip4Address vmIp = getFixedIpAddressForPort(port.annotations().value("portName")); - if (vmIp != null) { - rulePopulator.populateForwardingRule(vmIp, device.id(), port, cidr); - } - } - - /** - * Updates the port maps using the port information. - * - * @param device device info - * @param port port of the VM - */ - private void updatePortMaps(Device device, Port port) { - String portName = port.annotations().value("portName"); - String channelId = device.annotations().value("channelId"); - Ip4Address hostIpAddress = Ip4Address.valueOf(channelId.split(":")[0]); - if (portName.startsWith("vxlan")) { - tunnelPortMap.put(hostIpAddress, port); - } else { - String vni = getVniForPort(portName); - Ip4Address fixedIp = getFixedIpAddressForPort(portName); - if (vniPortMap.get(vni) == null) { - vniPortMap.put(vni, Lists.newArrayList()); - } - vniPortMap.get(vni).add(new PortInfo(device.id(), portName, fixedIp, hostIpAddress)); - } - } - - /** - * Returns CIDR information from the subnet map for the port. - * - * @param portName port name of the port of the VM - * @return CIDR of the VNI of the VM - */ - private Ip4Prefix getCidrForPort(String portName) { - String networkId = null; - String uuid = portName.substring(3); - OpenstackPort port = openstackPortMap.values().stream() - .filter(p -> p.id().startsWith(uuid)) - .findFirst().get(); - if (port == null) { - log.debug("No port information for port {}", portName); - return null; - } - - OpenstackSubnet subnet = openstackSubnetMap.values().stream() - .filter(s -> s.networkId().equals(port.networkId())) - .findFirst().get(); - if (subnet == null) { - log.debug("No subnet information for network {}", subnet.id()); - return null; - } - - return Ip4Prefix.valueOf(subnet.cidr()); - } - - /** - * Returns the VNI of the VM of the port. - * - * @param portName VM port - * @return VNI - */ - private String getVniForPort(String portName) { - String networkId = null; - String uuid = portName.substring(3); - OpenstackPort port = openstackPortMap.values().stream() - .filter(p -> p.id().startsWith(uuid)) - .findFirst().get(); - if (port == null) { - log.debug("No port information for port {}", portName); - return null; - } - OpenstackNetwork network = openstackNetworkMap.values().stream() - .filter(n -> n.id().equals(port.networkId())) - .findFirst().get(); - if (network == null) { - log.debug("No VNI information for network {}", network.id()); - return null; - } - - return network.segmentId(); - } - - /** - * Returns the Fixed IP address of the VM. - * - * @param portName VM port info - * @return IP address of the VM - */ - private Ip4Address getFixedIpAddressForPort(String portName) { - - // FIXME - For now we use the information stored from neutron Rest API call. - // TODO - Later, the information needs to be extracted from Neutron on-demand. - String uuid = portName.substring(3); - OpenstackPort port = openstackPortMap.values().stream() - .filter(p -> p.id().startsWith(uuid)) - .findFirst().get(); - - if (port == null) { - log.error("There is no port information for port name {}", portName); - return null; - } - - if (port.fixedIps().isEmpty()) { - log.error("There is no fixed IP info in the port information"); - return null; - } - - return (Ip4Address) port.fixedIps().values().toArray()[0]; - } - - /** - * Returns the MAC address of the VM of the port. - * - * @param portName VM port - * @return MAC address of the VM - */ - private MacAddress getVmMacAddressForPort(String portName) { - - String uuid = portName.substring(3); - OpenstackPort port = openstackPortMap.values().stream() - .filter(p -> p.id().startsWith(uuid)) - .findFirst().get(); - - if (port == null) { - log.error("There is no mac information for port name {}", portName); - return null; - } - - return port.macAddress(); - } - - private class InternalPacketProcessor implements PacketProcessor { - - @Override - public void process(PacketContext context) { - - if (context.isHandled()) { - return; - } - - InboundPacket pkt = context.inPacket(); - Ethernet ethernet = pkt.parsed(); - - if (ethernet.getEtherType() == Ethernet.TYPE_ARP) { - arpHandler.processPacketIn(pkt); - } - } - } - - private class InternalDeviceListener implements DeviceListener { - - @Override - public void event(DeviceEvent event) { - deviceEventExcutorService.execute(new InternalEventHandler(event)); - } - } - - private class InternalEventHandler implements Runnable { - - volatile DeviceEvent deviceEvent; - - InternalEventHandler(DeviceEvent deviceEvent) { - this.deviceEvent = deviceEvent; - } - - @Override - public void run() { - switch (deviceEvent.type()) { - case DEVICE_ADDED: - processDeviceAdded((Device) deviceEvent.subject()); - break; - case DEVICE_UPDATED: - Port port = (Port) deviceEvent.subject(); - if (port.isEnabled()) { - processPortAdded((Device) deviceEvent.subject(), deviceEvent.port()); - } - break; - case DEVICE_AVAILABILITY_CHANGED: - Device device = (Device) deviceEvent.subject(); - if (deviceService.isAvailable(device.id())) { - processDeviceAdded(device); - } - break; - case PORT_ADDED: - processPortAdded((Device) deviceEvent.subject(), deviceEvent.port()); - break; - case PORT_UPDATED: - processPortAdded((Device) deviceEvent.subject(), deviceEvent.port()); - break; - case PORT_REMOVED: - processPortRemoved((Device) deviceEvent.subject(), deviceEvent.port()); - break; - default: - break; - } - } - } - - private final class PortInfo { - DeviceId deviceId; - String portName; - Ip4Address fixedIp; - Ip4Address hostIp; - - private PortInfo(DeviceId deviceId, String portName, Ip4Address fixedIp, - Ip4Address hostIp) { - this.deviceId = deviceId; - this.portName = portName; - this.fixedIp = fixedIp; - this.hostIp = hostIp; - } - } - -}
\ No newline at end of file diff --git a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingRulePopulator.java b/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingRulePopulator.java deleted file mode 100644 index f6e98060..00000000 --- a/framework/src/onos/apps/openstackswitching/src/main/java/org/onosproject/openstackswitching/OpenstackSwitchingRulePopulator.java +++ /dev/null @@ -1,227 +0,0 @@ -/* -* 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.openstackswitching; - -import org.onlab.packet.Ethernet; -import org.onlab.packet.IPv4; -import org.onlab.packet.Ip4Address; -import org.onlab.packet.Ip4Prefix; -import org.onlab.packet.MacAddress; -import org.onlab.packet.TpPort; -import org.onosproject.core.ApplicationId; -import org.onosproject.net.DeviceId; -import org.onosproject.net.Port; -import org.onosproject.net.PortNumber; -import org.onosproject.net.flow.DefaultTrafficSelector; -import org.onosproject.net.flow.DefaultTrafficTreatment; -import org.onosproject.net.flow.TrafficSelector; -import org.onosproject.net.flow.TrafficTreatment; -import org.onosproject.net.flowobjective.DefaultForwardingObjective; -import org.onosproject.net.flowobjective.FlowObjectiveService; -import org.onosproject.net.flowobjective.ForwardingObjective; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -/** - * It populates switching flow rules. - * - */ -public class OpenstackSwitchingRulePopulator { - - private static Logger log = LoggerFactory - .getLogger(OpenstackSwitchingRulePopulator.class); - - private FlowObjectiveService flowObjectiveService; - private ApplicationId appId; - - /** - * Creates OpenstackSwitchingRulPopulator. - * - * @param appId application id - * @param flowObjectiveService FlowObjectiveService reference - */ - public OpenstackSwitchingRulePopulator(ApplicationId appId, - FlowObjectiveService flowObjectiveService) { - this.flowObjectiveService = flowObjectiveService; - this.appId = appId; - } - - /** - * Populates flows rules for forwarding packets to and from VMs. - * - * @param ip v4 IP Address - * @param id device ID - * @param port port - * @param cidr v4 IP prefix - * @return true if it succeeds to populate rules, false otherwise. - */ - public boolean populateForwardingRule(Ip4Address ip, DeviceId id, Port port, Ip4Prefix cidr) { - - - setFlowRuleForVMsInSameCnode(ip, id, port, cidr); - - return true; - } - - /** - * Populates the common flows rules for all VMs. - * - * - Send ARP packets to the controller - * - Send DHCP packets to the controller - * - * @param id Device ID to populates rules to - */ - public void populateDefaultRules(DeviceId id) { - - setFlowRuleForArp(id); - - log.warn("Default rule has been set"); - } - - /** - * Populates the forwarding rules for VMs with the same VNI but in other Code. - * - * @param vni VNI for the networks - * @param id device ID to populates the flow rules - * @param hostIp host IP address of the VM - * @param vmIp fixed IP address for the VM - * @param vmMac MAC address for the VM - * @param tunnelPort tunnel port number for the VM - * @param idx device ID for OVS of the other VM - * @param hostIpx host IP address of the other VM - * @param vmIpx fixed IP address of the other VM - * @param vmMacx MAC address for the other VM - * @param tunnelPortx x tunnel port number for other VM - */ - public void populateForwardingRuleForOtherCnode(String vni, DeviceId id, Ip4Address hostIp, - Ip4Address vmIp, MacAddress vmMac, PortNumber tunnelPort, - DeviceId idx, Ip4Address hostIpx, - Ip4Address vmIpx, MacAddress vmMacx, PortNumber tunnelPortx) { - setVxLanFlowRule(vni, id, hostIp, vmIp, vmMac, tunnelPort); - setVxLanFlowRule(vni, idx, hostIpx, vmIpx, vmMacx, tunnelPortx); - } - - /** - * Populates the flow rules for DHCP packets from VMs. - * - * @param id device ID to set the rules - */ - private void setFlowRuleForDhcp(DeviceId id) { - TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder(); - TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder(); - - sBuilder.matchEthType(Ethernet.TYPE_IPV4) - .matchIPProtocol(IPv4.PROTOCOL_UDP) - .matchUdpDst(TpPort.tpPort(OpenstackSwitchingManager.DHCP_PORT)); - tBuilder.setOutput(PortNumber.CONTROLLER); - - ForwardingObjective fo = DefaultForwardingObjective.builder() - .withSelector(sBuilder.build()) - .withTreatment(tBuilder.build()) - .withPriority(5000) - .withFlag(ForwardingObjective.Flag.VERSATILE) - .fromApp(appId) - .add(); - - flowObjectiveService.forward(id, fo); - } - - /** - * Populates the flow rules for ARP packets from VMs. - * - * @param id device ID to put rules. - */ - private void setFlowRuleForArp(DeviceId id) { - TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder(); - TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder(); - - sBuilder.matchEthType(Ethernet.TYPE_ARP); - tBuilder.setOutput(PortNumber.CONTROLLER); - - ForwardingObjective fo = DefaultForwardingObjective.builder() - .withSelector(sBuilder.build()) - .withTreatment(tBuilder.build()) - .withPriority(5000) - .withFlag(ForwardingObjective.Flag.VERSATILE) - .fromApp(appId) - .add(); - - flowObjectiveService.forward(id, fo); - } - - /** - * Sets the flow rules for traffic between VMs in the same Cnode. - * - * @param ip4Address VM IP address - * @param id device ID to put rules - * @param port VM port - * @param cidr subnet info of the VMs - */ - private void setFlowRuleForVMsInSameCnode(Ip4Address ip4Address, DeviceId id, - Port port, Ip4Prefix cidr) { - TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder(); - TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder(); - - sBuilder.matchEthType(Ethernet.TYPE_IPV4) - .matchIPDst(ip4Address.toIpPrefix()) - .matchIPSrc(cidr); - tBuilder.setOutput(port.number()); - - ForwardingObjective fo = DefaultForwardingObjective.builder() - .withSelector(sBuilder.build()) - .withTreatment(tBuilder.build()) - .withPriority(5000) - .withFlag(ForwardingObjective.Flag.VERSATILE) - .fromApp(appId) - .add(); - - flowObjectiveService.forward(id, fo); - } - - /** - * Sets the flow rules between traffic from VMs in different Cnode. - * - * @param vni VNI - * @param id device ID - * @param hostIp host IP of the VM - * @param vmIp fixed IP of the VM - * @param vmMac MAC address of the VM - * @param tunnelPort tunnel port to forward traffic to - */ - private void setVxLanFlowRule(String vni, DeviceId id, Ip4Address hostIp, - Ip4Address vmIp, MacAddress vmMac, PortNumber tunnelPort) { - TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder(); - TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder(); - - sBuilder.matchEthType(Ethernet.TYPE_IPV4) - .matchIPDst(vmIp.toIpPrefix()); - tBuilder.setTunnelId(Long.parseLong(vni)) - //.setTunnelDst() <- for Nicira ext - //.setEthDst(vmMac) - .setOutput(tunnelPort); - - ForwardingObjective fo = DefaultForwardingObjective.builder() - .withSelector(sBuilder.build()) - .withTreatment(tBuilder.build()) - .withPriority(5000) - .withFlag(ForwardingObjective.Flag.VERSATILE) - .fromApp(appId) - .add(); - - flowObjectiveService.forward(id, fo); - } -} |