diff options
Diffstat (limited to 'framework/src/onos/apps/routing-api')
21 files changed, 1928 insertions, 0 deletions
diff --git a/framework/src/onos/apps/routing-api/pom.xml b/framework/src/onos/apps/routing-api/pom.xml new file mode 100644 index 00000000..1b9fc2fa --- /dev/null +++ b/framework/src/onos/apps/routing-api/pom.xml @@ -0,0 +1,60 @@ +<?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/xsd/maven-4.0.0.xsd"> + <parent> + <artifactId>onos-apps</artifactId> + <groupId>org.onosproject</groupId> + <version>1.3.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + <modelVersion>4.0.0</modelVersion> + + <artifactId>onos-app-routing-api</artifactId> + + <packaging>bundle</packaging> + <description>API for routing applications</description> + + <dependencies> + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-misc</artifactId> + </dependency> + + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onos-incubator-api</artifactId> + </dependency> + + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-annotations</artifactId> + </dependency> + + <dependency> + <groupId>com.google.guava</groupId> + <artifactId>guava</artifactId> + </dependency> + + <dependency> + <groupId>org.onosproject</groupId> + <artifactId>onlab-junit</artifactId> + <scope>test</scope> + </dependency> + </dependencies> +</project> diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/BgpService.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/BgpService.java new file mode 100644 index 00000000..f5d95f22 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/BgpService.java @@ -0,0 +1,34 @@ +/* + * 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.routing; + +/** + * Provides a way of interacting with the BGP protocol component. + */ +public interface BgpService { + + /** + * Starts the BGP service. + * + * @param routeListener listener to send route updates to + */ + void start(RouteListener routeListener); + + /** + * Stops the BGP service. + */ + void stop(); +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibEntry.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibEntry.java new file mode 100644 index 00000000..e2e20498 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibEntry.java @@ -0,0 +1,100 @@ +/* + * 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.routing; + +import com.google.common.base.MoreObjects; +import org.onlab.packet.IpAddress; +import org.onlab.packet.IpPrefix; +import org.onlab.packet.MacAddress; + +import java.util.Objects; + +/** + * An entry in the Forwarding Information Base (FIB). + */ +public class FibEntry { + + private final IpPrefix prefix; + private final IpAddress nextHopIp; + private final MacAddress nextHopMac; + + /** + * Creates a new FIB entry. + * + * @param prefix IP prefix of the FIB entry + * @param nextHopIp IP address of the next hop + * @param nextHopMac MAC address of the next hop + */ + public FibEntry(IpPrefix prefix, IpAddress nextHopIp, MacAddress nextHopMac) { + this.prefix = prefix; + this.nextHopIp = nextHopIp; + this.nextHopMac = nextHopMac; + } + + /** + * Returns the IP prefix of the FIB entry. + * + * @return the IP prefix + */ + public IpPrefix prefix() { + return prefix; + } + + /** + * Returns the IP address of the next hop. + * + * @return the IP address + */ + public IpAddress nextHopIp() { + return nextHopIp; + } + + /** + * Returns the MAC address of the next hop. + * + * @return the MAC address + */ + public MacAddress nextHopMac() { + return nextHopMac; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof FibEntry)) { + return false; + } + + FibEntry that = (FibEntry) o; + + return Objects.equals(this.prefix, that.prefix) && + Objects.equals(this.nextHopIp, that.nextHopIp) && + Objects.equals(this.nextHopMac, that.nextHopMac); + } + + @Override + public int hashCode() { + return Objects.hash(prefix, nextHopIp, nextHopMac); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("prefix", prefix) + .add("nextHopIp", nextHopIp) + .add("nextHopMac", nextHopMac) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibListener.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibListener.java new file mode 100644 index 00000000..0c8e6272 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibListener.java @@ -0,0 +1,35 @@ +/* + * 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.routing; + +import java.util.Collection; + +/** + * A component that is able to process Forwarding Information Base (FIB) updates. + */ +public interface FibListener { + + /** + * Signals the FIB component of changes to the FIB. + * + * @param updates FIB updates of the UDPATE type + * @param withdraws FIB updates of the WITHDRAW type + */ + // TODO this interface should use only one collection when we have the new + // intent key API + void update(Collection<FibUpdate> updates, Collection<FibUpdate> withdraws); + +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibUpdate.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibUpdate.java new file mode 100644 index 00000000..dacb1596 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/FibUpdate.java @@ -0,0 +1,98 @@ +/* + * 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.routing; + +import com.google.common.base.MoreObjects; + +import java.util.Objects; + +/** + * Represents a change to the Forwarding Information Base (FIB). + */ +public class FibUpdate { + + /** + * Specifies the type of the FIB update. + */ + public enum Type { + /** + * The update contains a new or updated FIB entry for a prefix. + */ + UPDATE, + + /** + * The update signals that a prefix should be removed from the FIB. + */ + DELETE + } + + private final Type type; + private final FibEntry entry; + + /** + * Creates a new FIB update. + * + * @param type type of the update + * @param entry FIB entry describing the update + */ + public FibUpdate(Type type, FibEntry entry) { + this.type = type; + this.entry = entry; + } + + /** + * Returns the type of the update. + * + * @return update type + */ + public Type type() { + return type; + } + + /** + * Returns the FIB entry which contains update information. + * + * @return the FIB entry + */ + public FibEntry entry() { + return entry; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof FibUpdate)) { + return false; + } + + FibUpdate that = (FibUpdate) o; + + return Objects.equals(this.type, that.type) && + Objects.equals(this.entry, that.entry); + } + + @Override + public int hashCode() { + return Objects.hash(type, entry); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("type", type) + .add("entry", entry) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/IntentRequestListener.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/IntentRequestListener.java new file mode 100644 index 00000000..2d1bb311 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/IntentRequestListener.java @@ -0,0 +1,76 @@ +/* + * 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.routing; + +import org.onlab.packet.IpAddress; +import org.onlab.packet.IpPrefix; +import org.onlab.packet.MacAddress; +import org.onosproject.net.ConnectPoint; + +/** + * An interface to process intent requests. + */ +public interface IntentRequestListener { + + /** + * Sets up connectivity for packet from Internet to a host in local + * SDN network. + * + * @param dstIpAddress IP address of destination host in local SDN network + */ + void setUpConnectivityInternetToHost(IpAddress dstIpAddress); + + /** + * Sets up the connectivity for two hosts in local SDN network. + * + * @param dstIpAddress the destination IP address + * @param srcIpAddress the source IP address + * @param srcMacAddress the source MAC address + * @param srcConnectPoint the connectPoint of the source host + */ + void setUpConnectivityHostToHost(IpAddress dstIpAddress, + IpAddress srcIpAddress, + MacAddress srcMacAddress, + ConnectPoint srcConnectPoint); + + /** + * Adds one new ingress connect point into ingress points of an existing + * intent and resubmits the new intent. + * <p> + * If there is already an intent for an IP prefix in the system, we do not + * need to create a new one, we only need to update this existing intent by + * adding more ingress points. + * </p> + * + * @param ipPrefix the IP prefix used to search the existing + * MultiPointToSinglePointIntent + * @param ingressConnectPoint the ingress connect point to be added into + * the exiting intent + */ + void updateExistingMp2pIntent(IpPrefix ipPrefix, + ConnectPoint ingressConnectPoint); + + /** + * Checks whether there is a MultiPointToSinglePointIntent in memory for a + * given IP prefix. + * + * @param ipPrefix the IP prefix used to search the existing + * MultiPointToSinglePointIntent + * @return true if there is a MultiPointToSinglePointIntent, otherwise false + */ + boolean mp2pIntentExists(IpPrefix ipPrefix); + +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteEntry.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteEntry.java new file mode 100644 index 00000000..2b0ef989 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteEntry.java @@ -0,0 +1,146 @@ +/* + * Copyright 2014-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.routing; + +import com.google.common.base.MoreObjects; +import org.onlab.packet.IpAddress; +import org.onlab.packet.IpPrefix; + +import java.util.Objects; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * Represents a route entry for an IP prefix. + */ +public class RouteEntry { + private final IpPrefix prefix; // The IP prefix + private final IpAddress nextHop; // Next-hop IP address + + /** + * Class constructor. + * + * @param prefix the IP prefix of the route + * @param nextHop the next hop IP address for the route + */ + public RouteEntry(IpPrefix prefix, IpAddress nextHop) { + this.prefix = checkNotNull(prefix); + this.nextHop = checkNotNull(nextHop); + } + + /** + * Returns the IP version of the route. + * + * @return the IP version of the route + */ + public IpAddress.Version version() { + return nextHop.version(); + } + + /** + * Tests whether the IP version of this address is IPv4. + * + * @return true if the IP version of this address is IPv4, otherwise false. + */ + public boolean isIp4() { + return nextHop.isIp4(); + } + + /** + * Tests whether the IP version of this address is IPv6. + * + * @return true if the IP version of this address is IPv6, otherwise false. + */ + public boolean isIp6() { + return nextHop.isIp6(); + } + + /** + * Returns the IP prefix of the route. + * + * @return the IP prefix of the route + */ + public IpPrefix prefix() { + return prefix; + } + + /** + * Returns the next hop IP address for the route. + * + * @return the next hop IP address for the route + */ + public IpAddress nextHop() { + return nextHop; + } + + /** + * Creates the binary string representation of an IP prefix. + * The prefix can be either IPv4 or IPv6. + * The string length is equal to the prefix length. + * + * @param ipPrefix the IP prefix to use + * @return the binary string representation + */ + public static String createBinaryString(IpPrefix ipPrefix) { + if (ipPrefix.prefixLength() == 0) { + return ""; + } + + byte[] octets = ipPrefix.address().toOctets(); + StringBuilder result = new StringBuilder(ipPrefix.prefixLength()); + for (int i = 0; i < ipPrefix.prefixLength(); i++) { + int byteOffset = i / Byte.SIZE; + int bitOffset = i % Byte.SIZE; + int mask = 1 << (Byte.SIZE - 1 - bitOffset); + byte value = octets[byteOffset]; + boolean isSet = ((value & mask) != 0); + result.append(isSet ? "1" : "0"); + } + return result.toString(); + } + + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } + + // + // NOTE: Subclasses are considered as change of identity, hence + // equals() will return false if the class type doesn't match. + // + if (other == null || getClass() != other.getClass()) { + return false; + } + + RouteEntry otherRoute = (RouteEntry) other; + return Objects.equals(this.prefix, otherRoute.prefix) && + Objects.equals(this.nextHop, otherRoute.nextHop); + } + + @Override + public int hashCode() { + return Objects.hash(prefix, nextHop); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("prefix", prefix) + .add("nextHop", nextHop) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteListener.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteListener.java new file mode 100644 index 00000000..85752164 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteListener.java @@ -0,0 +1,30 @@ +/* + * Copyright 2014-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.routing; + +import java.util.Collection; + +/** + * An interface to receive route updates from route providers. + */ +public interface RouteListener { + /** + * Receives a route update from a route provider. + * + * @param routeUpdates the collection with updated route information + */ + void update(Collection<RouteUpdate> routeUpdates); +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteUpdate.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteUpdate.java new file mode 100644 index 00000000..0a3c2f31 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RouteUpdate.java @@ -0,0 +1,107 @@ +/* + * Copyright 2014-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.routing; + +import com.google.common.base.MoreObjects; + +import java.util.Objects; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * Represents a change in routing information. + */ +public class RouteUpdate { + private final Type type; // The route update type + private final RouteEntry routeEntry; // The updated route entry + + /** + * Specifies the type of a route update. + * <p> + * Route updates can either provide updated information for a route, or + * withdraw a previously updated route. + * </p> + */ + public enum Type { + /** + * The update contains updated route information for a route. + */ + UPDATE, + /** + * The update withdraws the route, meaning any previous information is + * no longer valid. + */ + DELETE + } + + /** + * Class constructor. + * + * @param type the type of the route update + * @param routeEntry the route entry with the update + */ + public RouteUpdate(Type type, RouteEntry routeEntry) { + this.type = type; + this.routeEntry = checkNotNull(routeEntry); + } + + /** + * Returns the type of the route update. + * + * @return the type of the update + */ + public Type type() { + return type; + } + + /** + * Returns the route entry the route update is for. + * + * @return the route entry the route update is for + */ + public RouteEntry routeEntry() { + return routeEntry; + } + + @Override + public boolean equals(Object other) { + if (other == this) { + return true; + } + + if (!(other instanceof RouteUpdate)) { + return false; + } + + RouteUpdate otherUpdate = (RouteUpdate) other; + + return Objects.equals(this.type, otherUpdate.type) && + Objects.equals(this.routeEntry, otherUpdate.routeEntry); + } + + @Override + public int hashCode() { + return Objects.hash(type, routeEntry); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("type", type) + .add("routeEntry", routeEntry) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RoutingService.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RoutingService.java new file mode 100644 index 00000000..8b7040e2 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/RoutingService.java @@ -0,0 +1,169 @@ +/* + * 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.routing; + +import org.onlab.packet.IpAddress; +import org.onlab.packet.MacAddress; +import org.onosproject.net.ConnectPoint; +import org.onosproject.routing.config.BgpConfig; + +import java.util.Collection; + +/** + * Provides a way of interacting with the RIB management component. + */ +public interface RoutingService { + + String ROUTER_APP_ID = "org.onosproject.router"; + + Class<BgpConfig> CONFIG_CLASS = BgpConfig.class; + + /** + * Specifies the type of an IP address or an IP prefix location. + */ + enum LocationType { + /** + * The location of an IP address or an IP prefix is in local SDN network. + */ + LOCAL, + /** + * The location of an IP address or an IP prefix is outside local SDN network. + */ + INTERNET, + /** + * There is no route for this IP address or IP prefix. + */ + NO_ROUTE + } + + /** + * Specifies the type of traffic. + * <p> + * We classify traffic by the first packet of each traffic. + * </p> + */ + enum TrafficType { + /** + * Traffic from a host located in local SDN network wants to + * communicate with destination host located in Internet (outside + * local SDN network). + */ + HOST_TO_INTERNET, + /** + * Traffic from Internet wants to communicate with a host located + * in local SDN network. + */ + INTERNET_TO_HOST, + /** + * Both the source host and destination host of a traffic are in + * local SDN network. + */ + HOST_TO_HOST, + /** + * Traffic from Internet wants to traverse local SDN network. + */ + INTERNET_TO_INTERNET, + /** + * Any traffic wants to communicate with a destination which has + * no route, or traffic from Internet wants to access a local private + * IP address. + */ + DROP, + /** + * Traffic does not belong to the types above. + */ + UNKNOWN + } + + /** + * Starts the routing service. + */ + void start(); + + /** + * Adds FIB listener. + * + * @param fibListener listener to send FIB updates to + */ + void addFibListener(FibListener fibListener); + + /** + * Adds intent creation and submission listener. + * + * @param intentRequestListener listener to send intent creation and + * submission request to + */ + void addIntentRequestListener(IntentRequestListener + intentRequestListener); + + /** + * Stops the routing service. + */ + void stop(); + + /** + * Gets all IPv4 routes known to SDN-IP. + * + * @return the SDN-IP IPv4 routes + */ + Collection<RouteEntry> getRoutes4(); + + /** + * Gets all IPv6 routes known to SDN-IP. + * + * @return the SDN-IP IPv6 routes + */ + Collection<RouteEntry> getRoutes6(); + + /** + * Evaluates the location of an IP address and returns the location type. + * + * @param ipAddress the IP address to evaluate + * @return the IP address location type + */ + LocationType getLocationType(IpAddress ipAddress); + + /** + * Finds out the route entry which has the longest matchable IP prefix. + * + * @param ipAddress IP address used to find out longest matchable IP prefix + * @return a route entry which has the longest matchable IP prefix if + * found, otherwise null + */ + RouteEntry getLongestMatchableRouteEntry(IpAddress ipAddress); + + /** + * Finds out the egress connect point where to emit the first packet + * based on destination IP address. + * + * @param dstIpAddress the destination IP address + * @return the egress connect point if found, otherwise null + */ + ConnectPoint getEgressConnectPoint(IpAddress dstIpAddress); + + /** + * Routes packet reactively. + * + * @param dstIpAddress the destination IP address of a packet + * @param srcIpAddress the source IP address of a packet + * @param srcConnectPoint the connect point where a packet comes from + * @param srcMacAddress the source MAC address of a packet + */ + void packetReactiveProcessor(IpAddress dstIpAddress, + IpAddress srcIpAddress, + ConnectPoint srcConnectPoint, + MacAddress srcMacAddress); +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/StaticRoutingService.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/StaticRoutingService.java new file mode 100644 index 00000000..7d75f5c8 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/StaticRoutingService.java @@ -0,0 +1,24 @@ +/* + * 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.routing; + +/** + * Convenience interface to obtain the FIB listener. + */ +public interface StaticRoutingService { + + FibListener getFibListener(); +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpConfig.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpConfig.java new file mode 100644 index 00000000..2f1ede79 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpConfig.java @@ -0,0 +1,101 @@ +/* + * 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.routing.config; + +import com.fasterxml.jackson.databind.JsonNode; +import com.google.common.collect.Sets; +import org.onlab.packet.IpAddress; +import org.onosproject.core.ApplicationId; +import org.onosproject.net.ConnectPoint; +import org.onosproject.net.config.Config; + +import java.util.Optional; +import java.util.Set; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * Configuration object for BGP config. + */ +public class BgpConfig extends Config<ApplicationId> { + + public static final String SPEAKERS = "bgpSpeakers"; + public static final String CONNECT_POINT = "connectPoint"; + public static final String NAME = "name"; + public static final String PEERS = "peers"; + + // TODO add methods for updating config + + /** + * Gets the set of configured BGP speakers. + * + * @return BGP speakers + */ + public Set<BgpSpeakerConfig> bgpSpeakers() { + Set<BgpSpeakerConfig> speakers = Sets.newHashSet(); + + JsonNode speakersNode = object.get(SPEAKERS); + speakersNode.forEach(jsonNode -> { + Set<IpAddress> listenAddresses = Sets.newHashSet(); + jsonNode.path(PEERS).forEach(addressNode -> + listenAddresses.add(IpAddress.valueOf(addressNode.asText())) + ); + + Optional<String> name; + if (jsonNode.get(NAME) == null) { + name = Optional.empty(); + } else { + name = Optional.of(jsonNode.get(NAME).asText()); + } + + speakers.add(new BgpSpeakerConfig(name, + ConnectPoint.deviceConnectPoint(jsonNode.path(CONNECT_POINT).asText()), + listenAddresses)); + }); + + return speakers; + } + + /** + * Configuration for a BGP speaker. + */ + public static class BgpSpeakerConfig { + + private Optional<String> name; + private ConnectPoint connectPoint; + private Set<IpAddress> peers; + + public BgpSpeakerConfig(Optional<String> name, ConnectPoint connectPoint, + Set<IpAddress> peers) { + this.name = checkNotNull(name); + this.connectPoint = checkNotNull(connectPoint); + this.peers = checkNotNull(peers); + } + + public Optional<String> name() { + return name; + } + + public ConnectPoint connectPoint() { + return connectPoint; + } + + public Set<IpAddress> peers() { + return peers; + } + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpPeer.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpPeer.java new file mode 100644 index 00000000..bf9e7def --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpPeer.java @@ -0,0 +1,96 @@ +/* + * Copyright 2014-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.routing.config; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.google.common.base.MoreObjects; +import org.onlab.packet.IpAddress; +import org.onosproject.net.ConnectPoint; +import org.onosproject.net.DeviceId; +import org.onosproject.net.NetTools; +import org.onosproject.net.PortNumber; + +import java.util.Objects; + +/** + * Configuration details for a BGP peer. + */ +public class BgpPeer { + private final ConnectPoint connectPoint; + private final IpAddress ipAddress; + + /** + * Creates a new BgpPeer. + * + * @param dpid the DPID of the switch the peer is attached at, as a String + * @param port the port the peer is attached at + * @param ipAddress the IP address of the peer as a String + */ + public BgpPeer(@JsonProperty("attachmentDpid") String dpid, + @JsonProperty("attachmentPort") long port, + @JsonProperty("ipAddress") String ipAddress) { + this.connectPoint = new ConnectPoint( + DeviceId.deviceId(NetTools.dpidToUri(dpid)), + PortNumber.portNumber(port)); + this.ipAddress = IpAddress.valueOf(ipAddress); + } + + /** + * Gets the connection point of the peer. + * + * @return the connection point + */ + public ConnectPoint connectPoint() { + return connectPoint; + } + + /** + * Gets the IP address of the peer. + * + * @return the IP address + */ + public IpAddress ipAddress() { + return ipAddress; + } + + @Override + public int hashCode() { + return Objects.hash(connectPoint, ipAddress); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + + if (!(obj instanceof BgpPeer)) { + return false; + } + + BgpPeer that = (BgpPeer) obj; + return Objects.equals(this.connectPoint, that.connectPoint) + && Objects.equals(this.ipAddress, that.ipAddress); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("connectPoint", connectPoint) + .add("ipAddress", ipAddress) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpSpeaker.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpSpeaker.java new file mode 100644 index 00000000..d0df5e70 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/BgpSpeaker.java @@ -0,0 +1,153 @@ +/* + * Copyright 2014-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.routing.config; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.google.common.base.MoreObjects; +import org.onlab.packet.MacAddress; +import org.onosproject.net.ConnectPoint; +import org.onosproject.net.DeviceId; +import org.onosproject.net.NetTools; +import org.onosproject.net.PortNumber; + +import java.util.List; +import java.util.Objects; + +/** + * Represents a BGP daemon in SDN network. + * <p> + * Each BGP speaker has a attachment point, which includes a switch DPID and a + * switch port. Each BGP speaker has one MAC address and several IP addresses, + * which are used to peer with BGP peers outside the SDN network. For each + * peer outside the SDN network, we configure a different IP address to BGP + * speaker inside the SDN network. + * </p> + * <p> + * Each BGP speaker has a name, which is a unique identifying String that is + * used to reference this speaker in the configuration. + * </p> + */ +public class BgpSpeaker { + private final String name; + private final ConnectPoint connectPoint; + private final MacAddress macAddress; + private List<InterfaceAddress> interfaceAddresses; + + /** + * Class constructor used by the JSON library to create an object. + * + * @param name the name of the BGP speaker inside SDN network + * @param attachmentDpid the DPID where the BGP speaker is attached to + * @param attachmentPort the port where the BGP speaker is attached to + * @param macAddress the MAC address of the BGP speaker + */ + @JsonCreator + public BgpSpeaker(@JsonProperty("name") String name, + @JsonProperty("attachmentDpid") String attachmentDpid, + @JsonProperty("attachmentPort") long attachmentPort, + @JsonProperty("macAddress") String macAddress) { + + this.name = name; + this.macAddress = MacAddress.valueOf(macAddress); + this.connectPoint = new ConnectPoint( + DeviceId.deviceId(NetTools.dpidToUri(attachmentDpid)), + PortNumber.portNumber(attachmentPort)); + } + + /** + * Sets the addresses we configured for the BGP speaker on all virtual + * {@link Interface}s. + * + * @param interfaceAddresses a list of IP addresses of the BGP speaker + * configured on all virtual interfaces + */ + @JsonProperty("interfaceAddresses") + public void setInterfaceAddresses( + List<InterfaceAddress> interfaceAddresses) { + this.interfaceAddresses = interfaceAddresses; + } + + /** + * Gets the BGP speaker name. + * + * @return the BGP speaker name + */ + public String name() { + return name; + } + + /** + * Gets the connect point where the BGP speaker is attached. + * + * @return the connect point + */ + public ConnectPoint connectPoint() { + return connectPoint; + } + + /** + * Gets the MAC address of the BGP speaker. + * + * @return the MAC address + */ + public MacAddress macAddress() { + return macAddress; + } + + /** + * Gets all IP addresses configured on all {@link Interface}s of the + * BGP speaker. + * + * @return a list of IP addresses of the BGP speaker configured on all + * virtual interfaces + */ + public List<InterfaceAddress> interfaceAddresses() { + return interfaceAddresses; + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof BgpSpeaker)) { + return false; + } + + BgpSpeaker otherBgpSpeaker = (BgpSpeaker) other; + + return name.equals(otherBgpSpeaker.name) && + connectPoint.equals( + otherBgpSpeaker.connectPoint) && + macAddress.equals(otherBgpSpeaker.macAddress) && + interfaceAddresses.equals(otherBgpSpeaker.interfaceAddresses); + } + + @Override + public int hashCode() { + return Objects.hash(name, connectPoint, macAddress, + interfaceAddresses); + + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("speakerName", name) + .add("connectPoint", connectPoint) + .add("macAddress", macAddress) + .add("interfaceAddresses", interfaceAddresses) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/Interface.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/Interface.java new file mode 100644 index 00000000..d6f6e574 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/Interface.java @@ -0,0 +1,133 @@ +/* + * Copyright 2014-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.routing.config; + +import com.google.common.base.MoreObjects; +import com.google.common.collect.Sets; +import org.onlab.packet.MacAddress; +import org.onlab.packet.VlanId; +import org.onosproject.net.ConnectPoint; +import org.onosproject.net.host.InterfaceIpAddress; +import org.onosproject.net.host.PortAddresses; + +import java.util.Objects; +import java.util.Set; + +/** + * An Interface is a set of addresses that are logically mapped to a switch + * port in the network. + */ +public class Interface { + private final ConnectPoint connectPoint; + private final Set<InterfaceIpAddress> ipAddresses; + private final MacAddress macAddress; + private final VlanId vlan; + + /** + * Creates an Interface based on a connection point, a set of interface + * IP addresses, and a MAC address. + * + * @param connectPoint the connect point this interface is mapped to + * @param ipAddresses the IP addresses for the interface + * @param macAddress the MAC address of the interface + * @param vlan VLAN identifier + */ + public Interface(ConnectPoint connectPoint, + Set<InterfaceIpAddress> ipAddresses, + MacAddress macAddress, VlanId vlan) { + this.connectPoint = connectPoint; + this.ipAddresses = Sets.newHashSet(ipAddresses); + this.macAddress = macAddress; + this.vlan = vlan; + } + + /** + * Creates an Interface based on a PortAddresses object. + * + * @param portAddresses the PortAddresses object to turn into an Interface + */ + public Interface(PortAddresses portAddresses) { + connectPoint = portAddresses.connectPoint(); + ipAddresses = Sets.newHashSet(portAddresses.ipAddresses()); + macAddress = portAddresses.mac(); + vlan = portAddresses.vlan(); + } + + /** + * Retrieves the connection point that this interface maps to. + * + * @return the connection point + */ + public ConnectPoint connectPoint() { + return connectPoint; + } + + /** + * Retrieves the set of IP addresses that are assigned to the interface. + * + * @return the set of interface IP addresses + */ + public Set<InterfaceIpAddress> ipAddresses() { + return ipAddresses; + } + + /** + * Retrieves the MAC address that is assigned to the interface. + * + * @return the MAC address + */ + public MacAddress mac() { + return macAddress; + } + + /** + * Retrieves the VLAN ID that is assigned to the interface. + * + * @return the VLAN ID + */ + public VlanId vlan() { + return vlan; + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof Interface)) { + return false; + } + + Interface otherInterface = (Interface) other; + + return connectPoint.equals(otherInterface.connectPoint) && + ipAddresses.equals(otherInterface.ipAddresses) && + macAddress.equals(otherInterface.macAddress) && + vlan.equals(otherInterface.vlan); + } + + @Override + public int hashCode() { + return Objects.hash(connectPoint, ipAddresses, macAddress, vlan); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("connectPoint", connectPoint) + .add("ipAddresses", ipAddresses) + .add("macAddress", macAddress) + .add("vlan", vlan) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/InterfaceAddress.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/InterfaceAddress.java new file mode 100644 index 00000000..e0d40fb4 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/InterfaceAddress.java @@ -0,0 +1,101 @@ +/* + * Copyright 2014-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.routing.config; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.google.common.base.MoreObjects; +import org.onlab.packet.IpAddress; +import org.onosproject.net.ConnectPoint; +import org.onosproject.net.DeviceId; +import org.onosproject.net.NetTools; +import org.onosproject.net.PortNumber; + +import java.util.Objects; + +/** + * Represents an address of a {@link BgpSpeaker} configured on an + * {@link Interface}. + * <p> + * Each InterfaceAddress includes the interface name and an IP address. + * </p> + */ +public class InterfaceAddress { + private final ConnectPoint connectPoint; + private final IpAddress ipAddress; + + /** + * Creates an InterfaceAddress object. + * + * @param dpid the DPID of the interface as a String + * @param port the port of the interface + * @param ipAddress the IP address of a {@link BgpSpeaker} configured on + * the interface + */ + public InterfaceAddress(@JsonProperty("interfaceDpid") String dpid, + @JsonProperty("interfacePort") int port, + @JsonProperty("ipAddress") String ipAddress) { + this.connectPoint = new ConnectPoint( + DeviceId.deviceId(NetTools.dpidToUri(dpid)), + PortNumber.portNumber(port)); + this.ipAddress = IpAddress.valueOf(ipAddress); + } + + /** + * Gets the connection point of the peer. + * + * @return the connection point + */ + public ConnectPoint connectPoint() { + return connectPoint; + } + + /** + * Gets the IP address of a BGP speaker configured on an {@link Interface}. + * + * @return the IP address + */ + public IpAddress ipAddress() { + return ipAddress; + } + + @Override + public int hashCode() { + return Objects.hash(connectPoint, ipAddress); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + + if (!(obj instanceof InterfaceAddress)) { + return false; + } + + InterfaceAddress that = (InterfaceAddress) obj; + return Objects.equals(this.connectPoint, that.connectPoint) + && Objects.equals(this.ipAddress, that.ipAddress); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("connectPoint", connectPoint) + .add("ipAddress", ipAddress) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/LocalIpPrefixEntry.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/LocalIpPrefixEntry.java new file mode 100644 index 00000000..d9d1824b --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/LocalIpPrefixEntry.java @@ -0,0 +1,141 @@ +/* + * 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.routing.config; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.google.common.base.MoreObjects; + +import java.util.Objects; + +import org.onlab.packet.IpAddress; +import org.onlab.packet.IpPrefix; + +/** + * Configuration details for an IP prefix entry. + */ +public class LocalIpPrefixEntry { + private final IpPrefix ipPrefix; + private final IpPrefixType type; + private final IpAddress gatewayIpAddress; + + /** + * Specifies the type of local IP prefix. + */ + public enum IpPrefixType { + /** + * Public IP prefixes should be exchanged by eBGP. + */ + PUBLIC, + /** + * Private IP prefixes should be used only locally and not exchanged + * by eBGP. + */ + PRIVATE, + /** + * For IP prefixes in blacklist. + */ + BLACK_LIST + } + + /** + * Creates a new IP prefix entry. + * + * @param ipPrefix an IP prefix as a String + * @param type an IP prefix type as an IpPrefixType + * @param gatewayIpAddress IP of the gateway + */ + public LocalIpPrefixEntry(@JsonProperty("ipPrefix") String ipPrefix, + @JsonProperty("type") IpPrefixType type, + @JsonProperty("gatewayIp") IpAddress + gatewayIpAddress) { + this.ipPrefix = IpPrefix.valueOf(ipPrefix); + this.type = type; + this.gatewayIpAddress = gatewayIpAddress; + } + + /** + * Gets the IP prefix of the IP prefix entry. + * + * @return the IP prefix + */ + public IpPrefix ipPrefix() { + return ipPrefix; + } + + /** + * Gets the IP prefix type of the IP prefix entry. + * + * @return the IP prefix type + */ + public IpPrefixType ipPrefixType() { + return type; + } + + /** + * Gets the gateway IP address of the IP prefix entry. + * + * @return the gateway IP address + */ + public IpAddress getGatewayIpAddress() { + return gatewayIpAddress; + } + + /** + * Tests whether the IP version of this entry is IPv4. + * + * @return true if the IP version of this entry is IPv4, otherwise false. + */ + public boolean isIp4() { + return ipPrefix.isIp4(); + } + + /** + * Tests whether the IP version of this entry is IPv6. + * + * @return true if the IP version of this entry is IPv6, otherwise false. + */ + public boolean isIp6() { + return ipPrefix.isIp6(); + } + + @Override + public int hashCode() { + return Objects.hash(ipPrefix, type); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + + if (!(obj instanceof LocalIpPrefixEntry)) { + return false; + } + + LocalIpPrefixEntry that = (LocalIpPrefixEntry) obj; + return Objects.equals(this.ipPrefix, that.ipPrefix) + && Objects.equals(this.type, that.type); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("ipPrefix", ipPrefix) + .add("ipPrefixType", type) + .toString(); + } +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/RoutingConfigurationService.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/RoutingConfigurationService.java new file mode 100644 index 00000000..f8ee21b9 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/RoutingConfigurationService.java @@ -0,0 +1,125 @@ +/* + * Copyright 2014-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.routing.config; + +import org.onlab.packet.IpAddress; +import org.onlab.packet.IpPrefix; +import org.onlab.packet.MacAddress; +import org.onosproject.net.ConnectPoint; + +import java.util.Map; +import java.util.Set; + +/** + * Provides information about the routing configuration. + */ +public interface RoutingConfigurationService { + + /** + * Gets the list of BGP speakers inside the SDN network. + * + * @return the map of BGP speaker names to BGP speaker objects + */ + Map<String, BgpSpeaker> getBgpSpeakers(); + + /** + * Gets the list of configured BGP peers. + * + * @return the map from peer IP address to BgpPeer object + */ + Map<IpAddress, BgpPeer> getBgpPeers(); + + /** + * Gets the MAC address configured for virtual gateway in SDN network. + * + * @return the MAC address of virtual gateway + */ + MacAddress getVirtualGatewayMacAddress(); + + /** + * Evaluates whether an IP address is a virtual gateway IP address. + * + * @param ipAddress the IP address to evaluate + * @return true if the IP address is a virtual gateway address, otherwise false + */ + boolean isVirtualGatewayIpAddress(IpAddress ipAddress); + + /** + * Evaluates whether an IP address belongs to local SDN network. + * + * @param ipAddress the IP address to evaluate + * @return true if the IP address belongs to local SDN network, otherwise false + */ + boolean isIpAddressLocal(IpAddress ipAddress); + + /** + * Evaluates whether an IP prefix belongs to local SDN network. + * + * @param ipPrefix the IP prefix to evaluate + * @return true if the IP prefix belongs to local SDN network, otherwise false + */ + boolean isIpPrefixLocal(IpPrefix ipPrefix); + + /** + * Retrieves the entire set of interfaces in the network. + * + * @return the set of interfaces + * @deprecated in Drake release - use InterfaceService instead + */ + @Deprecated + Set<Interface> getInterfaces(); + + /** + * Retrieves the entire set of connect points connected to BGP peers in the + * network. + * + * @return the set of connect points connected to BGP peers + */ + Set<ConnectPoint> getBgpPeerConnectPoints(); + + /** + * Retrieves the interface associated with the given connect point. + * + * @param connectPoint the connect point to retrieve interface information + * for + * @return the interface + * @deprecated in Drake release - use InterfaceService instead + */ + @Deprecated + Interface getInterface(ConnectPoint connectPoint); + + /** + * Retrieves the interface associated with the given IP address. + * + * @param ip IP address of the interface + * @return the interface + * @deprecated in Drake release - use InterfaceService instead + */ + @Deprecated + Interface getInterface(IpAddress ip); + + /** + * Retrieves the interface that matches the given IP address. Matching + * means that the IP address is in one of the interface's assigned subnets. + * + * @param ipAddress IP address to match + * @return the matching interface + * @deprecated in Drake release - use InterfaceService instead + */ + @Deprecated + Interface getMatchingInterface(IpAddress ipAddress); + +} diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/package-info.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/package-info.java new file mode 100644 index 00000000..c54c19d7 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/config/package-info.java @@ -0,0 +1,20 @@ +/* + * Copyright 2014-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. + */ + +/** + * Routing configuration interfaces. + */ +package org.onosproject.routing.config; diff --git a/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/package-info.java b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/package-info.java new file mode 100644 index 00000000..66e590b1 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/main/java/org/onosproject/routing/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. + */ + +/** + * API for routing libraries. + */ +package org.onosproject.routing; diff --git a/framework/src/onos/apps/routing-api/src/test/java/org/onosproject/routing/RouteEntryTest.java b/framework/src/onos/apps/routing-api/src/test/java/org/onosproject/routing/RouteEntryTest.java new file mode 100644 index 00000000..c47d2768 --- /dev/null +++ b/framework/src/onos/apps/routing-api/src/test/java/org/onosproject/routing/RouteEntryTest.java @@ -0,0 +1,159 @@ +/* + * Copyright 2014-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.routing; + +import org.hamcrest.Matchers; +import org.junit.Test; +import org.onlab.packet.Ip4Address; +import org.onlab.packet.Ip4Prefix; + +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.not; +import static org.junit.Assert.assertThat; + +/** + * Unit tests for the RouteEntry class. + */ +public class RouteEntryTest { + /** + * Tests valid class constructor. + */ + @Test + public void testConstructor() { + Ip4Prefix prefix = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop = Ip4Address.valueOf("5.6.7.8"); + + RouteEntry routeEntry = new RouteEntry(prefix, nextHop); + assertThat(routeEntry.toString(), + is("RouteEntry{prefix=1.2.3.0/24, nextHop=5.6.7.8}")); + } + + /** + * Tests invalid class constructor for null IPv4 prefix. + */ + @Test(expected = NullPointerException.class) + public void testInvalidConstructorNullPrefix() { + Ip4Prefix prefix = null; + Ip4Address nextHop = Ip4Address.valueOf("5.6.7.8"); + + new RouteEntry(prefix, nextHop); + } + + /** + * Tests invalid class constructor for null IPv4 next-hop. + */ + @Test(expected = NullPointerException.class) + public void testInvalidConstructorNullNextHop() { + Ip4Prefix prefix = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop = null; + + new RouteEntry(prefix, nextHop); + } + + /** + * Tests getting the fields of a route entry. + */ + @Test + public void testGetFields() { + Ip4Prefix prefix = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop = Ip4Address.valueOf("5.6.7.8"); + + RouteEntry routeEntry = new RouteEntry(prefix, nextHop); + assertThat(routeEntry.prefix(), is(prefix)); + assertThat(routeEntry.nextHop(), is(nextHop)); + } + + /** + * Tests creating a binary string from IPv4 prefix. + */ + @Test + public void testCreateBinaryString() { + Ip4Prefix prefix; + + prefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertThat(RouteEntry.createBinaryString(prefix), is("")); + + prefix = Ip4Prefix.valueOf("192.168.166.0/22"); + assertThat(RouteEntry.createBinaryString(prefix), + is("1100000010101000101001")); + + prefix = Ip4Prefix.valueOf("192.168.166.0/23"); + assertThat(RouteEntry.createBinaryString(prefix), + is("11000000101010001010011")); + + prefix = Ip4Prefix.valueOf("192.168.166.0/24"); + assertThat(RouteEntry.createBinaryString(prefix), + is("110000001010100010100110")); + + prefix = Ip4Prefix.valueOf("130.162.10.1/25"); + assertThat(RouteEntry.createBinaryString(prefix), + is("1000001010100010000010100")); + + prefix = Ip4Prefix.valueOf("255.255.255.255/32"); + assertThat(RouteEntry.createBinaryString(prefix), + is("11111111111111111111111111111111")); + } + + /** + * Tests equality of {@link RouteEntry}. + */ + @Test + public void testEquality() { + Ip4Prefix prefix1 = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop1 = Ip4Address.valueOf("5.6.7.8"); + RouteEntry routeEntry1 = new RouteEntry(prefix1, nextHop1); + + Ip4Prefix prefix2 = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop2 = Ip4Address.valueOf("5.6.7.8"); + RouteEntry routeEntry2 = new RouteEntry(prefix2, nextHop2); + + assertThat(routeEntry1, is(routeEntry2)); + } + + /** + * Tests non-equality of {@link RouteEntry}. + */ + @Test + public void testNonEquality() { + Ip4Prefix prefix1 = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop1 = Ip4Address.valueOf("5.6.7.8"); + RouteEntry routeEntry1 = new RouteEntry(prefix1, nextHop1); + + Ip4Prefix prefix2 = Ip4Prefix.valueOf("1.2.3.0/25"); // Different + Ip4Address nextHop2 = Ip4Address.valueOf("5.6.7.8"); + RouteEntry routeEntry2 = new RouteEntry(prefix2, nextHop2); + + Ip4Prefix prefix3 = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop3 = Ip4Address.valueOf("5.6.7.9"); // Different + RouteEntry routeEntry3 = new RouteEntry(prefix3, nextHop3); + + assertThat(routeEntry1, Matchers.is(not(routeEntry2))); + assertThat(routeEntry1, Matchers.is(not(routeEntry3))); + } + + /** + * Tests object string representation. + */ + @Test + public void testToString() { + Ip4Prefix prefix = Ip4Prefix.valueOf("1.2.3.0/24"); + Ip4Address nextHop = Ip4Address.valueOf("5.6.7.8"); + RouteEntry routeEntry = new RouteEntry(prefix, nextHop); + + assertThat(routeEntry.toString(), + is("RouteEntry{prefix=1.2.3.0/24, nextHop=5.6.7.8}")); + } +} |