upstream.
Change-Id: I49f8e41733afea8101ec50c0102213c8d18949ae
Signed-off-by: Ashlee Young <ashlee@wildernessvoice.com>
@Override
public int hashCode() {
- return Objects.hash(address);
+ return address.hashCode();
}
@Override
import com.fasterxml.jackson.databind.JsonNode;
import org.apache.karaf.shell.commands.Command;
import org.onosproject.cli.AbstractShellCommand;
-import org.onosproject.net.ConnectPoint;
-import org.onosproject.pim.impl.PIMNeighbors;
-import org.onosproject.pim.impl.PIMNeighborsCodec;
+import org.onosproject.pim.impl.PIMInterface;
+import org.onosproject.pim.impl.PIMInterfaces;
+import org.onosproject.pim.impl.PIMInterfacesCodec;
-import java.util.HashMap;
+import java.util.Collection;
-@Command(scope = "onos", name = "pim-neighbors", description = "Displays the pim neighbors")
+@Command(scope = "onos", name = "pim-interfaces", description = "Displays the pim interfaces")
public class PIMShowCommand extends AbstractShellCommand {
// prints either the json or cli version of the hash map connect point
- // neighbors from the PIMNeighbors class.
+ // neighbors from the PIMInterfaces class.
@Override
protected void execute() {
// grab connect point neighbors hash map to send in to json encoder.
- HashMap<ConnectPoint, PIMNeighbors> pimNbrs = PIMNeighbors.getConnectPointNeighbors();
+ Collection<PIMInterface> pimIntfs = PIMInterfaces.getInstance().getInterfaces();
if (outputJson()) {
- print("%s", json(pimNbrs));
+ print("%s", json(pimIntfs));
} else {
- print(PIMNeighbors.printPimNeighbors());
+ print(PIMInterfaces.getInstance().printInterfaces());
}
}
- private JsonNode json(HashMap<ConnectPoint, PIMNeighbors> pimNbrs) {
- return new PIMNeighborsCodec().encode(pimNbrs, this);
+ private JsonNode json(Collection<PIMInterface> pimIntfs) {
+ return new PIMInterfacesCodec().encode(pimIntfs, this);
}
}
\ No newline at end of file
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
-import org.onlab.packet.Ethernet;
-import org.onlab.packet.IPv4;
-import org.onlab.packet.Ip4Address;
-import org.onlab.packet.IpAddress;
-import org.onlab.packet.IpPrefix;
-import org.onlab.packet.PIM;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
-import org.onosproject.net.flow.DefaultTrafficSelector;
-import org.onosproject.net.flow.TrafficSelector;
-import org.onosproject.net.packet.InboundPacket;
-import org.onosproject.net.packet.PacketContext;
-import org.onosproject.net.packet.PacketPriority;
-import org.onosproject.net.packet.PacketProcessor;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.net.config.NetworkConfigService;
import org.onosproject.net.packet.PacketService;
import org.slf4j.Logger;
/**
- * Protocol Independent Multicast Emulation.
+ * Protocol Independent Multicast (PIM) Emulation. This component is responsible
+ * for reference the services this PIM module is going to need, then initializing
+ * the corresponding utility classes.
*/
@Component(immediate = true)
public class PIMComponent {
private final Logger log = getLogger(getClass());
+ // Register to receive PIM packets, used to send packets as well
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected PacketService packetService;
+ // Get the appId
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected CoreService coreService;
- private PIMPacketProcessor processor = new PIMPacketProcessor();
+ // Get the network configuration updates
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigService configService;
+
+ // Access defined network (IP) interfaces
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected InterfaceService interfaceService;
+
private static ApplicationId appId;
+ private PIMInterfaces pimInterfaces;
+ private PIMPacketHandler pimPacketHandler;
+
@Activate
public void activate() {
appId = coreService.registerApplication("org.onosproject.pim");
- packetService.addProcessor(processor, PacketProcessor.director(1));
+ // Initialize the Packet Handler class
+ pimPacketHandler = PIMPacketHandler.getInstance();
+ pimPacketHandler.initialize(packetService, appId);
- // Build a traffic selector for all multicast traffic
- TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
- selector.matchEthType(Ethernet.TYPE_IPV4);
- selector.matchIPProtocol(IPv4.PROTOCOL_PIM);
- packetService.requestPackets(selector.build(), PacketPriority.REACTIVE, appId);
+ // Initialize the Interface class
+ pimInterfaces = PIMInterfaces.getInstance();
+ pimInterfaces.initialize(configService, interfaceService);
log.info("Started");
}
@Deactivate
public void deactivate() {
- packetService.removeProcessor(processor);
- processor = null;
+ PIMPacketHandler.getInstance().stop();
log.info("Stopped");
}
-
- /**
- * Packet processor responsible for handling IGMP packets.
- */
- private class PIMPacketProcessor implements PacketProcessor {
-
- @Override
- public void process(PacketContext context) {
- // Stop processing if the packet has been handled, since we
- // can't do any more to it.
- if (context.isHandled()) {
- return;
- }
-
- InboundPacket pkt = context.inPacket();
- if (pkt == null) {
- return;
- }
-
- Ethernet ethPkt = pkt.parsed();
- if (ethPkt == null) {
- return;
- }
-
- /*
- * IPv6 MLD packets are handled by ICMP6. We'll only deal
- * with IPv4.
- */
- if (ethPkt.getEtherType() != Ethernet.TYPE_IPV4) {
- return;
- }
-
- IPv4 ip = (IPv4) ethPkt.getPayload();
- IpAddress gaddr = IpAddress.valueOf(ip.getDestinationAddress());
- IpAddress saddr = Ip4Address.valueOf(ip.getSourceAddress());
- log.debug("Packet (" + saddr.toString() + ", " + gaddr.toString() +
- "\tingress port: " + context.inPacket().receivedFrom().toString());
-
- if (ip.getProtocol() != IPv4.PROTOCOL_PIM) {
- log.debug("PIM Picked up a non PIM packet: IP protocol: " + ip.getProtocol());
- return;
- }
-
- // TODO: check incoming to be PIM.PIM_ADDRESS or "Our" address.
- IpPrefix spfx = IpPrefix.valueOf(saddr, 32);
- IpPrefix gpfx = IpPrefix.valueOf(gaddr, 32);
-
- PIM pim = (PIM) ip.getPayload();
- switch (pim.getPimMsgType()) {
-
- case PIM.TYPE_HELLO:
- PIMNeighbors.processHello(ethPkt, context.inPacket().receivedFrom());
- break;
-
- case PIM.TYPE_JOIN_PRUNE_REQUEST:
- // Create the function
- break;
-
- case PIM.TYPE_ASSERT:
- case PIM.TYPE_BOOTSTRAP:
- case PIM.TYPE_CANDIDATE_RP_ADV:
- case PIM.TYPE_GRAFT:
- case PIM.TYPE_GRAFT_ACK:
- case PIM.TYPE_REGISTER:
- case PIM.TYPE_REGISTER_STOP:
- log.debug("Unsupported PIM message type: " + pim.getPimMsgType());
- break;
-
- default:
- log.debug("Unkown PIM message type: " + pim.getPimMsgType());
- break;
- }
- }
- }
}
--- /dev/null
+/*
+ * 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.pim.impl;
+
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.IPv4;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.PIM;
+import org.onlab.packet.pim.PIMHello;
+import org.onlab.packet.pim.PIMHelloOption;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.host.InterfaceIpAddress;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * The PIM Interface is a wrapper around a ConnectPoint and used to provide
+ * hello options values when "talking" with PIM other PIM routers.
+ */
+public class PIMInterface {
+ private static Logger log = LoggerFactory.getLogger("PIMInterfaces");
+
+ // Interface from the interface subsystem
+ private Interface theInterface;
+
+ // The list of PIM neighbors adjacent to this interface
+ private Map<IpAddress, PIMNeighbor> neighbors = new HashMap<>();
+
+ // The designatedRouter for this LAN
+ private PIMNeighbor designatedRouter;
+
+ // The priority we use on this ConnectPoint.
+ private int priority = PIMHelloOption.DEFAULT_PRIORITY;
+
+ // The holdtime we are sending out.
+ private int holdtime = PIMHelloOption.DEFAULT_HOLDTIME;
+
+ // Then generation ID we are sending out. 0 means we need to generate a new random ID
+ private int genid = PIMHelloOption.DEFAULT_GENID;
+
+ // Our default prune delay
+ private int prunedelay = PIMHelloOption.DEFAULT_PRUNEDELAY;
+
+ /**
+ * Create a PIMInterface.
+ */
+ public PIMInterface(Interface intf) {
+
+ log.debug("Adding an interface: " + intf.toString() + "\n");
+ this.theInterface = intf;
+
+ // Send a hello to let our neighbors know we are alive
+ sendHello();
+ }
+
+ /**
+ * Get the PIM Interface.
+ *
+ * @return the PIM Interface
+ */
+ public Interface getInterface() {
+ return theInterface;
+ }
+
+ /**
+ * Getter for our IP address.
+ *
+ * @return our IP address.
+ */
+ public IpAddress getIpAddress() {
+ if (theInterface.ipAddresses().isEmpty()) {
+ return null;
+ }
+
+ // We will just assume the first interface on the list
+ IpAddress ipaddr = null;
+ for (InterfaceIpAddress ifipaddr : theInterface.ipAddresses()) {
+ ipaddr = ifipaddr.ipAddress();
+ break;
+ }
+ return ipaddr;
+ }
+
+ /**
+ * Get our priority.
+ *
+ * @return our priority.
+ */
+ public int getPriority() {
+ return this.priority;
+ }
+
+ /**
+ * Get the designated router on this connection.
+ *
+ * @return the PIMNeighbor representing the DR
+ */
+ public PIMNeighbor getDesignatedRouter() {
+ return designatedRouter;
+ }
+
+ /**
+ * Are we the DR on this CP?
+ *
+ * @return true if we are, false if not
+ */
+ public boolean areWeDr() {
+ return (designatedRouter != null &&
+ designatedRouter.getPrimaryAddr().equals(this.getIpAddress()));
+ }
+
+ /**
+ * Return a collection of PIM Neighbors.
+ *
+ * @return the collection of PIM Neighbors
+ */
+ public Collection<PIMNeighbor> getNeighbors() {
+ return this.neighbors.values();
+ }
+
+ /**
+ * Find the neighbor with the given IP address on this CP.
+ *
+ * @param ipaddr the IP address of the neighbor we are interested in
+ * @return the pim neighbor if it exists
+ */
+ public PIMNeighbor findNeighbor(IpAddress ipaddr) {
+ PIMNeighbor nbr = neighbors.get(ipaddr);
+ return nbr;
+ }
+
+ /**
+ * Add a new PIM neighbor to this list.
+ *
+ * @param nbr the neighbor to be added.
+ */
+ public void addNeighbor(PIMNeighbor nbr) {
+ if (neighbors.containsKey(nbr.getPrimaryAddr())) {
+
+ log.debug("We are adding a neighbor that already exists: {}", nbr.toString());
+ neighbors.remove(nbr.getPrimaryAddr());
+ }
+ neighbors.put(nbr.getPrimaryAddr(), nbr);
+ }
+
+ /**
+ * Remove the neighbor from our neighbor list.
+ *
+ * @param ipaddr the IP address of the neighbor to remove
+ */
+ public void removeNeighbor(IpAddress ipaddr) {
+
+ if (neighbors.containsKey(ipaddr)) {
+ neighbors.remove(ipaddr);
+ }
+ this.electDR();
+ }
+
+ /**
+ * Remove the given neighbor from the neighbor list.
+ *
+ * @param nbr the nbr to be removed.
+ */
+ public void removeNeighbor(PIMNeighbor nbr) {
+
+ neighbors.remove(nbr.getPrimaryAddr(), nbr);
+ this.electDR();
+ }
+
+ /**
+ * Elect a new DR on this ConnectPoint.
+ *
+ * @return the PIM Neighbor that wins
+ */
+ public PIMNeighbor electDR() {
+
+ for (PIMNeighbor nbr : this.neighbors.values()) {
+ if (this.designatedRouter == null) {
+ this.designatedRouter = nbr;
+ continue;
+ }
+
+ if (nbr.getPriority() > this.designatedRouter.getPriority()) {
+ this.designatedRouter = nbr;
+ continue;
+ }
+
+ // We could sort in ascending order
+ if (this.designatedRouter.getPrimaryAddr().compareTo(nbr.getPrimaryAddr()) > 0) {
+ this.designatedRouter = nbr;
+ continue;
+ }
+ }
+
+ return this.designatedRouter;
+ }
+
+ /**
+ * Elect a new DR given the new neighbor.
+ *
+ * @param nbr the new neighbor to use in DR election.
+ * @return the PIM Neighbor that wins DR election
+ */
+ public PIMNeighbor electDR(PIMNeighbor nbr) {
+
+ // Make sure I have
+ if (this.designatedRouter == null ||
+ this.designatedRouter.getPriority() < nbr.getPriority() ||
+ this.designatedRouter.getPrimaryAddr().compareTo(nbr.getPrimaryAddr()) > 0) {
+ this.designatedRouter = nbr;
+ }
+ return this.designatedRouter;
+ }
+
+ /**
+ * Find or create a pim neighbor with a given ip address and connect point.
+ *
+ * @param ipaddr of the pim neighbor
+ * @param mac The mac address of our sending neighbor
+ * @return an existing or new PIM neighbor
+ */
+ public PIMNeighbor findOrCreate(IpAddress ipaddr, MacAddress mac) {
+ PIMNeighbor nbr = this.findNeighbor(ipaddr);
+ if (nbr == null) {
+ nbr = new PIMNeighbor(ipaddr, mac, this);
+ this.addNeighbor(nbr);
+ this.electDR(nbr);
+ }
+ return nbr;
+ }
+
+ /**
+ * Process a hello packet received on this Interface.
+ *
+ * @param ethPkt the ethernet packet containing the hello message
+ * @param cp the ConnectPoint of this interface
+ */
+ public void processHello(Ethernet ethPkt, ConnectPoint cp) {
+ checkNotNull(ethPkt);
+ checkNotNull(cp);
+
+ MacAddress srcmac = ethPkt.getSourceMAC();
+ IPv4 ip = (IPv4) ethPkt.getPayload();
+ Ip4Address srcip = Ip4Address.valueOf(ip.getSourceAddress());
+
+ PIM pim = (PIM) ip.getPayload();
+ checkNotNull(pim);
+
+ PIMHello hello = (PIMHello) pim.getPayload();
+ checkNotNull(hello);
+
+ PIMNeighbor nbr = this.findOrCreate(srcip, srcmac);
+ if (nbr == null) {
+ log.error("Could not create a neighbor for: {1}", srcip.toString());
+ return;
+ }
+
+ ConnectPoint icp = theInterface.connectPoint();
+ checkNotNull(icp);
+ if (!cp.equals(icp)) {
+ log.error("PIM Hello message received from {} on incorrect interface {}",
+ nbr.getPrimaryAddr(), this.toString());
+ return;
+ }
+ nbr.refresh(hello);
+ }
+
+ /**
+ * Send a hello packet from this interface.
+ */
+ public void sendHello() {
+ PIM pim = new PIM();
+ PIMHello hello = new PIMHello();
+
+ // Create a PIM Hello
+ pim = new PIM();
+ pim.setVersion((byte) 2);
+ pim.setPIMType((byte) PIM.TYPE_HELLO);
+ pim.setChecksum((short) 0);
+
+ hello = new PIMHello();
+ hello.createDefaultOptions();
+ pim.setPayload(hello);
+ hello.setParent(pim);
+
+ log.debug("Sending hello: \n");
+ PIMPacketHandler.getInstance().sendPacket(pim, this);
+ }
+
+ /**
+ * prints the connectPointNeighbors list with each neighbor list.
+ *
+ * @return string of neighbors.
+ */
+ public String printNeighbors() {
+ String out = "PIM Neighbors Table: \n";
+ for (PIMNeighbor nbr : this.neighbors.values()) {
+ out += "\t" + nbr.toString();
+ }
+ return out;
+ }
+
+ @Override
+ public String toString() {
+ IpAddress ipaddr = this.getIpAddress();
+ String out = "PIM Neighbors: ";
+ if (ipaddr != null) {
+ out += "IP: " + ipaddr.toString();
+ } else {
+ out += "IP: *Null*";
+ }
+ out += "\tPR: " + String.valueOf(this.priority) + "\n";
+ return out;
+ }
+
+}
+
--- /dev/null
+/*
+ * 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.pim.impl;
+
+import org.jboss.netty.util.Timeout;
+import org.jboss.netty.util.TimerTask;
+import org.onosproject.incubator.net.config.basics.ConfigException;
+import org.onosproject.incubator.net.config.basics.InterfaceConfig;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.net.ConnectPoint;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import org.onosproject.net.config.NetworkConfigEvent;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * PIMInterfaces is a collection of all neighbors we have received
+ * PIM hello messages from. The main structure is a HashMap indexed
+ * by ConnectPoint with another HashMap indexed on the PIM neighbors
+ * IPAddress, it contains all PIM neighbors attached on that ConnectPoint.
+ */
+public final class PIMInterfaces {
+
+ private Logger log = LoggerFactory.getLogger("PIMInterfaces");
+
+ private static PIMInterfaces instance = null;
+
+ // Used to listen to network configuration changes
+ private NetworkConfigService configService;
+
+ // Used to access IP Interface definitions for our segment
+ private InterfaceService interfaceService;
+
+ // Internal class used to listen for network configuration changes
+ private InternalConfigListener configListener = new InternalConfigListener();
+
+ // This is the global container for all PIM Interfaces indexed by ConnectPoints.
+ private Map<ConnectPoint, PIMInterface> interfaces = new HashMap<>();
+
+ // Default hello message interval
+ private int helloMessageInterval = 60;
+
+ // Timer used to send hello messages on this interface
+ private Timeout helloTimer;
+
+ // Required by a utility class
+ private PIMInterfaces() {}
+
+ /**
+ * Get the instance of PIMInterfaces. Create the instance if needed.
+ *
+ * @return PIMInterface instance
+ */
+ public static PIMInterfaces getInstance() {
+ if (null == instance) {
+ instance = new PIMInterfaces();
+ }
+ return instance;
+ }
+
+ // Initialize the services
+ public void initialize(NetworkConfigService cs, InterfaceService is) {
+ configService = cs;
+ interfaceService = is;
+
+ // Initialize interfaces if they already exist
+ initInterfaces();
+
+ // Listen for network config changes
+ configService.addListener(configListener);
+ }
+
+ /**
+ * Listener for network config events.
+ */
+ private class InternalConfigListener implements NetworkConfigListener {
+
+ private void updateInterfaces(InterfaceConfig config) {
+ Set<Interface> intfs;
+ try {
+ intfs = config.getInterfaces();
+ } catch (ConfigException e) {
+ log.error(e.toString());
+ return;
+ }
+ for (Interface intf : intfs) {
+ addInterface(intf);
+ }
+ }
+
+ /**
+ * Remove the PIMInterface represented by the ConnectPoint. If the
+ * PIMInterface does not exist this function is a no-op.
+ *
+ * @param cp The connectPoint representing the PIMInterface to be removed.
+ */
+ private void removeInterface(ConnectPoint cp) {
+ removeInterface(cp);
+ }
+
+ @Override
+ public void event(NetworkConfigEvent event) {
+ switch (event.type()) {
+ case CONFIG_ADDED:
+ case CONFIG_UPDATED:
+ log.debug("Config updated: " + event.toString() + "\n");
+ if (event.configClass() == InterfaceConfig.class) {
+ InterfaceConfig config =
+ configService.getConfig((ConnectPoint) event.subject(), InterfaceConfig.class);
+ updateInterfaces(config);
+ }
+ break;
+ case CONFIG_REMOVED:
+ if (event.configClass() == InterfaceConfig.class) {
+ removeInterface((ConnectPoint) event.subject());
+ }
+ break;
+ case CONFIG_REGISTERED:
+ case CONFIG_UNREGISTERED:
+ default:
+ break;
+ }
+ }
+ }
+
+ // Configure interfaces if they already exist.
+ private void initInterfaces() {
+ Set<Interface> intfs = interfaceService.getInterfaces();
+ for (Interface intf : intfs) {
+ log.debug("Adding interface: " + intf.toString() + "\n");
+ addInterface(intf);
+ }
+ }
+
+ /**
+ * Create a PIM Interface and add to our interfaces list.
+ *
+ * @param intf the interface to add
+ * @return the PIMInterface
+ */
+ public PIMInterface addInterface(Interface intf) {
+ PIMInterface pif = new PIMInterface(intf);
+ interfaces.put(intf.connectPoint(), pif);
+
+ // If we have added our first interface start the hello timer.
+ if (interfaces.size() == 1) {
+ startHelloTimer();
+ }
+
+ // Return this interface
+ return pif;
+ }
+
+ /**
+ * Remove the PIMInterface from the given ConnectPoint.
+ *
+ * @param cp the ConnectPoint indexing the PIMInterface to be removed.
+ */
+ public void removeInterface(ConnectPoint cp) {
+ if (interfaces.containsKey(cp)) {
+ interfaces.remove(cp);
+ }
+
+ if (interfaces.size() == 0) {
+ PIMTimer.stop();
+ }
+ }
+
+ /**
+ * Return a collection of PIMInterfaces for use by the PIM Interface codec.
+ *
+ * @return the collection of PIMInterfaces
+ */
+ public Collection<PIMInterface> getInterfaces() {
+ return interfaces.values();
+ }
+
+ /**
+ * Get the PIM Interface indexed by the given ConnectPoint.
+ *
+ * @param cp the connect point
+ * @return the PIMInterface if it exists, NULL if not
+ */
+ public PIMInterface getInterface(ConnectPoint cp) {
+ return interfaces.get(cp);
+ }
+
+ /**
+ * Return a string of PIMInterfaces for the cli command.
+ *
+ * @return a string representing PIM interfaces
+ */
+ public String printInterfaces() {
+ String str = "";
+ for (PIMInterface pi : interfaces.values()) {
+ str += pi.toString();
+ }
+ return str;
+ }
+
+ /* ---------------------------------- PIM Hello Timer ----------------------------------- */
+
+ /**
+ * Start a new hello timer for this interface.
+ */
+ private void startHelloTimer() {
+ helloTimer = PIMTimer.getTimer().newTimeout(
+ new HelloTimer(),
+ helloMessageInterval,
+ TimeUnit.SECONDS);
+
+ log.debug("Started Hello Timer");
+ }
+
+ /**
+ * This inner class handles transmitting a PIM hello message on this ConnectPoint.
+ */
+ private final class HelloTimer implements TimerTask {
+
+ HelloTimer() {
+ }
+
+ @Override
+ public void run(Timeout timeout) throws Exception {
+
+ log.debug("Running Hello Timer\n");
+ // Technically we should not send all hello's in synch..
+ for (PIMInterface pi : interfaces.values()) {
+ pi.sendHello();
+ }
+
+ // restart the hello timer
+ if (interfaces.size() > 0) {
+ startHelloTimer();
+ }
+ }
+ }
+}
\ No newline at end of file
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.onosproject.codec.CodecContext;
import org.onosproject.codec.JsonCodec;
-import org.onosproject.net.ConnectPoint;
-import java.util.HashMap;
+import java.util.Collection;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* PIM neighbors Codec.
*/
-public class PIMNeighborsCodec extends JsonCodec<HashMap<ConnectPoint, PIMNeighbors>> {
+public class PIMInterfacesCodec extends JsonCodec<Collection<PIMInterface>> {
// JSON field names
//Return Name
private static final String CPNBRLIST = "connect_point_list";
* @return Encoded neighbors used by CLI and REST
*/
@Override
- public ObjectNode encode(HashMap<ConnectPoint, PIMNeighbors> cpn, CodecContext context) {
+ public ObjectNode encode(Collection<PIMInterface> cpn, CodecContext context) {
checkNotNull(cpn, "Pim Neighbors cannot be null");
ObjectNode pimNbrJsonCodec = context.mapper().createObjectNode();
ArrayNode cpnList = context.mapper().createArrayNode();
- for (PIMNeighbors pn: cpn.values()) {
+ for (PIMInterface pn: cpn) {
// get the PimNeighbors Obj, contains Neighbors list
// create the json object for a single Entry in the Neighbors list
ObjectNode cp = context.mapper().createObjectNode();
- cp.put(IP, pn.getOurIpAddress().toString());
- cp.put(PRIORITY, String.valueOf(pn.getOurPriority()));
+ cp.put(IP, pn.getIpAddress().toString());
+ cp.put(PRIORITY, String.valueOf(pn.getPriority()));
// create the array for the neighbors list
ArrayNode nbrsList = context.mapper().createArrayNode();
- for (PIMNeighbor nbr : pn.getOurNeighborsList().values()) {
+ for (PIMNeighbor nbr : pn.getNeighbors()) {
nbrsList.add(neighbor(nbr, context));
}
// adds pim neighbor to list
// Timeout for this neighbor
private volatile Timeout timeout;
- private boolean reelect = false;
-
// A back pointer the neighbors list this neighbor belongs to.
- private PIMNeighbors neighbors;
+ private PIMInterface pimInterface;
/**
* Construct this neighbor from the address and connect point.
*
* @param ipaddr IP Address of neighbor
* @param macaddr MAC Address of the neighbor
- * @param cp The ConnectPoint of this neighbor
+ * @param pimInterface The PIMInterface of this neighbor
*/
- public PIMNeighbor(IpAddress ipaddr, MacAddress macaddr, ConnectPoint cp) {
+ public PIMNeighbor(IpAddress ipaddr, MacAddress macaddr, PIMInterface pimInterface) {
this.macAddress = macaddr;
this.primaryAddr = ipaddr;
- this.connectPoint = cp;
+ this.pimInterface = pimInterface;
this.resetTimeout();
}
*
* @return the ConnectPoint
*/
- public ConnectPoint getConnectPoint() {
- return connectPoint;
- }
-
- /**
- * Set the ConnectPoint this router is connected to.
- *
- * @param connectPoint the ConnectPoint this router is connected to.
- */
- public void setConnectPoint(ConnectPoint connectPoint) {
- this.connectPoint = connectPoint;
+ public PIMInterface getPimInterface() {
+ return pimInterface;
}
/**
- * Set a back pointer to the neighbors list this neighbor is a member of.
- *
- * @param neighbors the neighbor list this neighbor belongs to
- */
- public void setNeighbors(PIMNeighbors neighbors) {
- this.neighbors = neighbors;
- }
-
- /**
- * We have received a fresh hello from a neighbor, now we need to process it.
+ * We have received a fresh hello from this neighbor, now we need to process it.
* Depending on the values received in the the hello options may force a
* re-election process.
*
public void refresh(PIMHello hello) {
checkNotNull(hello);
+ boolean reelect = false;
for (PIMHelloOption opt : hello.getOptions().values()) {
int len = opt.getOptLength();
- byte [] value = new byte[len];
- ByteBuffer bb = ByteBuffer.wrap(value);
+ ByteBuffer bb = ByteBuffer.wrap(opt.getValue());
switch (opt.getOptType()) {
case PIMHelloOption.OPT_GENID:
int newid = bb.getInt();
if (this.genId != newid) {
- // TODO: we have a newly rebooted neighbor. Send them our joins.
+
+ // We have a newly rebooted neighbor, this is where we would
+ // send them our joins.
this.genId = newid;
}
break;
if (this.priority != newpri) {
// The priorities have changed. We may need to re-elect a new DR?
- if (this.isDr || this.neighbors.getDesignatedRouter().getPriority() < priority) {
+ if (this.isDr || pimInterface.getDesignatedRouter().getPriority() < priority) {
reelect = true;
}
this.priority = newpri;
if (holdtime == 0) {
// We have a neighbor going down. We can remove all joins
// we have learned from them.
- // TODO: What else do we need to do when a neighbor goes down?
log.debug("PIM Neighbor has timed out: {}", this.primaryAddr.toString());
return;
}
if (reelect) {
- this.neighbors.electDR(this);
+ pimInterface.electDR(this);
}
// Reset the next timeout timer
@Override
public void run(Timeout timeout) throws Exception {
- // TODO: log.debug;
- PIMNeighbors neighbors = nbr.neighbors;
- neighbors.removeNeighbor(nbr.getPrimaryAddr());
+ log.debug("PIM Neighbor {} has timed out: ", nbr.toString());
+ nbr.pimInterface.removeNeighbor(nbr);
}
}
+++ /dev/null
-
-package org.onosproject.pim.impl;
-
-import org.jboss.netty.util.Timeout;
-import org.jboss.netty.util.TimerTask;
-import org.onlab.packet.Ethernet;
-import org.onlab.packet.IPv4;
-import org.onlab.packet.Ip4Address;
-import org.onlab.packet.IpAddress;
-import org.onlab.packet.MacAddress;
-import org.onlab.packet.PIM;
-import org.onlab.packet.pim.PIMHello;
-import org.onosproject.net.ConnectPoint;
-import java.util.HashMap;
-import java.util.concurrent.TimeUnit;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * PIMNeighbors is a collection of all neighbors we have received
- * PIM hello messages from. The main structure is a HashMap indexed
- * by ConnectPoint with another HashMap indexed on the PIM neighbors
- * IPAddress, it contains all PIM neighbors attached on that ConnectPoint.
- */
-public final class PIMNeighbors {
-
- private static Logger log = LoggerFactory.getLogger("PIMNeighbors");
-
- /**
- * This is the global container for all PIM neighbors indexed by ConnectPoints.
- *
- * NOTE: We'll have a problem if the same neighbor can show up on two interfaces
- * but that should never happen.
- */
- private static HashMap<ConnectPoint, PIMNeighbors> connectPointNeighbors = new HashMap<>();
-
- // The connect point these neighbors are connected to.
- private ConnectPoint connectPoint;
-
- // Pointer to the current designated router on this ConnectPoint.
- private PIMNeighbor designatedRouter;
-
- // The list of neighbors we have learned on this ConnectPoint.
- private HashMap<IpAddress, PIMNeighbor> neighbors = new HashMap<>();
-
- /*
- * TODO: turn ourIpAddress, ourPriority and OurHoldTime into config options.
- */
- // The IP address we are using to source our PIM hello messages on this connect Point.
- private IpAddress ourIpAddress;
-
- // The priority we use on this ConnectPoint.
- private int ourPriority = 1;
-
- // The holdtime we are sending out.
- private int ourHoldtime = 105;
-
- // Then generation ID we are sending out. 0 means we need to generate a new random ID
- private int ourGenid = 0;
-
- // Hello Timer for sending hello messages per ConnectPoint with neighbors.
- private volatile Timeout helloTimer;
-
- // The period of which we will be sending out PIM hello messages.
- private final int defaultPimHelloInterval = 30; // seconds
-
- /**
- * Create PIMNeighbors object per ConnectPoint.
- *
- * @param cp the ConnectPoint.
- * @return PIMNeighbors structure
- */
- public static PIMNeighbors getConnectPointNeighbors(ConnectPoint cp) {
- return connectPointNeighbors.get(cp);
- }
-
- /**
- * Process incoming hello message, we will need the Macaddress and IP address of the sender.
- *
- * @param ethPkt the ethernet header
- * @param receivedFrom the connect point we recieved this message from
- */
- public static void processHello(Ethernet ethPkt, ConnectPoint receivedFrom) {
- checkNotNull(ethPkt);
- checkNotNull(ethPkt);
-
- MacAddress srcmac = ethPkt.getSourceMAC();
- IPv4 ip = (IPv4) ethPkt.getPayload();
- Ip4Address srcip = Ip4Address.valueOf(ip.getSourceAddress());
-
- PIM pim = (PIM) ip.getPayload();
- checkNotNull(pim);
-
- PIMHello hello = (PIMHello) pim.getPayload();
- checkNotNull(hello);
-
- PIMNeighbor nbr = PIMNeighbors.findOrCreate(srcip, srcmac, receivedFrom);
- if (nbr == null) {
- log.error("Could not create a neighbor for: {1}", srcip.toString());
- return;
- }
-
- nbr.setConnectPoint(receivedFrom);
- nbr.refresh(hello);
- }
-
- /**
- * Create a PIM Neighbor.
- *
- * @param cp The ConnectPoint this neighbor was found on
- */
- public PIMNeighbors(ConnectPoint cp) {
- this.connectPoint = cp;
-
- // TODO: use network config to assign address.
- this.ourIpAddress = IpAddress.valueOf("10.2.2.2");
- this.addIpAddress(this.ourIpAddress);
- }
-
- /**
- * Create a PIM neighbor.
- *
- * @param cp the ConnectPoint this neighbor was found on
- * @param ourIp the IP address of this neighbor
- */
- public PIMNeighbors(ConnectPoint cp, IpAddress ourIp) {
- this.connectPoint = cp;
- this.addIpAddress(ourIp);
- }
-
- /**
- * Start the hello timer when we have been given an IP address.
- *
- * @param ourIp our IP address.
- */
- public void addIpAddress(IpAddress ourIp) {
- this.startHelloTimer();
-
- // Kick off the first pim hello packet
- this.sendHelloPacket();
- }
-
- /**
- * Getter for our IP address.
- *
- * @return our IP address.
- */
- public IpAddress getOurIpAddress() {
- return this.ourIpAddress;
- }
-
- /**
- * Get our priority.
- *
- * @return our priority.
- */
- public int getOurPriority() {
- return this.ourPriority;
- }
-
- /**
- * Get the neighbor list for this specific connectPoint.
- *
- * @return PIM neighbors on this ConnectPoint
- */
- public HashMap<IpAddress, PIMNeighbor> getOurNeighborsList() {
- return this.neighbors;
- }
-
- /**
- * Get the designated router on this connection.
- *
- * @return the PIMNeighbor representing the DR
- */
- public PIMNeighbor getDesignatedRouter() {
- return designatedRouter;
- }
-
- /**
- * Are we the DR on this CP?
- *
- * @return true if we are, false if not
- */
- public boolean weAreTheDr() {
- return (designatedRouter != null &&
- designatedRouter.getPrimaryAddr().equals(ourIpAddress));
- }
-
- /**
- * Find the neighbor with the given IP address on this CP.
- *
- * @param ipaddr the IP address of the neighbor we are interested in
- * @return the pim neighbor if it exists
- */
- public PIMNeighbor findNeighbor(IpAddress ipaddr) {
- PIMNeighbor nbr = neighbors.get(ipaddr);
- return nbr;
- }
-
- /**
- * Add a new PIM neighbor to this list.
- *
- * @param nbr the neighbor to be added.
- */
- public void addNeighbor(PIMNeighbor nbr) {
- if (neighbors.containsKey(nbr.getPrimaryAddr())) {
-
- // TODO: Hmmm, how should this be handled?
- log.debug("We are adding a neighbor that already exists: {}", nbr.toString());
- neighbors.remove(nbr.getPrimaryAddr(), nbr);
- }
- nbr.setNeighbors(this);
- neighbors.put(nbr.getPrimaryAddr(), nbr);
- }
-
- /**
- * Remove the neighbor from our neighbor list.
- *
- * @param ipaddr the IP address of the neighbor to remove
- */
- public void removeNeighbor(IpAddress ipaddr) {
-
- boolean reelect = (designatedRouter == null || designatedRouter.getPrimaryAddr().equals(ipaddr));
- if (neighbors.containsKey(ipaddr)) {
- neighbors.remove(ipaddr);
- }
- this.electDR();
- }
-
- /**
- * Remove the given neighbor from the neighbor list.
- *
- * @param nbr the nbr to be removed.
- */
- public void removeNeighbor(PIMNeighbor nbr) {
-
- boolean reelect = (designatedRouter == null || nbr.isDr());
- neighbors.remove(nbr.getPrimaryAddr(), nbr);
- this.electDR();
- }
-
- /**
- * Elect a new DR on this ConnectPoint.
- *
- * @return the PIM Neighbor that wins
- */
- public PIMNeighbor electDR() {
-
- for (PIMNeighbor nbr : this.neighbors.values()) {
- if (this.designatedRouter == null) {
- this.designatedRouter = nbr;
- continue;
- }
-
- if (nbr.getPriority() > this.designatedRouter.getPriority()) {
- this.designatedRouter = nbr;
- continue;
- }
-
- // We could sort in ascending order
- if (this.designatedRouter.getPrimaryAddr().compareTo(nbr.getPrimaryAddr()) > 0) {
- this.designatedRouter = nbr;
- continue;
- }
- }
-
- return this.designatedRouter;
- }
-
- /**
- * Elect a new DR given the new neighbor.
- *
- * @param nbr the new neighbor to use in DR election.
- * @return the PIM Neighbor that wins DR election
- */
- public PIMNeighbor electDR(PIMNeighbor nbr) {
-
- // Make sure I have
- if (this.designatedRouter == null ||
- this.designatedRouter.getPriority() < nbr.getPriority() ||
- this.designatedRouter.getPrimaryAddr().compareTo(nbr.getPrimaryAddr()) > 0) {
- this.designatedRouter = nbr;
- }
- return this.designatedRouter;
- }
-
- /**
- * Find or create a pim neighbor with a given ip address and connect point.
- *
- * @param ipaddr of the pim neighbor
- * @param mac The mac address of our sending neighbor
- * @param cp the connect point the neighbor was learned from
- * @return an existing or new PIM neighbor
- */
- public static PIMNeighbor findOrCreate(IpAddress ipaddr, MacAddress mac, ConnectPoint cp) {
- PIMNeighbors neighbors = connectPointNeighbors.get(cp);
- if (neighbors == null) {
- neighbors = new PIMNeighbors(cp);
- connectPointNeighbors.put(cp, neighbors);
- }
-
- PIMNeighbor nbr = neighbors.findNeighbor(ipaddr);
- if (nbr == null) {
- nbr = new PIMNeighbor(ipaddr, mac, cp);
- neighbors.addNeighbor(nbr);
- neighbors.electDR(nbr);
- }
- return nbr;
- }
-
- // Returns the connect point neighbors hash map
- public static HashMap<ConnectPoint, PIMNeighbors> getConnectPointNeighbors() {
- return connectPointNeighbors;
- }
-
- /* ---------------------------------- PIM Hello Timer ----------------------------------- */
-
- /**
- * Start a new hello timer for this ConnectPoint.
- */
- private void startHelloTimer() {
- this.helloTimer = PIMTimer.getTimer().newTimeout(
- new HelloTimer(this),
- this.defaultPimHelloInterval,
- TimeUnit.SECONDS);
-
- log.trace("Started Hello Timer: " + this.ourIpAddress.toString());
- }
-
- /**
- * This inner class handles transmitting a PIM hello message on this ConnectPoint.
- */
- private final class HelloTimer implements TimerTask {
- PIMNeighbors neighbors;
-
- HelloTimer(PIMNeighbors neighbors) {
- this.neighbors = neighbors;
- }
-
- @Override
- public void run(Timeout timeout) throws Exception {
-
- // Send off a hello packet
- sendHelloPacket();
-
- // restart the hello timer
- neighbors.startHelloTimer();
- }
- }
-
- private void sendHelloPacket() {
- PIMHello hello = new PIMHello();
-
- // TODO: we will need to implement the network config service to assign ip addresses & options
- /*
- hello.createDefaultOptions();
-
- Ethernet eth = hello.createPIMHello(this.ourIpAddress);
- hello.sendPacket(this.connectPoint);
- */
- }
-
- /**
- * prints the connectPointNeighbors list with each neighbor list.
- *
- * @return string of neighbors.
- */
- public static String printPimNeighbors() {
- String out = "PIM Neighbors Table: \n";
-
- for (PIMNeighbors pn: connectPointNeighbors.values()) {
-
- out += "CP:\n " + pn.toString();
- for (PIMNeighbor nbr : pn.neighbors.values()) {
- out += "\t" + nbr.toString();
- }
- }
- return out;
- }
-
- @Override
- public String toString() {
- String out = "PIM Neighbors: ";
- if (this.ourIpAddress != null) {
- out += "IP: " + this.ourIpAddress.toString();
- } else {
- out += "IP: *Null*";
- }
- out += "\tPR: " + String.valueOf(this.ourPriority) + "\n";
- return out;
- }
-}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.pim.impl;
+
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.IPv4;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.PIM;
+import org.onlab.packet.VlanId;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.ConnectPoint;
+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.packet.DefaultOutboundPacket;
+import org.onosproject.net.packet.InboundPacket;
+import org.onosproject.net.packet.OutboundPacket;
+import org.onosproject.net.packet.PacketContext;
+import org.onosproject.net.packet.PacketPriority;
+import org.onosproject.net.packet.PacketProcessor;
+import org.onosproject.net.packet.PacketService;
+import org.slf4j.Logger;
+
+import java.nio.ByteBuffer;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Handing Incoming and outgoing PIM packets.
+ */
+public final class PIMPacketHandler {
+ private final Logger log = getLogger(getClass());
+
+ private static PIMPacketHandler instance = null;
+
+ private PacketService packetService;
+ private PIMPacketProcessor processor = new PIMPacketProcessor();
+ private MacAddress pimDestinationMac = MacAddress.valueOf("01:00:5E:00:00:0d");
+
+ // Utility class
+ private PIMPacketHandler() {}
+
+ public static PIMPacketHandler getInstance() {
+ if (null == instance) {
+ instance = new PIMPacketHandler();
+ }
+ return instance;
+ }
+
+ /**
+ * Initialize the packet handling service.
+ *
+ * @param ps the packetService
+ * @param appId our application ID
+ */
+ public void initialize(PacketService ps, ApplicationId appId) {
+ packetService = ps;
+
+ // Build a traffic selector for all multicast traffic
+ TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
+ selector.matchEthType(Ethernet.TYPE_IPV4);
+ selector.matchIPProtocol(IPv4.PROTOCOL_PIM);
+ packetService.requestPackets(selector.build(), PacketPriority.REACTIVE, appId);
+
+ packetService.addProcessor(processor, PacketProcessor.director(1));
+ }
+
+ /**
+ * Shutdown the packet handling service.
+ */
+ public void stop() {
+ packetService.removeProcessor(processor);
+ processor = null;
+ }
+
+ /**
+ * Packet processor responsible for handling IGMP packets.
+ */
+ public class PIMPacketProcessor implements PacketProcessor {
+ private final Logger log = getLogger(getClass());
+
+ @Override
+ public void process(PacketContext context) {
+ // Stop processing if the packet has been handled, since we
+ // can't do any more to it.
+ if (context.isHandled()) {
+ return;
+ }
+
+ InboundPacket pkt = context.inPacket();
+ if (pkt == null) {
+ return;
+ }
+
+ Ethernet ethPkt = pkt.parsed();
+ if (ethPkt == null) {
+ return;
+ }
+
+ /*
+ * IPv6 MLD packets are handled by ICMP6. We'll only deal
+ * with IPv4.
+ */
+ if (ethPkt.getEtherType() != Ethernet.TYPE_IPV4) {
+ return;
+ }
+
+ IPv4 ip = (IPv4) ethPkt.getPayload();
+ IpAddress gaddr = IpAddress.valueOf(ip.getDestinationAddress());
+ IpAddress saddr = Ip4Address.valueOf(ip.getSourceAddress());
+ log.debug("Packet (" + saddr.toString() + ", " + gaddr.toString() +
+ "\tingress port: " + context.inPacket().receivedFrom().toString());
+
+ if (ip.getProtocol() != IPv4.PROTOCOL_PIM) {
+ log.debug("PIM Picked up a non PIM packet: IP protocol: " + ip.getProtocol());
+ return;
+ }
+
+ // TODO: check incoming to be PIM.PIM_ADDRESS or "Our" address.
+ IpPrefix spfx = IpPrefix.valueOf(saddr, 32);
+ IpPrefix gpfx = IpPrefix.valueOf(gaddr, 32);
+
+ PIM pim = (PIM) ip.getPayload();
+ switch (pim.getPimMsgType()) {
+
+ case PIM.TYPE_HELLO:
+ processHello(ethPkt, context.inPacket().receivedFrom());
+ break;
+
+ case PIM.TYPE_JOIN_PRUNE_REQUEST:
+ // Create the function
+ break;
+
+ case PIM.TYPE_ASSERT:
+ case PIM.TYPE_BOOTSTRAP:
+ case PIM.TYPE_CANDIDATE_RP_ADV:
+ case PIM.TYPE_GRAFT:
+ case PIM.TYPE_GRAFT_ACK:
+ case PIM.TYPE_REGISTER:
+ case PIM.TYPE_REGISTER_STOP:
+ log.debug("Unsupported PIM message type: " + pim.getPimMsgType());
+ break;
+
+ default:
+ log.debug("Unkown PIM message type: " + pim.getPimMsgType());
+ break;
+ }
+ }
+
+ /**
+ * Process incoming hello message, we will need the Macaddress and IP address of the sender.
+ *
+ * @param ethPkt the ethernet header
+ * @param receivedFrom the connect point we recieved this message from
+ */
+ private void processHello(Ethernet ethPkt, ConnectPoint receivedFrom) {
+ checkNotNull(ethPkt);
+ checkNotNull(receivedFrom);
+
+ // It is a problem if we don't have the
+ PIMInterfaces pintfs = PIMInterfaces.getInstance();
+ PIMInterface intf = pintfs.getInterface(receivedFrom);
+ if (intf == null) {
+ log.error("We received a PIM message on an interface we were not supposed to");
+ return;
+ }
+ intf.processHello(ethPkt, receivedFrom);
+ }
+ }
+
+ // Create an ethernet header and serialize then send
+ public void sendPacket(PIM pim, PIMInterface pimIntf) {
+
+ Interface theInterface = pimIntf.getInterface();
+
+ // Create the ethernet packet
+ Ethernet eth = new Ethernet();
+ eth.setDestinationMACAddress(pimDestinationMac);
+ eth.setSourceMACAddress(theInterface.mac());
+ eth.setEtherType(Ethernet.TYPE_IPV4);
+ if (theInterface.vlan() != VlanId.NONE) {
+ eth.setVlanID(theInterface.vlan().toShort());
+ }
+
+ // Create the IP Packet
+ IPv4 ip = new IPv4();
+ ip.setVersion((byte) 4);
+ ip.setTtl((byte) 20);
+ ip.setProtocol(IPv4.PROTOCOL_PIM);
+ ip.setChecksum((short) 0);
+ ip.setSourceAddress(checkNotNull(pimIntf.getIpAddress()).getIp4Address().toInt());
+ ip.setDestinationAddress(PIM.PIM_ADDRESS.getIp4Address().toInt());
+ eth.setPayload(ip);
+ ip.setParent(eth);
+
+ // Now set pim
+ ip.setPayload(pim);
+ pim.setParent(ip);
+
+ ConnectPoint cp = theInterface.connectPoint();
+ checkNotNull(cp);
+
+ TrafficTreatment treat = DefaultTrafficTreatment.builder().setOutput(cp.port()).build();
+ ByteBuffer bb = ByteBuffer.wrap(eth.serialize());
+ OutboundPacket packet = new DefaultOutboundPacket(cp.deviceId(), treat, bb);
+ checkNotNull(packet);
+
+ packetService.emit(packet);
+ }
+}
import org.jboss.netty.util.HashedWheelTimer;
+import static com.google.common.base.Preconditions.checkNotNull;
+
/**
* PIM Timer used for PIM Neighbors.
*/
PIMTimer.timer = hwTimer;
}
}
+
+ public static void start() {
+ if (PIMTimer.timer == null) {
+ getTimer();
+ }
+ checkNotNull(timer);
+ timer.start();
+ }
+
+ public static void stop() {
+ if (PIMTimer.timer == null) {
+ // No need to stop
+ return;
+ }
+ checkNotNull(timer);
+ timer.stop();
+ }
}
@Override
public int hashCode() {
- return Objects.hash(pathSegments);
+ return pathSegments.hashCode();
}
@Override
private final Map<Key, Intent> intents;
//
- // State to deal with SDN-IP Leader election and pushing Intents
+ // State to deal with the Leader election and pushing Intents
//
- private final ExecutorService bgpIntentsSynchronizerExecutor;
+ private final ExecutorService intentsSynchronizerExecutor;
private volatile boolean isElectedLeader = false;
private volatile boolean isActivatedLeader = false;
* @param appId the Application ID
* @param intentService the intent service
*/
- IntentSynchronizer(ApplicationId appId, IntentService intentService) {
+ public IntentSynchronizer(ApplicationId appId, IntentService intentService) {
this(appId, intentService,
- newSingleThreadExecutor(groupedThreads("onos/sdnip", "sync")));
+ newSingleThreadExecutor(groupedThreads("onos/" + appId, "sync")));
}
/**
intents = new ConcurrentHashMap<>();
- bgpIntentsSynchronizerExecutor = executorService;
+ intentsSynchronizerExecutor = executorService;
}
/**
public void stop() {
synchronized (this) {
// Stop the thread(s)
- bgpIntentsSynchronizerExecutor.shutdownNow();
+ intentsSynchronizerExecutor.shutdownNow();
//
- // Withdraw all SDN-IP intents
+ // Withdraw all app related intents
//
if (!isElectedLeader) {
return; // Nothing to do: not the leader anymore
// Build a batch operation to withdraw all intents from this
// application.
//
- log.debug("SDN-IP Intent Synchronizer shutdown: " +
+ log.debug("Intent Synchronizer shutdown: " +
"withdrawing all intents...");
IntentOperations.Builder builder = IntentOperations.builder(appId);
for (Intent intent : intentService.getIntents()) {
continue;
}
- log.trace("SDN-IP Intent Synchronizer withdrawing intent: {}",
+ log.trace("Intent Synchronizer withdrawing intent: {}",
intent);
builder.addWithdrawOperation(intent.id());
}
peerIntents.clear();
routeIntents.clear();
- log.debug("SDN-IP Intent Synchronizer shutdown completed");
+ log.debug("Intent Synchronizer shutdown completed");
*/
}
}
synchronized (this) {
intents.put(intent.key(), intent);
if (isElectedLeader && isActivatedLeader) {
- log.trace("SDN-IP Submitting intent: {}", intent);
+ log.trace("Submitting intent: {}", intent);
intentService.submit(intent);
}
}
synchronized (this) {
intents.remove(intent.key(), intent);
if (isElectedLeader && isActivatedLeader) {
- log.trace("SDN-IP Withdrawing intent: {}", intent);
+ log.trace("Withdrawing intent: {}", intent);
intentService.withdraw(intent);
}
}
}
/**
- * Signals the synchronizer that the SDN-IP leadership has changed.
+ * Signals the synchronizer that the leadership has changed.
*
* @param isLeader true if this instance is now the leader, otherwise false
*/
public void leaderChanged(boolean isLeader) {
- log.debug("SDN-IP Leader changed: {}", isLeader);
+ log.debug("Leader changed: {}", isLeader);
if (!isLeader) {
this.isElectedLeader = false;
this.isElectedLeader = true;
// Run the synchronization method off-thread
- bgpIntentsSynchronizerExecutor.execute(this::synchronizeIntents);
+ intentsSynchronizerExecutor.execute(this::synchronizeIntents);
}
private void synchronizeIntents() {
}
}
- log.debug("SDN-IP Intent Synchronizer: submitting {}, withdrawing {}",
+ log.debug("Intent Synchronizer: submitting {}, withdrawing {}",
intentsToAdd.size(), intentsToRemove.size());
// Withdraw Intents
for (Intent intent : intentsToRemove) {
intentService.withdraw(intent);
- log.trace("SDN-IP Intent Synchronizer: withdrawing intent: {}",
+ log.trace("Intent Synchronizer: withdrawing intent: {}",
intent);
}
if (!isElectedLeader) {
- log.debug("SDN-IP Intent Synchronizer: cannot withdraw intents: " +
+ log.debug("Intent Synchronizer: cannot withdraw intents: " +
"not elected leader anymore");
isActivatedLeader = false;
return;
// Add Intents
for (Intent intent : intentsToAdd) {
intentService.submit(intent);
- log.trace("SDN-IP Intent Synchronizer: submitting intent: {}",
+ log.trace("Intent Synchronizer: submitting intent: {}",
intent);
}
if (!isElectedLeader) {
- log.debug("SDN-IP Intent Synchronizer: cannot submit intents: " +
+ log.debug("Intent Synchronizer: cannot submit intents: " +
"not elected leader anymore");
isActivatedLeader = false;
return;
} else {
isActivatedLeader = false;
}
- log.debug("SDN-IP intent synchronization completed");
+ log.debug("Intent synchronization completed");
}
}
package org.onosproject.segmentrouting;
import java.util.List;
-import java.util.Objects;
-
import static com.google.common.base.Preconditions.checkNotNull;
/**
@Override
public int hashCode() {
- return Objects.hash(labelIds);
+ return labelIds.hashCode();
}
@Override
private void processDeviceAdded(Device device) {
log.debug("A new device with ID {} was added", device.id());
+ if (deviceConfiguration == null) {
+ log.warn("Device configuration uploading. Device {} will be "
+ + "processed after config completes.", device.id());
+ return;
+ }
// Irrespective of whether the local is a MASTER or not for this device,
// we need to create a SR-group-handler instance. This is because in a
// multi-instance setup, any instance can initiate forwarding/next-objectives
// for any switch (even if this instance is a SLAVE or not even connected
// to the switch). To handle this, a default-group-handler instance is necessary
// per switch.
- DefaultGroupHandler groupHandler = DefaultGroupHandler.
- createGroupHandler(device.id(),
- appId,
- deviceConfiguration,
- linkService,
- flowObjectiveService,
- nsNextObjStore,
- subnetNextObjStore);
- groupHandlerMap.put(device.id(), groupHandler);
-
- // Also, in some cases, drivers may need extra
- // information to process rules (eg. Router IP/MAC); and so, we send
- // port addressing rules to the driver as well irrespective of whether
- // this instance is the master or not.
- defaultRoutingHandler.populatePortAddressingRules(device.id());
-
+ if (groupHandlerMap.get(device.id()) == null) {
+ DefaultGroupHandler groupHandler = DefaultGroupHandler.
+ createGroupHandler(device.id(),
+ appId,
+ deviceConfiguration,
+ linkService,
+ flowObjectiveService,
+ nsNextObjStore,
+ subnetNextObjStore);
+ groupHandlerMap.put(device.id(), groupHandler);
+ // Also, in some cases, drivers may need extra
+ // information to process rules (eg. Router IP/MAC); and so, we send
+ // port addressing rules to the driver as well irrespective of whether
+ // this instance is the master or not.
+ defaultRoutingHandler.populatePortAddressingRules(device.id());
+ }
if (mastershipService.isLocalMaster(device.id())) {
+ DefaultGroupHandler groupHandler = groupHandlerMap.get(device.id());
groupHandler.createGroupsFromSubnetConfig();
}
}
// for any switch (even if this instance is a SLAVE or not even connected
// to the switch). To handle this, a default-group-handler instance is necessary
// per switch.
- DefaultGroupHandler groupHandler = DefaultGroupHandler
- .createGroupHandler(device.id(), appId,
- deviceConfiguration, linkService,
- flowObjectiveService,
- nsNextObjStore,
- subnetNextObjStore);
- groupHandlerMap.put(device.id(), groupHandler);
-
- // Also, in some cases, drivers may need extra
- // information to process rules (eg. Router IP/MAC); and so, we send
- // port addressing rules to the driver as well, irrespective of whether
- // this instance is the master or not.
- defaultRoutingHandler.populatePortAddressingRules(device.id());
-
+ if (groupHandlerMap.get(device.id()) == null) {
+ DefaultGroupHandler groupHandler = DefaultGroupHandler
+ .createGroupHandler(device.id(), appId,
+ deviceConfiguration, linkService,
+ flowObjectiveService,
+ nsNextObjStore,
+ subnetNextObjStore);
+ groupHandlerMap.put(device.id(), groupHandler);
+
+ // Also, in some cases, drivers may need extra
+ // information to process rules (eg. Router IP/MAC); and so, we send
+ // port addressing rules to the driver as well, irrespective of whether
+ // this instance is the master or not.
+ defaultRoutingHandler.populatePortAddressingRules(device.id());
+ }
if (mastershipService.isLocalMaster(device.id())) {
+ DefaultGroupHandler groupHandler = groupHandlerMap.get(device.id());
groupHandler.createGroupsFromSubnetConfig();
}
}
@Override
public int hashCode() {
- return Objects.hash(bindingHostId);
+ return bindingHostId.hashCode();
}
@Override
*/
package org.onosproject.vtnrsc;
+import static com.google.common.base.Preconditions.checkNotNull;
+
import com.google.common.base.MoreObjects;
import java.util.UUID;
* @param flowClassifierId flow classifier id.
*/
private FlowClassifierId(final UUID flowClassifierId) {
+ checkNotNull(flowClassifierId, "Flow classifier id can not be null");
this.flowClassifierId = flowClassifierId;
}
* @param flowClassifierId flow classifier id
* @return new flow classifier id
*/
- public static FlowClassifierId flowClassifierId(final UUID flowClassifierId) {
+ public static FlowClassifierId of(final UUID flowClassifierId) {
return new FlowClassifierId(flowClassifierId);
}
* @param flowClassifierId flow classifier id
* @return new flow classifier id
*/
- public static FlowClassifierId flowClassifierId(final String flowClassifierId) {
+ public static FlowClassifierId of(final String flowClassifierId) {
return new FlowClassifierId(UUID.fromString(flowClassifierId));
}
@Override
public int hashCode() {
- return Objects.hash(physicalNetwork);
+ return physicalNetwork.hashCode();
}
@Override
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.UUID;
-
-import com.google.common.base.Objects;
+import java.util.Objects;
/**
* Representation of a Port Chain ID.
}
/**
- * Constructor to create port chain id from UUID.
+ * Returns newly created port chain id object.
*
* @param id UUID of port chain
* @return object of port chain id
*/
- public static PortChainId portChainId(UUID id) {
+ public static PortChainId of(UUID id) {
return new PortChainId(id);
}
/**
- * Constructor to create port chain id from string.
+ * Returns newly created port chain id object.
*
* @param id port chain id in string
* @return object of port chain id
*/
- public static PortChainId portChainId(String id) {
+ public static PortChainId of(String id) {
return new PortChainId(UUID.fromString(id));
}
if (this == obj) {
return true;
}
-
- if (obj.getClass() == this.getClass()) {
- PortChainId that = (PortChainId) obj;
- return Objects.equal(this.portChainId, that.portChainId);
+ if (obj instanceof PortChainId) {
+ final PortChainId other = (PortChainId) obj;
+ return Objects.equals(this.portChainId, other.portChainId);
}
return false;
}
@Override
public String toString() {
- return toStringHelper(this)
- .add("portChainId", portChainId.toString())
- .toString();
+ return toStringHelper(this).add("portChainId", portChainId).toString();
}
}
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.UUID;
-
-import com.google.common.base.Objects;
+import java.util.Objects;
/**
* Representation of a Port Pair Group ID.
}
/**
- * Constructor to create port pair group id from UUID.
+ * Returns newly created port pair group id object.
*
- * @param id UUID of port pair group id
+ * @param id port pair group id in UUID
* @return object of port pair group id
*/
- public static PortPairGroupId portPairGroupId(UUID id) {
+ public static PortPairGroupId of(UUID id) {
return new PortPairGroupId(id);
}
/**
- * Constructor to create port pair group id from string.
+ * Returns newly created port pair group id object.
*
* @param id port pair group id in string
* @return object of port pair group id
*/
- public static PortPairGroupId portPairGroupId(String id) {
+ public static PortPairGroupId of(String id) {
return new PortPairGroupId(UUID.fromString(id));
}
if (this == obj) {
return true;
}
-
- if (obj.getClass() == this.getClass()) {
- PortPairGroupId that = (PortPairGroupId) obj;
- return Objects.equal(this.portPairGroupId, that.portPairGroupId);
+ if (obj instanceof PortPairGroupId) {
+ final PortPairGroupId other = (PortPairGroupId) obj;
+ return Objects.equals(this.portPairGroupId, other.portPairGroupId);
}
return false;
}
@Override
public String toString() {
- return toStringHelper(this)
- .add("portPairGroupId", portPairGroupId.toString())
+ return toStringHelper(this).add("portPairGroupId", portPairGroupId)
.toString();
}
}
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.UUID;
-
-import com.google.common.base.Objects;
+import java.util.Objects;
/**
* Representation of a Port Pair ID.
}
/**
- * Constructor to create port pair id from UUID.
+ * Returns newly created port pair id object.
*
* @param id UUID of port pair id
* @return object of port pair id
*/
- public static PortPairId portPairId(UUID id) {
+ public static PortPairId of(UUID id) {
return new PortPairId(id);
}
/**
- * Constructor to create port pair id from string.
+ * Returns newly created port pair id object.
*
* @param id port pair id in string
* @return object of port pair id
*/
- public static PortPairId portPairId(String id) {
+ public static PortPairId of(String id) {
return new PortPairId(UUID.fromString(id));
}
if (this == obj) {
return true;
}
-
- if (obj.getClass() == this.getClass()) {
- PortPairId that = (PortPairId) obj;
- return Objects.equal(this.portPairId, that.portPairId);
+ if (obj instanceof PortPairId) {
+ final PortPairId other = (PortPairId) obj;
+ return Objects.equals(this.portPairId, other.portPairId);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this)
- .add("portPairId", portPairId.toString())
+ .add("portPairId", portPairId)
.toString();
}
}
@Override
public int hashCode() {
- return Objects.hash(securityGroup);
+ return securityGroup.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(segmentationId);
+ return segmentationId.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(subnetId);
+ return subnetId.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(tenantId);
+ return tenantId.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(networkId);
+ return networkId.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(portId);
+ return portId.hashCode();
}
@Override
*/
package org.onosproject.vtnrsc.flowClassifier.impl;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
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.util.KryoNamespace;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.MultiValuedTimestamp;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
import org.onosproject.vtnrsc.FlowClassifierId;
import org.onosproject.vtnrsc.FlowClassifier;
import org.onosproject.vtnrsc.flowClassifier.FlowClassifierService;
-
import org.slf4j.Logger;
-import static org.slf4j.LoggerFactory.getLogger;
+import static org.slf4j.LoggerFactory.getLogger;
import static com.google.common.base.Preconditions.checkNotNull;
+
import com.google.common.collect.ImmutableList;
/**
private static final String FLOW_CLASSIFIER_NOT_NULL = "Flow Classifier cannot be null";
private static final String FLOW_CLASSIFIER_ID_NOT_NULL = "Flow Classifier Id cannot be null";
- private ConcurrentMap<FlowClassifierId, FlowClassifier> flowClassifierStore
- = new ConcurrentHashMap<FlowClassifierId, FlowClassifier>();
+ private EventuallyConsistentMap<FlowClassifierId, FlowClassifier> flowClassifierStore;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected StorageService storageService;
@Activate
private void activate() {
+ KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
+ .register(KryoNamespaces.API)
+ .register(MultiValuedTimestamp.class)
+ .register(FlowClassifier.class);
+ flowClassifierStore = storageService
+ .<FlowClassifierId, FlowClassifier>eventuallyConsistentMapBuilder()
+ .withName("flowclassifierstore").withSerializer(serializer)
+ .withTimestampProvider((k, v) -> new WallClockTimestamp()).build();
log.info("Flow Classifier service activated");
}
@Deactivate
private void deactivate() {
+ flowClassifierStore.destroy();
log.info("Flow Classifier service deactivated");
}
public boolean updateFlowClassifier(FlowClassifier flowClassifier) {
checkNotNull(flowClassifier, FLOW_CLASSIFIER_NOT_NULL);
FlowClassifierId id = flowClassifier.flowClassifierId();
- return flowClassifierStore.replace(id, flowClassifierStore.get(id), flowClassifier);
+ flowClassifierStore.put(id, flowClassifier);
+ return true;
}
@Override
--- /dev/null
+/*
+ * 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.vtnrsc.portchain.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Collections;
+
+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.util.KryoNamespace;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.MultiValuedTimestamp;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vtnrsc.PortChain;
+import org.onosproject.vtnrsc.PortChainId;
+import org.onosproject.vtnrsc.portchain.PortChainService;
+import org.slf4j.Logger;
+
+/**
+ * Provides implementation of the portChainService.
+ */
+@Component(immediate = true)
+@Service
+public class PortChainManager implements PortChainService {
+
+ private final Logger log = getLogger(getClass());
+
+ private static final String PORT_CHAIN_ID_NULL = "PortChain ID cannot be null";
+ private static final String PORT_CHAIN_NULL = "PortChain cannot be null";
+
+ private EventuallyConsistentMap<PortChainId, PortChain> portChainStore;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected StorageService storageService;
+
+ @Activate
+ public void activate() {
+
+ KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
+ .register(KryoNamespaces.API)
+ .register(MultiValuedTimestamp.class)
+ .register(PortChain.class);
+
+ portChainStore = storageService
+ .<PortChainId, PortChain>eventuallyConsistentMapBuilder()
+ .withName("portchainstore").withSerializer(serializer)
+ .withTimestampProvider((k, v) -> new WallClockTimestamp()).build();
+
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ portChainStore.destroy();
+ log.info("Stopped");
+ }
+
+ @Override
+ public boolean exists(PortChainId portChainId) {
+ checkNotNull(portChainId, PORT_CHAIN_ID_NULL);
+ return portChainStore.containsKey(portChainId);
+ }
+
+ @Override
+ public int getPortChainCount() {
+ return portChainStore.size();
+ }
+
+ @Override
+ public Iterable<PortChain> getPortChains() {
+ return Collections.unmodifiableCollection(portChainStore.values());
+ }
+
+ @Override
+ public PortChain getPortChain(PortChainId portChainId) {
+ checkNotNull(portChainId, PORT_CHAIN_ID_NULL);
+ return portChainStore.get(portChainId);
+ }
+
+ @Override
+ public boolean createPortChain(PortChain portChain) {
+ checkNotNull(portChain, PORT_CHAIN_NULL);
+
+ portChainStore.put(portChain.portChainId(), portChain);
+ if (!portChainStore.containsKey(portChain.portChainId())) {
+ log.debug("The portChain is created failed which identifier was {}", portChain.portChainId()
+ .toString());
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean updatePortChain(PortChain portChain) {
+ checkNotNull(portChain, PORT_CHAIN_NULL);
+
+ if (!portChainStore.containsKey(portChain.portChainId())) {
+ log.debug("The portChain is not exist whose identifier was {} ",
+ portChain.portChainId().toString());
+ return false;
+ }
+
+ portChainStore.put(portChain.portChainId(), portChain);
+
+ if (!portChain.equals(portChainStore.get(portChain.portChainId()))) {
+ log.debug("The portChain is updated failed whose identifier was {} ",
+ portChain.portChainId().toString());
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removePortChain(PortChainId portChainId) {
+ checkNotNull(portChainId, PORT_CHAIN_NULL);
+
+ portChainStore.remove(portChainId);
+ if (portChainStore.containsKey(portChainId)) {
+ log.debug("The portChain is removed failed whose identifier was {}",
+ portChainId.toString());
+ return false;
+ }
+ return true;
+ }
+}
--- /dev/null
+/*
+ * 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.
+ */
+
+/**
+ * Implementation of service for interacting with the inventory of port chains.
+ */
+package org.onosproject.vtnrsc.portchain.impl;
--- /dev/null
+/*
+ * 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.vtnrsc.portpair;
+
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairId;
+
+/**
+ * Service for interacting with the inventory of port pairs.
+ */
+public interface PortPairService {
+
+ /**
+ * Returns if the port pair is existed.
+ *
+ * @param portPairId port pair identifier
+ * @return true or false if one with the given identifier exists.
+ */
+ boolean exists(PortPairId portPairId);
+
+ /**
+ * Returns the number of port pairs known to the system.
+ *
+ * @return number of port pairs.
+ */
+ int getPortPairCount();
+
+ /**
+ * Returns an iterable collection of the currently known port pairs.
+ *
+ * @return collection of port pairs.
+ */
+ Iterable<PortPair> getPortPairs();
+
+ /**
+ * Returns the portPair with the given identifier.
+ *
+ * @param portPairId port pair identifier
+ * @return PortPair or null if port pair with the given identifier is not
+ * known.
+ */
+ PortPair getPortPair(PortPairId portPairId);
+
+ /**
+ * Creates a PortPair in the store.
+ *
+ * @param portPair the port pair to create
+ * @return true if given port pair is created successfully.
+ */
+ boolean createPortPair(PortPair portPair);
+
+ /**
+ * Updates the portPair in the store.
+ *
+ * @param portPair the port pair to update
+ * @return true if given port pair is updated successfully.
+ */
+ boolean updatePortPair(PortPair portPair);
+
+ /**
+ * Deletes portPair by given portPairId.
+ *
+ * @param portPairId id of port pair to remove
+ * @return true if the give port pair is deleted successfully.
+ */
+ boolean removePortPair(PortPairId portPairId);
+}
--- /dev/null
+/*
+ * 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.vtnrsc.portpair.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Collections;
+
+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.util.KryoNamespace;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.MultiValuedTimestamp;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.portpair.PortPairService;
+import org.slf4j.Logger;
+
+/**
+ * Provides implementation of the portPairService.
+ */
+@Component(immediate = true)
+@Service
+public class PortPairManager implements PortPairService {
+
+ private final Logger log = getLogger(getClass());
+
+ private static final String PORT_PAIR_ID_NULL = "PortPair ID cannot be null";
+ private static final String PORT_PAIR_NULL = "PortPair cannot be null";
+
+ private EventuallyConsistentMap<PortPairId, PortPair> portPairStore;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected StorageService storageService;
+
+ @Activate
+ public void activate() {
+
+ KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
+ .register(KryoNamespaces.API)
+ .register(MultiValuedTimestamp.class)
+ .register(PortPair.class);
+
+ portPairStore = storageService
+ .<PortPairId, PortPair>eventuallyConsistentMapBuilder()
+ .withName("portpairstore").withSerializer(serializer)
+ .withTimestampProvider((k, v) -> new WallClockTimestamp()).build();
+
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ portPairStore.destroy();
+ log.info("Stopped");
+ }
+
+ @Override
+ public boolean exists(PortPairId portPairId) {
+ checkNotNull(portPairId, PORT_PAIR_ID_NULL);
+ return portPairStore.containsKey(portPairId);
+ }
+
+ @Override
+ public int getPortPairCount() {
+ return portPairStore.size();
+ }
+
+ @Override
+ public Iterable<PortPair> getPortPairs() {
+ return Collections.unmodifiableCollection(portPairStore.values());
+ }
+
+ @Override
+ public PortPair getPortPair(PortPairId portPairId) {
+ checkNotNull(portPairId, PORT_PAIR_ID_NULL);
+ return portPairStore.get(portPairId);
+ }
+
+ @Override
+ public boolean createPortPair(PortPair portPair) {
+ checkNotNull(portPair, PORT_PAIR_NULL);
+
+ portPairStore.put(portPair.portPairId(), portPair);
+ if (!portPairStore.containsKey(portPair.portPairId())) {
+ log.debug("The portPair is created failed which identifier was {}", portPair.portPairId()
+ .toString());
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean updatePortPair(PortPair portPair) {
+ checkNotNull(portPair, PORT_PAIR_NULL);
+
+ if (!portPairStore.containsKey(portPair.portPairId())) {
+ log.debug("The portPair is not exist whose identifier was {} ",
+ portPair.portPairId().toString());
+ return false;
+ }
+
+ portPairStore.put(portPair.portPairId(), portPair);
+
+ if (!portPair.equals(portPairStore.get(portPair.portPairId()))) {
+ log.debug("The portPair is updated failed whose identifier was {} ",
+ portPair.portPairId().toString());
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removePortPair(PortPairId portPairId) {
+ checkNotNull(portPairId, PORT_PAIR_NULL);
+
+ portPairStore.remove(portPairId);
+ if (portPairStore.containsKey(portPairId)) {
+ log.debug("The portPair is removed failed whose identifier was {}",
+ portPairId.toString());
+ return false;
+ }
+ return true;
+ }
+}
--- /dev/null
+/*
+ * 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.
+ */
+
+/**
+ * Implementation of service for interacting with the inventory of port pairs.
+ */
+package org.onosproject.vtnrsc.portpair.impl;
*/
/**
- * Codecs for virtual tenant objects.
+ * Service for interacting with the inventory of port pairs.
*/
-package org.onosproject.vtnrsc.web;
+package org.onosproject.vtnrsc.portpair;
--- /dev/null
+/*
+ * 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.vtnrsc.portpairgroup.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Collections;
+
+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.util.KryoNamespace;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.MultiValuedTimestamp;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vtnrsc.PortPairGroup;
+import org.onosproject.vtnrsc.PortPairGroupId;
+import org.onosproject.vtnrsc.portpairgroup.PortPairGroupService;
+import org.slf4j.Logger;
+
+/**
+ * Provides implementation of the portPairGroupService.
+ */
+@Component(immediate = true)
+@Service
+public class PortPairGroupManager implements PortPairGroupService {
+
+ private final Logger log = getLogger(getClass());
+
+ private static final String PORT_PAIR_GROUP_ID_NULL = "PortPairGroup ID cannot be null";
+ private static final String PORT_PAIR_GROUP_NULL = "PortPairGroup cannot be null";
+
+ private EventuallyConsistentMap<PortPairGroupId, PortPairGroup> portPairGroupStore;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected StorageService storageService;
+
+ @Activate
+ public void activate() {
+
+ KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
+ .register(KryoNamespaces.API)
+ .register(MultiValuedTimestamp.class)
+ .register(PortPairGroup.class);
+
+ portPairGroupStore = storageService
+ .<PortPairGroupId, PortPairGroup>eventuallyConsistentMapBuilder()
+ .withName("portpairgroupstore").withSerializer(serializer)
+ .withTimestampProvider((k, v) -> new WallClockTimestamp()).build();
+
+ log.info("Started");
+ }
+
+ @Deactivate
+ public void deactivate() {
+ portPairGroupStore.destroy();
+ log.info("Stopped");
+ }
+
+ @Override
+ public boolean exists(PortPairGroupId portPairGroupId) {
+ checkNotNull(portPairGroupId, PORT_PAIR_GROUP_ID_NULL);
+ return portPairGroupStore.containsKey(portPairGroupId);
+ }
+
+ @Override
+ public int getPortPairGroupCount() {
+ return portPairGroupStore.size();
+ }
+
+ @Override
+ public Iterable<PortPairGroup> getPortPairGroups() {
+ return Collections.unmodifiableCollection(portPairGroupStore.values());
+ }
+
+ @Override
+ public PortPairGroup getPortPairGroup(PortPairGroupId portPairGroupId) {
+ checkNotNull(portPairGroupId, PORT_PAIR_GROUP_ID_NULL);
+ return portPairGroupStore.get(portPairGroupId);
+ }
+
+ @Override
+ public boolean createPortPairGroup(PortPairGroup portPairGroup) {
+ checkNotNull(portPairGroup, PORT_PAIR_GROUP_NULL);
+
+ portPairGroupStore.put(portPairGroup.portPairGroupId(), portPairGroup);
+ if (!portPairGroupStore.containsKey(portPairGroup.portPairGroupId())) {
+ log.debug("The portPairGroup is created failed which identifier was {}", portPairGroup.portPairGroupId()
+ .toString());
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean updatePortPairGroup(PortPairGroup portPairGroup) {
+ checkNotNull(portPairGroup, PORT_PAIR_GROUP_NULL);
+
+ if (!portPairGroupStore.containsKey(portPairGroup.portPairGroupId())) {
+ log.debug("The portPairGroup is not exist whose identifier was {} ",
+ portPairGroup.portPairGroupId().toString());
+ return false;
+ }
+
+ portPairGroupStore.put(portPairGroup.portPairGroupId(), portPairGroup);
+
+ if (!portPairGroup.equals(portPairGroupStore.get(portPairGroup.portPairGroupId()))) {
+ log.debug("The portPairGroup is updated failed whose identifier was {} ",
+ portPairGroup.portPairGroupId().toString());
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public boolean removePortPairGroup(PortPairGroupId portPairGroupId) {
+ checkNotNull(portPairGroupId, PORT_PAIR_GROUP_NULL);
+
+ portPairGroupStore.remove(portPairGroupId);
+ if (portPairGroupStore.containsKey(portPairGroupId)) {
+ log.debug("The portPairGroup is removed failed whose identifier was {}",
+ portPairGroupId.toString());
+ return false;
+ }
+ return true;
+ }
+}
--- /dev/null
+/*
+ * 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.
+ */
+
+/**
+ * Implementation of service for interacting with the inventory of port pair groups.
+ */
+package org.onosproject.vtnrsc.portpairgroup.impl;
public class FlowClassifierIdTest {
final FlowClassifierId flowClassifierId1 = FlowClassifierId
- .flowClassifierId("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ .of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
final FlowClassifierId sameAsFlowClassifierId1 = FlowClassifierId
- .flowClassifierId("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ .of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
final FlowClassifierId flowClassifierId2 = FlowClassifierId
- .flowClassifierId("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+ .of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
/**
* Checks that the FlowClassifierId class is immutable.
@Test
public void testConstruction() {
final String flowClassifierIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
- final FlowClassifierId flowClassifierId = FlowClassifierId.flowClassifierId(flowClassifierIdValue);
+ final FlowClassifierId flowClassifierId = FlowClassifierId.of(flowClassifierIdValue);
assertThat(flowClassifierId, is(notNullValue()));
assertThat(flowClassifierId.value(), is(UUID.fromString(flowClassifierIdValue)));
}
--- /dev/null
+/*
+ * 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.vtnrsc.portpair;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import org.junit.Test;
+import org.onosproject.vtnrsc.PortChainId;
+
+import com.google.common.testing.EqualsTester;
+import java.util.UUID;
+
+/**
+ * Unit tests for PortChainId class.
+ */
+public class PortChainIdTest {
+
+ final PortChainId portChainId1 = PortChainId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ final PortChainId sameAsPortChainId1 = PortChainId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ final PortChainId portChainId2 = PortChainId.of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+ /**
+ * Checks that the PortChainId class is immutable.
+ */
+ @Test
+ public void testImmutability() {
+ assertThatClassIsImmutable(PortChainId.class);
+ }
+
+ /**
+ * Checks the operation of equals() methods.
+ */
+ @Test
+ public void testEquals() {
+ new EqualsTester().addEqualityGroup(portChainId1, sameAsPortChainId1).addEqualityGroup(portChainId2)
+ .testEquals();
+ }
+
+ /**
+ * Checks the construction of a PortChainId object.
+ */
+ @Test
+ public void testConstruction() {
+ final String portChainIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+ final PortChainId portChainId = PortChainId.of(portChainIdValue);
+ assertThat(portChainId, is(notNullValue()));
+ assertThat(portChainId.value(), is(UUID.fromString(portChainIdValue)));
+ }
+}
--- /dev/null
+/*
+ * 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.vtnrsc.portpair;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import org.junit.Test;
+import org.onosproject.vtnrsc.PortPairId;
+
+import com.google.common.testing.EqualsTester;
+import java.util.UUID;
+
+/**
+ * Unit tests for PortPairId class.
+ */
+public class PortPairIdTest {
+
+ final PortPairId portPairId1 = PortPairId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ final PortPairId sameAsPortPairId1 = PortPairId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ final PortPairId portPairId2 = PortPairId.of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+ /**
+ * Checks that the PortPairId class is immutable.
+ */
+ @Test
+ public void testImmutability() {
+ assertThatClassIsImmutable(PortPairId.class);
+ }
+
+ /**
+ * Checks the operation of equals() methods.
+ */
+ @Test
+ public void testEquals() {
+ new EqualsTester().addEqualityGroup(portPairId1, sameAsPortPairId1).addEqualityGroup(portPairId2).testEquals();
+ }
+
+ /**
+ * Checks the construction of a PortPairId object.
+ */
+ @Test
+ public void testConstruction() {
+ final String portPairIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+ final PortPairId portPairId = PortPairId.of(portPairIdValue);
+ assertThat(portPairId, is(notNullValue()));
+ assertThat(portPairId.value(), is(UUID.fromString(portPairIdValue)));
+ }
+}
--- /dev/null
+/*
+ * 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.vtnrsc.portpair;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import org.junit.Test;
+import org.onosproject.vtnrsc.PortPairGroupId;
+
+import com.google.common.testing.EqualsTester;
+import java.util.UUID;
+
+/**
+ * Unit tests for PortPairGroupId class.
+ */
+public class PortPairGroupIdTest {
+
+ final PortPairGroupId portPairGroupId1 = PortPairGroupId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ final PortPairGroupId sameAsPortPairGroupId1 = PortPairGroupId
+ .of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ final PortPairGroupId portPairGroupId2 = PortPairGroupId.of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+ /**
+ * Checks that the PortPairGroupId class is immutable.
+ */
+ @Test
+ public void testImmutability() {
+ assertThatClassIsImmutable(PortPairGroupId.class);
+ }
+
+ /**
+ * Checks the operation of equals() methods.
+ */
+ @Test
+ public void testEquals() {
+ new EqualsTester().addEqualityGroup(portPairGroupId1, sameAsPortPairGroupId1)
+ .addEqualityGroup(portPairGroupId2).testEquals();
+ }
+
+ /**
+ * Checks the construction of a PortPairGroupId object.
+ */
+ @Test
+ public void testConstruction() {
+ final String portPairGroupIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+ final PortPairGroupId portPairGroupId = PortPairGroupId.of(portPairGroupIdValue);
+ assertThat(portPairGroupId, is(notNullValue()));
+ assertThat(portPairGroupId.value(), is(UUID.fromString(portPairGroupIdValue)));
+ }
+}
import org.onosproject.vtnrsc.FlowClassifierId;
import org.onosproject.rest.AbstractWebResource;
import org.onosproject.vtnrsc.flowClassifier.FlowClassifierService;
-import org.onosproject.vtnrsc.web.FlowClassifierCodec;
+import org.onosproject.vtnweb.web.FlowClassifierCodec;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
@Produces(MediaType.APPLICATION_JSON)
public Response getFlowClassifier(@PathParam("flow_id") String id) {
- if (!service.hasFlowClassifier(FlowClassifierId.flowClassifierId(UUID.fromString(id)))) {
+ if (!service.hasFlowClassifier(FlowClassifierId.of(UUID.fromString(id)))) {
return Response.status(NOT_FOUND).entity(FLOW_CLASSIFIER_NOT_FOUND).build();
}
FlowClassifier flowClassifier = nullIsNotFound(
- service.getFlowClassifier(FlowClassifierId.flowClassifierId(UUID.fromString(id))),
+ service.getFlowClassifier(FlowClassifierId.of(UUID.fromString(id))),
FLOW_CLASSIFIER_NOT_FOUND);
ObjectNode result = new ObjectMapper().createObjectNode();
@DELETE
public Response deleteFlowClassifier(@PathParam("flow_id") String id) throws IOException {
try {
- FlowClassifierId flowClassifierId = FlowClassifierId.flowClassifierId(UUID.fromString(id));
+ FlowClassifierId flowClassifierId = FlowClassifierId.of(UUID.fromString(id));
service.removeFlowClassifier(flowClassifierId);
return Response.status(201).entity("SUCCESS").build();
} catch (Exception e) {
--- /dev/null
+/*
+ * 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.vtnweb.resources;
+
+import static javax.ws.rs.core.Response.Status.NOT_FOUND;
+import static javax.ws.rs.core.Response.Status.OK;
+import static org.onlab.util.Tools.nullIsNotFound;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+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;
+
+import org.onosproject.rest.AbstractWebResource;
+import org.onosproject.vtnrsc.PortChain;
+import org.onosproject.vtnrsc.PortChainId;
+import org.onosproject.vtnrsc.portchain.PortChainService;
+import org.onosproject.vtnweb.web.PortChainCodec;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Query and program port chain.
+ */
+
+@Path("port_chains")
+public class PortChainWebResource extends AbstractWebResource {
+
+ private final Logger log = LoggerFactory.getLogger(PortChainWebResource.class);
+ private final PortChainService service = get(PortChainService.class);
+ public static final String PORT_CHAIN_NOT_FOUND = "Port chain not found";
+ public static final String PORT_CHAIN_ID_EXIST = "Port chain exists";
+ public static final String PORT_CHAIN_ID_NOT_EXIST = "Port chain does not exist with identifier";
+
+ /**
+ * Get details of all port chains created.
+ *
+ * @return 200 OK
+ */
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getPortChains() {
+ Iterable<PortChain> portChains = service.getPortChains();
+ ObjectNode result = new ObjectMapper().createObjectNode();
+ result.set("port_chains", new PortChainCodec().encode(portChains, this));
+ return ok(result).build();
+ }
+
+ /**
+ * Get details of a specified port chain id.
+ *
+ * @param id port chain id
+ * @return 200 OK, 404 if given identifier does not exist
+ */
+ @GET
+ @Path("{chain_id}")
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getPortPain(@PathParam("chain_id") String id) {
+
+ if (!service.exists(PortChainId.of(id))) {
+ return Response.status(NOT_FOUND).entity(PORT_CHAIN_NOT_FOUND).build();
+ }
+ PortChain portChain = nullIsNotFound(service.getPortChain(PortChainId.of(id)),
+ PORT_CHAIN_NOT_FOUND);
+ ObjectNode result = new ObjectMapper().createObjectNode();
+ result.set("port_chain", new PortChainCodec().encode(portChain, this));
+ return ok(result).build();
+ }
+
+ /**
+ * Creates a new port chain.
+ *
+ * @param stream port chain from JSON
+ * @return status of the request - CREATED if the JSON is correct,
+ * BAD_REQUEST if the JSON is invalid
+ */
+ @POST
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response createPortChain(InputStream stream) {
+ try {
+ ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
+ PortChain portChain = codec(PortChain.class).decode(jsonTree, this);
+ Boolean issuccess = nullIsNotFound(service.createPortChain(portChain), PORT_CHAIN_NOT_FOUND);
+ return Response.status(OK).entity(issuccess.toString()).build();
+ } catch (IOException e) {
+ log.error("Exception while creating port chain {}.", e.toString());
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Update details of a specified port chain id.
+ *
+ * @param id port chain id
+ * @param stream port chain json
+ * @return 200 OK, 404 if given identifier does not exist
+ */
+ @PUT
+ @Path("{chain_id}")
+ @Produces(MediaType.APPLICATION_JSON)
+ @Consumes(MediaType.APPLICATION_JSON)
+ public Response updatePortPain(@PathParam("chain_id") String id,
+ final InputStream stream) {
+ try {
+ ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
+ PortChain portChain = codec(PortChain.class).decode(jsonTree, this);
+ Boolean result = nullIsNotFound(service.updatePortChain(portChain), PORT_CHAIN_NOT_FOUND);
+ return Response.status(OK).entity(result.toString()).build();
+ } catch (IOException e) {
+ log.error("Update port chain failed because of exception {}.", e.toString());
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Delete details of a specified port chain id.
+ *
+ * @param id port chain id
+ */
+ @Path("{chain_id}")
+ @DELETE
+ public void deletePortPain(@PathParam("chain_id") String id) {
+ log.debug("Deletes port chain by identifier {}.", id);
+ PortChainId portChainId = PortChainId.of(id);
+
+ Boolean issuccess = nullIsNotFound(service.removePortChain(portChainId), PORT_CHAIN_NOT_FOUND);
+ if (!issuccess) {
+ log.debug("Port Chain identifier {} does not exist", id);
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.vtnweb.resources;
+
+import static javax.ws.rs.core.Response.Status.NOT_FOUND;
+import static javax.ws.rs.core.Response.Status.OK;
+import static org.onlab.util.Tools.nullIsNotFound;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+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;
+
+import org.onosproject.rest.AbstractWebResource;
+import org.onosproject.vtnrsc.PortPairGroup;
+import org.onosproject.vtnrsc.PortPairGroupId;
+import org.onosproject.vtnrsc.portpairgroup.PortPairGroupService;
+import org.onosproject.vtnweb.web.PortPairGroupCodec;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Query and program port pair group.
+ */
+
+@Path("port_pair_groups")
+public class PortPairGroupWebResource extends AbstractWebResource {
+
+ private final Logger log = LoggerFactory.getLogger(PortPairGroupWebResource.class);
+ private final PortPairGroupService service = get(PortPairGroupService.class);
+ public static final String PORT_PAIR_GROUP_NOT_FOUND = "Port pair group not found";
+ public static final String PORT_PAIR_GROUP_ID_EXIST = "Port pair group exists";
+ public static final String PORT_PAIR_GROUP_ID_NOT_EXIST = "Port pair group does not exist with identifier";
+
+ /**
+ * Get details of all port pair groups created.
+ *
+ * @return 200 OK
+ */
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getPortPairGroups() {
+ Iterable<PortPairGroup> portPairGroups = service.getPortPairGroups();
+ ObjectNode result = new ObjectMapper().createObjectNode();
+ result.set("port_pair_groups", new PortPairGroupCodec().encode(portPairGroups, this));
+ return ok(result).build();
+ }
+
+ /**
+ * Get details of a specified port pair group id.
+ *
+ * @param id port pair group id
+ * @return 200 OK, 404 if given identifier does not exist
+ */
+ @GET
+ @Path("{group_id}")
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getPortPairGroup(@PathParam("group_id") String id) {
+
+ if (!service.exists(PortPairGroupId.of(id))) {
+ return Response.status(NOT_FOUND)
+ .entity(PORT_PAIR_GROUP_NOT_FOUND).build();
+ }
+ PortPairGroup portPairGroup = nullIsNotFound(service.getPortPairGroup(PortPairGroupId.of(id)),
+ PORT_PAIR_GROUP_NOT_FOUND);
+
+ ObjectNode result = new ObjectMapper().createObjectNode();
+ result.set("port_pair_group", new PortPairGroupCodec().encode(portPairGroup, this));
+ return ok(result).build();
+ }
+
+ /**
+ * Creates a new port pair group.
+ *
+ * @param stream port pair group from JSON
+ * @return status of the request - CREATED if the JSON is correct,
+ * BAD_REQUEST if the JSON is invalid
+ */
+ @POST
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response createPortPairGroup(InputStream stream) {
+
+ try {
+ ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
+
+ PortPairGroup portPairGroup = codec(PortPairGroup.class).decode(jsonTree, this);
+ Boolean issuccess = nullIsNotFound(service.createPortPairGroup(portPairGroup),
+ PORT_PAIR_GROUP_NOT_FOUND);
+ return Response.status(OK).entity(issuccess.toString()).build();
+ } catch (IOException e) {
+ log.error("Exception while creating port pair group {}.", e.toString());
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Update details of a specified port pair group id.
+ *
+ * @param id port pair group id
+ * @param stream port pair group from json
+ * @return 200 OK, 404 if given identifier does not exist
+ */
+ @PUT
+ @Path("{group_id}")
+ @Produces(MediaType.APPLICATION_JSON)
+ @Consumes(MediaType.APPLICATION_JSON)
+ public Response updatePortPairGroup(@PathParam("group_id") String id,
+ final InputStream stream) {
+ try {
+ ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
+ PortPairGroup portPairGroup = codec(PortPairGroup.class).decode(jsonTree, this);
+ Boolean isSuccess = nullIsNotFound(service.updatePortPairGroup(portPairGroup), PORT_PAIR_GROUP_NOT_FOUND);
+ return Response.status(OK).entity(isSuccess.toString()).build();
+ } catch (IOException e) {
+ log.error("Update port pair group failed because of exception {}.", e.toString());
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Delete details of a specified port pair group id.
+ *
+ * @param id port pair group id
+ */
+ @Path("{group_id}")
+ @DELETE
+ public void deletePortPairGroup(@PathParam("group_id") String id) {
+ log.debug("Deletes port pair group by identifier {}.", id);
+ PortPairGroupId portPairGroupId = PortPairGroupId.of(id);
+ Boolean issuccess = nullIsNotFound(service.removePortPairGroup(portPairGroupId),
+ PORT_PAIR_GROUP_NOT_FOUND);
+ if (!issuccess) {
+ log.debug("Port pair group identifier {} does not exist", id);
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.vtnweb.resources;
+
+import static javax.ws.rs.core.Response.Status.NOT_FOUND;
+import static javax.ws.rs.core.Response.Status.OK;
+import static org.onlab.util.Tools.nullIsNotFound;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+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;
+
+import org.onosproject.rest.AbstractWebResource;
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.portpair.PortPairService;
+import org.onosproject.vtnweb.web.PortPairCodec;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Query and program port pair.
+ */
+@Path("port_pairs")
+public class PortPairWebResource extends AbstractWebResource {
+
+ private final Logger log = LoggerFactory.getLogger(PortPairWebResource.class);
+ private final PortPairService service = get(PortPairService.class);
+ public static final String PORT_PAIR_NOT_FOUND = "Port pair not found";
+ public static final String PORT_PAIR_ID_EXIST = "Port pair exists";
+ public static final String PORT_PAIR_ID_NOT_EXIST = "Port pair does not exist with identifier";
+
+ /**
+ * Get details of all port pairs created.
+ *
+ * @return 200 OK
+ */
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getPortPairs() {
+ Iterable<PortPair> portPairs = service.getPortPairs();
+ ObjectNode result = new ObjectMapper().createObjectNode();
+ result.set("port_pairs", new PortPairCodec().encode(portPairs, this));
+ return ok(result).build();
+ }
+
+ /**
+ * Get details of a specified port pair id.
+ *
+ * @param id port pair id
+ * @return 200 OK, 404 if given identifier does not exist
+ */
+ @GET
+ @Path("{pair_id}")
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response getPortPair(@PathParam("portPairId") String id) {
+
+ if (!service.exists(PortPairId.of(id))) {
+ return Response.status(NOT_FOUND)
+ .entity(PORT_PAIR_NOT_FOUND).build();
+ }
+ PortPair portPair = nullIsNotFound(service.getPortPair(PortPairId.of(id)),
+ PORT_PAIR_NOT_FOUND);
+
+ ObjectNode result = new ObjectMapper().createObjectNode();
+ result.set("port_pair", new PortPairCodec().encode(portPair, this));
+ return ok(result).build();
+ }
+
+ /**
+ * Creates a new port pair.
+ *
+ * @param stream port pair from JSON
+ * @return status of the request - CREATED if the JSON is correct,
+ * BAD_REQUEST if the JSON is invalid
+ */
+ @POST
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response createPortPair(InputStream stream) {
+ try {
+ ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
+
+ PortPair portPair = codec(PortPair.class).decode(jsonTree, this);
+ Boolean isSuccess = nullIsNotFound(service.createPortPair(portPair),
+ PORT_PAIR_NOT_FOUND);
+ return Response.status(OK).entity(isSuccess.toString()).build();
+ } catch (IOException e) {
+ log.error("Exception while creating port pair {}.", e.toString());
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Update details of a specified port pair id.
+ *
+ * @param id port pair id
+ * @param stream port pair from json
+ * @return 200 OK, 404 if the given identifier does not exist
+ */
+ @PUT
+ @Path("{pair_id}")
+ @Produces(MediaType.APPLICATION_JSON)
+ @Consumes(MediaType.APPLICATION_JSON)
+ public Response updatePortPair(@PathParam("pair_id") String id,
+ final InputStream stream) {
+ try {
+ ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
+ PortPair portPair = codec(PortPair.class).decode(jsonTree, this);
+ Boolean isSuccess = nullIsNotFound(service.updatePortPair(portPair), PORT_PAIR_NOT_FOUND);
+ return Response.status(OK).entity(isSuccess.toString()).build();
+ } catch (IOException e) {
+ log.error("Update port pair failed because of exception {}.", e.toString());
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Delete details of a specified port pair id.
+ *
+ * @param id port pair id
+ */
+ @Path("{pair_id}")
+ @DELETE
+ public void deletePortPair(@PathParam("pair_id") String id) {
+
+ PortPairId portPairId = PortPairId.of(id);
+ Boolean isSuccess = nullIsNotFound(service.removePortPair(portPairId),
+ PORT_PAIR_NOT_FOUND);
+ if (!isSuccess) {
+ log.debug("Port pair identifier {} does not exist", id);
+ }
+ }
+}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.vtnrsc.web;
+package org.onosproject.vtnweb.web;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.onlab.util.Tools.nullIsIllegal;
String flowClassifierId = nullIsIllegal(json.get(FLOW_CLASSIFIER_ID),
FLOW_CLASSIFIER_ID + MISSING_MEMBER_MESSAGE).asText();
- resultBuilder.setFlowClassifierId(FlowClassifierId.flowClassifierId(UUID.fromString(flowClassifierId)));
+ resultBuilder.setFlowClassifierId(FlowClassifierId.of(UUID.fromString(flowClassifierId)));
String tenantId = nullIsIllegal(json.get(TENANT_ID), TENANT_ID + MISSING_MEMBER_MESSAGE).asText();
resultBuilder.setTenantId(TenantId.tenantId(tenantId));
.put("DST_PORT", flowClassifier.dstPort().toString());
return result;
}
-}
\ No newline at end of file
+}
String id = nullIsIllegal(json.get(ID),
ID + MISSING_MEMBER_MESSAGE).asText();
- resultBuilder.setId(PortChainId.portChainId(id));
+ resultBuilder.setId(PortChainId.of(id));
String tenantId = nullIsIllegal(json.get(TENANT_ID),
TENANT_ID + MISSING_MEMBER_MESSAGE).asText();
ArrayNode arrayNode = (ArrayNode) json.path(PORT_PAIR_GROUPS);
if (arrayNode != null) {
List<PortPairGroupId> list = Lists.newArrayList();
- arrayNode.forEach(i -> list.add(PortPairGroupId.portPairGroupId(i.asText())));
+ arrayNode.forEach(i -> list.add(PortPairGroupId.of(i.asText())));
resultBuilder.setPortPairGroups(list);
}
arrayNode = (ArrayNode) json.path(FLOW_CLASSIFIERS);
if (arrayNode != null) {
List<FlowClassifierId> list = Lists.newArrayList();
- arrayNode.forEach(i -> list.add(FlowClassifierId.flowClassifierId(UUID.fromString(i.asText()))));
+ arrayNode.forEach(i -> list.add(FlowClassifierId.of(UUID.fromString(i.asText()))));
resultBuilder.setFlowClassifiers(list);
}
--- /dev/null
+/*
+ * 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.vtnweb.web;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onlab.util.Tools.nullIsIllegal;
+
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.core.CoreService;
+import org.onosproject.vtnrsc.DefaultPortPair;
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.TenantId;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Port Pair JSON codec.
+ */
+public final class PortPairCodec extends JsonCodec<PortPair> {
+
+ private static final String ID = "id";
+ private static final String TENANT_ID = "tenant_id";
+ private static final String NAME = "name";
+ private static final String DESCRIPTION = "description";
+ private static final String INGRESS = "ingress";
+ private static final String EGRESS = "egress";
+ private static final String MISSING_MEMBER_MESSAGE =
+ " member is required in PortPair";
+
+ @Override
+ public PortPair decode(ObjectNode json, CodecContext context) {
+ if (json == null || !json.isObject()) {
+ return null;
+ }
+
+ PortPair.Builder resultBuilder = new DefaultPortPair.Builder();
+
+ CoreService coreService = context.getService(CoreService.class);
+
+ String id = nullIsIllegal(json.get(ID),
+ ID + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setId(PortPairId.of(id));
+
+ String tenantId = nullIsIllegal(json.get(TENANT_ID),
+ TENANT_ID + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setTenantId(TenantId.tenantId(tenantId));
+
+ String name = nullIsIllegal(json.get(NAME),
+ NAME + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setName(name);
+
+ String description = nullIsIllegal(json.get(DESCRIPTION),
+ DESCRIPTION + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setDescription(description);
+
+ String ingressPort = nullIsIllegal(json.get(INGRESS),
+ INGRESS + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setIngress(ingressPort);
+
+ String egressPort = nullIsIllegal(json.get(EGRESS),
+ EGRESS + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setEgress(egressPort);
+
+ return resultBuilder.build();
+ }
+
+ @Override
+ public ObjectNode encode(PortPair portPair, CodecContext context) {
+ checkNotNull(portPair, "port pair cannot be null");
+ ObjectNode result = context.mapper().createObjectNode()
+ .put(ID, portPair.portPairId().toString())
+ .put(TENANT_ID, portPair.tenantId().toString())
+ .put(NAME, portPair.name())
+ .put(DESCRIPTION, portPair.description())
+ .put(INGRESS, portPair.ingress())
+ .put(EGRESS, portPair.egress());
+ return result;
+ }
+}
--- /dev/null
+/*
+ * 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.vtnweb.web;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onlab.util.Tools.nullIsIllegal;
+
+import java.util.List;
+
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.core.CoreService;
+import org.onosproject.vtnrsc.DefaultPortPairGroup;
+import org.onosproject.vtnrsc.PortPairGroup;
+import org.onosproject.vtnrsc.PortPairGroupId;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.TenantId;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.Lists;
+
+/**
+ * Port Pair Group JSON codec.
+ */
+public final class PortPairGroupCodec extends JsonCodec<PortPairGroup> {
+
+ private static final String ID = "id";
+ private static final String TENANT_ID = "tenant_id";
+ private static final String NAME = "name";
+ private static final String DESCRIPTION = "description";
+ private static final String PORT_PAIRS = "port_pairs";
+ private static final String MISSING_MEMBER_MESSAGE =
+ " member is required in PortPairGroup";
+
+ @Override
+ public PortPairGroup decode(ObjectNode json, CodecContext context) {
+ if (json == null || !json.isObject()) {
+ return null;
+ }
+
+ PortPairGroup.Builder resultBuilder = new DefaultPortPairGroup.Builder();
+
+ CoreService coreService = context.getService(CoreService.class);
+
+ String id = nullIsIllegal(json.get(ID),
+ ID + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setId(PortPairGroupId.of(id));
+
+ String tenantId = nullIsIllegal(json.get(TENANT_ID),
+ TENANT_ID + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setTenantId(TenantId.tenantId(tenantId));
+
+ String name = nullIsIllegal(json.get(NAME),
+ NAME + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setName(name);
+
+ String description = nullIsIllegal(json.get(DESCRIPTION),
+ DESCRIPTION + MISSING_MEMBER_MESSAGE).asText();
+ resultBuilder.setDescription(description);
+
+ List<PortPairId> list = Lists.newArrayList();
+ ArrayNode arrayNode = (ArrayNode) json.path(PORT_PAIRS);
+ arrayNode.forEach(i -> list.add(PortPairId.of(i.asText())));
+ resultBuilder.setPortPairs(list);
+
+ return resultBuilder.build();
+ }
+
+ @Override
+ public ObjectNode encode(PortPairGroup portPairGroup, CodecContext context) {
+ checkNotNull(portPairGroup, "port pair group cannot be null");
+ ObjectNode result = context.mapper().createObjectNode()
+ .put(ID, portPairGroup.portPairGroupId().toString())
+ .put(TENANT_ID, portPairGroup.tenantId().toString())
+ .put(NAME, portPairGroup.name())
+ .put(DESCRIPTION, portPairGroup.description())
+ .put(PORT_PAIRS, portPairGroup.portPairs().toString());
+ return result;
+ }
+}
org.onosproject.vtnweb.resources.TenantNetworkWebResource,
org.onosproject.vtnweb.resources.SubnetWebResource,
org.onosproject.vtnweb.resources.VirtualPortWebResource
+ org.onosproject.vtnweb.resources.FlowClassifierWebResource
+ org.onosproject.vtnweb.resources.PortChainWebResource
+ org.onosproject.vtnweb.resources.PortPairGroupWebResource
+ org.onosproject.vtnweb.resources.PortPairWebResource
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
--- /dev/null
+/*
+ * 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.vtnweb.web;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.TenantId;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Port pair codec unit tests.
+ */
+public class PortPairCodecTest {
+
+ SfcCodecContext context;
+ JsonCodec<PortPair> portPairCodec;
+ /**
+ * Sets up for each test. Creates a context and fetches the port pair
+ * codec.
+ */
+ @Before
+ public void setUp() {
+ context = new SfcCodecContext();
+ portPairCodec = context.codec(PortPair.class);
+ assertThat(portPairCodec, notNullValue());
+ }
+
+ /**
+ * Reads in a port pair from the given resource and decodes it.
+ *
+ * @param resourceName resource to use to read the JSON for the port pair
+ * @return decoded port pair
+ * @throws IOException if processing the resource fails
+ */
+ private PortPair getPortPair(String resourceName) throws IOException {
+ InputStream jsonStream = PortPairCodecTest.class
+ .getResourceAsStream(resourceName);
+ ObjectMapper mapper = new ObjectMapper();
+ JsonNode json = mapper.readTree(jsonStream);
+ assertThat(json, notNullValue());
+ PortPair portPair = portPairCodec.decode((ObjectNode) json, context);
+ assertThat(portPair, notNullValue());
+ return portPair;
+ }
+
+ /**
+ * Checks that a simple port pair decodes properly.
+ *
+ * @throws IOException if the resource cannot be processed
+ */
+ @Test
+ public void codecPortPairTest() throws IOException {
+
+ PortPair portPair = getPortPair("portPair.json");
+
+ assertThat(portPair, notNullValue());
+
+ PortPairId portPairId = PortPairId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+ TenantId tenantId = TenantId.tenantId("d382007aa9904763a801f68ecf065cf5");
+
+ assertThat(portPair.portPairId().toString(), is(portPairId.toString()));
+ assertThat(portPair.name(), is("PP1"));
+ assertThat(portPair.tenantId().toString(), is(tenantId.toString()));
+ assertThat(portPair.description(), is("SF-A"));
+ assertThat(portPair.ingress().toString(), is("dace4513-24fc-4fae-af4b-321c5e2eb3d1"));
+ assertThat(portPair.egress().toString(), is("aef3478a-4a56-2a6e-cd3a-9dee4e2ec345"));
+ }
+}
--- /dev/null
+/*
+ * 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.vtnweb.web;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.vtnrsc.FlowClassifier;
+import org.onosproject.vtnrsc.PortChain;
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairGroup;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Mock codec context for use in codec unit tests.
+ */
+public class SfcCodecContext implements CodecContext {
+
+ private final ObjectMapper mapper = new ObjectMapper();
+ private final Map<Class<?>, JsonCodec> codecs = new ConcurrentHashMap<>();
+
+ /**
+ * Constructs a new mock codec context.
+ */
+ public SfcCodecContext() {
+ codecs.clear();
+ registerCodec(PortPair.class, new PortPairCodec());
+ registerCodec(PortChain.class, new PortChainCodec());
+ registerCodec(PortPairGroup.class, new PortPairGroupCodec());
+ registerCodec(FlowClassifier.class, new FlowClassifierCodec());
+ }
+
+ @Override
+ public ObjectMapper mapper() {
+ return mapper;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> T getService(Class<T> serviceClass) {
+ // TODO
+ return null;
+ }
+
+ /**
+ * Registers the specified JSON codec for the given entity class.
+ *
+ * @param entityClass entity class
+ * @param codec JSON codec
+ * @param <T> entity type
+ */
+ public <T> void registerCodec(Class<T> entityClass, JsonCodec<T> codec) {
+ codecs.putIfAbsent(entityClass, codec);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> JsonCodec<T> codec(Class<T> entityClass) {
+ return codecs.get(entityClass);
+ }
+}
--- /dev/null
+{
+ "id": "78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae",
+ "name": "PP1",
+ "tenant_id": "d382007aa9904763a801f68ecf065cf5",
+ "description": "SF-A",
+ "ingress": "dace4513-24fc-4fae-af4b-321c5e2eb3d1",
+ "egress": "aef3478a-4a56-2a6e-cd3a-9dee4e2ec345"
+}
+
--- /dev/null
+/*
+ * 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.bgp.controller;
+
+import java.util.concurrent.ExecutorService;
+
+/**
+ * Abstraction of an BGP connect peer, initiate remote connection to BGP peer on configuration.
+ */
+public interface BGPConnectPeer {
+
+ /**
+ * Returns the executor initialized to connect peer.
+ *
+ * @return connectExecutor the connection executor
+ */
+ ExecutorService connectExecutor();
+}
@Override
BGPOpenMsg build() throws BGPParseException;
- /**
- * Returns hold time of Open Message.
- *
- * @return hold time of Open Message
- */
- short getHoldTime();
-
/**
* Sets hold time in Open Message and return its builder.
*
*/
Builder setHoldTime(short holdtime);
- /**
- * Returns as number of Open Message.
- *
- * @return as number of Open Message
- */
- short getAsNumber();
-
/**
* Sets AS number in Open Message and return its builder.
*
*/
Builder setAsNumber(short asNumber);
- /**
- * Returns BGP Identifier of Open Message.
- *
- * @return BGP Identifier of Open Message
- */
- int getBgpId();
-
/**
* Sets BGP Identifier in Open Message and return its builder.
*
*/
Builder setBgpId(int bgpId);
- /**
- * Returns capabilities of Open Message.
- *
- * @return capabilities of Open Message
- */
- LinkedList<BGPValueType> getCapabilityTlv();
-
/**
* Sets capabilities in Open Message and return its builder.
*
--- /dev/null
+/*
+ * 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.bgpio.protocol.link_state;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.onosproject.bgpio.types.BGPErrorType;
+import org.onosproject.bgpio.types.BGPValueType;
+import org.onosproject.bgpio.types.IPv4AddressTlv;
+import org.onosproject.bgpio.types.IPv6AddressTlv;
+import org.onosproject.bgpio.types.LinkLocalRemoteIdentifiersTlv;
+import org.onosproject.bgpio.types.attr.BgpAttrNodeMultiTopologyId;
+import org.onosproject.bgpio.util.UnSupportedAttribute;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+
+/**
+ * Implementation of local node descriptors, remote node descriptors and link descriptors.
+ */
+public class BGPLinkLSIdentifier {
+ private static final Logger log = LoggerFactory.getLogger(BGPLinkLSIdentifier.class);
+ public static final short IPV4_INTERFACE_ADDRESS_TYPE = 259;
+ public static final short IPV4_NEIGHBOR_ADDRESS_TYPE = 260;
+ public static final short IPV6_INTERFACE_ADDRESS_TYPE = 261;
+ public static final short IPV6_NEIGHBOR_ADDRESS_TYPE = 262;
+ public static final int TYPE_AND_LEN = 4;
+
+ private NodeDescriptors localNodeDescriptors;
+ private NodeDescriptors remoteNodeDescriptors;
+ private List<BGPValueType> linkDescriptor;
+
+ /**
+ * Initialize fields.
+ */
+ public BGPLinkLSIdentifier() {
+ this.localNodeDescriptors = null;
+ this.remoteNodeDescriptors = null;
+ this.linkDescriptor = null;
+ }
+
+ /**
+ * Constructors to initialize parameters.
+ *
+ * @param localNodeDescriptors local node descriptors
+ * @param remoteNodeDescriptors remote node descriptors
+ * @param linkDescriptor link descriptors
+ */
+ public BGPLinkLSIdentifier(NodeDescriptors localNodeDescriptors, NodeDescriptors remoteNodeDescriptors,
+ LinkedList<BGPValueType> linkDescriptor) {
+ this.localNodeDescriptors = Preconditions.checkNotNull(localNodeDescriptors);
+ this.remoteNodeDescriptors = Preconditions.checkNotNull(remoteNodeDescriptors);
+ this.linkDescriptor = Preconditions.checkNotNull(linkDescriptor);
+ }
+
+ /**
+ * Reads channel buffer and parses link identifier.
+ *
+ * @param cb ChannelBuffer
+ * @param protocolId in linkstate nlri
+ * @return object of BGPLinkLSIdentifier
+ * @throws BGPParseException while parsing link identifier
+ */
+ public static BGPLinkLSIdentifier parseLinkIdendifier(ChannelBuffer cb, byte protocolId) throws BGPParseException {
+ //Parse local node descriptor
+ NodeDescriptors localNodeDescriptors = new NodeDescriptors();
+ localNodeDescriptors = parseNodeDescriptors(cb, NodeDescriptors.LOCAL_NODE_DES_TYPE, protocolId);
+
+ //Parse remote node descriptor
+ NodeDescriptors remoteNodeDescriptors = new NodeDescriptors();
+ remoteNodeDescriptors = parseNodeDescriptors(cb, NodeDescriptors.REMOTE_NODE_DES_TYPE, protocolId);
+
+ //Parse link descriptor
+ LinkedList<BGPValueType> linkDescriptor = new LinkedList<>();
+ linkDescriptor = parseLinkDescriptors(cb);
+ return new BGPLinkLSIdentifier(localNodeDescriptors, remoteNodeDescriptors, linkDescriptor);
+ }
+
+ /**
+ * Parses Local/Remote node descriptors.
+ *
+ * @param cb ChannelBuffer
+ * @param desType descriptor type
+ * @param protocolId protocol identifier
+ * @return object of NodeDescriptors
+ * @throws BGPParseException while parsing Local/Remote node descriptors
+ */
+ public static NodeDescriptors parseNodeDescriptors(ChannelBuffer cb, short desType, byte protocolId)
+ throws BGPParseException {
+ ChannelBuffer tempBuf = cb;
+ short type = cb.readShort();
+ short length = cb.readShort();
+ if (cb.readableBytes() < length) {
+ throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.OPTIONAL_ATTRIBUTE_ERROR,
+ tempBuf.readBytes(cb.readableBytes() + TYPE_AND_LEN));
+ }
+ NodeDescriptors nodeIdentifier = new NodeDescriptors();
+ ChannelBuffer tempCb = cb.readBytes(length);
+
+ if (type == desType) {
+ nodeIdentifier = NodeDescriptors.read(tempCb, length, desType, protocolId);
+ } else {
+ throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.MALFORMED_ATTRIBUTE_LIST, null);
+ }
+ return nodeIdentifier;
+ }
+
+ /**
+ * Parses link descriptors.
+ *
+ * @param cb ChannelBuffer
+ * @return list of link descriptors
+ * @throws BGPParseException while parsing link descriptors
+ */
+ public static LinkedList<BGPValueType> parseLinkDescriptors(ChannelBuffer cb) throws BGPParseException {
+ LinkedList<BGPValueType> linkDescriptor = new LinkedList<>();
+ BGPValueType tlv = null;
+ int count = 0;
+
+ while (cb.readableBytes() > 0) {
+ ChannelBuffer tempBuf = cb;
+ short type = cb.readShort();
+ short length = cb.readShort();
+ if (cb.readableBytes() < length) {
+ throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.OPTIONAL_ATTRIBUTE_ERROR,
+ tempBuf.readBytes(cb.readableBytes() + TYPE_AND_LEN));
+ }
+ ChannelBuffer tempCb = cb.readBytes(length);
+ switch (type) {
+ case LinkLocalRemoteIdentifiersTlv.TYPE:
+ tlv = LinkLocalRemoteIdentifiersTlv.read(tempCb);
+ break;
+ case IPV4_INTERFACE_ADDRESS_TYPE:
+ tlv = IPv4AddressTlv.read(tempCb, IPV4_INTERFACE_ADDRESS_TYPE);
+ break;
+ case IPV4_NEIGHBOR_ADDRESS_TYPE:
+ tlv = IPv4AddressTlv.read(tempCb, IPV4_NEIGHBOR_ADDRESS_TYPE);
+ break;
+ case IPV6_INTERFACE_ADDRESS_TYPE:
+ tlv = IPv6AddressTlv.read(tempCb, IPV6_INTERFACE_ADDRESS_TYPE);
+ break;
+ case IPV6_NEIGHBOR_ADDRESS_TYPE:
+ tlv = IPv6AddressTlv.read(tempCb, IPV6_NEIGHBOR_ADDRESS_TYPE);
+ break;
+ case BgpAttrNodeMultiTopologyId.ATTRNODE_MULTITOPOLOGY:
+ tlv = BgpAttrNodeMultiTopologyId.read(tempCb);
+ count = count++;
+ //MultiTopologyId TLV cannot repeat more than once
+ if (count > 1) {
+ //length + 4 implies data contains type, length and value
+ throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR,
+ BGPErrorType.OPTIONAL_ATTRIBUTE_ERROR, tempBuf.readBytes(length
+ + TYPE_AND_LEN));
+ }
+ break;
+ default:
+ UnSupportedAttribute.skipBytes(tempCb, length);
+ }
+ linkDescriptor.add(tlv);
+ }
+ return linkDescriptor;
+ }
+
+ /**
+ * Returns local node descriptors.
+ *
+ * @return local node descriptors
+ */
+ public NodeDescriptors localNodeDescriptors() {
+ return this.localNodeDescriptors;
+ }
+
+ /**
+ * Returns remote node descriptors.
+ *
+ * @return remote node descriptors
+ */
+ public NodeDescriptors remoteNodeDescriptors() {
+ return this.remoteNodeDescriptors;
+ }
+
+ /**
+ * Returns link descriptors.
+ *
+ * @return link descriptors
+ */
+ public List<BGPValueType> linkDescriptors() {
+ return this.linkDescriptor;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(linkDescriptor, localNodeDescriptors, remoteNodeDescriptors);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj instanceof BGPLinkLSIdentifier) {
+ int countObjSubTlv = 0;
+ int countOtherSubTlv = 0;
+ boolean isCommonSubTlv = true;
+ BGPLinkLSIdentifier other = (BGPLinkLSIdentifier) obj;
+ Iterator<BGPValueType> objListIterator = other.linkDescriptor.iterator();
+ countOtherSubTlv = other.linkDescriptor.size();
+ countObjSubTlv = linkDescriptor.size();
+ if (countObjSubTlv != countOtherSubTlv) {
+ return false;
+ } else {
+ while (objListIterator.hasNext() && isCommonSubTlv) {
+ BGPValueType subTlv = objListIterator.next();
+ isCommonSubTlv = Objects.equals(linkDescriptor.contains(subTlv),
+ other.linkDescriptor.contains(subTlv));
+ }
+ return isCommonSubTlv && Objects.equals(this.localNodeDescriptors, other.localNodeDescriptors)
+ && Objects.equals(this.remoteNodeDescriptors, other.remoteNodeDescriptors);
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("localNodeDescriptors", localNodeDescriptors)
+ .add("remoteNodeDescriptors", remoteNodeDescriptors)
+ .add("linkDescriptor", linkDescriptor)
+ .toString();
+ }
+}
\ No newline at end of file
if (this.isLargeAsCapabilityTlvSet) {
BGPValueType tlv;
- int iValue = this.getAsNumber();
- tlv = new FourOctetAsNumCapabilityTlv(iValue);
+ int value = this.asNumber;
+ tlv = new FourOctetAsNumCapabilityTlv(value);
this.capabilityTlv.add(tlv);
}
return this;
}
- @Override
- public short getHoldTime() {
- return this.holdTime;
- }
-
- @Override
- public short getAsNumber() {
- return this.asNumber;
- }
-
- @Override
- public int getBgpId() {
- return this.bgpId;
- }
-
- @Override
- public LinkedList<BGPValueType> getCapabilityTlv() {
- return this.capabilityTlv;
- }
-
@Override
public Builder setHoldTime(short holdTime) {
this.holdTime = holdTime;
--- /dev/null
+/*
+ * 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.bgpio.types;
+
+import java.net.InetAddress;
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+
+/**
+ * Provides Implementation of IPv4AddressTlv.
+ */
+public class IPv4AddressTlv implements BGPValueType {
+ private static final Logger log = LoggerFactory.getLogger(IPv4AddressTlv.class);
+ private static final int LENGTH = 4;
+
+ private Ip4Address address;
+ private short type;
+
+ /**
+ * Constructor to initialize parameters.
+ *
+ * @param address Ipv4 address of interface/neighbor
+ * @param type address type
+ */
+ public IPv4AddressTlv(Ip4Address address, short type) {
+ this.address = Preconditions.checkNotNull(address);
+ this.type = type;
+ }
+
+ /**
+ * Returns Ipv4 address of interface/neighbor.
+ *
+ * @return Ipv4 address of interface/neighbor
+ */
+ public Ip4Address getValue() {
+ return address;
+ }
+
+ @Override
+ public short getType() {
+ return this.type;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(address);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj instanceof IPv4AddressTlv) {
+ IPv4AddressTlv other = (IPv4AddressTlv) obj;
+ return Objects.equals(this.address, other.address) && Objects.equals(this.type, other.type);
+ }
+ return false;
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) {
+ int iLenStartIndex = cb.writerIndex();
+ cb.writeShort(type);
+ cb.writeShort(LENGTH);
+ cb.writeInt(address.toInt());
+ return cb.writerIndex() - iLenStartIndex;
+ }
+
+ /**
+ * Reads the channel buffer and returns object of IPv4AddressTlv.
+ *
+ * @param cb channelBuffer
+ * @param type address type
+ * @return object of IPv4AddressTlv
+ * @throws BGPParseException while parsing IPv4AddressTlv
+ */
+ public static IPv4AddressTlv read(ChannelBuffer cb, short type) throws BGPParseException {
+ //TODO: use Validation.toInetAddress once Validation is merged
+ InetAddress ipAddress = (InetAddress) cb.readBytes(LENGTH);
+ if (ipAddress.isMulticastAddress()) {
+ throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, (byte) 0, null);
+ }
+ Ip4Address address = Ip4Address.valueOf(ipAddress);
+ return IPv4AddressTlv.of(address, type);
+ }
+
+ /**
+ * Returns object of this class with specified values.
+ *
+ * @param address Ipv4 interface/neighbor Address
+ * @param type says Ipv4 address of interface/neighbor tlv type
+ * @return object of this class
+ */
+ public static IPv4AddressTlv of(final Ip4Address address , final short type) {
+ return new IPv4AddressTlv(address, type);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("type", type)
+ .add("LENGTH", LENGTH)
+ .add("address", address)
+ .toString();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgpio.types;
+
+import java.net.InetAddress;
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onlab.packet.Ip6Address;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+
+/**
+ * Provides Implementation of IPv6AddressTlv.
+ */
+public class IPv6AddressTlv implements BGPValueType {
+ private static final Logger log = LoggerFactory.getLogger(IPv6AddressTlv.class);
+ private static final int LENGTH = 16;
+
+ private final Ip6Address address;
+ private short type;
+
+ /**
+ * Constructor to initialize parameters.
+ *
+ * @param address Ipv6 address of interface/neighbor
+ * @param type address type
+ */
+ public IPv6AddressTlv(Ip6Address address, short type) {
+ this.address = Preconditions.checkNotNull(address);
+ this.type = type;
+ }
+
+ /**
+ * Returns Ipv6 address of interface/neighbor.
+ *
+ * @return Ipv6 address of interface/neighbor
+ */
+ public Ip6Address getValue() {
+ return address;
+ }
+
+ @Override
+ public short getType() {
+ return type;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(address);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj instanceof IPv6AddressTlv) {
+ IPv6AddressTlv other = (IPv6AddressTlv) obj;
+ return Objects.equals(this.address, other.address) && Objects.equals(this.type, other.type);
+ }
+ return false;
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) {
+ int iLenStartIndex = cb.writerIndex();
+ cb.writeShort(type);
+ cb.writeShort(LENGTH);
+ cb.writeBytes(address.toOctets());
+ return cb.writerIndex() - iLenStartIndex;
+ }
+
+ /**
+ * Reads the channel buffer and returns object of IPv6AddressTlv.
+ *
+ * @param cb channelBuffer
+ * @param type address type
+ * @return object of IPv6AddressTlv
+ * @throws BGPParseException while parsing IPv6AddressTlv
+ */
+ public static IPv6AddressTlv read(ChannelBuffer cb, short type) throws BGPParseException {
+ //TODO: use Validation.toInetAddress once Validation is merged
+ InetAddress ipAddress = (InetAddress) cb.readBytes(LENGTH);
+ if (ipAddress.isMulticastAddress()) {
+ throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, (byte) 0, null);
+ }
+ Ip6Address address = Ip6Address.valueOf(ipAddress);
+ return IPv6AddressTlv.of(address, type);
+ }
+
+ /**
+ * Returns object of this class with specified values.
+ *
+ * @param address Ipv6 interface/neighbor address
+ * @param type says Ipv6 address of interface/neighbor tlv type
+ * @return object of this class
+ */
+ public static IPv6AddressTlv of(final Ip6Address address , final short type) {
+ return new IPv6AddressTlv(address, type);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("type", type)
+ .add("LENGTH", LENGTH)
+ .add("address", address)
+ .toString();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgpio.types;
+
+import java.util.Objects;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * Provides Implementation of Link Local/Remote IdentifiersTlv.
+ */
+public class LinkLocalRemoteIdentifiersTlv implements BGPValueType {
+ private static final Logger log = LoggerFactory.getLogger(LinkLocalRemoteIdentifiersTlv.class);
+ public static final short TYPE = 258;
+ private static final int LENGTH = 8;
+
+ private final int linkLocalIdentifer;
+ private final int linkRemoteIdentifer;
+
+ /**
+ * Constructor to initialize parameters.
+ *
+ * @param linkLocalIdentifer link local Identifer
+ * @param linkRemoteIdentifer link remote Identifer
+ */
+ public LinkLocalRemoteIdentifiersTlv(int linkLocalIdentifer, int linkRemoteIdentifer) {
+ this.linkLocalIdentifer = linkLocalIdentifer;
+ this.linkRemoteIdentifer = linkRemoteIdentifer;
+ }
+
+ /**
+ * Returns link remote Identifer.
+ *
+ * @return link remote Identifer
+ */
+ public int getLinkRemoteIdentifier() {
+ return linkRemoteIdentifer;
+ }
+
+ /**
+ * Returns link local Identifer.
+ *
+ * @return link local Identifer
+ */
+ public int getLinkLocalIdentifier() {
+ return linkLocalIdentifer;
+ }
+
+ @Override
+ public short getType() {
+ return TYPE;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(linkLocalIdentifer, linkRemoteIdentifer);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj instanceof LinkLocalRemoteIdentifiersTlv) {
+ LinkLocalRemoteIdentifiersTlv other = (LinkLocalRemoteIdentifiersTlv) obj;
+ return Objects.equals(this.linkLocalIdentifer, other.linkLocalIdentifer)
+ && Objects.equals(this.linkRemoteIdentifer, other.linkRemoteIdentifer);
+ }
+ return false;
+ }
+
+ @Override
+ public int write(ChannelBuffer cb) {
+ int iLenStartIndex = cb.writerIndex();
+ cb.writeShort(TYPE);
+ cb.writeShort(LENGTH);
+ cb.writeInt(linkLocalIdentifer);
+ cb.writeInt(linkRemoteIdentifer);
+ return cb.writerIndex() - iLenStartIndex;
+ }
+
+ /**
+ * Reads the channel buffer and returns object of LinkLocalRemoteIdentifiersTlv.
+ *
+ * @param cb channelBuffer
+ * @return object of LinkLocalRemoteIdentifiersTlv
+ */
+ public static LinkLocalRemoteIdentifiersTlv read(ChannelBuffer cb) {
+ int linkLocalIdentifer = cb.readInt();
+ int linkRemoteIdentifer = cb.readInt();
+ return LinkLocalRemoteIdentifiersTlv.of(linkLocalIdentifer, linkRemoteIdentifer);
+ }
+
+ /**
+ * Returns object of this class with specified link local identifer and link remote identifer.
+ *
+ * @param linkLocalIdentifer link local identifier
+ * @param linkRemoteIdentifer link remote identifier
+ * @return object of LinkLocalRemoteIdentifiersTlv
+ */
+ public static LinkLocalRemoteIdentifiersTlv of(final int linkLocalIdentifer, final int linkRemoteIdentifer) {
+ return new LinkLocalRemoteIdentifiersTlv(linkLocalIdentifer, linkRemoteIdentifer);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("TYPE", TYPE)
+ .add("LENGTH", LENGTH)
+ .add("linkLocalIdentifer", linkLocalIdentifer)
+ .add("linkRemoteIdentifer", linkRemoteIdentifer)
+ .toString();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import com.google.common.testing.EqualsTester;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.AreaIDTlv;
+
+/**
+ * Test for AreaID Tlv.
+ */
+public class AreaIdTest {
+ private final int value1 = 10;
+ private final int value2 = 20;
+ private final AreaIDTlv tlv1 = AreaIDTlv.of(value1);
+ private final AreaIDTlv sameAsTlv1 = AreaIDTlv.of(value1);
+ private final AreaIDTlv tlv2 = AreaIDTlv.of(value2);
+
+ @Test
+ public void testEquality() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.As4Path;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for As4Path BGP Path Attribute.
+ */
+public class As4PathTest {
+ //Two scenarios as4path set and sequence
+ private final List<Integer> as4pathSet1 = new ArrayList<>();
+ private final List<Integer> as4pathSeq1 = new ArrayList<>();
+ private final List<Integer> as4pathSet2 = new ArrayList<>();
+ private final List<Integer> as4pathSeq2 = new ArrayList<>();
+ private final As4Path attr1 = new As4Path(as4pathSet1, null);
+ private final As4Path sameAsAttr1 = new As4Path(as4pathSet1, null);
+ private final As4Path attr2 = new As4Path(as4pathSet2, null);
+ private final As4Path attr3 = new As4Path(null, as4pathSeq1);
+ private final As4Path sameAsAttr3 = new As4Path(null, as4pathSeq1);
+ private final As4Path attr4 = new As4Path(null, as4pathSeq2);
+
+ @Test
+ public void basics() {
+ as4pathSet1.add(197358);
+ as4pathSet1.add(12883);
+ as4pathSet2.add(2008989);
+ as4pathSeq1.add(3009009);
+ as4pathSeq2.add(409900);
+ new EqualsTester()
+ .addEqualityGroup(attr1, sameAsAttr1)
+ .addEqualityGroup(attr2)
+ .addEqualityGroup(attr3, sameAsAttr3)
+ .addEqualityGroup(attr4)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.AsPath;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for AsPath BGP Path Attribute.
+ */
+public class AsPathTest {
+ //Two scenarios aspath set and sequence
+ private final List<Short> aspathSet1 = new ArrayList<>();
+ private final List<Short> aspathSet2 = new ArrayList<>();
+ private final List<Short> aspathSeq1 = new ArrayList<>();
+ private final List<Short> aspathSeq2 = new ArrayList<>();
+ private final AsPath attr1 = new AsPath(aspathSet1, null);
+ private final AsPath sameAsAttr1 = new AsPath(aspathSet1, null);
+ private final AsPath attr2 = new AsPath(aspathSet2, null);
+ private final AsPath attr3 = new AsPath(null, aspathSeq1);
+ private final AsPath sameAsAttr3 = new AsPath(null, aspathSeq1);
+ private final AsPath attr4 = new AsPath(null, aspathSeq2);
+
+ @Test
+ public void basics() {
+ aspathSet1.add((short) 100);
+ aspathSet1.add((short) 300);
+ aspathSet2.add((short) 200);
+ aspathSeq2.add((short) 400);
+ aspathSeq1.add((short) 300);
+ new EqualsTester()
+ .addEqualityGroup(attr1, sameAsAttr1)
+ .addEqualityGroup(attr2)
+ .addEqualityGroup(attr3, sameAsAttr3)
+ .addEqualityGroup(attr4)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import com.google.common.testing.EqualsTester;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.AutonomousSystemTlv;
+
+/**
+ * Test for AutonomousSystem Tlv.
+ */
+public class AutonomousSystemTest {
+ private final int value1 = 101;
+ private final int value2 = 201;
+ private final AutonomousSystemTlv tlv1 = AutonomousSystemTlv.of(value1);
+ private final AutonomousSystemTlv sameAsTlv1 = AutonomousSystemTlv.of(value1);
+ private final AutonomousSystemTlv tlv2 = AutonomousSystemTlv.of(value2);
+
+ @Test
+ public void testEquality() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.junit.Test;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.onosproject.bgpio.protocol.BGPFactories;
+import org.onosproject.bgpio.protocol.BGPKeepaliveMsg;
+import org.onosproject.bgpio.protocol.BGPMessage;
+import org.onosproject.bgpio.protocol.BGPMessageReader;
+import org.onosproject.bgpio.types.BGPHeader;
+
+/**
+ * Test case for BGP KEEPALIVE Message.
+ */
+public class BGPKeepaliveMsgTest {
+
+ /**
+ * This test case checks BGP Keepalive message.
+ */
+ @Test
+ public void keepaliveMessageTest1() throws BGPParseException {
+
+ // BGP KEEPALIVE Message
+ byte[] keepaliveMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ 0x00, 0x13, 0x04};
+
+ byte[] testKeepaliveMsg;
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(keepaliveMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPKeepaliveMsg.class));
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+
+ int readLen = buf.writerIndex();
+ testKeepaliveMsg = new byte[readLen];
+ buf.readBytes(testKeepaliveMsg, 0, readLen);
+
+ assertThat(testKeepaliveMsg, is(keepaliveMsg));
+ }
+}
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.BGPLSIdentifierTlv;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for BGPLSIdentifier Tlv.
+ */
+public class BGPLSIdentifierTest {
+ private final int value1 = 8738;
+ private final int value2 = 13107;
+ private final BGPLSIdentifierTlv tlv1 = BGPLSIdentifierTlv.of(value1);
+ private final BGPLSIdentifierTlv sameAsTlv1 = new BGPLSIdentifierTlv(value1);
+ private final BGPLSIdentifierTlv tlv2 = new BGPLSIdentifierTlv(value2);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.junit.Test;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.onosproject.bgpio.protocol.BGPFactories;
+import org.onosproject.bgpio.protocol.BGPMessage;
+import org.onosproject.bgpio.protocol.BGPMessageReader;
+import org.onosproject.bgpio.protocol.BGPOpenMsg;
+import org.onosproject.bgpio.types.BGPHeader;
+
+/**
+ * Test cases for BGP Open Message.
+ */
+public class BGPOpenMsgTest {
+
+ /**
+ * This test case checks open message without optional parameter.
+ */
+ @Test
+ public void openMessageTest1() throws BGPParseException {
+ //Open message without optional parameter
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ 0x00, 0x1d, 0x01, 0X04, (byte) 0xfe, 0x09, 0x00,
+ (byte) 0xb4, (byte) 0xc0, (byte) 0xa8, 0x00, 0x0f,
+ 0x00};
+
+ byte[] testOpenMsg;
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+
+ int readLen = buf.writerIndex();
+ testOpenMsg = new byte[readLen];
+ buf.readBytes(testOpenMsg, 0, readLen);
+
+ assertThat(testOpenMsg, is(openMsg));
+ }
+
+ /**
+ * This test case checks open message with Multiprotocol extension
+ * capability.
+ */
+ @Test
+ public void openMessageTest2() throws BGPParseException {
+
+ // OPEN Message (MultiProtocolExtension-CAPABILITY).
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, 0x00, 0x25,
+ 0x01, //BGP Header
+ 0X04, //Version
+ (byte) 0x00, (byte) 0xc8, // AS Number
+ 0x00, (byte) 0xb4, // Hold time
+ (byte) 0xb6, (byte) 0x02, 0x5d,
+ (byte) 0xc8, // BGP Identifier
+ 0x08, 0x02, 0x06, // Opt Parameter length
+ 0x01, 0x04, 0x00, 0x00, 0x00, (byte) 0xc8}; // Multiprotocol CAPABILITY
+
+ byte[] testOpenMsg;
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+
+ int readLen = buf.writerIndex();
+ testOpenMsg = new byte[readLen];
+ buf.readBytes(testOpenMsg, 0, readLen);
+
+ assertThat(testOpenMsg, is(openMsg));
+ }
+
+ /**
+ * This test case checks open message with Four-octet AS number
+ * capability.
+ */
+ @Test
+ public void openMessageTest3() throws BGPParseException {
+
+ // OPEN Message (Four-Octet AS number capability).
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, 0x00, 0x25,
+ 0x01, //BGPHeader
+ 0X04, //Version
+ (byte) 0x00, (byte) 0xc8, //AS Number
+ 0x00, (byte) 0xb4, //Hold Time
+ (byte) 0xb6, (byte) 0x02, 0x5d,
+ (byte) 0xc8, //BGP Identifier
+ 0x08, 0x02, 0x06, //Opt Parameter Length
+ 0x41, 0x04, 0x00, 0x01, 0x00, 0x01}; //Four Octet AS Number-CAPABILITY-TLV
+
+ byte[] testOpenMsg;
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+
+ int readLen = buf.writerIndex();
+ testOpenMsg = new byte[readLen];
+ buf.readBytes(testOpenMsg, 0, readLen);
+
+ assertThat(testOpenMsg, is(openMsg));
+ }
+
+ /**
+ * This test case checks open message with capabilities.
+ */
+ @Test
+ public void openMessageTest4() throws BGPParseException {
+
+ // OPEN Message with capabilities.
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, 0x00, 0x2b,
+ 0x01, //BGPHeader
+ 0X04, //Version
+ (byte) 0x00, (byte) 0xc8, //AS Number
+ 0x00, (byte) 0xb4, //Hold Time
+ (byte) 0xb6, (byte) 0x02, 0x5d, (byte) 0xc8, //BGP Identifier
+ 0x0e, 0x02, 0x0c, //Opt Parameter Length
+ 0x01, 0x04, 0x00, 0x00, 0x00, (byte) 0xc8, // Multiprotocol extension capability
+ 0x41, 0x04, 0x00, 0x01, 0x00, 0x01}; //Four Octet AS Number-CAPABILITY-TLV
+
+ byte[] testOpenMsg;
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+
+ int readLen = buf.writerIndex();
+ testOpenMsg = new byte[readLen];
+ buf.readBytes(testOpenMsg, 0, readLen);
+
+ assertThat(testOpenMsg, is(openMsg));
+ }
+
+ /**
+ * In this test case, Invalid version is given as input and expecting
+ * an exception.
+ */
+ @Test(expected = BGPParseException.class)
+ public void openMessageTest5() throws BGPParseException {
+
+ // OPEN Message with invalid version number.
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, 0x00, 0x1d, 0x01, 0X05,
+ (byte) 0xfe, 0x09, 0x00, (byte) 0xb4,
+ (byte) 0xc0, (byte) 0xa8, 0x00, 0x0f,
+ 0x00};
+
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ }
+
+ /**
+ * In this test case, Marker is set as 0 in input and expecting
+ * an exception.
+ */
+ @Test(expected = BGPParseException.class)
+ public void openMessageTest6() throws BGPParseException {
+
+ // OPEN Message with marker set to 0.
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0x00, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ 0x00, 0x00, 0x1d, 0x01, 0X04,
+ (byte) 0xfe, 0x09, 0x00, (byte) 0xb4,
+ (byte) 0xc0, (byte) 0xa8, 0x00, 0x0f,
+ 0x00};
+
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ }
+
+ /**
+ * In this test case, Invalid message length is given as input and expecting
+ * an exception.
+ */
+ @Test(expected = BGPParseException.class)
+ public void openMessageTest7() throws BGPParseException {
+
+ // OPEN Message with invalid header length.
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, 0x00, 0x1e, 0x01, 0X04,
+ (byte) 0xfe, 0x09, 0x00, (byte) 0xb4,
+ (byte) 0xc0, (byte) 0xa8, 0x00, 0x0f,
+ 0x00};
+
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ }
+
+ /**
+ * In this test case, Invalid message type is given as input and expecting
+ * an exception.
+ */
+ @Test(expected = BGPParseException.class)
+ public void openMessageTest8() throws BGPParseException {
+
+ // OPEN Message with invalid message type.
+ byte[] openMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, 0x00, 0x1d, 0x05, 0X04,
+ (byte) 0xfe, 0x09, 0x00, (byte) 0xb4,
+ (byte) 0xc0, (byte) 0xa8, 0x00, 0x0f,
+ 0x00};
+
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(openMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message;
+ BGPHeader bgpHeader = new BGPHeader();
+ message = reader.readFrom(buffer, bgpHeader);
+
+ assertThat(message, instanceOf(BGPOpenMsg.class));
+ }
+}
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.attr.BgpLinkAttrMplsProtocolMask;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for MPLS protocol mask attribute.
+ */
+public class BgpLinkAttrMplsProtocolMaskTest {
+ private final boolean val = true;
+ private final boolean val1 = false;
+
+ private final BgpLinkAttrMplsProtocolMask data = BgpLinkAttrMplsProtocolMask
+ .of(val, val);
+ private final BgpLinkAttrMplsProtocolMask sameAsData = BgpLinkAttrMplsProtocolMask
+ .of(val, val);
+ private final BgpLinkAttrMplsProtocolMask diffData = BgpLinkAttrMplsProtocolMask
+ .of(val, val1);
+
+ @Test
+ public void basics() {
+
+ new EqualsTester().addEqualityGroup(data, sameAsData)
+ .addEqualityGroup(diffData).testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.junit.Test;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.onosproject.bgpio.protocol.BGPFactories;
+import org.onosproject.bgpio.protocol.BGPMessage;
+import org.onosproject.bgpio.protocol.BGPMessageReader;
+import org.onosproject.bgpio.protocol.BGPNotificationMsg;
+import org.onosproject.bgpio.types.BGPHeader;
+
+/**
+ * Test for Notification message.
+ */
+public class BgpNotificationMsgTest {
+
+ /**
+ * Notification message with error code, error subcode and data.
+ *
+ * @throws BGPParseException while decoding and encoding notification message
+ */
+ @Test
+ public void bgpNotificationMessageTest1() throws BGPParseException {
+ byte[] notificationMsg = new byte[] {(byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, 0x00,
+ 0x17, 0x03, 0x02, 0x02,
+ (byte) 0xfe, (byte) 0xb0};
+
+ byte[] testNotificationMsg = {0};
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(notificationMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message = null;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+ assertThat(message, instanceOf(BGPNotificationMsg.class));
+
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+ testNotificationMsg = buf.array();
+
+ int iReadLen = buf.writerIndex() - 0;
+ testNotificationMsg = new byte[iReadLen];
+ buf.readBytes(testNotificationMsg, 0, iReadLen);
+ assertThat(testNotificationMsg, is(notificationMsg));
+ }
+
+ /**
+ * Notification message without data.
+ *
+ * @throws BGPParseException while decoding and encoding notification message
+ */
+ @Test
+ public void bgpNotificationMessageTest2() throws BGPParseException {
+ byte[] notificationMsg = new byte[] {(byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, 0x00,
+ 0x15, 0x03, 0x02, 0x00};
+
+ byte[] testNotificationMsg = {0};
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(notificationMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message = null;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+ assertThat(message, instanceOf(BGPNotificationMsg.class));
+
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+ testNotificationMsg = buf.array();
+
+ int iReadLen = buf.writerIndex() - 0;
+ testNotificationMsg = new byte[iReadLen];
+ buf.readBytes(testNotificationMsg, 0, iReadLen);
+ assertThat(testNotificationMsg, is(notificationMsg));
+ }
+
+ //Negative scenarios
+ /**
+ * Notification message with wrong maker value.
+ *
+ * @throws BGPParseException while decoding and encoding notification message
+ */
+ @Test(expected = BGPParseException.class)
+ public void bgpNotificationMessageTest3() throws BGPParseException {
+ byte[] notificationMsg = new byte[] {(byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ 0x01, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, 0x00,
+ 0x15, 0x03, 0x02, 0x00};
+
+ byte[] testNotificationMsg = {0};
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(notificationMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message = null;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+ assertThat(message, instanceOf(BGPNotificationMsg.class));
+
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+ testNotificationMsg = buf.array();
+
+ int iReadLen = buf.writerIndex() - 0;
+ testNotificationMsg = new byte[iReadLen];
+ buf.readBytes(testNotificationMsg, 0, iReadLen);
+ assertThat(testNotificationMsg, is(notificationMsg));
+ }
+
+ /**
+ * Notification message without error subcode.
+ *
+ * @throws BGPParseException while decoding and encoding notification message
+ */
+ @Test(expected = BGPParseException.class)
+ public void bgpNotificationMessageTest4() throws BGPParseException {
+ byte[] notificationMsg = new byte[] {(byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, 0x00,
+ 0x14, 0x03, 0x02};
+
+ byte[] testNotificationMsg = {0};
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(notificationMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message = null;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+ assertThat(message, instanceOf(BGPNotificationMsg.class));
+
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+ testNotificationMsg = buf.array();
+
+ int iReadLen = buf.writerIndex() - 0;
+ testNotificationMsg = new byte[iReadLen];
+ buf.readBytes(testNotificationMsg, 0, iReadLen);
+ assertThat(testNotificationMsg, is(notificationMsg));
+ }
+
+ /**
+ * Notification message with wrong message length.
+ *
+ * @throws BGPParseException while decoding and encoding notification message
+ */
+ @Test(expected = BGPParseException.class)
+ public void bgpNotificationMessageTest5() throws BGPParseException {
+ byte[] notificationMsg = new byte[] {(byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, 0x00,
+ 0x14, 0x03, 0x02, 0x02};
+
+ byte[] testNotificationMsg = {0};
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ buffer.writeBytes(notificationMsg);
+
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ BGPMessage message = null;
+ BGPHeader bgpHeader = new BGPHeader();
+
+ message = reader.readFrom(buffer, bgpHeader);
+ assertThat(message, instanceOf(BGPNotificationMsg.class));
+
+ ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
+ message.writeTo(buf);
+ testNotificationMsg = buf.array();
+
+ int iReadLen = buf.writerIndex() - 0;
+ testNotificationMsg = new byte[iReadLen];
+ buf.readBytes(testNotificationMsg, 0, iReadLen);
+ assertThat(testNotificationMsg, is(notificationMsg));
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.attr.BgpPrefixAttrMetric;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for BGP prefix metric attribute.
+ */
+public class BgpPrefixAttrMetricTest {
+ private final int val = 1111;
+ private final int val1 = 2222;
+
+ private final BgpPrefixAttrMetric data = BgpPrefixAttrMetric.of(val);
+ private final BgpPrefixAttrMetric sameAsData = BgpPrefixAttrMetric.of(val);
+ private final BgpPrefixAttrMetric diffData = BgpPrefixAttrMetric.of(val1);
+
+ @Test
+ public void basics() {
+
+ new EqualsTester().addEqualityGroup(data, sameAsData)
+ .addEqualityGroup(diffData).testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.IPReachabilityInformationTlv;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for IPReachabilityInformation Tlv.
+ */
+public class IPReachabilityInformationTest {
+ private final byte[] value1 = new byte[] {(byte) 0xc0, (byte) 0xa8, 0x4d, 0x01};
+ private final byte[] value2 = new byte[] {(byte) 0xc0};
+ private final IPReachabilityInformationTlv tlv1 = IPReachabilityInformationTlv.of((byte) 0x17, value1, (short) 4);
+ private final IPReachabilityInformationTlv sameAsTlv1 = IPReachabilityInformationTlv
+ .of((byte) 0x17, value1, (short) 4);
+ private final IPReachabilityInformationTlv tlv2 = IPReachabilityInformationTlv.of((byte) 0x05, value2, (short) 1);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.bgpio.types.IPv4AddressTlv;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for IPv4Address Tlv.
+ */
+public class IPv4AddressTest {
+ private final Ip4Address value1 = Ip4Address.valueOf("127.0.0.1");
+ private final Ip4Address value2 = Ip4Address.valueOf("127.0.0.1");
+ private final IPv4AddressTlv tlv1 = IPv4AddressTlv.of(value1, (short) 259);
+ private final IPv4AddressTlv sameAsTlv1 = IPv4AddressTlv.of(value1, (short) 259);
+ private final IPv4AddressTlv tlv2 = IPv4AddressTlv.of(value2, (short) 260);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onlab.packet.Ip6Address;
+import org.onosproject.bgpio.types.IPv6AddressTlv;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for IPv6Address Tlv.
+ */
+public class IPv6AddressTest {
+ private final Ip6Address value1 = Ip6Address.valueOf("2001:db8:0:0:0:0:2:1");
+ private final Ip6Address value2 = Ip6Address.valueOf("2001:db8:0:0:0:0:2:1");
+ private final IPv6AddressTlv tlv1 = IPv6AddressTlv.of(value1, (short) 261);
+ private final IPv6AddressTlv sameAsTlv1 = IPv6AddressTlv.of(value1, (short) 261);
+ private final IPv6AddressTlv tlv2 = IPv6AddressTlv.of(value2, (short) 262);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.IsIsNonPseudonode;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for IsIsNonPseudonode Tlv.
+ */
+public class IsIsNonPseudonodeTest {
+ private final byte[] value1 = new byte[] {0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58};
+ private final byte[] value2 = new byte[] {0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x59};
+ private final IsIsNonPseudonode tlv1 = IsIsNonPseudonode.of(value1);
+ private final IsIsNonPseudonode sameAsTlv1 = IsIsNonPseudonode.of(value1);
+ private final IsIsNonPseudonode tlv2 = IsIsNonPseudonode.of(value2);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.IsIsPseudonode;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for IsIsPseudonode Tlv.
+ */
+public class IsIsPseudonodeTest {
+ private final byte[] value1 = new byte[] {0x01, 0x02, 0x01, 0x02, 0x01, 0x02};
+ private final byte[] value2 = new byte[] {0x01, 0x02, 0x01, 0x02, 0x01, 0x03};
+ private final IsIsPseudonode tlv1 = IsIsPseudonode.of(value1, (byte) 1);
+ private final IsIsPseudonode sameAsTlv1 = IsIsPseudonode.of(value1, (byte) 1);
+ private final IsIsPseudonode tlv2 = IsIsPseudonode.of(value2, (byte) 1);
+
+ @Test
+ public void testEquality() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.LinkLocalRemoteIdentifiersTlv;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for LinkLocalRemoteIdentifiers Tlv.
+ */
+public class LinkLocalRemoteIdentifiersTest {
+ private final int value1 = 0x12101010;
+ private final int value2 = 0x12101012;
+ private final LinkLocalRemoteIdentifiersTlv tlv1 = LinkLocalRemoteIdentifiersTlv.of(value1, value2);
+ private final LinkLocalRemoteIdentifiersTlv sameAsTlv1 = LinkLocalRemoteIdentifiersTlv.of(value1, value2);
+ private final LinkLocalRemoteIdentifiersTlv tlv2 = LinkLocalRemoteIdentifiersTlv.of(value2, value1);
+
+ @Test
+ public void testEquality() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.Origin;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for Origin BGP Path Attribute.
+ */
+public class OriginTest {
+ private final byte value1 = 0x01;
+ private final byte value2 = 0x02;
+ private final Origin attr1 = new Origin(value1);
+ private final Origin sameAsAttr1 = new Origin(value1);
+ private final Origin attr2 = new Origin(value2);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(attr1, sameAsAttr1)
+ .addEqualityGroup(attr2)
+ .testEquals();
+ }
+}
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.OSPFNonPseudonode;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for OSPFNonPseudonode Tlv.
+ */
+public class OspfNonPseudonodeTest {
+ private final int value1 = 0x12121212;
+ private final int value2 = 0x12121211;
+ private final OSPFNonPseudonode tlv1 = OSPFNonPseudonode.of(value1);
+ private final OSPFNonPseudonode sameAsTlv1 = OSPFNonPseudonode.of(value1);
+ private final OSPFNonPseudonode tlv2 = OSPFNonPseudonode.of(value2);
+
+ @Test
+ public void basics() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onlab.packet.Ip4Address;
+import org.onosproject.bgpio.types.OSPFPseudonode;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for OSPFPseudonode Tlv.
+ */
+public class OspfPseudonodeTest {
+ private final int value1 = 0xc3223409;
+ private final int value2 = 0xc3223406;
+ private final Ip4Address drInterface1 = Ip4Address.valueOf(0xaf91e01);
+ private final Ip4Address drInterface2 = Ip4Address.valueOf(0xaf91e02);
+ private final OSPFPseudonode tlv1 = OSPFPseudonode.of(value1, drInterface1);
+ private final OSPFPseudonode sameAsTlv1 = OSPFPseudonode.of(value1, drInterface1);
+ private final OSPFPseudonode tlv2 = OSPFPseudonode.of(value2, drInterface2);
+
+ @Test
+ public void testEquality() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.bgp;
+
+import org.junit.Test;
+import org.onosproject.bgpio.types.OSPFRouteTypeTlv;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test for OSPFRouteType Tlv.
+ */
+public class OspfRouteTypeTest {
+ private final byte value1 = 5;
+ private final byte value2 = 4;
+ private final OSPFRouteTypeTlv tlv1 = OSPFRouteTypeTlv.of(value1);
+ private final OSPFRouteTypeTlv sameAsTlv1 = OSPFRouteTypeTlv.of(value1);
+ private final OSPFRouteTypeTlv tlv2 = OSPFRouteTypeTlv.of(value2);
+
+ @Test
+ public void testEquality() {
+ new EqualsTester()
+ .addEqualityGroup(tlv1, sameAsTlv1)
+ .addEqualityGroup(tlv2)
+ .testEquals();
+ }
+}
\ No newline at end of file
import org.jboss.netty.handler.codec.frame.FrameDecoder;
import org.onosproject.bgpio.protocol.BGPMessage;
import org.onlab.util.HexDump;
+import org.onosproject.bgpio.protocol.BGPFactories;
+import org.onosproject.bgpio.protocol.BGPMessageReader;
+import org.onosproject.bgpio.types.BGPHeader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception {
-
- List<BGPMessage> msgList = new LinkedList<BGPMessage>();
-
log.debug("MESSAGE IS RECEIVED.");
if (!channel.isConnected()) {
log.info("Channel is not connected.");
HexDump.dump(buffer);
- // TODO: decode bgp messages
+ BGPMessageReader<BGPMessage> reader = BGPFactories.getGenericReader();
+ List<BGPMessage> msgList = new LinkedList<BGPMessage>();
+
+ while (buffer.readableBytes() > 0) {
+ BGPHeader bgpHeader = new BGPHeader();
+ BGPMessage message = reader.readFrom(buffer, bgpHeader);
+ msgList.add(message);
+ }
return msgList;
}
}
\ No newline at end of file
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.net.Link;
+import org.onosproject.net.PortNumber;
import org.onosproject.net.flow.DefaultTrafficSelector;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.TrafficSelector;
required = false, multiValued = false)
private String pushVlan = null;
- @Option(name = "--setQueue", description = "Set Queue ID",
+ @Option(name = "--setQueue", description = "Set Queue ID (for OpenFlow 1.0, " +
+ "also the port has to be specified, i.e., <port>/<queue>",
required = false, multiValued = false)
private String setQueue = null;
emptyTreatment = false;
}
if (!isNullOrEmpty(setQueue)) {
- treatmentBuilder.setQueue(Long.parseLong(setQueue));
+ // OpenFlow 1.0 notation (for ENQUEUE): <port>/<queue>
+ if (setQueue.contains("/")) {
+ String[] queueConfig = setQueue.split("/");
+ PortNumber port = PortNumber.portNumber(Long.parseLong(queueConfig[0]));
+ long queueId = Long.parseLong(queueConfig[1]);
+ treatmentBuilder.setQueue(queueId, port);
+ } else {
+ treatmentBuilder.setQueue(Long.parseLong(setQueue));
+ }
emptyTreatment = false;
}
*/
Set<Permission> getPermissions(ApplicationId appId);
+ /**
+ * Registers application pre-deactivation processing hook.
+ *
+ * @param appId application identifier
+ * @param hook pre-deactivation hook
+ */
+ void registerDeactivateHook(ApplicationId appId, Runnable hook);
}
@Override
public int hashCode() {
- return Objects.hash(name);
+ return name.hashCode();
}
/**
import java.util.Objects;
import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
/**
* Default implementation of a controller instance descriptor.
* @param tcpPort TCP port
*/
public DefaultControllerNode(NodeId id, IpAddress ip, int tcpPort) {
- this.id = id;
+ this.id = checkNotNull(id);
this.ip = ip;
this.tcpPort = tcpPort;
}
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id.hashCode();
}
@Override
/**
* Returns an existing application id from a given id.
+ *
* @param id the short value of the id
* @return an application id
*/
/**
* Returns an existing application id from a given id.
+ *
* @param name the name portion of the ID to look up
* @return an application id
*/
* to follow the reverse DNS convention, e.g.
* {@code org.flying.circus.app}
*
- * @param identifier string identifier
+ * @param name string identifier
+ * @return the application id
+ */
+ ApplicationId registerApplication(String name);
+
+ /**
+ * Registers a new application by its name, which is expected
+ * to follow the reverse DNS convention, e.g.
+ * {@code org.flying.circus.app}, along with its pre-deactivation hook.
+ *
+ * @param name string identifier
+ * @param preDeactivate pre-deactivation hook
* @return the application id
*/
- ApplicationId registerApplication(String identifier);
+ ApplicationId registerApplication(String name, Runnable preDeactivate);
/**
* Returns an id generator for a given topic.
@Override
public int hashCode() {
- return Objects.hash(id);
+ return Short.hashCode(id);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id;
}
@Override
@Override
public int hashCode() {
- return Objects.hash(format);
+ return format.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(links);
+ return links.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(str);
+ return str.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(name);
+ return name.hashCode();
}
@Override
@Override
public Builder setQueue(long queueId) {
- return add(Instructions.setQueue(queueId));
+ return add(Instructions.setQueue(queueId, null));
+ }
+
+ @Override
+ public Builder setQueue(long queueId, PortNumber port) {
+ return add(Instructions.setQueue(queueId, port));
}
@Override
*/
Builder setQueue(long queueId);
+ /**
+ * Sets the Queue ID for a specific port.
+ *
+ * @param queueId a queue ID
+ * @param port a port number
+ * @return a treatment builder
+ */
+ Builder setQueue(long queueId, PortNumber port);
+
/**
* Sets a meter to be used by this flow.
*
*/
package org.onosproject.net.flow.instructions;
+import com.google.common.base.MoreObjects;
import org.onlab.packet.EthType;
import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
* Creates a set-queue instruction.
*
* @param queueId Queue Id
+ * @param port Port number
* @return set-queue instruction
*/
- public static SetQueueInstruction setQueue(final long queueId) {
+ public static SetQueueInstruction setQueue(final long queueId, final PortNumber port) {
checkNotNull(queueId, "queue ID cannot be null");
- return new SetQueueInstruction(queueId);
+ return new SetQueueInstruction(queueId, port);
}
public static MeterInstruction meterTraffic(final MeterId meterId) {
@Override
public int hashCode() {
- return Objects.hash(type().ordinal());
+ return type().ordinal();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(type().ordinal());
+ return type().ordinal();
}
@Override
*/
public static final class SetQueueInstruction implements Instruction {
private final long queueId;
+ private final PortNumber port;
private SetQueueInstruction(long queueId) {
this.queueId = queueId;
+ this.port = null;
+ }
+
+ private SetQueueInstruction(long queueId, PortNumber port) {
+ this.queueId = queueId;
+ this.port = port;
}
public long queueId() {
return queueId;
}
+ public PortNumber port() {
+ return port;
+ }
+
@Override
public Type type() {
return Type.QUEUE;
@Override
public String toString() {
- return toStringHelper(type().toString())
- .add("queueId", queueId).toString();
+ MoreObjects.ToStringHelper toStringHelper = toStringHelper(type().toString());
+ toStringHelper.add("queueId", queueId);
+
+ if (port() != null) {
+ toStringHelper.add("port", port);
+ }
+ return toStringHelper.toString();
}
@Override
public int hashCode() {
- return Objects.hash(type().ordinal(), queueId);
+ return Objects.hash(type().ordinal(), queueId, port);
}
@Override
}
if (obj instanceof SetQueueInstruction) {
SetQueueInstruction that = (SetQueueInstruction) obj;
- return Objects.equals(queueId, that.queueId);
+ return Objects.equals(queueId, that.queueId) && Objects.equals(port, that.port);
}
return false;
@Override
public int hashCode() {
- return Objects.hash(lambda);
+ return lambda.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(oduSignalId);
+ return oduSignalId.hashCode();
}
@Override
*/
@Override
public int hashCode() {
- return super.hashCode() + Objects.hash(id);
+ return Objects.hash(super.hashCode(), id);
}
/*
@Override
public int hashCode() {
- return Objects.hash(bandwidth);
+ return bandwidth.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(lambda);
+ return Objects.hashCode(lambda);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(latency);
+ return latency.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(obstacles);
+ return obstacles.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(waypoints);
+ return waypoints.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(bandwidth);
+ return bandwidth.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(bandwidth);
+ return bandwidth.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(lambda);
+ return Objects.hashCode(lambda);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(mplsLabel);
+ return Objects.hashCode(mplsLabel);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id;
}
@Override
import java.util.Objects;
import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
/**
* Implementation of the topology edge backed by a link.
public DefaultTopologyEdge(TopologyVertex src, TopologyVertex dst, Link link) {
this.src = src;
this.dst = dst;
- this.link = link;
+ this.link = checkNotNull(link);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(link);
+ return link.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(deviceId);
+ return deviceId.hashCode();
}
@Override
}
@Override
public int hashCode() {
- return Objects.hash(unixTimestamp);
+ return Long.hashCode(unixTimestamp);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id.hashCode();
}
@Override
import com.google.common.collect.Sets;
-import java.text.DecimalFormat;
+import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
*/
public class PropertyPanel {
- private static final DecimalFormat DF0 = new DecimalFormat("#,###");
+ private static final NumberFormat NF = NumberFormat.getInstance();
private String title;
private String typeId;
this.typeId = typeId;
}
+ /**
+ * Returns a number formatter to use for formatting integer and long
+ * property values.
+ * <p>
+ * This default implementation uses a formatter for the default
+ * locale. For example:
+ * <pre>
+ * Locale.ENGLISH : 1000 -> "1,000"
+ * Locale.FRENCH : 1000 -> "1 000"
+ * Locale.GERMAN : 1000 -> "1.000"
+ * </pre>
+ *
+ * @return the number formatter
+ */
+ protected NumberFormat formatter() {
+ return NF;
+ }
+
/**
* Adds an ID field to the panel data, to be included in
* the returned JSON data to the client.
* @return self, for chaining
*/
public PropertyPanel addProp(String key, int value) {
- properties.add(new Prop(key, DF0.format(value)));
+ properties.add(new Prop(key, formatter().format(value)));
return this;
}
* @return self, for chaining
*/
public PropertyPanel addProp(String key, long value) {
- properties.add(new Prop(key, DF0.format(value)));
+ properties.add(new Prop(key, formatter().format(value)));
return this;
}
return null;
}
+ @Override
+ public void registerDeactivateHook(ApplicationId appId, Runnable hook) {
+ }
+
@Override
public void addListener(ApplicationListener listener) {
}
}
@Override
- public ApplicationId registerApplication(String identifier) {
+ public ApplicationId registerApplication(String name) {
+ return null;
+ }
+
+ @Override
+ public ApplicationId registerApplication(String name, Runnable preDeactivate) {
return null;
}
new MplsLabelResourceAllocation(MplsLabel.valueOf(10)));
}
+ @Override
public IntentId intentId() {
return null;
}
+ @Override
public Collection<Link> links() {
return null;
}
+ @Override
public Set<ResourceRequest> resources() {
return null;
}
@Override
public int hashCode() {
- return Objects.hash(priority);
+ return priority;
}
@Override
import org.junit.Test;
import org.onosproject.ui.topo.PropertyPanel.Prop;
+import java.text.NumberFormat;
import java.util.HashMap;
import java.util.Iterator;
+import java.util.Locale;
import java.util.Map;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
/**
* Unit tests for {@link PropertyPanel}.
*/
public class PropertyPanelTest {
+ // Modified property panel subclass to use ENGLISH locale formatter so
+ // we know formatted numbers will use comma for the thousand separator.
+ private static final class EnglishPropertyPanel extends PropertyPanel {
+ private static final NumberFormat ENGLISH_FORMATTER =
+ NumberFormat.getInstance(Locale.ENGLISH);
+
+ public EnglishPropertyPanel(String title, String typeId) {
+ super(title, typeId);
+ }
+
+ @Override
+ protected NumberFormat formatter() {
+ return ENGLISH_FORMATTER;
+ }
+ }
+
private static final String TITLE_ORIG = "Original Title";
private static final String TYPE_ORIG = "Original type ID";
private static final String TITLE_NEW = "New Title";
@Test
public void basic() {
- pp = new PropertyPanel(TITLE_ORIG, TYPE_ORIG);
+ pp = new EnglishPropertyPanel(TITLE_ORIG, TYPE_ORIG);
assertEquals("wrong title", TITLE_ORIG, pp.title());
assertEquals("wrong type", TYPE_ORIG, pp.typeId());
assertNull("id?", pp.id());
}
@Override
public int hashCode() {
- return Objects.hash(nanoTimestamp);
+ return Long.hashCode(nanoTimestamp);
}
@Override
*/
package org.onosproject.app.impl;
+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.onosproject.app.ApplicationState;
import org.onosproject.app.ApplicationStore;
import org.onosproject.app.ApplicationStoreDelegate;
-import org.onosproject.event.AbstractListenerManager;
import org.onosproject.core.Application;
import org.onosproject.core.ApplicationId;
+import org.onosproject.event.AbstractListenerManager;
import org.onosproject.security.Permission;
import org.onosproject.security.SecurityUtil;
import org.slf4j.Logger;
import java.io.InputStream;
+import java.util.Map;
import java.util.Set;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.onosproject.app.ApplicationEvent.Type.*;
-import static org.onosproject.security.AppPermission.Type.*;
import static org.onosproject.security.AppGuard.checkPermission;
+import static org.onosproject.security.AppPermission.Type.APP_READ;
import static org.slf4j.LoggerFactory.getLogger;
/**
private boolean initializing;
+ // Application supplied hooks for pre-activation processing.
+ private final Map<String, Runnable> deactivateHooks = Maps.newConcurrentMap();
+
@Activate
public void activate() {
eventDispatcher.addSink(ApplicationEvent.class, listenerRegistry);
return store.getPermissions(appId);
}
+ @Override
+ public void registerDeactivateHook(ApplicationId appId, Runnable hook) {
+ checkPermission(APP_READ);
+ checkNotNull(appId, APP_ID_NULL);
+ checkNotNull(hook, "Hook cannot be null");
+ deactivateHooks.put(appId.name(), hook);
+ }
+
@Override
public Application install(InputStream appDescStream) {
checkNotNull(appDescStream, "Application archive stream cannot be null");
private synchronized boolean uninstallAppFeatures(Application app) throws Exception {
boolean changed = false;
+ invokeHook(deactivateHooks.get(app.id().name()), app.id());
for (String name : app.features()) {
Feature feature = featuresService.getFeature(name);
if (feature != null && featuresService.isInstalled(feature)) {
return changed;
}
+ // Invokes the specified function, if not null.
+ private void invokeHook(Runnable hook, ApplicationId appId) {
+ if (hook != null) {
+ try {
+ hook.run();
+ } catch (Exception e) {
+ log.warn("Deactivate hook for application {} encountered an error",
+ appId.name(), e);
+ }
+ }
+ }
+
}
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onlab.util.SharedExecutors;
+import org.onosproject.app.ApplicationService;
import org.onosproject.cfg.ComponentConfigService;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.ApplicationIdStore;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Strings.isNullOrEmpty;
import static org.onosproject.security.AppGuard.checkPermission;
-import static org.onosproject.security.AppPermission.Type.*;
+import static org.onosproject.security.AppPermission.Type.APP_READ;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected IdBlockStore idBlockStore;
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ApplicationService appService;
+
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected ComponentConfigService cfgService;
@Override
public Version version() {
checkPermission(APP_READ);
-
return version;
}
@Override
public Set<ApplicationId> getAppIds() {
checkPermission(APP_READ);
-
return applicationIdStore.getAppIds();
}
@Override
public ApplicationId getAppId(Short id) {
checkPermission(APP_READ);
-
return applicationIdStore.getAppId(id);
}
@Override
public ApplicationId getAppId(String name) {
checkPermission(APP_READ);
-
return applicationIdStore.getAppId(name);
}
return applicationIdStore.registerApplication(name);
}
+ @Override
+ public ApplicationId registerApplication(String name, Runnable preDeactivate) {
+ ApplicationId id = registerApplication(name);
+ appService.registerDeactivateHook(id, preDeactivate);
+ return id;
+ }
+
@Override
public IdGenerator getIdGenerator(String topic) {
IdBlockAllocator allocator = new StoreBasedIdBlockAllocator(topic, idBlockStore);
*/
private static Integer getIntegerProperty(Dictionary<?, ?> properties,
String propertyName) {
- Integer value = null;
+ Integer value;
try {
String s = (String) properties.get(propertyName);
- value = isNullOrEmpty(s) ? value : Integer.parseInt(s.trim());
+ value = isNullOrEmpty(s) ? null : Integer.parseInt(s.trim());
} catch (NumberFormatException | ClassCastException e) {
value = null;
}
checkNotNull(consumer);
checkNotNull(resources);
- // TODO: implement support of resource hierarchy
- // allocation for a particular resource implies allocations for all of the sub-resources need to be done
-
boolean success = store.allocate(resources, consumer);
if (!success) {
return ImmutableList.of();
/**
* A class registering resources when they are detected.
*/
-@Component(immediate = true, enabled = false)
+@Component(immediate = true)
@Beta
public final class ResourceRegistrar {
import org.onosproject.app.ApplicationState;
import org.onosproject.app.ApplicationStoreAdapter;
import org.onosproject.common.app.ApplicationArchive;
+import org.onosproject.common.event.impl.TestEventDispatcher;
import org.onosproject.core.Application;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.DefaultApplication;
import org.onosproject.core.DefaultApplicationId;
-import org.onosproject.common.event.impl.TestEventDispatcher;
import java.io.InputStream;
import java.net.URI;
import java.util.Optional;
import java.util.Set;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
import static org.onosproject.app.ApplicationEvent.Type.*;
import static org.onosproject.app.ApplicationState.ACTIVE;
import static org.onosproject.app.ApplicationState.INSTALLED;
private ApplicationManager mgr = new ApplicationManager();
private ApplicationListener listener = new TestListener();
+ private boolean deactivated = false;
+
@Before
public void setUp() {
injectEventDispatcher(mgr, new TestEventDispatcher());
assertEquals("incorrect app count", 1, mgr.getApplications().size());
assertEquals("incorrect app", app, mgr.getApplication(APP_ID));
assertEquals("incorrect app state", INSTALLED, mgr.getState(APP_ID));
+ mgr.registerDeactivateHook(app.id(), this::deactivateHook);
+ }
+
+ private void deactivateHook() {
+ deactivated = true;
}
@Test
install();
mgr.activate(APP_ID);
assertEquals("incorrect app state", ACTIVE, mgr.getState(APP_ID));
+ assertFalse("preDeactivate hook wrongly called", deactivated);
}
@Test
activate();
mgr.deactivate(APP_ID);
assertEquals("incorrect app state", INSTALLED, mgr.getState(APP_ID));
+ assertTrue("preDeactivate hook not called", deactivated);
}
@Override
public int hashCode() {
- return Objects.hash(value);
+ return Long.hashCode(value);
}
@Override
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id;
}
@Override
import org.onosproject.store.service.Serializer;
import org.onosproject.store.service.StorageService;
import org.onosproject.store.service.TransactionContext;
-import org.onosproject.store.service.TransactionException;
import org.onosproject.store.service.TransactionalMap;
import org.onosproject.store.service.Versioned;
import org.slf4j.Logger;
TransactionContext tx = service.transactionContextBuilder().build();
tx.begin();
- try {
- TransactionalMap<ResourcePath, List<ResourcePath>> childTxMap =
- tx.getTransactionalMap(CHILD_MAP, SERIALIZER);
+ TransactionalMap<ResourcePath, List<ResourcePath>> childTxMap =
+ tx.getTransactionalMap(CHILD_MAP, SERIALIZER);
- Map<ResourcePath, List<ResourcePath>> resourceMap = resources.stream()
- .filter(x -> x.parent().isPresent())
- .collect(Collectors.groupingBy(x -> x.parent().get()));
+ Map<ResourcePath, List<ResourcePath>> resourceMap = resources.stream()
+ .filter(x -> x.parent().isPresent())
+ .collect(Collectors.groupingBy(x -> x.parent().get()));
- for (Map.Entry<ResourcePath, List<ResourcePath>> entry: resourceMap.entrySet()) {
- if (!isRegistered(childTxMap, entry.getKey())) {
- return abortTransaction(tx);
- }
-
- if (!appendValues(childTxMap, entry.getKey(), entry.getValue())) {
- return abortTransaction(tx);
- }
+ for (Map.Entry<ResourcePath, List<ResourcePath>> entry: resourceMap.entrySet()) {
+ if (!isRegistered(childTxMap, entry.getKey())) {
+ return abortTransaction(tx);
}
- return commitTransaction(tx);
- } catch (TransactionException e) {
- log.error("Exception thrown, abort the transaction", e);
- return abortTransaction(tx);
+ if (!appendValues(childTxMap, entry.getKey(), entry.getValue())) {
+ return abortTransaction(tx);
+ }
}
+
+ return tx.commit();
}
@Override
TransactionContext tx = service.transactionContextBuilder().build();
tx.begin();
- try {
- TransactionalMap<ResourcePath, List<ResourcePath>> childTxMap =
- tx.getTransactionalMap(CHILD_MAP, SERIALIZER);
- TransactionalMap<ResourcePath, ResourceConsumer> consumerTxMap =
- tx.getTransactionalMap(CONSUMER_MAP, SERIALIZER);
-
- Map<ResourcePath, List<ResourcePath>> resourceMap = resources.stream()
- .filter(x -> x.parent().isPresent())
- .collect(Collectors.groupingBy(x -> x.parent().get()));
-
- // even if one of the resources is allocated to a consumer,
- // all unregistrations are regarded as failure
- for (Map.Entry<ResourcePath, List<ResourcePath>> entry: resourceMap.entrySet()) {
- if (entry.getValue().stream().anyMatch(x -> consumerTxMap.get(x) != null)) {
- return abortTransaction(tx);
- }
-
- if (!removeValues(childTxMap, entry.getKey(), entry.getValue())) {
- return abortTransaction(tx);
- }
+ TransactionalMap<ResourcePath, List<ResourcePath>> childTxMap =
+ tx.getTransactionalMap(CHILD_MAP, SERIALIZER);
+ TransactionalMap<ResourcePath, ResourceConsumer> consumerTxMap =
+ tx.getTransactionalMap(CONSUMER_MAP, SERIALIZER);
+
+ Map<ResourcePath, List<ResourcePath>> resourceMap = resources.stream()
+ .filter(x -> x.parent().isPresent())
+ .collect(Collectors.groupingBy(x -> x.parent().get()));
+
+ // even if one of the resources is allocated to a consumer,
+ // all unregistrations are regarded as failure
+ for (Map.Entry<ResourcePath, List<ResourcePath>> entry: resourceMap.entrySet()) {
+ if (entry.getValue().stream().anyMatch(x -> consumerTxMap.get(x) != null)) {
+ return abortTransaction(tx);
}
- return commitTransaction(tx);
- } catch (TransactionException e) {
- log.error("Exception thrown, abort the transaction", e);
- return abortTransaction(tx);
+ if (!removeValues(childTxMap, entry.getKey(), entry.getValue())) {
+ return abortTransaction(tx);
+ }
}
+
+ return tx.commit();
}
@Override
TransactionContext tx = service.transactionContextBuilder().build();
tx.begin();
- try {
- TransactionalMap<ResourcePath, List<ResourcePath>> childTxMap =
- tx.getTransactionalMap(CHILD_MAP, SERIALIZER);
- TransactionalMap<ResourcePath, ResourceConsumer> consumerTxMap =
- tx.getTransactionalMap(CONSUMER_MAP, SERIALIZER);
-
- for (ResourcePath resource: resources) {
- if (!isRegistered(childTxMap, resource)) {
- return abortTransaction(tx);
- }
-
- ResourceConsumer oldValue = consumerTxMap.put(resource, consumer);
- if (oldValue != null) {
- return abortTransaction(tx);
- }
+ TransactionalMap<ResourcePath, List<ResourcePath>> childTxMap =
+ tx.getTransactionalMap(CHILD_MAP, SERIALIZER);
+ TransactionalMap<ResourcePath, ResourceConsumer> consumerTxMap =
+ tx.getTransactionalMap(CONSUMER_MAP, SERIALIZER);
+
+ for (ResourcePath resource: resources) {
+ if (!isRegistered(childTxMap, resource)) {
+ return abortTransaction(tx);
}
- return commitTransaction(tx);
- } catch (TransactionException e) {
- log.error("Exception thrown, abort the transaction", e);
- return abortTransaction(tx);
+ ResourceConsumer oldValue = consumerTxMap.put(resource, consumer);
+ if (oldValue != null) {
+ return abortTransaction(tx);
+ }
}
+
+ return tx.commit();
}
@Override
TransactionContext tx = service.transactionContextBuilder().build();
tx.begin();
- try {
- TransactionalMap<ResourcePath, ResourceConsumer> consumerTxMap =
- tx.getTransactionalMap(CONSUMER_MAP, SERIALIZER);
- Iterator<ResourcePath> resourceIte = resources.iterator();
- Iterator<ResourceConsumer> consumerIte = consumers.iterator();
-
- while (resourceIte.hasNext() && consumerIte.hasNext()) {
- ResourcePath resource = resourceIte.next();
- ResourceConsumer consumer = consumerIte.next();
-
- // if this single release fails (because the resource is allocated to another consumer,
- // the whole release fails
- if (!consumerTxMap.remove(resource, consumer)) {
- return abortTransaction(tx);
- }
- }
+ TransactionalMap<ResourcePath, ResourceConsumer> consumerTxMap =
+ tx.getTransactionalMap(CONSUMER_MAP, SERIALIZER);
+ Iterator<ResourcePath> resourceIte = resources.iterator();
+ Iterator<ResourceConsumer> consumerIte = consumers.iterator();
+
+ while (resourceIte.hasNext() && consumerIte.hasNext()) {
+ ResourcePath resource = resourceIte.next();
+ ResourceConsumer consumer = consumerIte.next();
- return commitTransaction(tx);
- } catch (TransactionException e) {
- log.error("Exception thrown, abort the transaction", e);
- return abortTransaction(tx);
+ // if this single release fails (because the resource is allocated to another consumer,
+ // the whole release fails
+ if (!consumerTxMap.remove(resource, consumer)) {
+ return abortTransaction(tx);
+ }
}
+
+ return tx.commit();
}
@Override
return false;
}
- /**
- * Commit the transaction.
- *
- * @param tx transaction context
- * @return always true
- */
- private boolean commitTransaction(TransactionContext tx) {
- tx.commit();
- return true;
- }
-
/**
* Appends the values to the existing values associated with the specified key.
* If the map already has all the given values, appending will not happen.
import org.onosproject.store.service.Serializer;
import org.onosproject.store.service.StorageService;
import org.onosproject.store.service.TransactionContext;
-import org.onosproject.store.service.TransactionException;
import org.onosproject.store.service.TransactionalMap;
import org.onosproject.store.service.Versioned;
intentAllocs.put(allocations.intentId(), allocations);
allocations.links().forEach(link -> allocateLinkResource(tx, link, allocations));
tx.commit();
- } catch (TransactionException | ResourceAllocationException e) {
+ } catch (ResourceAllocationException e) {
log.error("Exception thrown, rolling back", e);
tx.abort();
} catch (Exception e) {
after.remove(allocations);
linkAllocs.replace(linkId, before, after);
});
- tx.commit();
- success = true;
- } catch (TransactionException e) {
- log.debug("Transaction failed, retrying", e);
- tx.abort();
- } catch (Exception e) {
+ success = tx.commit();
+ } catch (Exception e) {
log.error("Exception thrown during releaseResource {}", allocations, e);
tx.abort();
throw e;
import static org.slf4j.LoggerFactory.getLogger;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.onlab.packet.VlanId;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
import org.onosproject.net.flow.DefaultFlowRule;
import org.onosproject.net.flow.DefaultTrafficSelector;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.FlowRuleOperationsContext;
import org.onosproject.net.flow.TrafficSelector;
import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.PortCriterion;
+import org.onosproject.net.flow.criteria.VlanIdCriterion;
import org.slf4j.Logger;
private final Logger log = getLogger(getClass());
+ @Override
+ protected List<FlowRule> processVlanIdFilter(PortCriterion portCriterion,
+ VlanIdCriterion vidCriterion,
+ VlanId assignedVlan,
+ ApplicationId applicationId) {
+ List<FlowRule> rules = new ArrayList<FlowRule>();
+ TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
+ TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
+ selector.matchVlanId(vidCriterion.vlanId());
+ if (vidCriterion.vlanId() == VlanId.NONE) {
+ // untagged packets are assigned vlans
+ treatment.pushVlan().setVlanId(assignedVlan);
+ }
+ treatment.transition(TMAC_TABLE);
+
+ // ofdpa cannot match on ALL portnumber, so we need to use separate
+ // rules for each port.
+ List<PortNumber> portnums = new ArrayList<PortNumber>();
+ if (portCriterion.port() == PortNumber.ALL) {
+ for (Port port : deviceService.getPorts(deviceId)) {
+ if (port.number().toLong() > 0 && port.number().toLong() < OFPP_MAX) {
+ portnums.add(port.number());
+ }
+ }
+ } else {
+ portnums.add(portCriterion.port());
+ }
+ for (PortNumber pnum : portnums) {
+ selector.matchInPort(pnum);
+ FlowRule rule = DefaultFlowRule.builder()
+ .forDevice(deviceId)
+ .withSelector(selector.build())
+ .withTreatment(treatment.build())
+ .withPriority(DEFAULT_PRIORITY)
+ .fromApp(applicationId)
+ .makePermanent()
+ .forTable(VLAN_TABLE).build();
+ rules.add(rule);
+ }
+ return rules;
+ }
+
+
@Override
protected void initializePipeline() {
processPortTable();
+ // vlan table processing not required, as default is to drop packets
+ // which can be accomplished without a table-miss-entry.
processTmacTable();
processIpTable();
+ processMplsTable();
processBridgingTable();
processAclTable();
- // XXX implement table miss entries and default groups
- //processVlanTable();
- //processMPLSTable();
- //processGroupTable();
}
@Override
}));
}
+ @Override
+ protected void processMplsTable() {
+ //table miss entry
+ FlowRuleOperations.Builder ops = FlowRuleOperations.builder();
+ TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
+ TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
+ selector = DefaultTrafficSelector.builder();
+ treatment = DefaultTrafficTreatment.builder();
+ treatment.transition(MPLS_TABLE_1);
+ FlowRule rule = DefaultFlowRule.builder()
+ .forDevice(deviceId)
+ .withSelector(selector.build())
+ .withTreatment(treatment.build())
+ .withPriority(LOWEST_PRIORITY)
+ .fromApp(driverId)
+ .makePermanent()
+ .forTable(MPLS_TABLE_0).build();
+ ops = ops.add(rule);
+
+ treatment.transition(ACL_TABLE);
+ rule = DefaultFlowRule.builder()
+ .forDevice(deviceId)
+ .withSelector(selector.build())
+ .withTreatment(treatment.build())
+ .withPriority(LOWEST_PRIORITY)
+ .fromApp(driverId)
+ .makePermanent()
+ .forTable(MPLS_TABLE_1).build();
+ ops = ops.add(rule);
+
+ flowRuleService.apply(ops.build(new FlowRuleOperationsContext() {
+ @Override
+ public void onSuccess(FlowRuleOperations ops) {
+ log.info("Initialized MPLS tables");
+ }
+
+ @Override
+ public void onError(FlowRuleOperations ops) {
+ log.info("Failed to initialize MPLS tables");
+ }
+ }));
+ }
+
private void processBridgingTable() {
//table miss entry
FlowRuleOperations.Builder ops = FlowRuleOperations.builder();
protected static final long OFPP_MAX = 0xffffff00L;
private static final int HIGHEST_PRIORITY = 0xffff;
- private static final int DEFAULT_PRIORITY = 0x8000;
+ protected static final int DEFAULT_PRIORITY = 0x8000;
protected static final int LOWEST_PRIORITY = 0x0;
/*
if (vidCriterion.vlanId() == VlanId.NONE) {
// untagged packets are assigned vlans
treatment.pushVlan().setVlanId(assignedVlan);
- // XXX ofdpa may require an additional vlan match on the assigned vlan
- // and it may not require the push.
+ // XXX ofdpa will require an additional vlan match on the assigned vlan
+ // and it may not require the push. This is not in compliance with OF
+ // standard. Waiting on what the exact flows are going to look like.
}
treatment.transition(TMAC_TABLE);
@Override
public int hashCode() {
- return 43 * super.hashCode() + Objects.hash(connectPoint);
+ return 43 * super.hashCode() + connectPoint.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(logicId);
+ return Objects.hashCode(logicId);
}
@Override
@Override
public int hashCode() {
- return 31 * super.hashCode() + Objects.hash(networkId);
+ return 31 * super.hashCode() + networkId.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(id);
+ return id.hashCode();
}
@Override
import org.onlab.packet.IpPrefix;
import org.onosproject.common.event.impl.TestEventDispatcher;
import org.onosproject.core.ApplicationId;
-import org.onosproject.core.CoreService;
+import org.onosproject.core.CoreServiceAdapter;
import org.onosproject.core.DefaultApplicationId;
-import org.onosproject.core.IdGenerator;
-import org.onosproject.core.Version;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.PortNumber;
import org.onosproject.net.mcast.McastEvent;
import org.onosproject.store.service.TestStorageService;
import java.util.List;
-import java.util.Set;
import static junit.framework.Assert.fail;
import static junit.framework.TestCase.assertEquals;
public class MulticastRouteManagerTest {
McastRoute r1 = new McastRoute(IpPrefix.valueOf("1.1.1.1/8"),
- IpPrefix.valueOf("1.1.1.2/8"),
- McastRoute.Type.IGMP);
+ IpPrefix.valueOf("1.1.1.2/8"),
+ McastRoute.Type.IGMP);
McastRoute r11 = new McastRoute(IpPrefix.valueOf("1.1.1.1/8"),
- IpPrefix.valueOf("1.1.1.2/8"),
- McastRoute.Type.STATIC);
+ IpPrefix.valueOf("1.1.1.2/8"),
+ McastRoute.Type.STATIC);
McastRoute r2 = new McastRoute(IpPrefix.valueOf("2.2.2.1/8"),
- IpPrefix.valueOf("2.2.2.2/8"),
- McastRoute.Type.PIM);
+ IpPrefix.valueOf("2.2.2.2/8"),
+ McastRoute.Type.PIM);
ConnectPoint cp1 = new ConnectPoint(did("1"), PortNumber.portNumber(1));
injectEventDispatcher(manager, new TestEventDispatcher());
TestUtils.setField(manager, "storageService", new TestStorageService());
TestUtils.setField(manager, "coreService", new TestCoreService());
- events = Lists.newArrayList();
+ events = Lists.newArrayList();
manager.activate();
manager.addListener(listener);
}
for (int i = 0; i < evs.length; i++) {
if (evs[i] != events.get(i).type()) {
- fail(String.format("Mismtached events# obtained -> %s : expected %s",
+ fail(String.format("Mismatched events# obtained -> %s : expected %s",
events, evs));
}
}
}
class TestMulticastListener implements McastListener {
-
@Override
public void event(McastEvent event) {
events.add(event);
}
}
- private class TestCoreService implements CoreService {
- @Override
- public Version version() {
- return null;
- }
-
- @Override
- public Set<ApplicationId> getAppIds() {
- return null;
- }
-
- @Override
- public ApplicationId getAppId(Short id) {
- return null;
- }
-
- @Override
- public ApplicationId getAppId(String name) {
- return null;
- }
-
- @Override
- public ApplicationId registerApplication(String identifier) {
- return new DefaultApplicationId(0, identifier);
- }
-
+ private class TestCoreService extends CoreServiceAdapter {
@Override
- public IdGenerator getIdGenerator(String topic) {
- return null;
+ public ApplicationId registerApplication(String name) {
+ return new DefaultApplicationId(0, name);
}
}
}
return FACTORY13;
}
-
- public Map<String, String> getControllerNodeIPs() {
- // We return a copy of the mapping so we can guarantee that
- // the mapping return is the same as one that will be (or was)
- // dispatched to IHAListeners
- HashMap<String, String> retval = new HashMap<>();
- synchronized (controllerNodeIPsCache) {
- retval.putAll(controllerNodeIPsCache);
- }
- return retval;
- }
-
-
- public long getSystemStartTime() {
- return (this.systemStartTime);
- }
-
// **************
// Initialization
// **************
}
- public Long getUptime() {
+ public Long getSystemUptime() {
RuntimeMXBean rb = ManagementFactory.getRuntimeMXBean();
return rb.getUptime();
}
+ public long getSystemStartTime() {
+ return (this.systemStartTime);
+ }
+
/**
* Forward to the driver-manager to get an IOFSwitch instance.
*
--- /dev/null
+/*
+ * 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.openflow;
+
+import java.net.SocketAddress;
+
+import org.jboss.netty.channel.Channel;
+import org.jboss.netty.channel.ChannelConfig;
+import org.jboss.netty.channel.ChannelFactory;
+import org.jboss.netty.channel.ChannelFuture;
+import org.jboss.netty.channel.ChannelPipeline;
+
+/**
+ * Adapter for testing against a netty channel.
+ */
+public class ChannelAdapter implements Channel {
+ @Override
+ public Integer getId() {
+ return null;
+ }
+
+ @Override
+ public ChannelFactory getFactory() {
+ return null;
+ }
+
+ @Override
+ public Channel getParent() {
+ return null;
+ }
+
+ @Override
+ public ChannelConfig getConfig() {
+ return null;
+ }
+
+ @Override
+ public ChannelPipeline getPipeline() {
+ return null;
+ }
+
+ @Override
+ public boolean isOpen() {
+ return false;
+ }
+
+ @Override
+ public boolean isBound() {
+ return false;
+ }
+
+ @Override
+ public boolean isConnected() {
+ return false;
+ }
+
+ @Override
+ public SocketAddress getLocalAddress() {
+ return null;
+ }
+
+ @Override
+ public SocketAddress getRemoteAddress() {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture write(Object o) {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture write(Object o, SocketAddress socketAddress) {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture bind(SocketAddress socketAddress) {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture connect(SocketAddress socketAddress) {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture disconnect() {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture unbind() {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture close() {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture getCloseFuture() {
+ return null;
+ }
+
+ @Override
+ public int getInterestOps() {
+ return 0;
+ }
+
+ @Override
+ public boolean isReadable() {
+ return false;
+ }
+
+ @Override
+ public boolean isWritable() {
+ return false;
+ }
+
+ @Override
+ public ChannelFuture setInterestOps(int i) {
+ return null;
+ }
+
+ @Override
+ public ChannelFuture setReadable(boolean b) {
+ return null;
+ }
+
+ @Override
+ public Object getAttachment() {
+ return null;
+ }
+
+ @Override
+ public void setAttachment(Object o) {
+
+ }
+
+ @Override
+ public int compareTo(Channel o) {
+ return 0;
+ }
+}
--- /dev/null
+/*
+ * 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.openflow;
+
+import org.jboss.netty.channel.Channel;
+import org.jboss.netty.channel.ChannelEvent;
+import org.jboss.netty.channel.ChannelHandler;
+import org.jboss.netty.channel.ChannelHandlerContext;
+import org.jboss.netty.channel.ChannelPipeline;
+
+/**
+ * Adapter for testing against a netty channel handler context.
+ */
+public class ChannelHandlerContextAdapter implements ChannelHandlerContext {
+ @Override
+ public Channel getChannel() {
+ return null;
+ }
+
+ @Override
+ public ChannelPipeline getPipeline() {
+ return null;
+ }
+
+ @Override
+ public String getName() {
+ return null;
+ }
+
+ @Override
+ public ChannelHandler getHandler() {
+ return null;
+ }
+
+ @Override
+ public boolean canHandleUpstream() {
+ return false;
+ }
+
+ @Override
+ public boolean canHandleDownstream() {
+ return false;
+ }
+
+ @Override
+ public void sendUpstream(ChannelEvent channelEvent) {
+
+ }
+
+ @Override
+ public void sendDownstream(ChannelEvent channelEvent) {
+
+ }
+
+ @Override
+ public Object getAttachment() {
+ return null;
+ }
+
+ @Override
+ public void setAttachment(Object o) {
+
+ }
+}
--- /dev/null
+/*
+ * 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.openflow;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.projectfloodlight.openflow.protocol.OFMessage;
+import org.projectfloodlight.openflow.protocol.OFType;
+import org.projectfloodlight.openflow.protocol.OFVersion;
+
+import com.google.common.hash.PrimitiveSink;
+
+/**
+ * Adapter for testing against an OpenFlow message.
+ */
+public class OfMessageAdapter implements OFMessage {
+ @Override
+ public OFVersion getVersion() {
+ return null;
+ }
+
+ @Override
+ public OFType getType() {
+ return null;
+ }
+
+ @Override
+ public long getXid() {
+ return 0;
+ }
+
+ @Override
+ public void writeTo(ChannelBuffer channelBuffer) { }
+
+ @Override
+ public Builder createBuilder() {
+ return null;
+ }
+
+ @Override
+ public void putTo(PrimitiveSink sink) { }
+}
--- /dev/null
+/*
+ * 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.openflow.controller.impl;
+
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.junit.Test;
+import org.onosproject.openflow.ChannelAdapter;
+import org.onosproject.openflow.ChannelHandlerContextAdapter;
+import org.projectfloodlight.openflow.protocol.OFHello;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
+
+/**
+ * Tests for the OpenFlow message decoder.
+ */
+public class OFMessageDecoderTest {
+
+ static class ConnectedChannel extends ChannelAdapter {
+ @Override
+ public boolean isConnected() {
+ return true;
+ }
+ }
+
+ private ChannelBuffer getHelloMessageBuffer() {
+ // OFHello, OF version 1, xid of 0, total of 8 bytes
+ byte[] messageData = {0x1, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0};
+ ChannelBuffer channelBuffer = ChannelBuffers.dynamicBuffer();
+ channelBuffer.writeBytes(messageData);
+ return channelBuffer;
+ }
+
+ /**
+ * Tests decoding a message on a closed channel.
+ *
+ * @throws Exception when an exception is thrown from the decoder
+ */
+ @Test
+ public void testDecodeNoChannel() throws Exception {
+ OFMessageDecoder decoder = new OFMessageDecoder();
+ ChannelBuffer channelBuffer = getHelloMessageBuffer();
+ Object message =
+ decoder.decode(new ChannelHandlerContextAdapter(),
+ new ChannelAdapter(),
+ channelBuffer);
+ assertThat(message, nullValue());
+ }
+
+ /**
+ * Tests decoding a message.
+ *
+ * @throws Exception when an exception is thrown from the decoder
+ */
+ @Test
+ public void testDecode() throws Exception {
+ OFMessageDecoder decoder = new OFMessageDecoder();
+ ChannelBuffer channelBuffer = getHelloMessageBuffer();
+ Object message =
+ decoder.decode(new ChannelHandlerContextAdapter(),
+ new ConnectedChannel(),
+ channelBuffer);
+ assertThat(message, notNullValue());
+ assertThat(message, instanceOf(OFHello.class));
+ }
+
+}
--- /dev/null
+/*
+ * 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.openflow.controller.impl;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.junit.Test;
+import org.onosproject.openflow.OfMessageAdapter;
+import org.projectfloodlight.openflow.protocol.OFMessage;
+
+import com.google.common.collect.ImmutableList;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+/**
+ * Tests for the OpenFlow message encoder.
+ */
+public class OFMessageEncoderTest {
+
+ static class MockOfMessage extends OfMessageAdapter {
+ static int nextId = 1;
+ final int id;
+
+ MockOfMessage() {
+ id = nextId++;
+ }
+
+ @Override
+ public void writeTo(ChannelBuffer channelBuffer) {
+ String message = "message" + Integer.toString(id) + " ";
+ channelBuffer.writeBytes(message.getBytes(StandardCharsets.UTF_8));
+ }
+ }
+
+ /**
+ * Tests that encoding a non-list returns the object specified.
+ *
+ * @throws Exception on exception in the encoder
+ */
+ @Test
+ public void testNoList() throws Exception {
+ OFMessageEncoder encoder = new OFMessageEncoder();
+ MockOfMessage message = new MockOfMessage();
+ OFMessage returnedMessage =
+ (OFMessage) encoder.encode(null, null, message);
+ assertThat(message, is(returnedMessage));
+ }
+
+ /**
+ * Tests that encoding a list returns the proper encoded payload.
+ *
+ * @throws Exception on exception in the encoder
+ */
+ @Test
+ public void testList() throws Exception {
+ OFMessageEncoder encoder = new OFMessageEncoder();
+ MockOfMessage message1 = new MockOfMessage();
+ MockOfMessage message2 = new MockOfMessage();
+ MockOfMessage message3 = new MockOfMessage();
+ List<MockOfMessage> messages = ImmutableList.of(message1, message2, message3);
+ ChannelBuffer returnedChannel =
+ (ChannelBuffer) encoder.encode(null, null, messages);
+ assertThat(returnedChannel, notNullValue());
+ byte[] channelBytes = returnedChannel.array();
+ String expectedListMessage = "message1 message2 message3 ";
+ String listMessage =
+ (new String(channelBytes, StandardCharsets.UTF_8))
+ .substring(0, expectedListMessage.length());
+ assertThat(listMessage, is(expectedListMessage));
+ }
+}
<groupId>org.onosproject</groupId>
<artifactId>onlab-junit</artifactId>
</dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.11</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-core</artifactId>
+ <version>1.3</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-library</artifactId>
+ <version>1.3</version>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
}
/**
- * Returns the type of the event.
+ * Returns the type of event.
*
* @return event type
*/
}
/**
- * Returns the subject of the event.
+ * Returns the subject of event.
*
* @return subject to which this event pertains
*/
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
import org.onlab.packet.IpAddress;
/**
- * The class representing a OpenStack Compute or Network nodeId. This class is
- * immutable.
+ * The class representing a OpenStack Compute or Network nodeId.
+ * This class is immutable.
*/
public final class OvsdbNodeId {
private static final String SCHEME = "ovsdb";
private final String ipAddress;
/**
- * Creates a new node identifier from a IpAddress ipAddress, a long port.
+ * Creates a new node identifier from an IpAddress ipAddress, a long port.
*
* @param ipAddress node IP address
* @param port node port
@Override
public int hashCode() {
- return Objects.hash(nodeId);
+ return nodeId.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(value);
+ return Objects.hashCode(value);
}
@Override
import java.util.Objects;
/**
- * The class representing a port type. This class is immutable.
+ * The class representing a port type.
+ * This class is immutable.
*/
public class OvsdbPortType {
private final String value;
/**
- * Constructor from a String port type.
+ * Constructor from a String.
*
* @param value the port type to use
*/
}
/**
- * Gets the value of the port type.
+ * Gets the value of port type.
*
- * @return the value of the port type
+ * @return the value of port type
*/
public String value() {
return value;
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(rows);
+ return rows.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(result);
+ return result.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(map);
+ return map.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(set);
+ return set.hashCode();
}
@Override
@Override
public int hashCode() {
- return Objects.hash(value);
+ return value.hashCode();
}
@Override
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_uuid", "getTableUuidColumn");
- return (Column) getColumnHandler(columnDesc);
+ return getColumnHandler(columnDesc);
}
@Override
return null;
}
ColumnDescription columnDesc = new ColumnDescription("_version", "getTableVersionColumn");
- return (Column) getColumnHandler(columnDesc);
+ return getColumnHandler(columnDesc);
}
/**
@Override
public int hashCode() {
- return Objects.hash(row);
+ return row.hashCode();
}
@Override
@Override
public String toString() {
- TableSchema schema = (TableSchema) getTableSchema();
+ TableSchema schema = getTableSchema();
String tableName = schema.name();
return toStringHelper(this).add("tableName", tableName).add("row", row).toString();
}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepCloseMsg;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepErrorMsg;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepInitiateMsg;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
+
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.Is.is;
import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
public class PcepInitiateMsgExtTest {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepInitiateMsg;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Assert;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepKeepaliveMsg;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepLabelUpdateMsg;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.core.Is.is;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
-import org.onosproject.pcepio.protocol.PcepOpenMsg;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
/**
* Test cases for PCEP OPEN Message.
*/
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.core.Is.is;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
-import org.onosproject.pcepio.protocol.PcepReportMsg;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
public class PcepReportMsgExtTest {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
-import org.onosproject.pcepio.protocol.PcepReportMsg;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
-import org.onosproject.pcepio.protocol.PcepTEReportMsg;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.Matchers.instanceOf;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
-import org.onosproject.pcepio.protocol.PcepUpdateMsg;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
/**
* Test cases for PCEP update message.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.core.Is.is;
+package org.onosproject.pcepio.protocol;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
-import static org.hamcrest.MatcherAssert.assertThat;
import org.junit.Test;
import org.onosproject.pcepio.exceptions.PcepParseException;
-import org.onosproject.pcepio.protocol.PcepFactories;
-import org.onosproject.pcepio.protocol.PcepMessage;
-import org.onosproject.pcepio.protocol.PcepMessageReader;
-import org.onosproject.pcepio.protocol.PcepUpdateMsg;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.core.Is.is;
public class PcepUpdateMsgTest {
/**
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.AdministrativeGroupTlv;
/**
* Test of the AdministrativeGroupTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.AutonomousSystemTlv;
/**
* Test of the AutonomousSystemTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.BGPLSidentifierTlv;
/**
* Test of the BGPLSidentifierTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.GmplsCapabilityTlv;
/**
* Test of the GmplsCapabilityTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IGPMetricTlv;
/**
* Test of the IGPMetricTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4InterfaceAddressTlv;
/**
* Test of the IPv4InterfaceAddressTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4NeighborAddressTlv;
/**
* Test of the IPv4NeighborAddressTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4SubObject;
/**
* Test of the IPv4SubObject.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4TERouterIdOfLocalNodeTlv;
/**
* Test of the IPv4TERouterIdOfLocalNodeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4TERouterIdOfRemoteNodeTlv;
/**
* Test of the IPv4TERouterIdOfRemoteNodeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv6InterfaceAddressTlv;
/**
* Test of the IPv6InterfaceAddressTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv6NeighborAddressTlv;
/**
* Test of the IPv6NeighborAddressTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv6SubObject;
/**
* Test of the IPv6SubObject.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv6TERouterIdofLocalNodeTlv;
/**
* Test of the IPv6TERouterIdofLocalNodeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv6TERouterIdofRemoteNodeTlv;
/**
* Test of the IPv6TERouterIdofRemoteNodeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.ISISAreaIdentifierTlv;
/**
* Test of the ISISAreaIdentifierTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.LabelSubObject;
/**
* Test of the LabelSubObject.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.LinkLocalRemoteIdentifiersTlv;
/**
* Test of the LinkLocalRemoteIdentifiersTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.LinkNameTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for LinkNameTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.LinkProtectionTypeTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the LinkProtectionTypeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
import java.util.LinkedList;
-import org.onosproject.pcepio.types.LocalTENodeDescriptorsTlv;
-import org.onosproject.pcepio.types.AutonomousSystemTlv;
-import org.onosproject.pcepio.types.BGPLSidentifierTlv;
-import org.onosproject.pcepio.types.PcepValueType;
-
/**
* Test of the LocalTENodeDescriptorsTlv.
*/
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.MPLSProtocolMaskTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the MPLSProtocolMaskTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.MaximumLinkBandwidthTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the MaximumLinkBandwidthTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.MaximumReservableLinkBandwidthTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the MaximumReservableLinkBandwidthTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.NexthopIPv4addressTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for NexthopIPv4addressTlv.
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.NexthopIPv6addressTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for NexthopIPv6addressTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.NexthopUnnumberedIPv4IDTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for NexthopUnnumberedIPv4IDTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.NodeFlagBitsTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the NodeFlagBitsTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.NodeNameTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the NodeNameTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
-
import org.junit.Test;
-import org.onosproject.pcepio.types.OSPFareaIDsubTlv;
/**
* Test of the OSPFareaIDsubTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.OpaqueLinkAttributeTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the OpaqueLinkAttributeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PathKeySubObject;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the PathKeySubObject.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PathSetupTypeTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the PathSetupTypeTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PceccCapabilityTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test of the PceccCapabilityTlv.
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PcepNaiIpv4Adjacency;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for PcepNaiIpv4Adjacency.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PcepNaiIpv4NodeId;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
public class PcepNaiIpv4NodeIdTest {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PcepNaiIpv6Adjacency;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
public class PcepNaiIpv6AdjacencyTest {
private final byte[] localIpv6Addr1 = {(byte) 0x01010101 };
public void basics() {
new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals();
}
-}
\ No newline at end of file
+}
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PcepNaiIpv6NodeId;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for PcepNaiIpv6NodeId.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.PcepNaiUnnumberedAdjacencyIpv4;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
public class PcepNaiUnnumberedAdjacencyIpv4Test {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import java.util.LinkedList;
+package org.onosproject.pcepio.types;
+import com.google.common.testing.EqualsTester;
import org.junit.Test;
-import org.onosproject.pcepio.types.AutonomousSystemTlv;
-import org.onosproject.pcepio.types.BGPLSidentifierTlv;
-import org.onosproject.pcepio.types.PcepValueType;
-import org.onosproject.pcepio.types.RemoteTENodeDescriptorsTlv;
-import com.google.common.testing.EqualsTester;
+import java.util.LinkedList;
/**
* Test case for Remote TE Node Descriptors tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.RouterIDSubTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for Router ID Sub tlv.
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.RoutingUniverseTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Equality test for RoutingUniverseTlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.SharedRiskLinkGroupTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for Shared Risk Link Group tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
+import com.google.common.testing.EqualsTester;
import org.junit.Test;
import org.onosproject.pcepio.protocol.PcepNai;
-import org.onosproject.pcepio.types.SrEroSubObject;
-
-import com.google.common.testing.EqualsTester;
public class SrEroSubObjectTest {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.StatefulIPv4LspIdentidiersTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
public class StatefulIPv4LspIdentidiersTlvTest {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.StatefulLspDbVerTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for Stateful Lsp Db Ver tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
-import org.junit.Test;
-import org.onosproject.pcepio.types.StatefulLspErrorCodeTlv;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
public class StatefulLspErrorCodeTlvTest {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
-import org.junit.Test;
-import org.onosproject.pcepio.types.StatefulPceCapabilityTlv;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for Stateful Pce Capability tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.SymbolicPathNameTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for Symbolic path tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.TEDefaultMetricTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for TE Default Metric tlv.
public void basics() {
new EqualsTester().addEqualityGroup(tlv1, tlv2).addEqualityGroup(tlv3).testEquals();
}
-}
\ No newline at end of file
+}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import java.util.LinkedList;
+package org.onosproject.pcepio.types;
+import com.google.common.testing.EqualsTester;
import org.junit.Test;
-import org.onosproject.pcepio.types.AdministrativeGroupTlv;
-import org.onosproject.pcepio.types.MaximumReservableLinkBandwidthTlv;
-import org.onosproject.pcepio.types.PcepValueType;
-import org.onosproject.pcepio.types.TELinkAttributesTlv;
-import com.google.common.testing.EqualsTester;
+import java.util.LinkedList;
/**
* Test case for TE Link Attribute Tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import java.util.LinkedList;
+package org.onosproject.pcepio.types;
+import com.google.common.testing.EqualsTester;
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4InterfaceAddressTlv;
-import org.onosproject.pcepio.types.LinkLocalRemoteIdentifiersTlv;
-import org.onosproject.pcepio.types.PcepValueType;
-import org.onosproject.pcepio.types.TELinkDescriptorsTlv;
-import com.google.common.testing.EqualsTester;
+import java.util.LinkedList;
/**
* Test case for TE link descriptors Tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import java.util.LinkedList;
+package org.onosproject.pcepio.types;
+import com.google.common.testing.EqualsTester;
import org.junit.Test;
-import org.onosproject.pcepio.types.IPv4TERouterIdOfLocalNodeTlv;
-import org.onosproject.pcepio.types.NodeFlagBitsTlv;
-import org.onosproject.pcepio.types.PcepValueType;
-import org.onosproject.pcepio.types.TENodeAttributesTlv;
-import com.google.common.testing.EqualsTester;
+import java.util.LinkedList;
/**
* Test case for TE Node Attribute tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
-
-import org.junit.Test;
-import org.onosproject.pcepio.types.TedCapabilityTlv;
+package org.onosproject.pcepio.types;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Test case for TED Capability tlv.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onosproject.pcepio;
+package org.onosproject.pcepio.types;
-import org.junit.Test;
-import org.onosproject.pcepio.types.UnreservedBandwidthTlv;
import com.google.common.testing.EqualsTester;
+import org.junit.Test;
/**
* Unit Test case for Unreserved Bandwidth Tlv.
import org.projectfloodlight.openflow.protocol.OFFlowStatsEntry;
import org.projectfloodlight.openflow.protocol.action.OFAction;
import org.projectfloodlight.openflow.protocol.action.OFActionCircuit;
+import org.projectfloodlight.openflow.protocol.action.OFActionEnqueue;
import org.projectfloodlight.openflow.protocol.action.OFActionExperimenter;
import org.projectfloodlight.openflow.protocol.action.OFActionGroup;
import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
OFActionSetQueue setQueue = (OFActionSetQueue) act;
builder.setQueue(setQueue.getQueueId());
break;
+ case ENQUEUE:
+ OFActionEnqueue enqueue = (OFActionEnqueue) act;
+ builder.setQueue(enqueue.getQueueId(), PortNumber.portNumber(enqueue.getPort().getPortNumber()));
+ break;
case STRIP_VLAN:
case POP_VLAN:
builder.popVlan();
case SET_NW_TOS:
case SET_NW_TTL:
- case ENQUEUE:
default:
log.warn("Action type {} not yet implemented.", act.getType());
}
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.flow.instructions.Instruction;
import org.onosproject.net.flow.instructions.Instructions.OutputInstruction;
+import org.onosproject.net.flow.instructions.Instructions.SetQueueInstruction;
import org.onosproject.net.flow.instructions.L2ModificationInstruction;
import org.onosproject.net.flow.instructions.L2ModificationInstruction.ModEtherInstruction;
import org.onosproject.net.flow.instructions.L2ModificationInstruction.ModVlanIdInstruction;
import org.projectfloodlight.openflow.protocol.OFFlowModFlags;
import org.projectfloodlight.openflow.protocol.action.OFAction;
import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
+import org.projectfloodlight.openflow.protocol.action.OFActionEnqueue;
import org.projectfloodlight.openflow.protocol.match.Match;
import org.projectfloodlight.openflow.types.IPv4Address;
import org.projectfloodlight.openflow.types.MacAddress;
}
acts.add(action.build());
break;
+ case QUEUE:
+ SetQueueInstruction queue = (SetQueueInstruction) i;
+ if (queue.port() == null) {
+ log.warn("Required argument 'port' undefined for OFActionEnqueue");
+ }
+ OFActionEnqueue.Builder queueBuilder = factory().actions().buildEnqueue()
+ .setQueueId(queue.queueId())
+ .setPort(OFPort.ofInt((int) queue.port().toLong()));
+ acts.add(queueBuilder.build());
+ break;
case L0MODIFICATION:
case GROUP:
case TABLE:
<dependency name="Archetypes" requires="Setup"/>
<import file="${ONOS_SCENARIOS}/wrapup.xml"/>
- <dependency name="Wrapup" requires="~Archetypes,~Setup,~Net-Fast"/>
+ <dependency name="Wrapup" requires="Prerequisites,~Archetypes,~Setup,~Net-Fast"/>
</scenario>
@Override
public int hashCode() {
- return Objects.hash(cycle);
+ return cycle.hashCode();
}
@Override
*/
public class DisjointPathPair<V extends Vertex, E extends Edge<V>> implements Path<V, E> {
- private Path<V, E> primary, secondary;
- boolean primaryActive = true;
+ private final Path<V, E> primary, secondary;
+ private boolean primaryActive = true;
/**
* Creates a disjoint path pair from two paths.
* @return boolean representing whether it has backup
*/
public boolean hasBackup() {
- return secondary != null && secondary.edges() != null;
+ return secondary != null;
}
@Override
@Override
public int hashCode() {
- return hasBackup() ? Objects.hash(primary) + Objects.hash(secondary) :
+ // Note: DisjointPathPair with primary and secondary swapped
+ // must result in same hashCode
+ return hasBackup() ? primary.hashCode() + secondary.hashCode() :
Objects.hash(primary);
}
+++ /dev/null
-/*
- * 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.onlab.graph;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-
-import static com.google.common.collect.ImmutableSet.of;
-import static com.google.common.base.MoreObjects.toStringHelper;
-
-
-public class DisjointPathPair<V extends Vertex, E extends Edge<V>> implements Path<V, E> {
- public Path<V, E> path1, path2;
- boolean usingPath1 = true;
-
-<<<<<<< HEAD
- /**
- * Creates a Disjoint Path Pair from two paths.
- *
- * @param p1 first path
- * @param p2 second path
- */
-=======
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public DisjointPathPair(Path<V, E> p1, Path<V, E> p2) {
- path1 = p1;
- path2 = p2;
- }
-<<<<<<< HEAD
-
- @Override
-=======
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public V src() {
- return path1.src();
- }
-
-<<<<<<< HEAD
- @Override
- public V dst() {
- return path1.dst();
- }
-
- @Override
-=======
- public V dst() {
- return path1.dst();
- }
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public double cost() {
- if (!hasBackup()) {
- return path1.cost();
- }
- return path1.cost() + path2.cost();
- }
-<<<<<<< HEAD
-
- @Override
-=======
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public List<E> edges() {
- if (usingPath1 || !hasBackup()) {
- return path1.edges();
- } else {
- return path2.edges();
- }
- }
-<<<<<<< HEAD
-
- /**
- * Checks if this path pair contains a backup/secondary path.
- *
- * @return boolean representing whether it has backup
- */
- public boolean hasBackup() {
- return path2 != null && path2.edges() != null;
- }
-
- /**
- * Switches this disjoint path pair to using its backup path, instead of
- * using its primary.
- */
- public void useBackup() {
- usingPath1 = !usingPath1;
- }
-
- @Override
-=======
- public boolean hasBackup() {
- return path2 != null && path2.edges() != null;
- }
- public void useBackup() {
- usingPath1 = !usingPath1;
- }
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public String toString() {
- return toStringHelper(this)
- .add("src", src())
- .add("dst", dst())
- .add("cost", cost())
- .add("edges", edges())
- .toString();
- }
-<<<<<<< HEAD
-
- @Override
-=======
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public int hashCode() {
- Set<Path<V, E>> paths;
- if (!hasBackup()) {
- paths = of(path1);
- } else {
- paths = of(path1, path2);
- }
- return Objects.hash(paths);
- }
-<<<<<<< HEAD
-
- @Override
-=======
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj instanceof DisjointPathPair) {
- final DisjointPathPair other = (DisjointPathPair) obj;
- return Objects.equals(this.src(), other.src()) &&
- Objects.equals(this.dst(), other.dst()) &&
- (Objects.equals(this.path1, other.path1) &&
- Objects.equals(this.path2, other.path2)) ||
- (Objects.equals(this.path1, other.path2) &&
- Objects.equals(this.path2, other.path1));
- }
- return false;
- }
-<<<<<<< HEAD
-
- /**
- * Returns number of paths inside this path pair object.
- *
- * @return number of paths
- */
-=======
->>>>>>> Disjoint Path Pairs (Suurballe) utils
- public int size() {
- if (hasBackup()) {
- return 2;
- }
- return 1;
- }
-}
import com.google.common.base.MoreObjects;
import com.google.common.collect.ComparisonChain;
-import java.util.Objects;
-
/**
* Class representing frequency. This class is intended to be used for a value whose unit is Hz
* and its family (KHz, MHz, etc.).
@Override
public int hashCode() {
- return Objects.hash(frequency);
+ return Long.hashCode(frequency);
}
@Override
--- /dev/null
+package org.onlab.graph;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Test of DisjointPathPair.
+ */
+public class DisjointPathPairTest {
+
+ private static final TestVertex A = new TestVertex("A");
+ private static final TestVertex B = new TestVertex("B");
+ private static final TestVertex C = new TestVertex("C");
+ private static final TestVertex D = new TestVertex("D");
+
+ private static final TestEdge AB = new TestEdge(A, B, 1.0);
+ private static final TestEdge BC = new TestEdge(B, C, 1.0);
+ private static final TestEdge AD = new TestEdge(A, D, 1.0);
+ private static final TestEdge DC = new TestEdge(D, C, 1.0);
+
+ private static final Path<TestVertex, TestEdge> ABC
+ = new DefaultPath<>(ImmutableList.of(AB, BC), 1.0);
+ private static final Path<TestVertex, TestEdge> ADC
+ = new DefaultPath<>(ImmutableList.of(AD, DC), 1.0);
+
+ @Test
+ public void testSwappingPrimarySecondaryDoesntImpactHashCode() {
+ assertEquals(new DisjointPathPair<>(ABC, ADC).hashCode(),
+ new DisjointPathPair<>(ADC, ABC).hashCode());
+ }
+
+ @Test
+ public void testSwappingPrimarySecondaryDoesntImpactEquality() {
+ new EqualsTester()
+ .addEqualityGroup(new DisjointPathPair<>(ABC, ADC),
+ new DisjointPathPair<>(ADC, ABC));
+ }
+
+}
@Override
public int hashCode() {
- return Objects.hash(name);
+ return name.hashCode();
}
@Override
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
*/
public class Coordinator {
- private static final int MAX_THREADS = 16;
+ private static final int MAX_THREADS = 64;
private final ExecutorService executor = newFixedThreadPool(MAX_THREADS);
}
/**
- * Wants for completion of the entire process flow.
+ * Waits for completion of the entire process flow.
*
* @return exit code to use
* @throws InterruptedException if interrupted while waiting for completion
*/
public int waitFor() throws InterruptedException {
- latch.await();
+ while (!store.isComplete()) {
+ latch.await(1, TimeUnit.SECONDS);
+ }
return store.hasFailures() ? 1 : 0;
}
substitute(step.command())));
}
} else if (directive == SKIP) {
- if (step instanceof Group) {
- Group group = (Group) step;
- group.children().forEach(child -> delegate.onCompletion(child, SKIPPED));
- }
- delegate.onCompletion(step, SKIPPED);
+ skipStep(step);
}
}
+ /**
+ * Recursively skips the specified step or group and any steps/groups within.
+ *
+ * @param step step or group
+ */
+ private void skipStep(Step step) {
+ if (step instanceof Group) {
+ Group group = (Group) step;
+ store.markComplete(step, SKIPPED);
+ group.children().forEach(this::skipStep);
+ }
+ delegate.onCompletion(step, SKIPPED);
+
+ }
+
/**
* Determines the state of the specified step.
*
Status depStatus = store.getStatus(dependency.dst());
if (depStatus == WAITING || depStatus == IN_PROGRESS) {
return NOOP;
- } else if ((depStatus == FAILED || depStatus == SKIPPED) &&
- !dependency.isSoft()) {
+ } else if (((depStatus == FAILED || depStatus == SKIPPED) && !dependency.isSoft()) ||
+ (step.group() != null && store.getStatus(step.group()) == SKIPPED)) {
return SKIP;
}
}
@Override
public int hashCode() {
- return Objects.hash(name);
+ return name.hashCode();
}
@Override
Code Review / onosfw.git / commitdiff