/*
* Copyright 2016-present 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.ui.impl.topo.model;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.cluster.ClusterService;
import org.onosproject.cluster.ClusterServiceAdapter;
import org.onosproject.cluster.ControllerNode;
import org.onosproject.cluster.DefaultControllerNode;
import org.onosproject.cluster.NodeId;
import org.onosproject.cluster.RoleInfo;
import org.onosproject.mastership.MastershipService;
import org.onosproject.mastership.MastershipServiceAdapter;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DefaultAnnotations;
import org.onosproject.net.DefaultDevice;
import org.onosproject.net.DefaultHost;
import org.onosproject.net.DefaultLink;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.Host;
import org.onosproject.net.HostId;
import org.onosproject.net.HostLocation;
import org.onosproject.net.Link;
import org.onosproject.net.PortNumber;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.device.DeviceServiceAdapter;
import org.onosproject.net.flow.FlowRuleService;
import org.onosproject.net.host.HostService;
import org.onosproject.net.host.HostServiceAdapter;
import org.onosproject.net.intent.IntentService;
import org.onosproject.net.link.LinkService;
import org.onosproject.net.link.LinkServiceAdapter;
import org.onosproject.net.provider.ProviderId;
import org.onosproject.net.region.DefaultRegion;
import org.onosproject.net.region.Region;
import org.onosproject.net.region.RegionId;
import org.onosproject.net.region.RegionService;
import org.onosproject.ui.UiTopoLayoutService;
import org.onosproject.ui.impl.AbstractUiImplTest;
import org.onosproject.ui.model.ServiceBundle;
import org.onosproject.ui.model.topo.UiTopoLayout;
import org.onosproject.ui.model.topo.UiTopoLayoutId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.onosproject.cluster.NodeId.nodeId;
import static org.onosproject.net.DeviceId.deviceId;
import static org.onosproject.net.HostId.hostId;
import static org.onosproject.net.PortNumber.portNumber;
import static org.onosproject.ui.model.topo.UiTopoLayoutId.layoutId;
/**
* Base class for model test classes.
*/
abstract class AbstractTopoModelTest extends AbstractUiImplTest {
/*
Our mock environment:
Three controllers: C1, C2, C3
Nine devices: D1 .. D9
D4 ---+ +--- D7
| |
D5 --- D1 --- D2 --- D3 --- D8
| |
D6 ---+ +--- D9
Twelve hosts (two per D4 ... D9) H4a, H4b, H5a, H5b, ...
Layouts:
LROOT : (default)
+-- L1 : R1
+-- L2 : R2
+-- L3 : R3
Regions:
R1 : D1, D2, D3
R2 : D4, D5, D6
R3 : D7, D8, D9
Mastership:
C1 : D1, D2, D3
C2 : D4, D5, D6
C3 : D7, D8, D9
Roles: (backups)
C1 -> C2, C3
C2 -> C1, C3
C3 -> C1, C2
*/
protected static final String C1 = "C1";
protected static final String C2 = "C2";
protected static final String C3 = "C3";
protected static final NodeId CNID_1 = nodeId(C1);
protected static final NodeId CNID_2 = nodeId(C2);
protected static final NodeId CNID_3 = nodeId(C3);
protected static final ControllerNode CNODE_1 = cnode(CNID_1, "10.0.0.1");
protected static final ControllerNode CNODE_2 = cnode(CNID_2, "10.0.0.2");
protected static final ControllerNode CNODE_3 = cnode(CNID_3, "10.0.0.3");
protected static final String R1 = "R1";
protected static final String R2 = "R2";
protected static final String R3 = "R3";
protected static final Set<NodeId> SET_C1 = ImmutableSet.of(CNID_1);
protected static final Set<NodeId> SET_C2 = ImmutableSet.of(CNID_2);
protected static final Set<NodeId> SET_C3 = ImmutableSet.of(CNID_3);
protected static final Region REGION_1 =
region(R1, Region.Type.METRO, ImmutableList.of(SET_C1, SET_C2));
protected static final Region REGION_2 =
region(R2, Region.Type.CAMPUS, ImmutableList.of(SET_C2, SET_C1));
protected static final Region REGION_3 =
region(R3, Region.Type.CAMPUS, ImmutableList.of(SET_C3, SET_C1));
protected static final Set<Region> REGION_SET =
ImmutableSet.of(REGION_1, REGION_2, REGION_3);
protected static final String LROOT = "LROOT";
protected static final String L1 = "L1";
protected static final String L2 = "L2";
protected static final String L3 = "L3";
protected static final UiTopoLayout LAYOUT_ROOT = layout(LROOT, null, null);
protected static final UiTopoLayout LAYOUT_1 = layout(L1, REGION_1, LROOT);
protected static final UiTopoLayout LAYOUT_2 = layout(L2, REGION_2, LROOT);
protected static final UiTopoLayout LAYOUT_3 = layout(L3, REGION_3, LROOT);
protected static final Set<UiTopoLayout> LAYOUT_SET =
ImmutableSet.of(LAYOUT_ROOT, LAYOUT_1, LAYOUT_2, LAYOUT_3);
protected static final Set<UiTopoLayout> ROOT_KIDS =
ImmutableSet.of(LAYOUT_1, LAYOUT_2, LAYOUT_3);
protected static final Set<UiTopoLayout> PEERS_OF_1 =
ImmutableSet.of(LAYOUT_2, LAYOUT_3);
protected static final Set<UiTopoLayout> PEERS_OF_2 =
ImmutableSet.of(LAYOUT_1, LAYOUT_3);
protected static final Set<UiTopoLayout> PEERS_OF_3 =
ImmutableSet.of(LAYOUT_1, LAYOUT_2);
protected static final String D1 = "d1";
protected static final String D2 = "d2";
protected static final String D3 = "d3";
protected static final String D4 = "d4";
protected static final String D5 = "d5";
protected static final String D6 = "d6";
protected static final String D7 = "d7";
protected static final String D8 = "d8";
protected static final String D9 = "d9";
protected static final String MFR = "Mfr";
protected static final String HW = "h/w";
protected static final String SW = "s/w";
protected static final String SERIAL = "ser123";
protected static final DeviceId DEVID_1 = deviceId(D1);
protected static final DeviceId DEVID_2 = deviceId(D2);
protected static final DeviceId DEVID_3 = deviceId(D3);
protected static final DeviceId DEVID_4 = deviceId(D4);
protected static final DeviceId DEVID_5 = deviceId(D5);
protected static final DeviceId DEVID_6 = deviceId(D6);
protected static final DeviceId DEVID_7 = deviceId(D7);
protected static final DeviceId DEVID_8 = deviceId(D8);
protected static final DeviceId DEVID_9 = deviceId(D9);
protected static final Device DEV_1 = device(D1);
protected static final Device DEV_2 = device(D2);
protected static final Device DEV_3 = device(D3);
protected static final Device DEV_4 = device(D4);
protected static final Device DEV_5 = device(D5);
protected static final Device DEV_6 = device(D6);
protected static final Device DEV_7 = device(D7);
protected static final Device DEV_8 = device(D8);
protected static final Device DEV_9 = device(D9);
protected static final List<Device> ALL_DEVS =
ImmutableList.of(
DEV_1, DEV_2, DEV_3,
DEV_4, DEV_5, DEV_6,
DEV_7, DEV_8, DEV_9
);
private static final Set<DeviceId> DEVS_TRUNK =
ImmutableSet.of(DEVID_1, DEVID_2, DEVID_3);
private static final Set<DeviceId> DEVS_LEFT =
ImmutableSet.of(DEVID_4, DEVID_5, DEVID_6);
private static final Set<DeviceId> DEVS_RIGHT =
ImmutableSet.of(DEVID_7, DEVID_8, DEVID_9);
private static final String[][] LINK_CONNECT_DATA = {
{D1, "12", D2, "21"},
{D2, "23", D3, "32"},
{D4, "41", D1, "14"},
{D5, "51", D1, "15"},
{D6, "61", D1, "16"},
{D7, "73", D3, "37"},
{D8, "83", D3, "38"},
{D9, "93", D3, "39"},
};
private static final String HOST_MAC_PREFIX = "aa:00:00:00:00:";
/**
* Returns IP address instance for given string.
*
* @param s string
* @return IP address
*/
protected static IpAddress ip(String s) {
return IpAddress.valueOf(s);
}
/**
* Returns controller node instance for given ID and IP.
*
* @param id identifier
* @param ip IP address
* @return controller node instance
*/
protected static ControllerNode cnode(NodeId id, String ip) {
return new DefaultControllerNode(id, ip(ip));
}
/**
* Returns UI topology layout instance with the specified parameters.
*
* @param layoutId the layout ID
* @param region the backing region
* @param parentId the parent layout ID
* @return layout instance
*/
protected static UiTopoLayout layout(String layoutId, Region region,
String parentId) {
UiTopoLayoutId pid = parentId == null
? UiTopoLayoutId.DEFAULT_ID : layoutId(parentId);
return new UiTopoLayout(layoutId(layoutId)).region(region).parent(pid);
}
/**
* Returns a region instance with specified parameters.
*
* @param id region id
* @param type region type
* @param masters ordered list of master sets
* @return region instance
*/
protected static Region region(String id, Region.Type type,
List<Set<NodeId>> masters) {
return new DefaultRegion(RegionId.regionId(id), "Region-" + id,
type, DefaultAnnotations.EMPTY, masters);
}
/**
* Returns device with given ID.
*
* @param id device ID
* @return device instance
*/
protected static Device device(String id) {
return new DefaultDevice(ProviderId.NONE, deviceId(id),
Device.Type.SWITCH, MFR, HW, SW, SERIAL, null);
}
/**
* Returns canned results.
* <p>
* At some future point, we may make this "programmable", so that
* its state can be changed over the course of a unit test.
*/
protected static final ServiceBundle MOCK_SERVICES =
new ServiceBundle() {
@Override
public UiTopoLayoutService layout() {
return MOCK_LAYOUT;
}
@Override
public ClusterService cluster() {
return MOCK_CLUSTER;
}
@Override
public MastershipService mastership() {
return MOCK_MASTER;
}
@Override
public RegionService region() {
return MOCK_REGION;
}
@Override
public DeviceService device() {
return MOCK_DEVICE;
}
@Override
public LinkService link() {
return MOCK_LINK;
}
@Override
public HostService host() {
return MOCK_HOST;
}
@Override
public IntentService intent() {
return null;
}
@Override
public FlowRuleService flow() {
return null;
}
};
private static final ClusterService MOCK_CLUSTER = new MockClusterService();
private static final MastershipService MOCK_MASTER = new MockMasterService();
private static final UiTopoLayoutService MOCK_LAYOUT = new MockLayoutService();
private static final RegionService MOCK_REGION = new MockRegionService();
private static final DeviceService MOCK_DEVICE = new MockDeviceService();
private static final LinkService MOCK_LINK = new MockLinkService();
private static final HostService MOCK_HOST = new MockHostService();
private static class MockClusterService extends ClusterServiceAdapter {
private final Map<NodeId, ControllerNode> nodes = new HashMap<>();
private final Map<NodeId, ControllerNode.State> states = new HashMap<>();
MockClusterService() {
nodes.put(CNODE_1.id(), CNODE_1);
nodes.put(CNODE_2.id(), CNODE_2);
nodes.put(CNODE_3.id(), CNODE_3);
states.put(CNODE_1.id(), ControllerNode.State.READY);
states.put(CNODE_2.id(), ControllerNode.State.ACTIVE);
states.put(CNODE_3.id(), ControllerNode.State.ACTIVE);
}
@Override
public Set<ControllerNode> getNodes() {
return ImmutableSet.copyOf(nodes.values());
}
@Override
public ControllerNode getNode(NodeId nodeId) {
return nodes.get(nodeId);
}
@Override
public ControllerNode.State getState(NodeId nodeId) {
return states.get(nodeId);
}
}
private static class MockMasterService extends MastershipServiceAdapter {
private final Map<NodeId, Set<DeviceId>> masterOf = new HashMap<>();
MockMasterService() {
masterOf.put(CNODE_1.id(), DEVS_TRUNK);
masterOf.put(CNODE_2.id(), DEVS_LEFT);
masterOf.put(CNODE_3.id(), DEVS_RIGHT);
}
@Override
public NodeId getMasterFor(DeviceId deviceId) {
if (DEVS_TRUNK.contains(deviceId)) {
return CNID_1;
}
if (DEVS_LEFT.contains(deviceId)) {
return CNID_2;
}
if (DEVS_RIGHT.contains(deviceId)) {
return CNID_3;
}
return null;
}
@Override
public Set<DeviceId> getDevicesOf(NodeId nodeId) {
return masterOf.get(nodeId);
}
@Override
public RoleInfo getNodesFor(DeviceId deviceId) {
NodeId master = null;
List<NodeId> backups = new ArrayList<>();
if (DEVS_TRUNK.contains(deviceId)) {
master = CNID_1;
backups.add(CNID_2);
backups.add(CNID_3);
} else if (DEVS_LEFT.contains(deviceId)) {
master = CNID_2;
backups.add(CNID_1);
backups.add(CNID_3);
} else if (DEVS_RIGHT.contains(deviceId)) {
master = CNID_3;
backups.add(CNID_1);
backups.add(CNID_2);
}
return new RoleInfo(master, backups);
}
}
// TODO: consider implementing UiTopoLayoutServiceAdapter and extending that here
private static class MockLayoutService implements UiTopoLayoutService {
private final Map<UiTopoLayoutId, UiTopoLayout> map = new HashMap<>();
private final Map<UiTopoLayoutId, Set<UiTopoLayout>> peers = new HashMap<>();
private final Map<RegionId, UiTopoLayout> byRegion = new HashMap<>();
MockLayoutService() {
map.put(LAYOUT_ROOT.id(), LAYOUT_ROOT);
map.put(LAYOUT_1.id(), LAYOUT_1);
map.put(LAYOUT_2.id(), LAYOUT_2);
map.put(LAYOUT_3.id(), LAYOUT_3);
peers.put(LAYOUT_ROOT.id(), ImmutableSet.of());
peers.put(LAYOUT_1.id(), ImmutableSet.of(LAYOUT_2, LAYOUT_3));
peers.put(LAYOUT_2.id(), ImmutableSet.of(LAYOUT_1, LAYOUT_3));
peers.put(LAYOUT_3.id(), ImmutableSet.of(LAYOUT_1, LAYOUT_2));
byRegion.put(REGION_1.id(), LAYOUT_1);
byRegion.put(REGION_2.id(), LAYOUT_2);
byRegion.put(REGION_3.id(), LAYOUT_3);
}
@Override
public UiTopoLayout getRootLayout() {
return LAYOUT_ROOT;
}
@Override
public Set<UiTopoLayout> getLayouts() {
return LAYOUT_SET;
}
@Override
public boolean addLayout(UiTopoLayout layout) {
return false;
}
@Override
public UiTopoLayout getLayout(UiTopoLayoutId layoutId) {
return map.get(layoutId);
}
@Override
public UiTopoLayout getLayout(RegionId regionId) {
return byRegion.get(regionId);
}
@Override
public Set<UiTopoLayout> getPeerLayouts(UiTopoLayoutId layoutId) {
return peers.get(layoutId);
}
@Override
public Set<UiTopoLayout> getChildren(UiTopoLayoutId layoutId) {
return LAYOUT_ROOT.id().equals(layoutId)
? ROOT_KIDS
: Collections.emptySet();
}
@Override
public boolean removeLayout(UiTopoLayout layout) {
return false;
}
}
private static class MockRegionService extends RegionServiceAdapter {
private final Map<RegionId, Region> lookup = new HashMap<>();
MockRegionService() {
lookup.put(REGION_1.id(), REGION_1);
lookup.put(REGION_2.id(), REGION_2);
lookup.put(REGION_3.id(), REGION_3);
}
@Override
public Set<Region> getRegions() {
return REGION_SET;
}
@Override
public Region getRegion(RegionId regionId) {
return lookup.get(regionId);
}
@Override
public Region getRegionForDevice(DeviceId deviceId) {
if (DEVS_TRUNK.contains(deviceId)) {
return REGION_1;
}
if (DEVS_LEFT.contains(deviceId)) {
return REGION_2;
}
if (DEVS_RIGHT.contains(deviceId)) {
return REGION_3;
}
return null;
}
@Override
public Set<DeviceId> getRegionDevices(RegionId regionId) {
if (REGION_1.id().equals(regionId)) {
return DEVS_TRUNK;
}
if (REGION_2.id().equals(regionId)) {
return DEVS_LEFT;
}
if (REGION_3.id().equals(regionId)) {
return DEVS_RIGHT;
}
return Collections.emptySet();
}
}
private static class MockDeviceService extends DeviceServiceAdapter {
private final Map<DeviceId, Device> devices = new HashMap<>();
MockDeviceService() {
for (Device dev : ALL_DEVS) {
devices.put(dev.id(), dev);
}
}
@Override
public int getDeviceCount() {
return devices.size();
}
@Override
public Iterable<Device> getDevices() {
return ImmutableList.copyOf(devices.values());
}
@Override
public Device getDevice(DeviceId deviceId) {
return devices.get(deviceId);
}
}
/**
* Synthesizes a pair of unidirectional links between two devices. The
* string array should be of the form:
* <pre>
* { "device-A-id", "device-A-port", "device-B-id", "device-B-port" }
* </pre>
*
* @param linkPairData device ids and ports
* @return pair of synthesized links
*/
protected static List<Link> makeLinkPair(String[] linkPairData) {
DeviceId devA = deviceId(linkPairData[0]);
PortNumber portA = portNumber(Long.valueOf(linkPairData[1]));
DeviceId devB = deviceId(linkPairData[2]);
PortNumber portB = portNumber(Long.valueOf(linkPairData[3]));
Link linkA = DefaultLink.builder()
.providerId(ProviderId.NONE)
.type(Link.Type.DIRECT)
.src(new ConnectPoint(devA, portA))
.dst(new ConnectPoint(devB, portB))
.build();
Link linkB = DefaultLink.builder()
.providerId(ProviderId.NONE)
.type(Link.Type.DIRECT)
.src(new ConnectPoint(devB, portB))
.dst(new ConnectPoint(devA, portA))
.build();
return ImmutableList.of(linkA, linkB);
}
private static class MockLinkService extends LinkServiceAdapter {
private final Set<Link> links = new HashSet<>();
MockLinkService() {
for (String[] linkPair : LINK_CONNECT_DATA) {
links.addAll(makeLinkPair(linkPair));
}
}
@Override
public int getLinkCount() {
return links.size();
}
@Override
public Iterable<Link> getLinks() {
return ImmutableSet.copyOf(links);
}
// TODO: possibly fill out other methods if we find the model uses them
}
/**
* Creates a default host connected at the given edge device and port. Note
* that an identifying hex character ("a" - "f") should be supplied. This
* will be included in the MAC address of the host (and equivalent value
* as last byte in IP address).
*
* @param device edge device
* @param port port number
* @param hexChar identifying hex character
* @return host connected at that location
*/
protected static Host createHost(Device device, int port, String hexChar) {
DeviceId deviceId = device.id();
String devNum = deviceId.toString().substring(1);
MacAddress mac = MacAddress.valueOf(HOST_MAC_PREFIX + devNum + hexChar);
HostId hostId = hostId(String.format("%s/-1", mac));
int ipByte = Integer.valueOf(hexChar, 16);
if (ipByte < 10 || ipByte > 15) {
throw new IllegalArgumentException("hexChar must be a-f");
}
HostLocation loc = new HostLocation(deviceId, portNumber(port), 0);
IpAddress ip = ip("10." + devNum + ".0." + ipByte);
return new DefaultHost(ProviderId.NONE, hostId, mac, VlanId.NONE,
loc, ImmutableSet.of(ip));
}
/**
* Creates a pair of hosts connected to the specified device.
*
* @param d edge device
* @return pair of hosts
*/
protected static List<Host> createHostPair(Device d) {
List<Host> hosts = new ArrayList<>();
hosts.add(createHost(d, 101, "a"));
hosts.add(createHost(d, 102, "b"));
return hosts;
}
private static class MockHostService extends HostServiceAdapter {
private final Map<HostId, Host> hosts = new HashMap<>();
MockHostService() {
for (Device d : ALL_DEVS) {
for (Host h : createHostPair(d)) {
hosts.put(h.id(), h);
}
}
}
@Override
public int getHostCount() {
return hosts.size();
}
@Override
public Iterable<Host> getHosts() {
return ImmutableSet.copyOf(hosts.values());
}
@Override
public Host getHost(HostId hostId) {
return hosts.get(hostId);
}
// TODO: possibly fill out other methods, should the model require them
}
}