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

    HostService service = AbstractShellCommand.get(HostService.class);
    Iterator<Host> it = service.getHosts().iterator();
    SortedSet<String> strings = delegate.getStrings();
    while (it.hasNext()) {
        strings.add(it.next().id().toString());
    }

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

}
 

import org.onosproject.net.host.HostService; //导入依赖的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.host.HostService; //导入依赖的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.host.HostService; //导入依赖的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.host.HostService; //导入依赖的package包/类
/**
 * Sets up the host service with details of some hosts.
 */
private void setUpHostService() {
    hostService = createMock(HostService.class);

    hostService.addListener(anyObject(HostListener.class));
    expectLastCall().andDelegateTo(new TestHostService()).anyTimes();

    Host host1 = createHost(MAC1, V4_NEXT_HOP1);
    expectHost(host1);

    Host host2 = createHost(MAC2, V4_NEXT_HOP2);
    expectHost(host2);

    Host host3 = createHost(MAC3, V6_NEXT_HOP1);
    expectHost(host3);

    Host host4 = createHost(MAC4, V6_NEXT_HOP2);
    expectHost(host4);

    replay(hostService);
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    hostService = createMock(HostService.class);
    routingConfigurationService =
            createMock(RoutingConfigurationService.class);

    RouteSourceService routeSourceService = createMock(RouteSourceService.class);
    routeSourceService.start(anyObject(RouteListener.class));
    routeSourceService.stop();
    replay(routeSourceService);

    fibListener = createMock(FibListener.class);

    router = new DefaultRouter();
    router.coreService = createNiceMock(CoreService.class);
    router.hostService = hostService;
    router.routingConfigurationService = routingConfigurationService;
    router.routeSourceService = routeSourceService;
    router.activate();

    router.addFibListener(fibListener);
    router.start();

    internalHostListener = router.new InternalHostListener();
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
@Before
public void setUp() {
    networkConfigListener = createMock(NetworkConfigListener.class);
    deviceService = new TestDeviceService();
    deviceListener = createMock(DeviceListener.class);

    interfaceListener = createMock(InterfaceListener.class);
    deviceService.addListener(deviceListener);
    setUpInterfaceService();
    interfaceService = new InternalInterfaceService();
    interfaceService.addListener(interfaceListener);
    networkConfigService = new TestNetworkConfigService();
    networkConfigService.addListener(networkConfigListener);
    flowObjectiveService = createMock(FlowObjectiveService.class);
    setUpFlowObjectiveService();
    controlPlaneRedirectManager.coreService = coreService;
    controlPlaneRedirectManager.flowObjectiveService = flowObjectiveService;
    controlPlaneRedirectManager.networkConfigService = networkConfigService;
    controlPlaneRedirectManager.interfaceService = interfaceService;
    controlPlaneRedirectManager.deviceService = deviceService;
    controlPlaneRedirectManager.hostService = createNiceMock(HostService.class);
    controlPlaneRedirectManager.mastershipService = mastershipService;
    controlPlaneRedirectManager.activate();
    verify(flowObjectiveService);
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
@Override
public void modifyHostDetails(PropertyPanel pp, HostId hostId) {
    pp.title(MY_HOST_TITLE);
    pp.removeAllProps();
    PortPairService portPairService = AbstractShellCommand.get(PortPairService.class);
    VirtualPortService virtualPortService = AbstractShellCommand.get(VirtualPortService.class);
    HostService hostService = AbstractShellCommand.get(HostService.class);
    Iterable<PortPair> portPairs = portPairService.getPortPairs();
    for (PortPair portPair : portPairs) {
        VirtualPort vPort = virtualPortService.getPort(VirtualPortId.portId(portPair.ingress()));
        MacAddress dstMacAddress = vPort.macAddress();
        Host host = hostService.getHost(HostId.hostId(dstMacAddress));
        if (hostId.toString().equals(host.id().toString())) {
            pp.addProp("SF Name", portPair.name());
            pp.addProp("SF Ip", vPort.fixedIps().iterator().next().ip());
        }
    }
    pp.addProp("SF host Address", hostId.toString());
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
/**
 * Explicit constructor.
 *
 * @param appId application id.
 */
public SfcFlowRuleInstallerImpl(ApplicationId appId) {
    this.appId = checkNotNull(appId, "ApplicationId can not be null");
    ServiceDirectory serviceDirectory = new DefaultServiceDirectory();
    this.flowObjectiveService = serviceDirectory.get(FlowObjectiveService.class);
    this.driverService = serviceDirectory.get(DriverService.class);
    this.deviceService = serviceDirectory.get(DeviceService.class);
    this.hostService = serviceDirectory.get(HostService.class);
    this.virtualPortService = serviceDirectory.get(VirtualPortService.class);
    this.vtnRscService = serviceDirectory.get(VtnRscService.class);
    this.portPairService = serviceDirectory.get(PortPairService.class);
    this.portPairGroupService = serviceDirectory.get(PortPairGroupService.class);
    this.flowClassifierService = serviceDirectory.get(FlowClassifierService.class);
    this.tenantNetworkService = serviceDirectory.get(TenantNetworkService.class);
    nshSi = 0xff;
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
/**
 * Creates a node selection entity, from the given payload, using the
 * supplied device and host services. Note that if a device or host was
 * hovered over by the mouse, it is available via {@link #hovered()}.
 *
 * @param payload message payload
 * @param deviceService device service
 * @param hostService host service
 */
public NodeSelection(ObjectNode payload,
                     DeviceService deviceService,
                     HostService hostService) {
    this.deviceService = deviceService;
    this.hostService = hostService;

    ids = extractIds(payload);
    hover = extractHover(payload);

    // start by extracting the hovered element if any
    if (isNullOrEmpty(hover)) {
        hovered = null;
    } else {
        setHoveredElement();
    }

    // now go find the devices and hosts that are in the selection list
    Set<String> unmatched = findDevices(ids);
    unmatched = findHosts(unmatched);
    if (unmatched.size() > 0) {
        log.debug("Skipping unmatched IDs {}", unmatched);
    }

}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    super.setUp();
    Host hostOne = createMock(Host.class);
    expect(hostOne.mac()).andReturn(new MacAddress(HOST_ONE_MAC.getBytes())).anyTimes();
    expect(hostOne.vlan()).andReturn(VlanId.vlanId()).anyTimes();
    replay(hostOne);

    Host hostTwo = createMock(Host.class);
    expect(hostTwo.mac()).andReturn(new MacAddress(HOST_TWO_MAC.getBytes())).anyTimes();
    expect(hostTwo.vlan()).andReturn(VlanId.vlanId()).anyTimes();
    replay(hostTwo);

    mockHostService = createMock(HostService.class);
    expect(mockHostService.getHost(eq(hostOneId))).andReturn(hostOne).anyTimes();
    expect(mockHostService.getHost(eq(hostTwoId))).andReturn(hostTwo).anyTimes();
    replay(mockHostService);
}
 

import org.onosproject.net.host.HostService; //导入依赖的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.host.HostService; //导入依赖的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.host.HostService; //导入依赖的package包/类
@Override
public void process(ObjectNode message) {
    ObjectNode payload = payload(message);
    String sortCol = string(payload, "sortCol", "id");
    String sortDir = string(payload, "sortDir", "asc");

    HostService service = get(HostService.class);
    TableRow[] rows = generateTableRows(service);
    RowComparator rc =
            new RowComparator(sortCol, RowComparator.direction(sortDir));
    Arrays.sort(rows, rc);
    ArrayNode hosts = generateArrayNode(rows);
    ObjectNode rootNode = mapper.createObjectNode();
    rootNode.set("hosts", hosts);

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

import org.onosproject.net.host.HostService; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    hostService = createMock(HostService.class);
    routingConfigurationService =
            createMock(RoutingConfigurationService.class);

    BgpService bgpService = createMock(BgpService.class);
    bgpService.start(anyObject(RouteListener.class));
    bgpService.stop();
    replay(bgpService);

    fibListener = createMock(FibListener.class);

    router = new Router();
    router.hostService = hostService;
    router.routingConfigurationService = routingConfigurationService;
    router.bgpService = bgpService;
    router.activate();

    router.addFibListener(fibListener);
    router.start();

    internalHostListener = router.new InternalHostListener();
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
/**
 * Class constructor.
 *
 * @param appId the Application ID
 * @param intentService the intent service
 * @param hostService the host service
 * @param configService the SDN-IP configuration service
 */
IntentSynchronizer(ApplicationId appId, IntentService intentService,
                   HostService hostService,
                   RoutingConfigurationService configService) {
    this.appId = appId;
    this.intentService = intentService;
    this.hostService = hostService;
    peerIntents = new ConcurrentHashMap<>();
    routeIntents = new ConcurrentHashMap<>();

    this.configService = configService;

    bgpIntentsSynchronizerExecutor = Executors.newSingleThreadExecutor(
            new ThreadFactoryBuilder()
            .setNameFormat("sdnip-intents-synchronizer-%d").build());
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    proxyArp = new ProxyArpManager();
    packetService = new TestPacketService();
    proxyArp.packetService = packetService;

    // Create a host service mock here. Must be replayed by tests once the
    // expectations have been set up
    hostService = createMock(HostService.class);
    proxyArp.hostService = hostService;

    createTopology();
    proxyArp.deviceService = deviceService;
    proxyArp.linkService = linkService;

    proxyArp.activate();
}
 

import org.onosproject.net.host.HostService; //导入依赖的package包/类
/**
 * Initializes test mocks and environment.
 */
@Before
public void setUpTest() {
    expect(mockHostService.getHosts()).andReturn(hosts).anyTimes();

    // Register the services needed for the test
    final CodecManager codecService =  new CodecManager();
    codecService.activate();
    ServiceDirectory testDirectory =
            new TestServiceDirectory()
                    .add(HostService.class, mockHostService)
                    .add(HostAdminService.class, mockHostService)
                    .add(CodecService.class, codecService)
                    .add(HostProviderRegistry.class, mockHostProviderRegistry);
    setServiceDirectory(testDirectory);
}
 

import org.onosproject.net.host.HostService; //导入依赖的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.host.HostService; //导入依赖的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);
}