import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Gets infrastructure links.
 * Returns array of all links, or links for the specified device or port.
 * @onos.rsModel LinksGet
 * @param deviceId  (optional) device identifier
 * @param port      (optional) port number
 * @param direction (optional) direction qualifier
 * @return 200 OK with array of all links, or links for the specified device or port
 */
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getLinks(@QueryParam("device") String deviceId,
                         @QueryParam("port") String port,
                         @QueryParam("direction") String direction) {
    LinkService service = get(LinkService.class);
    Iterable<Link> links;

    if (deviceId != null && port != null) {
        links = getConnectPointLinks(new ConnectPoint(deviceId(deviceId),
                                                      portNumber(port)),
                                     direction, service);
    } else if (deviceId != null) {
        links = getDeviceLinks(deviceId(deviceId), direction, service);
    } else {
        links = service.getLinks();
    }
    return ok(encodeArray(Link.class, "links", links)).build();
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
private ObjectNode portData(Port p, DeviceId id) {
    ObjectNode port = objectNode();
    LinkService ls = get(LinkService.class);
    String name = p.annotations().value(AnnotationKeys.PORT_NAME);

    port.put(ID, capitalizeFully(p.number().toString()));
    port.put(TYPE, capitalizeFully(p.type().toString()));
    port.put(SPEED, p.portSpeed());
    port.put(ENABLED, p.isEnabled());
    port.put(NAME, name != null ? name : "");

    Set<Link> links = ls.getEgressLinks(new ConnectPoint(id, p.number()));
    if (!links.isEmpty()) {
        StringBuilder egressLinks = new StringBuilder();
        for (Link l : links) {
            ConnectPoint dest = l.dst();
            egressLinks.append(dest.elementId()).append("/")
                    .append(dest.port()).append(" ");
        }
        port.put(LINK_DEST, egressLinks.toString());
    }

    return port;
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Creates the services bundle.
 *
 * @param intentService     intent service reference
 * @param deviceService     device service reference
 * @param hostService       host service reference
 * @param linkService       link service reference
 * @param flowService       flow service reference
 * @param flowStatsService  flow statistics service reference
 * @param portStatsService  port statistics service reference
 */
public ServicesBundle(IntentService intentService,
                      DeviceService deviceService,
                      HostService hostService,
                      LinkService linkService,
                      FlowRuleService flowService,
                      StatisticService flowStatsService,
                      PortStatisticsService portStatsService) {
    this.intentService = checkNotNull(intentService);
    this.deviceService = checkNotNull(deviceService);
    this.hostService = checkNotNull(hostService);
    this.linkService = checkNotNull(linkService);
    this.flowService = checkNotNull(flowService);
    this.flowStatsService = checkNotNull(flowStatsService);
    this.portStatsService = checkNotNull(portStatsService);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
@Override
public void init(UiConnection connection, ServiceDirectory directory) {
    super.init(connection, directory);
    this.directory = checkNotNull(directory, "Directory cannot be null");
    clusterService = directory.get(ClusterService.class);
    deviceService = directory.get(DeviceService.class);
    linkService = directory.get(LinkService.class);
    hostService = directory.get(HostService.class);
    mastershipService = directory.get(MastershipService.class);
    intentService = directory.get(IntentService.class);
    flowService = directory.get(FlowRuleService.class);
    flowStatsService = directory.get(StatisticService.class);
    portStatsService = directory.get(PortStatisticsService.class);
    topologyService = directory.get(TopologyService.class);
    tunnelService = directory.get(TunnelService.class);

    servicesBundle = new ServicesBundle(intentService, deviceService,
                                        hostService, linkService,
                                        flowService,
                                        flowStatsService, portStatsService);

    String ver = directory.get(CoreService.class).version().toString();
    version = ver.replace(".SNAPSHOT", "*").replaceFirst("~.*$", "");
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Initializes a new topology simulator with access to the specified service
 * directory and various provider services.
 *
 * @param topoShape             topology shape specifier
 * @param deviceCount           number of devices in the topology
 * @param hostCount             number of hosts per device
 * @param directory             service directory
 * @param deviceProviderService device provider service
 * @param hostProviderService   host provider service
 * @param linkProviderService   link provider service
 */
protected void init(String topoShape, int deviceCount, int hostCount,
                    ServiceDirectory directory,
                    DeviceProviderService deviceProviderService,
                    HostProviderService hostProviderService,
                    LinkProviderService linkProviderService) {
    this.deviceCount = deviceCount;
    this.hostCount = hostCount;
    this.directory = directory;

    this.clusterService = directory.get(ClusterService.class);
    this.mastershipService = directory.get(MastershipService.class);

    this.deviceService = directory.get(DeviceAdminService.class);
    this.hostService = directory.get(HostService.class);
    this.linkService = directory.get(LinkService.class);
    this.deviceProviderService = deviceProviderService;
    this.hostProviderService = hostProviderService;
    this.linkProviderService = linkProviderService;

    localNode = clusterService.getLocalNode().id();

    processTopoShape(topoShape);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Starts the mutation process.
 *
 * @param mutationRate          link events per second
 * @param linkService           link service
 * @param deviceService         device service
 * @param linkProviderService   link provider service
 * @param deviceProviderService device provider service
 * @param simulator             topology simulator
 */
void start(double mutationRate,
           LinkService linkService, DeviceService deviceService,
           LinkProviderService linkProviderService,
           DeviceProviderService deviceProviderService,
           TopologySimulator simulator) {
    savedLinks.clear();
    stopped = false;
    this.linkService = linkService;
    this.deviceService = deviceService;
    this.linkProviderService = linkProviderService;
    this.deviceProviderService = deviceProviderService;
    this.simulator = simulator;
    activeLinks = reduceLinks();
    inactiveLinks = Lists.newArrayList();
    adjustRate(mutationRate);
    executor.execute(this);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
@Override
public int complete(String buffer, int cursor, List<String> candidates) {
    // Delegate string completer
    StringsCompleter delegate = new StringsCompleter();

    // Fetch our service and feed it's offerings to the string completer
    LinkService service = AbstractShellCommand.get(LinkService.class);

    // Link source the previous argument.
    ArgumentCompleter.ArgumentList list = getArgumentList();
    String srcArg = list.getArguments()[list.getCursorArgumentIndex() - 1];

    // Generate the device ID/port number identifiers
    SortedSet<String> strings = delegate.getStrings();
    try {
        ConnectPoint src = ConnectPoint.deviceConnectPoint(srcArg);
        service.getEgressLinks(src)
                .forEach(link -> strings.add(link.dst().elementId().toString() +
                                                     "/" + link.dst().port()));
    } catch (NumberFormatException e) {
        System.err.println("Invalid connect-point");
    }

    // Now let the completer do the work for figuring out what to offer.
    return delegate.complete(buffer, cursor, candidates);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
@Override
public int complete(String buffer, int cursor, List<String> candidates) {
    // Delegate string completer
    StringsCompleter delegate = new StringsCompleter();

    // Fetch our service and feed it's offerings to the string completer
    LinkService service = AbstractShellCommand.get(LinkService.class);

    // Generate the device ID/port number identifiers
    SortedSet<String> strings = delegate.getStrings();
    service.getLinks()
            .forEach(link -> strings.add(link.src().elementId().toString() +
                                                 "/" + link.src().port()));

    // Now let the completer do the work for figuring out what to offer.
    return delegate.complete(buffer, cursor, candidates);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
protected DefaultGroupHandler(DeviceId deviceId, ApplicationId appId,
                              DeviceProperties config,
                              LinkService linkService,
                              FlowObjectiveService flowObjService,
                              SegmentRoutingManager srManager) {
    this.deviceId = checkNotNull(deviceId);
    this.appId = checkNotNull(appId);
    this.deviceConfig = checkNotNull(config);
    this.linkService = checkNotNull(linkService);
    this.allSegmentIds = checkNotNull(config.getAllDeviceSegmentIds());
    try {
        this.nodeSegmentId = config.getSegmentId(deviceId);
        this.isEdgeRouter = config.isEdgeDevice(deviceId);
        this.nodeMacAddr = checkNotNull(config.getDeviceMac(deviceId));
    } catch (DeviceConfigNotFoundException e) {
        log.warn(e.getMessage()
                + " Skipping value assignment in DefaultGroupHandler");
    }
    this.flowObjectiveService = flowObjService;
    this.nsNextObjStore = srManager.nsNextObjStore;
    this.subnetNextObjStore = srManager.subnetNextObjStore;
    this.portNextObjStore = srManager.portNextObjStore;
    this.srManager = srManager;

    populateNeighborMaps();
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Creates a group handler object based on the type of device. If device is
 * of edge type it returns edge group handler, else it returns transit group
 * handler.
 *
 * @param deviceId device identifier
 * @param appId application identifier
 * @param config interface to retrieve the device properties
 * @param linkService link service object
 * @param flowObjService flow objective service object
 * @param srManager segment routing manager
 * @throws DeviceConfigNotFoundException if the device configuration is not found
 * @return default group handler type
 */
public static DefaultGroupHandler createGroupHandler(
                                      DeviceId deviceId,
                                      ApplicationId appId,
                                      DeviceProperties config,
                                      LinkService linkService,
                                      FlowObjectiveService flowObjService,
                                      SegmentRoutingManager srManager)
                                              throws DeviceConfigNotFoundException {
    // handle possible exception in the caller
    if (config.isEdgeDevice(deviceId)) {
        return new DefaultEdgeGroupHandler(deviceId, appId, config,
                                           linkService,
                                           flowObjService,
                                           srManager
                                           );
    } else {
        return new DefaultTransitGroupHandler(deviceId, appId, config,
                                              linkService,
                                              flowObjService,
                                              srManager);
    }
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
@GET
public Response getLinks(@QueryParam("device") String deviceId,
                         @QueryParam("port") String port,
                         @QueryParam("direction") String direction) {
    LinkService service = get(LinkService.class);
    Iterable<Link> links;

    if (deviceId != null && port != null) {
        links = getConnectPointLinks(new ConnectPoint(deviceId(deviceId),
                                                      portNumber(port)),
                                     direction, service);
    } else if (deviceId != null) {
        links = getDeviceLinks(deviceId(deviceId), direction, service);
    } else {
        links = service.getLinks();
    }
    return ok(encodeArray(Link.class, "links", links)).build();
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Creates a messaging facility for creating messages for topology viewer.
 *
 * @param directory service directory
 */
protected TopologyViewMessages(ServiceDirectory directory) {
    this.directory = checkNotNull(directory, "Directory cannot be null");
    clusterService = directory.get(ClusterService.class);
    deviceService = directory.get(DeviceService.class);
    linkService = directory.get(LinkService.class);
    hostService = directory.get(HostService.class);
    mastershipService = directory.get(MastershipService.class);
    intentService = directory.get(IntentService.class);
    flowService = directory.get(FlowRuleService.class);
    statService = directory.get(StatisticService.class);
    topologyService = directory.get(TopologyService.class);

    String ver = directory.get(CoreService.class).version().toString();
    version = ver.replace(".SNAPSHOT", "*").replaceFirst("~.*$", "");
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
@Override
public void process(ObjectNode message) {
    ObjectNode payload = payload(message);
    String sortCol = string(payload, "sortCol", "id");
    String sortDir = string(payload, "sortDir", "asc");

    DeviceService service = get(DeviceService.class);
    MastershipService mastershipService = get(MastershipService.class);
    LinkService linkService = get(LinkService.class);
    TableRow[] rows = generateTableRows(service,
                                        mastershipService,
                                        linkService);
    RowComparator rc =
            new RowComparator(sortCol, RowComparator.direction(sortDir));
    Arrays.sort(rows, rc);
    ArrayNode devices = generateArrayNode(rows);
    ObjectNode rootNode = mapper.createObjectNode();
    rootNode.set("devices", devices);

    connection().sendMessage("deviceDataResponse", 0, rootNode);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
@Override
public void init(UiConnection connection, ServiceDirectory directory) {
    super.init(connection, directory);
    this.directory = checkNotNull(directory, "Directory cannot be null");
    clusterService = directory.get(ClusterService.class);
    deviceService = directory.get(DeviceService.class);
    linkService = directory.get(LinkService.class);
    hostService = directory.get(HostService.class);
    mastershipService = directory.get(MastershipService.class);
    intentService = directory.get(IntentService.class);
    flowService = directory.get(FlowRuleService.class);
    statService = directory.get(StatisticService.class);
    topologyService = directory.get(TopologyService.class);

    String ver = directory.get(CoreService.class).version().toString();
    version = ver.replace(".SNAPSHOT", "*").replaceFirst("~.*$", "");
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
protected DefaultGroupHandler(DeviceId deviceId,
                           ApplicationId appId,
                           DeviceProperties config,
                           LinkService linkService,
                           GroupService groupService) {
    this.deviceId = checkNotNull(deviceId);
    this.appId = checkNotNull(appId);
    this.deviceConfig = checkNotNull(config);
    this.linkService = checkNotNull(linkService);
    this.groupService = checkNotNull(groupService);
    allSegmentIds = checkNotNull(config.getAllDeviceSegmentIds());
    nodeSegmentId = config.getSegmentId(deviceId);
    isEdgeRouter = config.isEdgeDevice(deviceId);
    nodeMacAddr = checkNotNull(config.getDeviceMac(deviceId));

    this.groupService.addListener(listener);

    populateNeighborMaps();
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Creates a group handler object based on the type of device. If
 * device is of edge type it returns edge group handler, else it
 * returns transit group handler.
 *
 * @param deviceId device identifier
 * @param appId application identifier
 * @param config interface to retrieve the device properties
 * @param linkService link service object
 * @param groupService group service object
 * @return default group handler type
 */
public static DefaultGroupHandler createGroupHandler(DeviceId deviceId,
                                              ApplicationId appId,
                                              DeviceProperties config,
                                              LinkService linkService,
                                              GroupService groupService) {
    if (config.isEdgeDevice(deviceId)) {
        return new DefaultEdgeGroupHandler(deviceId,
                                           appId,
                                           config,
                                           linkService,
                                           groupService);
    } else {
        return new DefaultTransitGroupHandler(deviceId,
                                              appId,
                                              config,
                                              linkService,
                                              groupService);
    }
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Creates the services bundle, from the given directly.
 *
 * @param directory service directory
 */
public ServicesBundle(ServiceDirectory directory) {
    checkNotNull(directory, "Directory cannot be null");

    clusterService = directory.get(ClusterService.class);

    topologyService = directory.get(TopologyService.class);
    deviceService = directory.get(DeviceService.class);
    hostService = directory.get(HostService.class);
    linkService = directory.get(LinkService.class);
    tunnelService = directory.get(TunnelService.class);

    mastershipService = directory.get(MastershipService.class);
    mastershipAdminService = directory.get(MastershipAdminService.class);
    intentService = directory.get(IntentService.class);
    flowService = directory.get(FlowRuleService.class);
    flowStatsService = directory.get(StatisticService.class);
    portStatsService = directory.get(PortStatisticsService.class);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Creates an instance with a reference to the services directory, so that
 * additional information about network elements may be looked up on
 * on the fly.
 *
 * @param directory service directory
 * @param userName  logged in user name
 */
public Topo2Jsonifier(ServiceDirectory directory, String userName) {
    this.directory = checkNotNull(directory, "Directory cannot be null");
    this.userName = checkNotNull(userName, "User name cannot be null");

    clusterService = directory.get(ClusterService.class);
    deviceService = directory.get(DeviceService.class);
    linkService = directory.get(LinkService.class);
    hostService = directory.get(HostService.class);
    mastershipService = directory.get(MastershipService.class);
    intentService = directory.get(IntentService.class);
    flowService = directory.get(FlowRuleService.class);
    flowStatsService = directory.get(StatisticService.class);
    portStatsService = directory.get(PortStatisticsService.class);
    topologyService = directory.get(TopologyService.class);
    tunnelService = directory.get(TunnelService.class);
    uiextService = directory.get(UiExtensionService.class);
    prefService = directory.get(UiPreferencesService.class);
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Helper method to find the next hop IP address.
 * The logic is to check if the destination ports have an IP address
 * by checking the logical interface (e.g., for port physical ge-2/0/1,
 * a logical interface may be ge-2/0/1.0
 *
 * @param deviceId the device id of the flow rule to be installed
 * @param port     output port of the flow rule treatment
 * @return optional IPv4 address of a next hop
 */
private Optional<Ip4Address> findIpDst(DeviceId deviceId, Port port) {
    LinkService linkService = this.handler().get(LinkService.class);
    Set<Link> links = linkService.getEgressLinks(new ConnectPoint(deviceId, port.number()));
    DeviceService deviceService = this.handler().get(DeviceService.class);
    //Using only links with adjacency discovered by the LLDP protocol (see LinkDiscoveryJuniperImpl)
    Map<DeviceId, Port> dstPorts = links.stream().filter(l ->
            IP_STRING.toUpperCase().equals(l.annotations().value("layer")))
            .collect(Collectors.toMap(
                    l -> l.dst().deviceId(),
                    l -> deviceService.getPort(l.dst().deviceId(), l.dst().port())));
    for (Map.Entry<DeviceId, Port> entry : dstPorts.entrySet()) {
        String portName = entry.getValue().annotations().value(AnnotationKeys.PORT_NAME);

        Optional<Port> childPort = deviceService.getPorts(entry.getKey()).stream()
                .filter(p -> Strings.nullToEmpty(
                        p.annotations().value(AnnotationKeys.PORT_NAME)).contains(portName.trim()))
                .filter(p -> isIp(p))
                .findAny();
        if (childPort.isPresent()) {
            return Optional.ofNullable(Ip4Address.valueOf(childPort.get().annotations().value("ip")));
        }
    }

    return Optional.empty();
}
 

import org.onosproject.net.link.LinkService; //导入依赖的package包/类
/**
 * Tests the getLink() method using a null src connect point.
 */
@Test(expected = NullPointerException.class)
public void testGetLinkByNullSrc() {

    manager.registerTenantId(TenantId.tenantId(tenantIdValue1));
    VirtualNetwork virtualNetwork = manager.createVirtualNetwork(TenantId.tenantId(tenantIdValue1));
    VirtualDevice srcVirtualDevice =
            manager.createVirtualDevice(virtualNetwork.id(), DID1);
    VirtualDevice dstVirtualDevice =
            manager.createVirtualDevice(virtualNetwork.id(), DID2);
    ConnectPoint src = new ConnectPoint(srcVirtualDevice.id(), PortNumber.portNumber(1));
    ConnectPoint dst = new ConnectPoint(dstVirtualDevice.id(), PortNumber.portNumber(2));
    manager.createVirtualLink(virtualNetwork.id(), src, dst);
    manager.createVirtualLink(virtualNetwork.id(), dst, src);

    LinkService linkService = manager.get(virtualNetwork.id(), LinkService.class);

    // test the getLink() method with a null src connect point.
    linkService.getLink(null, dst);
}