홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
jcc
Committed by Gerrit Code Review
4a20a5f2 1 parent da4abde4

[ONOS-700][ONOS-1801]refactor tunnel subsystem api. 

1.use more abstract and more flexible entity[TunnelPoint] to represent
for source or destination point of tunnel,instead of Label
2.suport for muti-producer
3.use Order entity to record tunnel-order relationship
4.modify Tunnel entity to add more properties.
5.rename Label and LabelId to OpticalTunnelPoint and OpticalLogicId in
order to keep code style consistently,at the same time
OpticalTunnelPoint implements TunnelPoint
6.add junit test

Change-Id: I371afcef5501e468a43758c5982e7a93b443b114
Expand all
Inline Side-by-side
Showing 23 changed files with 1062 additions and 381 deletions
package org.onosproject.net.tunnel;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.MoreObjects.toStringHelper;
import java.util.Objects;
......@@ -12,43 +13,46 @@ import org.onosproject.net.PortNumber;
import org.onosproject.net.provider.ProviderId;
/**
* Default label model implementation.
* Default optical tunnel point model implementation.
*/
public class DefaultLabel extends AbstractModel implements Label {
public class DefaultOpticalTunnelEndPoint extends AbstractModel implements OpticalTunnelEndPoint {
private final Optional<ElementId> elementId;
private final Optional<PortNumber> portNumber;
private final Optional<Label> parentLabel;
private final Optional<OpticalTunnelEndPoint> parentPoint;
private final Type type;
private final LabelId id;
private final OpticalLogicId id;
private final boolean isGlobal;
/**
* Creates a label attributed to the specified provider (may be null).
* if provider is null, which means the label is not managed by the SB.
* Creates a optical tunnel point attributed to the specified provider (may be null).
* if provider is null, which means the optical tunnel point is not managed by the SB.
*
* @param providerId tunnelProvider Id
* @param elementId parent network element
* @param number port number
* @param parentLabel parent port or parent label
* @param parentPoint parent port or parent label
* @param type port type
* @param id LabelId
* @param isGlobal indicator whether the label is global significant or not
* @param annotations optional key/value annotations
*/
public DefaultLabel(ProviderId providerId, Optional<ElementId> elementId,
Optional<PortNumber> number, Optional<Label> parentLabel,
Type type, LabelId id, boolean isGlobal, Annotations... annotations) {
public DefaultOpticalTunnelEndPoint(ProviderId providerId, Optional<ElementId> elementId,
Optional<PortNumber> number, Optional<OpticalTunnelEndPoint> parentPoint,
Type type, OpticalLogicId id, boolean isGlobal, Annotations... annotations) {
super(providerId, annotations);
checkNotNull(type, "type cannot be null");
checkNotNull(id, "id cannot be null");
checkNotNull(isGlobal, "isGlobal cannot be null");
this.elementId = elementId;
this.portNumber = number;
this.parentLabel = parentLabel;
this.parentPoint = parentPoint;
this.id = id;
this.type = type;
this.isGlobal = isGlobal;
}
@Override
public LabelId id() {
public OpticalLogicId id() {
return id;
}
......@@ -63,8 +67,8 @@ public class DefaultLabel extends AbstractModel implements Label {
}
@Override
public Optional<Label> parentLabel() {
return parentLabel;
public Optional<OpticalTunnelEndPoint> parentPoint() {
return parentPoint;
}
@Override
......@@ -79,7 +83,7 @@ public class DefaultLabel extends AbstractModel implements Label {
@Override
public int hashCode() {
return Objects.hash(elementId, portNumber, parentLabel, id);
return Objects.hash(elementId, portNumber, parentPoint, id);
}
@Override
......@@ -87,14 +91,14 @@ public class DefaultLabel extends AbstractModel implements Label {
if (this == obj) {
return true;
}
if (obj instanceof DefaultLabel) {
final DefaultLabel other = (DefaultLabel) obj;
if (obj instanceof DefaultOpticalTunnelEndPoint) {
final DefaultOpticalTunnelEndPoint other = (DefaultOpticalTunnelEndPoint) obj;
return Objects.equals(this.id, other.id) &&
Objects.equals(this.type, other.type) &&
Objects.equals(this.isGlobal, other.isGlobal) &&
Objects.equals(this.elementId, other.elementId) &&
Objects.equals(this.portNumber, other.portNumber) &&
Objects.equals(this.parentLabel, other.parentLabel);
Objects.equals(this.parentPoint, other.parentPoint);
}
return false;
}
......@@ -104,7 +108,7 @@ public class DefaultLabel extends AbstractModel implements Label {
return toStringHelper(this)
.add("elementId", elementId)
.add("portNumber", portNumber)
.add("parentLabel", parentLabel)
.add("parentPoint", parentPoint)
.add("type", type)
.add("id", id)
.add("isGlobal", isGlobal)
......
package org.onosproject.net.tunnel;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkState;
import java.util.Objects;
import org.onosproject.core.IdGenerator;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.AbstractModel;
import org.onosproject.net.Annotations;
import org.onosproject.net.NetworkResource;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.resource.BandwidthResource;
/**
* Default tunnel model implementation.
* The default implementation of an network tunnel. supports for creating a
* tunnel by connect point ,IP address, MAC address, device and so on.
*/
public final class DefaultTunnel extends AbstractModel implements Tunnel {
private final TunnelId id;
private final Label src;
private final Label dst;
private final Type type;
private final TunnelEndPoint src; // a source point of tunnel.
private final TunnelEndPoint dst; // a destination point of tunnel.
private final State state;
private final boolean isDurable;
private final boolean isBidirectional;
private final BandwidthResource bandwidth;
private final Type type; // tunnel type
private final DefaultGroupId groupId; // represent for a group flow table
// which a tunnel match up
// tunnel producer
private final TunnelId tunnelId; // tunnel identify generated by
// ONOS as primary key
private final TunnelName tunnelName; // name of a tunnel
/**
* Constructs an tunnel using the builder pattern.
* Creates an active infrastructure tunnel using the supplied information.
*
* @param providerId provider identity, can be null if comes from the NB
* @param builder tunnelBuilder
* @param producerName provider identity
* @param src tunnel source
* @param dst tunnel destination
* @param type tunnel type
* @param groupId groupId
* @param tunnelId tunnelId
* @param tunnelName tunnel name
* @param annotations optional key/value annotations
* @return
*/
private DefaultTunnel(ProviderId providerId, TunnelBuilder builder, Annotations... annotations) {
super(providerId, annotations);
this.id = builder.id;
this.src = builder.src;
this.dst = builder.dst;
this.type = builder.type;
this.state = builder.state;
this.isDurable = builder.isDurable;
this.isBidirectional = builder.isBidirectional;
this.bandwidth = builder.bandwidth;
public DefaultTunnel(ProviderId producerName, TunnelEndPoint src,
TunnelEndPoint dst, Type type, DefaultGroupId groupId,
TunnelId tunnelId, TunnelName tunnelName,
Annotations... annotations) {
this(producerName, src, dst, type, Tunnel.State.ACTIVE, groupId,
tunnelId, tunnelName, annotations);
}
@Override
public TunnelId id() {
return id;
/**
* Creates an tunnel using the supplied information.
*
* @param producerName provider identity
* @param src tunnel source
* @param dst tunnel destination
* @param type tunnel type
* @param state tunnel state
* @param groupId groupId
* @param tunnelId tunnelId
* @param tunnelName tunnel name
* @param annotations optional key/value annotations
*/
public DefaultTunnel(ProviderId producerName, TunnelEndPoint src,
TunnelEndPoint dst, Type type, State state,
DefaultGroupId groupId, TunnelId tunnelId,
TunnelName tunnelName, Annotations... annotations) {
super(producerName, annotations);
checkNotNull(producerName, "producerName cannot be null");
checkNotNull(src, "src cannot be null");
checkNotNull(dst, "dst cannot be null");
checkNotNull(type, "type cannot be null");
checkNotNull(state, "state cannot be null");
this.src = src;
this.dst = dst;
this.type = type;
this.state = state;
this.groupId = groupId;
this.tunnelId = tunnelId;
this.tunnelName = tunnelName;
}
@Override
public Label src() {
public TunnelEndPoint src() {
return src;
}
@Override
public Label dst() {
public TunnelEndPoint dst() {
return dst;
}
......@@ -70,29 +101,31 @@ public final class DefaultTunnel extends AbstractModel implements Tunnel {
}
@Override
public boolean isDurable() {
return isDurable;
public NetworkResource resource() {
return null;
}
@Override
public boolean isBidirectional() {
return isBidirectional;
public TunnelId tunnelId() {
return tunnelId;
}
@Override
public BandwidthResource bandwidth() {
return bandwidth;
public DefaultGroupId groupId() {
return groupId;
}
@Override
public TunnelName tunnelName() {
return tunnelName;
}
@Override
public int hashCode() {
return Objects.hash(id);
return Objects.hash(src, dst, type, groupId, tunnelId, tunnelName,
state);
}
/**
* {@inheritDoc}
* Note that only TunnelId is considered on equality check.
*/
@Override
public boolean equals(Object obj) {
if (this == obj) {
......@@ -100,69 +133,23 @@ public final class DefaultTunnel extends AbstractModel implements Tunnel {
}
if (obj instanceof DefaultTunnel) {
final DefaultTunnel other = (DefaultTunnel) obj;
return Objects.equals(this.id, other.id);
return Objects.equals(this.src, other.src)
&& Objects.equals(this.dst, other.dst)
&& Objects.equals(this.type, other.type)
&& Objects.equals(this.groupId, other.groupId)
&& Objects.equals(this.tunnelId, other.tunnelId)
&& Objects.equals(this.tunnelName, other.tunnelName)
&& Objects.equals(this.state, other.state);
}
return false;
}
@Override
public String toString() {
return toStringHelper(this)
.add("tunnelId", id)
.add("src", src)
.add("dst", dst)
.add("type", type)
.add("state", state)
.add("durable", isDurable)
.add("isBidirectional", isBidirectional)
.add("bandwidth", bandwidth)
.toString();
}
public static class TunnelBuilder {
private TunnelId id = null;
private Label src = null;
private Label dst = null;
private Type type = null;
private State state = null;
private boolean isDurable = false;
private boolean isBidirectional = false;
private BandwidthResource bandwidth = null;
private static IdGenerator idGenerator;
public TunnelBuilder labelSrcDst(Label src, Label dst) {
this.src = src;
this.dst = dst;
return this;
}
public TunnelBuilder state(State state) {
this.state = state;
return this;
}
public TunnelBuilder isDurable(boolean isDurable) {
this.isDurable = isDurable;
return this;
}
public TunnelBuilder isBidirectional(boolean isBidirectional) {
this.isBidirectional = isBidirectional;
return this;
}
public TunnelBuilder bandwidth(BandwidthResource bandwidth) {
this.bandwidth = bandwidth;
return this;
}
public DefaultTunnel build(ProviderId providerId, Annotations... annotations) {
checkState(idGenerator != null, "Id generator is not bound.");
this.id = TunnelId.valueOf(idGenerator.getNewId());
return new DefaultTunnel(providerId, this, annotations);
}
return toStringHelper(this).add("src", src).add("dst", dst)
.add("type", type).add("state", state).add("groupId", groupId)
.add("producerTunnelId", tunnelId)
.add("tunnelName", tunnelName).toString();
}
}
......
......@@ -15,11 +15,13 @@
*/
package org.onosproject.net.tunnel;
import com.google.common.base.MoreObjects;
import static com.google.common.base.Preconditions.checkNotNull;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.AbstractDescription;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.SparseAnnotations;
import org.onosproject.net.provider.ProviderId;
import com.google.common.base.MoreObjects;
/**
* Default implementation of immutable tunnel description entity.
......@@ -28,30 +30,45 @@ public class DefaultTunnelDescription extends AbstractDescription
implements TunnelDescription {
private final TunnelId tunnelId;
private final ConnectPoint src;
private final ConnectPoint dst;
private final TunnelEndPoint src;
private final TunnelEndPoint dst;
private final Tunnel.Type type;
private final boolean isBidirectional;
private final DefaultGroupId groupId; // represent for a group flow table
// which a tunnel match up
// tunnel producer
private final ProviderId producerName; // tunnel producer name
private final TunnelName tunnelName; // name of a tunnel
/**
* Creates a tunnel description using the supplied information.
*
* @param id TunnelId
* @param src ConnectPoint source
* @param dst ConnectPoint destination
* @param src TunnelPoint source
* @param dst TunnelPoint destination
* @param type tunnel type
* @param isBidirectional boolean
* @param groupId groupId
* @param producerName tunnel producer
* @param tunnelName tunnel name
* @param annotations optional key/value annotations
*/
public DefaultTunnelDescription(TunnelId id, ConnectPoint src, ConnectPoint dst,
Tunnel.Type type, boolean isBidirectional,
public DefaultTunnelDescription(TunnelId id, TunnelEndPoint src,
TunnelEndPoint dst, Tunnel.Type type,
DefaultGroupId groupId,
ProviderId producerName,
TunnelName tunnelName,
SparseAnnotations... annotations) {
super(annotations);
checkNotNull(producerName, "producerName cannot be null");
checkNotNull(src, "src cannot be null");
checkNotNull(dst, "dst cannot be null");
checkNotNull(type, "type cannot be null");
this.tunnelId = id;
this.src = src;
this.dst = dst;
this.type = type;
this.isBidirectional = isBidirectional;
this.groupId = groupId;
this.producerName = producerName;
this.tunnelName = tunnelName;
}
@Override
......@@ -60,12 +77,12 @@ public class DefaultTunnelDescription extends AbstractDescription
}
@Override
public ConnectPoint src() {
public TunnelEndPoint src() {
return src;
}
@Override
public ConnectPoint dst() {
public TunnelEndPoint dst() {
return dst;
}
......@@ -75,8 +92,18 @@ public class DefaultTunnelDescription extends AbstractDescription
}
@Override
public boolean isBidirectional() {
return isBidirectional;
public DefaultGroupId groupId() {
return groupId;
}
@Override
public ProviderId producerName() {
return producerName;
}
@Override
public TunnelName tunnelName() {
return tunnelName;
}
@Override
......@@ -86,7 +113,9 @@ public class DefaultTunnelDescription extends AbstractDescription
.add("src", src())
.add("dst", dst())
.add("type", type())
.add("isBidirectional", isBidirectional())
.add("tunnelName", tunnelName())
.add("producerName", producerName())
.add("groupId", groupId())
.toString();
}
......
package org.onosproject.net.tunnel;
import java.util.Objects;
import org.onlab.packet.IpAddress;
import com.google.common.base.MoreObjects;
/**
* Represent for a tunnel point using ip address.
*/
public final class IpTunnelEndPoint implements TunnelEndPoint {
private final IpAddress ip;
/**
* Public construction is prohibited.
* @param ip ip address
*/
private IpTunnelEndPoint(IpAddress ip) {
this.ip = ip;
}
/**
* Create a IP tunnel end point.
* @param ip IP address
* @return IpTunnelEndPoint
*/
public static IpTunnelEndPoint ipTunnelPoint(IpAddress ip) {
return new IpTunnelEndPoint(ip);
}
@Override
public int hashCode() {
return Objects.hash(ip);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof IpTunnelEndPoint) {
final IpTunnelEndPoint other = (IpTunnelEndPoint) obj;
return Objects.equals(this.ip, other.ip);
}
return false;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass()).add("ip", ip).toString();
}
}
......@@ -21,17 +21,17 @@ import com.google.common.primitives.UnsignedLongs;
/**
* Representation of a label Id, a logical port identifier.
*/
public final class LabelId {
public final class OpticalLogicId {
/**
* Represents a logical Id.
*/
private final long labelId;
private final long logicId;
/**
* Constructor, public creation is prohibited.
*/
private LabelId(long id) {
this.labelId = id;
private OpticalLogicId(long id) {
this.logicId = id;
}
/**
......@@ -40,26 +40,26 @@ public final class LabelId {
* @param id identifier as long value
* @return LabelId
*/
public static LabelId labelId(long id) {
return new LabelId(id);
public static OpticalLogicId logicId(long id) {
return new OpticalLogicId(id);
}
public static LabelId labelId(String string) {
return new LabelId(UnsignedLongs.decode(string));
public static OpticalLogicId logicId(String string) {
return new OpticalLogicId(UnsignedLongs.decode(string));
}
public long toLong() {
return labelId;
return logicId;
}
@Override
public String toString() {
return UnsignedLongs.toString(labelId);
return UnsignedLongs.toString(logicId);
}
@Override
public int hashCode() {
return Objects.hash(labelId);
return Objects.hash(logicId);
}
@Override
......@@ -67,9 +67,9 @@ public final class LabelId {
if (this == obj) {
return true;
}
if (obj instanceof LabelId) {
final LabelId other = (LabelId) obj;
return this.labelId == other.labelId;
if (obj instanceof OpticalLogicId) {
final OpticalLogicId other = (OpticalLogicId) obj;
return this.logicId == other.logicId;
}
return false;
}
......
......@@ -25,76 +25,51 @@ import org.onosproject.net.Provided;
/**
* Generic representation of a logical port entity in a consistent way,
* it is used to identify e.g., VLAN#, MPLS label#, ODUk timeSlot, WDM lambda, etc.
* it is used to identify e.g., ODUk timeSlot, WDM lambda, etc.
* It supports nested case.
*/
public interface Label extends Annotated, Provided, NetworkResource {
public interface OpticalTunnelEndPoint extends TunnelEndPoint, Annotated, Provided, NetworkResource {
/** Represents coarse Label type classification. */
enum Type {
/** Represents coarse tunnel point type classification. */
public enum Type {
/**
* Signifies VLAN-based tag.
*/
VLAN,
/**
* Signifies LAG-based label.
*/
LAG,
/**
* Signifies MPLS-based label.
*/
MPLS,
/**
* Signifies IP-based label.
*/
IP,
/**
* Signifies optical data unit-based label.
* Signifies optical data unit-based tunnel point.
*/
TIMESLOT,
/**
* Signifies optical wavelength-based label.
*/
LAMBDA,
/**
* Signifies device-based identifier for the label.
* Signifies optical wavelength-based tunnel point.
*/
DEVICE
LAMBDA
}
/**
* Returns the identifier to this Label.
* Returns the identifier.
*
* @return identifier
*/
LabelId id();
OpticalLogicId id();
/**
* Returns the parent network element to which this label belongs.
* Returns the parent network element to which this tunnel point belongs.
*
* @return parent network element
*/
Optional<ElementId> elementId();
/**
* Returns the parent network port to which this label belongs, can not be be null.
* Returns the parent network port to which this tunnel point belongs, can not be be null.
*
* @return port number
*/
Optional<PortNumber> portNumber();
/**
* Returns the parent label to which this label belongs, optional.
* Returns the parent tunnel point to which this tunnel point belongs, optional.
*
* @return parent label, if it is null, the parent is a physical port
* @return parent tunnel point, if it is null, the parent is a physical port
*/
Optional<Label> parentLabel();
Optional<OpticalTunnelEndPoint> parentPoint();
/**
* Indicates whether or not the port is global significant.
......@@ -104,9 +79,9 @@ public interface Label extends Annotated, Provided, NetworkResource {
boolean isGlobal();
/**
* Returns the label type.
* Returns the tunnel point type.
*
* @return label type
* @return tunnel point type
*/
Type type();
}
......
......@@ -15,50 +15,44 @@
*/
package org.onosproject.net.tunnel;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.Annotated;
import org.onosproject.net.NetworkResource;
import org.onosproject.net.Provided;
import org.onosproject.net.resource.BandwidthResource;
/**
* Abstraction of a generalized Tunnel entity (bandwidth pipe) for either L3/L2 networks or L1/L0 networks,
* representation of e.g., VLAN, GRE tunnel, MPLS LSP, L1 ODUk connection, WDM OCH, etc.. Each Tunnel is
* associated with at least two Label objects that model the logical ports essentially.
* Abstraction of a generalized Tunnel entity (bandwidth pipe) for either L3/L2
* networks or L1/L0 networks, representation of e.g., VLAN, GRE tunnel, MPLS
* LSP, L1 ODUk connection, WDM OCH, etc.. Each Tunnel is associated with at
* least two tunnel end point objects that model the logical ports essentially.
* Note that it supports nested case.
*/
public interface Tunnel extends Annotated, Provided, NetworkResource {
/**
* Coarse representation of the Tunnel types.
* Tunnel technology type.
*/
enum Type {
/**
* Signifies that this is a MPLS tunnel.
*/
MPLS,
/**
* Signifies that this is a L2 tunnel.
*/
VLAN,
/**
* Signifies that this is a DC L2 extension tunnel.
*/
VXLAN,
/**
* Signifies that this is a L3 tunnel.
*/
GRE,
/**
* Signifies that this is a MPLS tunnel.
*/
LSP,
/**
* Signifies that this is a L1 OTN tunnel.
*/
ODUk,
ODUK,
/**
* Signifies that this is a L0 OCH tunnel.
*/
......@@ -67,53 +61,52 @@ public interface Tunnel extends Annotated, Provided, NetworkResource {
/**
* Representation of the tunnel state.
*
*/
enum State {
public enum State {
/**
* Signifies that a tunnel is currently in a initialized state.
*/
INIT,
/**
* Signifies that a tunnel is currently established but no traffic.
*/
ESTABLISHED,
/**
* Signifies that a tunnel is currently serving the traffic.
* Signifies that a tunnel is currently active. This state means that
* this tunnel is available. It can be borrowed by consumer.
*/
ACTIVE,
/**
* Signifies that a tunnel is currently out of service.
*/
FAILED,
/**
* Signifies that a tunnel is currently in maintenance state.
* Signifies that a tunnel is currently inactive. This state means that
* this tunnel can not be borrowed by consumer.
*/
INACTIVE
}
TunnelId id();
/**
* Returns the tunnel state.
*
* @return tunnel state
*/
State state();
/**
* Returns the tunnel source point (source Label object).
* the origin of a tunnel.
*
* @return source Label object
* @return the origin of a tunnel
*/
Label src();
TunnelEndPoint src();
/**
* Returns the tunnel destination point (destination Label object).
* the terminal of a tunnel.
*
* @return destination Label object
* @return the terminal of a tunnel
*/
Label dst();
TunnelEndPoint dst();
/**
* Returns the tunnel type.
......@@ -123,36 +116,31 @@ public interface Tunnel extends Annotated, Provided, NetworkResource {
Type type();
/**
* Returns the tunnel state.
* Returns group flow table id which a tunnel match up.
*
* @return tunnel state
* @return OpenFlowGroupId
*/
State state();
DefaultGroupId groupId();
/**
* Indicates if the tunnel is to be considered durable.
* Returns tunnel identify generated by ONOS as primary key.
*
* @return true if the tunnel is durable
* @return TunnelId
*/
boolean isDurable();
TunnelId tunnelId();
/**
* Indicates if the tunnel is to be considered Bidirectional.
* Return the name of a tunnel.
*
* @return true if the tunnel is Bidirectional
* @return Tunnel Name
*/
boolean isBidirectional();
TunnelName tunnelName();
/**
* Return the tunnel bandwidth.
* Network resource backing the tunnel, e.g. lambda, VLAN id, MPLS tag.
*
* @return tunnel bandwidth
* @return backing resource
*/
BandwidthResource bandwidth();
}
NetworkResource resource();
}
......
......@@ -15,9 +15,8 @@
*/
package org.onosproject.net.tunnel;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DeviceId;
import org.onosproject.net.Path;
import org.onosproject.net.provider.ProviderId;
/**
* Service for administering the inventory of provisioned tunnels.
......@@ -37,17 +36,9 @@ public interface TunnelAdminService {
*
* @param src source label
* @param dst destination label
* @param producerName producer name
*/
void removeTunnels(Label src, Label dst);
/**
* Removes all provisioned tunnels leading to and from the
* specified connection point.
*
* @param src source connection point
* @param dst destination connection point
*/
void removeTunnels(ConnectPoint src, ConnectPoint dst);
void removeTunnels(TunnelEndPoint src, TunnelEndPoint dst, ProviderId producerName);
/**
* Removes all provisioned tunnels leading to and from the
......@@ -56,24 +47,9 @@ public interface TunnelAdminService {
* @param src source connection point
* @param dst destination connection point
* @param type tunnel type
* @param producerName producer name
*/
void removeTunnels(ConnectPoint src, ConnectPoint dst, Tunnel.Type type);
/**
* Removes all provisioned tunnels leading to and from the
* specified connection point.
*
* @param connectPoint connection point
*/
void removeTunnels(ConnectPoint connectPoint);
/**
* Removes all provisioned tunnels leading to and from the
* specified device.
*
* @param deviceId device identifier
*/
void removeTunnels(DeviceId deviceId);
void removeTunnels(TunnelEndPoint src, TunnelEndPoint dst, Tunnel.Type type, ProviderId producerName);
/**
* Invokes the core to update a tunnel based on specified tunnel parameters.
......
......@@ -15,13 +15,16 @@
*/
package org.onosproject.net.tunnel;
import org.onosproject.net.ConnectPoint;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.Annotated;
import org.onosproject.net.Description;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.Tunnel.Type;
/**
* Describes the tunnel.
* Describes a tunnel.
*/
public interface TunnelDescription extends Description {
public interface TunnelDescription extends Description, Annotated {
/**
* Returns the tunnel id.
......@@ -35,27 +38,40 @@ public interface TunnelDescription extends Description {
*
* @return tunnel source ConnectionPoint
*/
ConnectPoint src();
TunnelEndPoint src();
/**
* Returns the connection point destination.
*
* @return tunnel destination
*/
ConnectPoint dst();
TunnelEndPoint dst();
/**
* Returns the tunnel type.
*
* @return tunnel type
*/
Tunnel.Type type();
Type type();
/**
* Returns if the tunnel is bidirectional.
* Returns group flow table id which a tunnel match up.
*
* @return true if bidirectional, otherwise false
* @return OpenFlowGroupId
*/
boolean isBidirectional();
DefaultGroupId groupId();
/**
* Returns tunnel producer name.
*
* @return producer name
*/
ProviderId producerName();
/**
* Return the name of a tunnel.
*
* @return Tunnel Name
*/
TunnelName tunnelName();
}
......
package org.onosproject.net.tunnel;
/**
* Represents for source end point or destination end point of a tunnel. Maybe a tunnel
* based on ConnectPoint, IpAddress, MacAddress and so on is built.
*/
public interface TunnelEndPoint {
}
......@@ -20,7 +20,7 @@ import org.onosproject.event.AbstractEvent;
/**
* Describes tunnel events.
*/
public class TunnelEvent extends AbstractEvent<TunnelEvent.Type, Tunnel> {
public final class TunnelEvent extends AbstractEvent<TunnelEvent.Type, Tunnel> {
/**
* Type of tunnel events.
......
package org.onosproject.net.tunnel;
import java.util.Objects;
/**
* Represents for a unique tunnel name. TunnelId is generated by ONOS while
* TunnelName is given by producer. The consumer can borrow tunnels with
* TunnelId or TunnelName.
*/
public final class TunnelName {
private final String str;
// Default constructor for serialization
private TunnelName(String tunnelName) {
this.str = tunnelName;
}
/**
* Creates a tunnel name using the supplied URI string.
*
* @param tunnelName tunnel name string
* @return tunnel name object
*/
public static TunnelName tunnelName(String tunnelName) {
return new TunnelName(tunnelName);
}
/**
* The string of tunnel name.
*
* @return the string of tunnel name
*/
public String value() {
return str;
}
@Override
public int hashCode() {
return Objects.hash(str);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof TunnelName) {
final TunnelName that = (TunnelName) obj;
return this.getClass() == that.getClass()
&& Objects.equals(this.str, that.str);
}
return false;
}
@Override
public String toString() {
return str;
}
}
......@@ -25,7 +25,7 @@ import org.onosproject.net.provider.Provider;
public interface TunnelProvider extends Provider {
/**
* Instructs the provider to setup a tunnel.
* Instructs the provider to setup a tunnel. It's used by consumers.
*
* @param tunnel Tunnel
* @param path explicit route or null for the tunnel
......@@ -34,6 +34,7 @@ public interface TunnelProvider extends Provider {
/**
* Instructs the provider to setup a tunnel given the respective device.
* It's used by consumers.
*
* @param srcElement device
* @param tunnel Tunnel
......@@ -42,7 +43,7 @@ public interface TunnelProvider extends Provider {
void setupTunnel(ElementId srcElement, Tunnel tunnel, Path path);
/**
* Instructs the provider to release a tunnel.
* Instructs the provider to release a tunnel. It's used by consumers.
*
* @param tunnel Tunnel
*/
......@@ -50,6 +51,7 @@ public interface TunnelProvider extends Provider {
/**
* Instructs the provider to release a tunnel given the respective device.
* It's used by consumers.
*
* @param srcElement device
* @param tunnel Tunnel
......@@ -57,20 +59,46 @@ public interface TunnelProvider extends Provider {
void releaseTunnel(ElementId srcElement, Tunnel tunnel);
/**
* Instructs the provider to update a tunnel.
* Instructs the provider to update a tunnel. It's used by consumers. Maybe
* some consumers enable to update a tunnel.
*
* @param tunnel Tunnel
* @param path explicit route (path changed) or null (path not changed) for the tunnel
* @param path explicit route (path changed) or null (path not changed) for
* the tunnel
*/
void updateTunnel(Tunnel tunnel, Path path);
/**
* Instructs the provider to update a tunnel given the respective device.
* It's used by consumers. Maybe some consumers enable to update a tunnel.
*
* @param srcElement device
* @param tunnel Tunnel
* @param path explicit route (path changed) or null (path not changed) for the tunnel
* @param path explicit route (path changed) or null (path not changed) for
* the tunnel
*/
void updateTunnel(ElementId srcElement, Tunnel tunnel, Path path);
/**
* Signals that the provider has added a tunnel. It's used by producers.
*
* @param tunnel tunnel information
* @return tunnel identity
*/
TunnelId tunnelAdded(TunnelDescription tunnel);
/**
* Signals that the provider has removed a tunnel. It's used by producers.
*
* @param tunnel tunnel information
*/
void tunnelRemoved(TunnelDescription tunnel);
/**
* Signals that the a tunnel was changed (e.g., sensing changes of
* tunnel).It's used by producers.
*
* @param tunnel tunnel information
*/
void tunnelUpdated(TunnelDescription tunnel);
}
......
......@@ -26,8 +26,9 @@ public interface TunnelProviderService extends ProviderService<TunnelProvider> {
* Signals that the provider has added a tunnel.
*
* @param tunnel tunnel information
* @return tunnel identity
*/
void tunnelAdded(TunnelDescription tunnel);
TunnelId tunnelAdded(TunnelDescription tunnel);
/**
* Signals that the provider has removed a tunnel.
......
......@@ -17,88 +17,166 @@ package org.onosproject.net.tunnel;
import java.util.Collection;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Path;
import org.onosproject.net.resource.BandwidthResource;
import org.onosproject.core.ApplicationId;
import org.onosproject.net.Annotations;
import org.onosproject.net.tunnel.Tunnel.Type;
/**
* Service for interacting with the tunnel inventory.
* Service for interacting with the inventory of tunnels.
*/
public interface TunnelService {
/**
* Invokes the core to create a tunnel based on specified parameters.
* Borrows a specific tunnel. Annotations parameter is reserved.If there
* is no tunnel in the store, returns a "null" object, and record the tunnel subscription.
* Where tunnel is created, ONOS notifies this consumer actively.
*
* @param src sourcePoint
* @param dst destinationPoint
* @param bw bandwidth
* @param path explicit path or null
* @param consumerId a tunnel consumer
* @param tunnelId tunnel identify generated by onos
* @param annotations Annotations
* @return Tunnel subscribed tunnel
*/
void requestTunnel(ConnectPoint src, ConnectPoint dst, BandwidthResource bw, Path path);
Tunnel borrowTunnel(ApplicationId consumerId, TunnelId tunnelId,
Annotations... annotations);
/**
* Invokes the core to create a tunnel based on specified parameters with a tunnel type.
* Borrows a specific tunnel by tunnelName. Annotations parameter is reserved.If there
* is no tunnel in the store, return a "null" object, and record the tunnel subscription.
* Where tunnel is created, ONOS notifies this consumer actively.
*
* @param src sourcePoint
* @param dst destinationPoint
* @param type tunnelType
* @param bw bandwidth
* @param path explicit path or null
* @param consumerId a tunnel consumer
* @param tunnelName tunnel name
* @param annotations Annotations
* @return collection of subscribed Tunnels
*/
void requestTunnel(ConnectPoint src, ConnectPoint dst, Tunnel.Type type, BandwidthResource bw, Path path);
Collection<Tunnel> borrowTunnel(ApplicationId consumerId, TunnelName tunnelName,
Annotations... annotations);
/**
* Returns the count of all known tunnels in the dataStore.
* Borrows all tunnels between source and destination. Annotations
* parameter is reserved.If there is no any tunnel in the store, return a
* empty collection,and record the tunnel subscription. Where tunnel is created, ONOS
* notifies this consumer actively. Otherwise ONOS core returns all the
* tunnels, consumer determined which one to use.
*
* @return number of tunnels
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel
* @param annotations Annotations
* @return collection of subscribed Tunnels
*/
int getTunnelCount();
Collection<Tunnel> borrowTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Annotations... annotations);
/**
* Returns a collection of all known tunnel based on the type.
* Borrows all specified type tunnels between source and destination.
* Annotations parameter is reserved.If there is no any tunnel in the store,
* return a empty collection, and record the tunnel subscription. Where tunnel is
* created, ONOS notifies this consumer actively. Otherwise,ONOS core returns
* all available tunnels, consumer determined which one to use.
*
*@param type tunnelType
* @return all tunnels for a specific type
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel
* @param type tunnel type
* @param annotations Annotations
* @return collection of available Tunnels
*/
Collection<Tunnel> borrowTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations);
/**
* Returns back a specific tunnel to store.
*
* @param consumerId a tunnel consumer
* @param tunnelId tunnel identify generated by ONOS
* @param annotations Annotations
* @return success or fail
*/
Collection<Tunnel> getTunnels(Tunnel.Type type);
boolean returnTunnel(ApplicationId consumerId, TunnelId tunnelId,
Annotations... annotations);
/**
* Returns set of all tunnels from the specified connectpoint.
* Returns all specific name tunnel back store. Annotations parameter is reserved.if there
* is no tunnel in the store, return a "null" object, and record the tunnel subscription.
* Where tunnel is created, ONOS notifies this consumer actively.
*
* @param connectPoint device/portnumber
* @param type tunnelType
* @return set of tunnels
* @param consumerId a tunnel consumer
* @param tunnelName tunnel name
* @param annotations Annotations
* @return boolean
*/
Collection<Tunnel> getTunnels(ConnectPoint connectPoint, Tunnel.Type type);
boolean returnTunnel(ApplicationId consumerId, TunnelName tunnelName,
Annotations... annotations);
/**
* Returns set of all tunnels from the
* specified source connectpoint and destination connectpoint.
* Returns all specific type tunnels between source and destination back
* store. Annotations parameter is reserved.
*
* @param src sourcePoint
* @param dst destinationPoint
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel
* @param type tunnel type
* @return set of tunnels
* @param annotations Annotations
* @return success or fail
*/
boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations);
/**
* Returns all tunnels between source and destination back the store.
* Annotations parameter is reserved.
*
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel.
* @param annotations Annotations
* @return success or fail
*/
Collection<Tunnel> getTunnels(ConnectPoint src, ConnectPoint dst, Tunnel.Type type);
boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Annotations... annotations);
/**
* Returns the tunnel between the specified source
* and destination connection points.
* Returns a tunnel by a specific tunnel identity.
*
* @param src source label
* @param dst destination label
* @return tunnel from source to destination; null if none found
* @param tunnelId tunnel identify generated by tunnel producer
* @return Tunnel
*/
Tunnel getTunnel(Label src, Label dst);
Tunnel queryTunnel(TunnelId tunnelId);
/**
* Returns the tunnel based on the Id.
* Returns all tunnel subscription record by consumer.
*
* @param id tunnelId
* @return tunnel with specified Id
* @param consumerId consumer identity
* @return Collection of TunnelSubscription
*/
Tunnel getTunnel(TunnelId id);
Collection<TunnelSubscription> queryTunnelSubscription(ApplicationId consumerId);
/**
* Returns all specified type tunnels.
*
* @param type tunnel type
* @return Collection of tunnels
*/
Collection<Tunnel> queryTunnel(Type type);
/**
* Returns all tunnels between source point and destination point.
*
* @param src a source point of tunnel.
* @param dst a destination point of tunnel.
* @return Collection of tunnels
*/
Collection<Tunnel> queryTunnel(TunnelEndPoint src, TunnelEndPoint dst);
/**
* Returns all tunnels.
*
* @return all tunnels
*/
int tunnelCount();
/**
* Adds the specified tunnel listener.
......@@ -113,5 +191,4 @@ public interface TunnelService {
* @param listener tunnel listener
*/
void removeListener(TunnelListener listener);
}
......
......@@ -15,100 +15,206 @@
*/
package org.onosproject.net.tunnel;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DeviceId;
import java.util.Collection;
import org.onosproject.core.ApplicationId;
import org.onosproject.net.Annotations;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.tunnel.Tunnel.Type;
import org.onosproject.store.Store;
/**
* Manages inventory of tunnels.
* Manages inventory of tunnel; not intended for direct use.
*/
public interface TunnelStore extends Store<TunnelEvent, TunnelStoreDelegate> {
/**
* Creates or updates a tunnel.
*
* @param tunnel tunnel
* @return tunnel identity
*/
TunnelId createOrUpdateTunnel(Tunnel tunnel);
/**
* Deletes a tunnel by a specific tunnel identifier.
*
* @param tunnelId tunnel unique identifier generated by ONOS
*/
void deleteTunnel(TunnelId tunnelId);
/**
* Deletes all tunnels between source point and destination point.
*
* @param src a source point of tunnel.
* @param dst a destination point of tunnel.
* @param producerName producerName
*/
void deleteTunnel(TunnelEndPoint src, TunnelEndPoint dst,
ProviderId producerName);
/**
* Returns the number of tunnels in the store.
* Deletes all specific type tunnels between source point and destination
* point.
*
* @return number of tunnels
* @param src a source point of tunnel.
* @param dst a destination point of tunnel.
* @param type tunnel type
* @param producerName producerName
*/
int getTunnelCount();
void deleteTunnel(TunnelEndPoint src, TunnelEndPoint dst,
Tunnel.Type type, ProviderId producerName);
/**
* Returns an iterable collection of all tunnel in the inventory.
* Returns a specific tunnel. Annotations parameter is reserved. If there
* is no tunnel in the store, return a "null" object, and record the tunnel subscription.
* Where tunnel is created, ONOS notifies this consumer actively.
*
* @return collection of all tunnels
* @param consumerId a tunnel consumer
* @param tunnelId tunnel identify generated by onos
* @param annotations parameter
* @return Tunnel subscribed tunnel
*/
Iterable<Tunnel> getTunnels();
Tunnel borrowTunnel(ApplicationId consumerId, TunnelId tunnelId,
Annotations... annotations);
/**
* Returns all tunnels egressing from the specified device.
* Returns a specific tunnel by tunnelName. Annotations parameter is
* reserved. If there is no tunnel in the store, return a "null" object,and
* record the tunnel subscription. Where tunnel is created, ONOS notifies this consumer
* actively.
*
* @param deviceId device identifier
* @return set of device tunnels
* @param consumerId a tunnel consumer
* @param tunnelName tunnel name
* @param annotations parameter
* @return collection of subscribed Tunnels
*/
Iterable<Tunnel> getDeviceEgressTunnels(DeviceId deviceId);
Collection<Tunnel> borrowTunnel(ApplicationId consumerId,
TunnelName tunnelName,
Annotations... annotations);
/**
* Returns all tunnels ingressing from the specified device.
* Returns all tunnels between source and destination. Annotations
* parameter is reserved. If there is no any tunnel in the store, return a
* empty collection, and record the tunnel subscription. Where tunnel is created, ONOS
* notifies this consumer actively. Otherwise ONOS core returns all the
* tunnels, consumer determined which one to use.
*
* @param deviceId device identifier
* @return set of device tunnels
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel
* @param annotations parameter
* @return collection of subscribed Tunnels
*/
Iterable<Tunnel> getDeviceIngressTunnels(DeviceId deviceId);
Collection<Tunnel> borrowTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Annotations... annotations);
/**
* Returns the tunnel between the two end-points and the tunnel type.
* Returns all specified type tunnels between source and destination.
* Annotations parameter is reserved. If there is no any tunnel in the store,
* return a empty collection, and record the tunnel subscription. Where tunnel is
* created, ONOS notifies this consumer actively. Otherwise,ONOS core returns
* all available tunnels, consumer determined which one to use.
*
* @param src source connection point
* @param dst destination connection point
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel
* @param type tunnel type
* @return tunnels or null if one not found between the end-points
* @param annotations Annotations
* @return collection of available Tunnels
*/
Iterable<Tunnel> getTunnel(ConnectPoint src, ConnectPoint dst, Tunnel.Type type);
Collection<Tunnel> borrowTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations);
/**
* Returns all tunnels egressing from the specified connection point.
* Returns back a specific tunnel to store.
*
* @param src source connection point
* @return set of connection point tunnels
* @param consumerId a tunnel consumer
* @param tunnelId tunnel identify generated by ONOS
* @param annotations Annotations
* @return success or fail
*/
Iterable<Tunnel> getEgressTunnels(ConnectPoint src);
boolean returnTunnel(ApplicationId consumerId, TunnelId tunnelId,
Annotations... annotations);
/**
* Returns all tunnels ingressing to the specified connection point.
* Returns all specific name tunnel back store. Annotations parameter is
* reserved.If there is no tunnel in the store, return a "null" object,and
* record the tunnel subscription. Where tunnel is created, ONOS notifies this consumer
* actively.
*
* @param dst destination connection point
* @return set of connection point tunnels
* @param consumerId a tunnel consumer
* @param tunnelName tunnel name
* @param annotations Annotations
* @return boolean
*/
Iterable<Tunnel> getIngressTunnels(ConnectPoint dst);
boolean returnTunnel(ApplicationId consumerId, TunnelName tunnelName,
Annotations... annotations);
/**
* Creates a new tunnel based on the given information.
* Returns all specific type tunnels between source and destination back
* store. Annotations parameter is reserved.
*
* @param providerId provider identity (e.g., PCEP provider)
* @param tunnel tunnel information
* @return create tunnel event
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel
* @param type tunnel type
* @param annotations Annotations
* @return success or fail
*/
TunnelEvent addTunnel(ProviderId providerId,
Tunnel tunnel);
boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Type type,
Annotations... annotations);
/**
* Updates a new tunnel based on the given information.
* Returns all tunnels between source and destination back the store.
* Annotations parameter is reserved.
*
* @param providerId provider identity (e.g., PCEP provider)
* @param tunnel tunnel
* @return update tunnel event
* @param consumerId a tunnel consumer
* @param src a source point of tunnel.
* @param dst a destination point of tunnel.
* @param annotations Annotations
* @return success or fail
*/
TunnelEvent updateTunnel(ProviderId providerId,
Tunnel tunnel);
boolean returnTunnel(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, Annotations... annotations);
/**
* Removes a new tunnel based on the given information.
* Returns a tunnel by a specific tunnel identity.
*
* @param providerId provider identity (e.g., PCEP provider)
* @param tunnel tunnel
* @return remove tunnel event
* @param tunnelId tunnel identify generated by tunnel producer
* @return Tunnel
*/
Tunnel queryTunnel(TunnelId tunnelId);
/**
* Returns all tunnel subscription record by consumer.
*
* @param consumerId consumer identity
* @return Collection of TunnelSubscription
*/
Collection<TunnelSubscription> queryTunnelSubscription(ApplicationId consumerId);
/**
* Returns all specified type tunnels.
*
* @param type tunnel type
* @return Collection of tunnels
*/
Collection<Tunnel> queryTunnel(Type type);
/**
* Returns all tunnels between source point and destination point.
*
* @param src a source point of tunnel.
* @param dst a destination point of tunnel.
* @return Collection of tunnels
*/
TunnelEvent removeTunnel(ProviderId providerId,
Tunnel tunnel);
Collection<Tunnel> queryTunnel(TunnelEndPoint src, TunnelEndPoint dst);
/**
* Returns all tunnels.
* @return all tunnels
*/
int tunnelCount();
}
......
package org.onosproject.net.tunnel;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Objects;
import org.onosproject.core.ApplicationId;
import org.onosproject.net.AbstractAnnotated;
import org.onosproject.net.Annotations;
import org.onosproject.net.tunnel.Tunnel.Type;
import com.google.common.base.MoreObjects;
/**
* Represents for a order that consumer subscribe tunnel. ONOS maintains request
* information, it means ONOS knows how much resource echo consumer uses in the
* ONOS. Although there is no a tunnel that consumer want to use, when producer
* creates a new tunnel, ONOS will notify the consumers that want to use it.
*/
public final class TunnelSubscription extends AbstractAnnotated {
private final ApplicationId consumerId;
private final TunnelEndPoint src;
private final TunnelEndPoint dst;
private final Type type;
private final TunnelId tunnelId;
private final TunnelName tunnelName;
/**
* Creates a TunnelSubscription.
*
* @param consumerId consumer identity
* @param src source tunnel end point of tunnel
* @param dst destination tunnel end point of tunnel
* @param tunnelId tunnel identity
* @param type tunnel type
* @param tunnelName the name of a tunnel
* @param annotations parameter
*/
public TunnelSubscription(ApplicationId consumerId, TunnelEndPoint src,
TunnelEndPoint dst, TunnelId tunnelId, Type type,
TunnelName tunnelName, Annotations... annotations) {
super(annotations);
checkNotNull(consumerId, "consumerId cannot be null");
this.consumerId = consumerId;
this.src = src;
this.dst = dst;
this.type = type;
this.tunnelId = tunnelId;
this.tunnelName = tunnelName;
}
/**
* Returns consumer identity.
*
* @return consumerId consumer id
*/
public ApplicationId consumerId() {
return consumerId;
}
/**
* Returns source point of tunnel.
*
* @return source point
*/
public TunnelEndPoint src() {
return src;
}
/**
* Returns destination point of tunnel.
*
* @return destination point
*/
public TunnelEndPoint dst() {
return dst;
}
/**
* Returns tunnel type.
*
* @return tunnel type
*/
public Type type() {
return type;
}
/**
* Returns tunnel identity.
*
* @return tunnel id
*/
public TunnelId tunnelId() {
return tunnelId;
}
/**
* Returns tunnel name.
*
* @return tunnel name
*/
public TunnelName tunnelName() {
return tunnelName;
}
@Override
public int hashCode() {
return Objects.hash(consumerId, src, dst, type, tunnelId, tunnelName);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof TunnelSubscription) {
final TunnelSubscription other = (TunnelSubscription) obj;
return Objects.equals(this.src, other.src)
&& Objects.equals(this.dst, other.dst)
&& Objects.equals(this.consumerId, other.consumerId)
&& Objects.equals(this.type, other.type)
&& Objects.equals(this.tunnelId, other.tunnelId)
&& Objects.equals(this.tunnelName, other.tunnelName);
}
return false;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass())
.add("src", src)
.add("dst", dst)
.add("consumerId", consumerId)
.add("type", type)
.add("tunnelId", tunnelId)
.add("tunnelName", tunnelName).toString();
}
}
package org.onosproject.net.tunnel;
import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
import org.junit.Test;
import org.onlab.packet.IpAddress;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.provider.ProviderId;
import com.google.common.testing.EqualsTester;
/**
* Test of the default tunnel model entity.
*/
public class DefaultTunnelTest {
/**
* Checks that the Order class is immutable.
*/
@Test
public void testImmutability() {
assertThatClassIsImmutable(DefaultTunnel.class);
}
@Test
public void testEquality() {
TunnelEndPoint src = IpTunnelEndPoint.ipTunnelPoint(IpAddress
.valueOf(23423));
TunnelEndPoint dst = IpTunnelEndPoint.ipTunnelPoint(IpAddress
.valueOf(32421));
DefaultGroupId groupId = new DefaultGroupId(92034);
TunnelName tunnelName = TunnelName.tunnelName("TunnelName");
TunnelId tunnelId = TunnelId.valueOf(41654654);
ProviderId producerName1 = new ProviderId("producer1", "13");
ProviderId producerName2 = new ProviderId("producer2", "13");
Tunnel p1 = new DefaultTunnel(producerName1, src, dst, Tunnel.Type.VXLAN,
Tunnel.State.ACTIVE, groupId, tunnelId,
tunnelName);
Tunnel p2 = new DefaultTunnel(producerName1, src, dst, Tunnel.Type.VXLAN,
Tunnel.State.ACTIVE, groupId, tunnelId,
tunnelName);
Tunnel p3 = new DefaultTunnel(producerName2, src, dst, Tunnel.Type.OCH,
Tunnel.State.ACTIVE, groupId, tunnelId,
tunnelName);
new EqualsTester().addEqualityGroup(p1, p2).addEqualityGroup(p3)
.testEquals();
}
}
package org.onosproject.net.tunnel;
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.onlab.packet.IpAddress;
import org.onosproject.core.DefaultGroupId;
import org.onosproject.net.provider.ProviderId;
/**
* Test of a tunnel event.
*/
public class TunnelEventTest {
/**
* Checks that the Order class is immutable.
*/
@Test
public void testImmutability() {
assertThatClassIsImmutable(TunnelEvent.class);
}
/**
* Checks the operation of equals(), hashCode() and toString() methods.
*/
@Test
public void testConstructor() {
TunnelEndPoint src = IpTunnelEndPoint.ipTunnelPoint(IpAddress
.valueOf(23423));
TunnelEndPoint dst = IpTunnelEndPoint.ipTunnelPoint(IpAddress
.valueOf(32421));
DefaultGroupId groupId = new DefaultGroupId(92034);
TunnelName tunnelName = TunnelName.tunnelName("TunnelName");
TunnelId tunnelId = TunnelId.valueOf(41654654);
ProviderId producerName1 = new ProviderId("producer1", "13");
Tunnel p1 = new DefaultTunnel(producerName1, src, dst, Tunnel.Type.VXLAN,
Tunnel.State.ACTIVE, groupId, tunnelId,
tunnelName);
TunnelEvent e1 = new TunnelEvent(TunnelEvent.Type.TUNNEL_ADDED, p1);
assertThat(e1, is(notNullValue()));
assertThat(e1.type(), is(TunnelEvent.Type.TUNNEL_ADDED));
assertThat(e1.subject(), is(p1));
}
}
package org.onosproject.net.tunnel;
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 com.google.common.testing.EqualsTester;
/**
* Unit tests for tunnel id class.
*/
public class TunnelIdTest {
final TunnelId tunnelId1 = TunnelId.valueOf(1);
final TunnelId sameAstunnelId1 = TunnelId.valueOf(1);
final TunnelId tunnelId2 = TunnelId.valueOf(2);
/**
* Checks that the TunnelId class is immutable.
*/
@Test
public void testImmutability() {
assertThatClassIsImmutable(TunnelId.class);
}
/**
* Checks the operation of equals(), hashCode() and toString() methods.
*/
@Test
public void testEquals() {
new EqualsTester()
.addEqualityGroup(tunnelId1, sameAstunnelId1)
.addEqualityGroup(tunnelId2)
.testEquals();
}
/**
* Checks the construction of a FlowId object.
*/
@Test
public void testConstruction() {
final long tunnelIdValue = 7777L;
final TunnelId tunnelId = TunnelId.valueOf(tunnelIdValue);
assertThat(tunnelId, is(notNullValue()));
assertThat(tunnelId.id(), is(tunnelIdValue));
}
}
package org.onosproject.net.tunnel;
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 com.google.common.testing.EqualsTester;
/**
* Unit tests for tunnel name class.
*/
public class TunnelNameTest {
final TunnelName name1 = TunnelName.tunnelName("name1");
final TunnelName sameAsName1 = TunnelName.tunnelName("name1");
final TunnelName name2 = TunnelName.tunnelName("name2");
/**
* Checks that the TunnelName class is immutable.
*/
@Test
public void testImmutability() {
assertThatClassIsImmutable(TunnelName.class);
}
/**
* Checks the operation of equals(), hashCode() and toString() methods.
*/
@Test
public void testEquals() {
new EqualsTester().addEqualityGroup(name1, sameAsName1)
.addEqualityGroup(name2).testEquals();
}
/**
* Checks the construction of a OpenFlowGroupId object.
*/
@Test
public void testConstruction() {
final String nameValue = "name3";
final TunnelName name = TunnelName.tunnelName(nameValue);
assertThat(name, is(notNullValue()));
assertThat(name.value(), is(nameValue));
}
}
package org.onosproject.net.tunnel;
import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
import org.junit.Test;
import org.onlab.packet.IpAddress;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.DefaultApplicationId;
import com.google.common.testing.EqualsTester;
/**
* Test of order model entity.
*/
public class TunnelSubscriptionTest {
/**
* Checks that the Order class is immutable.
*/
@Test
public void testImmutability() {
assertThatClassIsImmutable(TunnelSubscription.class);
}
/**
* Checks the operation of equals(), hashCode() and toString() methods.
*/
@Test
public void testEquality() {
TunnelEndPoint src = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(23423));
TunnelEndPoint dst = IpTunnelEndPoint.ipTunnelPoint(IpAddress.valueOf(32421));
ApplicationId appId = new DefaultApplicationId(243, "test");
ApplicationId appId2 = new DefaultApplicationId(2431, "test1");
TunnelId tunnelId = TunnelId.valueOf(41654654);
TunnelSubscription p1 = new TunnelSubscription(appId, src, dst, tunnelId, Tunnel.Type.VXLAN,
null);
TunnelSubscription p2 = new TunnelSubscription(appId, src, dst, tunnelId, Tunnel.Type.VXLAN,
null);
TunnelSubscription p3 = new TunnelSubscription(appId2, src, dst, tunnelId, Tunnel.Type.VXLAN,
null);
new EqualsTester().addEqualityGroup(p1, p2).addEqualityGroup(p3)
.testEquals();
}
}