import org.onosproject.net.device.DeviceService; //导入依赖的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
    DeviceService service = AbstractShellCommand.get(DeviceService.class);

    // Generate the device ID/port number identifiers
    for (Device device : service.getDevices()) {
        SortedSet<String> strings = delegate.getStrings();
        for (Port port : service.getPorts(device.id())) {
            if (!port.number().isLogical()) {
                strings.add(device.id().toString() + "/" + port.number());
            }
        }
    }

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

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
private void printDevice(DeviceService deviceService,
                         DriverService driverService,
                         Device device) {
    super.printDevice(deviceService, device);
    if (!device.is(InterfaceConfig.class)) {
        // The relevant behavior is not supported by the device.
        print(ERROR_RESULT);
        return;
    }
    DriverHandler h = driverService.createHandler(device.id());
    InterfaceConfig interfaceConfig = h.behaviour(InterfaceConfig.class);

    List<DeviceInterfaceDescription> interfaces =
            interfaceConfig.getInterfaces(device.id());
    if (interfaces == null) {
        print(ERROR_RESULT);
    } else if (interfaces.isEmpty()) {
        print(NO_INTERFACES);
    } else {
        interfaces.forEach(this::printInterface);
    }
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
/**
 * Gets table statistics for all tables of all devices.
 *
 * @onos.rsModel StatisticsFlowsTables
 * @return 200 OK with JSON encoded array of table statistics
 */
@GET
@Path("flows/tables")
@Produces(MediaType.APPLICATION_JSON)
public Response getTableStatistics() {
    final FlowRuleService service = get(FlowRuleService.class);
    final Iterable<Device> devices = get(DeviceService.class).getDevices();
    final ObjectNode root = mapper().createObjectNode();
    final ArrayNode rootArrayNode = root.putArray("statistics");
    for (final Device device : devices) {
        final ObjectNode deviceStatsNode = mapper().createObjectNode();
        deviceStatsNode.put("device", device.id().toString());
        final ArrayNode statisticsNode = deviceStatsNode.putArray("table");
        final Iterable<TableStatisticsEntry> tableStatsEntries = service.getFlowTableStatistics(device.id());
        if (tableStatsEntries != null) {
            for (final TableStatisticsEntry entry : tableStatsEntries) {
                statisticsNode.add(codec(TableStatisticsEntry.class).encode(entry, this));
            }
        }
        rootArrayNode.add(deviceStatsNode);
    }

    return ok(root).build();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
/**
 * Gets port statistics of all devices.
 * @onos.rsModel StatisticsPorts
 * @return 200 OK with JSON encoded array of port statistics
 */
@GET
@Path("ports")
@Produces(MediaType.APPLICATION_JSON)
public Response getPortStatistics() {
    final DeviceService service = get(DeviceService.class);
    final Iterable<Device> devices = service.getDevices();
    final ObjectNode root = mapper().createObjectNode();
    final ArrayNode rootArrayNode = root.putArray("statistics");
    for (final Device device : devices) {
        final ObjectNode deviceStatsNode = mapper().createObjectNode();
        deviceStatsNode.put("device", device.id().toString());
        final ArrayNode statisticsNode = deviceStatsNode.putArray("ports");
        final Iterable<PortStatistics> portStatsEntries = service.getPortStatistics(device.id());
        if (portStatsEntries != null) {
            for (final PortStatistics entry : portStatsEntries) {
                statisticsNode.add(codec(PortStatistics.class).encode(entry, this));
            }
        }
        rootArrayNode.add(deviceStatsNode);
    }

    return ok(root).build();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
/**
 * Gets port statistics of a specified devices.
 * @onos.rsModel StatisticsPorts
 * @param deviceId device ID
 * @return 200 OK with JSON encoded array of port statistics
 */
@GET
@Path("ports/{deviceId}")
@Produces(MediaType.APPLICATION_JSON)
public Response getPortStatisticsByDeviceId(@PathParam("deviceId") String deviceId) {
    final DeviceService service = get(DeviceService.class);
    final Iterable<PortStatistics> portStatsEntries =
            service.getPortStatistics(DeviceId.deviceId(deviceId));
    final ObjectNode root = mapper().createObjectNode();
    final ArrayNode rootArrayNode = root.putArray("statistics");
    final ObjectNode deviceStatsNode = mapper().createObjectNode();
    deviceStatsNode.put("device", deviceId);
    final ArrayNode statisticsNode = deviceStatsNode.putArray("ports");
    if (portStatsEntries != null) {
        for (final PortStatistics entry : portStatsEntries) {
            statisticsNode.add(codec(PortStatistics.class).encode(entry, this));
        }
    }
    rootArrayNode.add(deviceStatsNode);

    return ok(root).build();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
/**
 * Gets all flow entries. Returns array of all flow rules in the system.
 *
 * @return 200 OK with a collection of flows
 * @onos.rsModel FlowEntries
 */
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getFlows() {
    final Iterable<Device> devices = get(DeviceService.class).getDevices();
    for (final Device device : devices) {
        final Iterable<FlowEntry> flowEntries = service.getFlowEntries(device.id());
        if (flowEntries != null) {
            for (final FlowEntry entry : flowEntries) {
                flowsNode.add(codec(FlowEntry.class).encode(entry, this));
            }
        }
    }

    return ok(root).build();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
/**
 * Initializes test mocks and environment.
 */
@Before
public void setUpMocks() {
    mockDeviceService = createMock(DeviceService.class);

    expect(mockDeviceService.isAvailable(isA(DeviceId.class)))
            .andReturn(true)
            .anyTimes();
    expect(mockDeviceService.getRole(isA(DeviceId.class)))
            .andReturn(MastershipRole.MASTER)
            .anyTimes();

    // Register the services needed for the test
    CodecManager codecService =  new CodecManager();
    codecService.activate();
    ServiceDirectory testDirectory =
            new TestServiceDirectory()
                    .add(DeviceService.class, mockDeviceService)
                    .add(CodecService.class, codecService);

    BaseResource.setServiceDirectory(testDirectory);
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
private void populateRow(TableModel.Row row, Device dev,
                         DeviceService ds, MastershipService ms) {
    DeviceId id = dev.id();
    boolean available = ds.isAvailable(id);
    String iconId = available ? ICON_ID_ONLINE : ICON_ID_OFFLINE;

    row.cell(ID, id)
        .cell(NAME, deviceName(dev))
        .cell(AVAILABLE, available)
        .cell(AVAILABLE_IID, iconId)
        .cell(TYPE_IID, getTypeIconId(dev))
        .cell(MFR, dev.manufacturer())
        .cell(HW, dev.hwVersion())
        .cell(SW, dev.swVersion())
        .cell(PROTOCOL, deviceProtocol(dev))
        .cell(NUM_PORTS, ds.getPorts(id).size())
        .cell(MASTER_ID, ms.getMasterFor(id));
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的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.device.DeviceService; //导入依赖的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.device.DeviceService; //导入依赖的package包/类
@Override
public void init(DeviceId deviceId, PipelinerContext context) {
    this.deviceId = deviceId;

    // Initialize OFDPA group handler
    groupHandler = new CpqdOfdpa2GroupHandler();
    groupHandler.init(deviceId, context);

    serviceDirectory = context.directory();
    coreService = serviceDirectory.get(CoreService.class);
    flowRuleService = serviceDirectory.get(FlowRuleService.class);
    groupService = serviceDirectory.get(GroupService.class);
    flowObjectiveStore = context.store();
    deviceService = serviceDirectory.get(DeviceService.class);

    driverId = coreService.registerApplication(
            "org.onosproject.driver.CpqdOfdpa2Pipeline");

    initializePipeline();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
@Override
public void init(DeviceId deviceId, PipelinerContext context) {
    this.deviceId = deviceId;

    // Initialize OFDPA group handler
    groupHandler = new Ofdpa2GroupHandler();
    groupHandler.init(deviceId, context);

    serviceDirectory = context.directory();
    coreService = serviceDirectory.get(CoreService.class);
    flowRuleService = serviceDirectory.get(FlowRuleService.class);
    groupService = serviceDirectory.get(GroupService.class);
    flowObjectiveStore = context.store();
    deviceService = serviceDirectory.get(DeviceService.class);

    driverId = coreService.registerApplication(
            "org.onosproject.driver.Ofdpa2Pipeline");

    initializePipeline();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
@Override
public void init(DeviceId deviceId, PipelinerContext context) {
    this.deviceId = deviceId;

    // Initialize OFDPA group handler
    groupHandler = new CpqdOfdpa2GroupHandler();
    groupHandler.init(deviceId, context);

    serviceDirectory = context.directory();
    coreService = serviceDirectory.get(CoreService.class);
    flowRuleService = serviceDirectory.get(FlowRuleService.class);
    groupService = serviceDirectory.get(GroupService.class);
    flowObjectiveStore = context.store();
    deviceService = serviceDirectory.get(DeviceService.class);

    driverId = coreService.registerApplication(
            "org.onosproject.driver.CpqdOfdpa2VlanPipeline");

    initializePipeline();
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
@Override
public Set<OchSignal> queryLambdas(PortNumber port) {
    DeviceService deviceService = opticalView(this.handler().get(DeviceService.class));
    Port p = deviceService.getPort(this.data().deviceId(), port);

    // Only OMS ports expose lambda resources
    if (!p.type().equals(Port.Type.OMS)) {
        return Collections.emptySet();
    }

    short lambdaCount = ((OmsPort) p).totalChannels();
    // OMS ports expose 'lambdaCount' fixed grid lambdas of 50GHz width, starting from min-frequency 191.7 THz.
    return IntStream.rangeClosed(1, lambdaCount)
            .mapToObj(x -> OchSignal.newDwdmSlot(ChannelSpacing.CHL_50GHZ, x))
            .collect(Collectors.toSet());
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
@Override
public DeviceDescription discoverDeviceDetails() {
    SnmpController controller = checkNotNull(handler().get(SnmpController.class));
    DeviceId deviceId = handler().data().deviceId();
    SnmpDevice snmpDevice = controller.getDevice(deviceId);
    DeviceService deviceService = checkNotNull(handler().get(DeviceService.class));
    Device device = deviceService.getDevice(deviceId);
    DeviceDescription desc = null;
    String ipAddress = snmpDevice.getSnmpHost();
    int port = snmpDevice.getSnmpPort();

    ISnmpConfiguration config = new V2cSnmpConfiguration();
    config.setPort(port);

    try (ISnmpSession session = controller.getSession(deviceId)) {
        // Each session will be auto-closed.
        String deviceOid = session.identifyDevice();
        desc = populateDescription(session, device);

    } catch (IOException | RuntimeException ex) {
        log.error("Failed to walk device.", ex.getMessage());
        log.debug("Detailed problem was ", ex);
    }
    return desc;
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的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.device.DeviceService; //导入依赖的package包/类
@Override
protected void execute() {
    DeviceService deviceService = get(DeviceService.class);
    CoreService coreService = get(CoreService.class);
    FlowRuleService flowRuleService = get(FlowRuleService.class);
    ApplicationId appId = coreService.registerApplication("eval.add.dummy");

    Iterable<Device> devices = deviceService.getDevices();

    for (Device d : devices) {
        for (FlowEntry r : flowRuleService.getFlowEntries(d.id())) {
            if (r.appId() == appId.id()) {
                flowRuleService.removeFlowRules((FlowRule) r);
            }
        }
    }
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
@Override
protected void execute() {
    CoreService coreService = get(CoreService.class);
    DeviceService deviceService = get(DeviceService.class);
    FlowRuleService service = get(FlowRuleService.class);

    compilePredicate();

    SortedMap<Device, List<FlowEntry>> flows = getSortedFlows(deviceService, service, coreService);

    if (outputJson()) {
        print("%s", json(flows.keySet(), flows));
    } else {
        flows.forEach((device, flow) -> printFlows(device, flow, coreService));
    }
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
@Override
protected void execute() {
    DeviceService deviceService = get(DeviceService.class);
    DeviceAdminService deviceAdminService = get(DeviceAdminService.class);
    Device dev = deviceService.getDevice(DeviceId.deviceId(uri));
    if (dev == null) {
        print(" %s", "Device does not exist");
        return;
    }
    PortNumber pnum = PortNumber.portNumber(portNumber);
    Port p = deviceService.getPort(dev.id(), pnum);
    if (p == null) {
        print(" %s", "Port does not exist");
        return;
    }
    if (portState.equals("enable")) {
        deviceAdminService.changePortState(dev.id(), pnum, true);
    } else if (portState.equals("disable")) {
        deviceAdminService.changePortState(dev.id(), pnum, false);
    } else {
        print(" %s", "State must be enable or disable");
    }
}
 

import org.onosproject.net.device.DeviceService; //导入依赖的package包/类
/**
 * Prints information about the specified device.
 *
 * @param deviceService device service
 * @param device        infrastructure device
 */
protected void printDevice(DeviceService deviceService, Device device) {
    if (device != null) {
        String driver = get(DriverService.class).getDriver(device.id()).name();
        if (shortOnly) {
            print(FMT_SHORT, device.id(), deviceService.isAvailable(device.id()),
                  deviceService.getRole(device.id()), device.type(), driver);
        } else {
            print(FMT, device.id(), deviceService.isAvailable(device.id()),
                  deviceService.getRole(device.id()), device.type(),
                  device.manufacturer(), device.hwVersion(), device.swVersion(),
                  device.serialNumber(), driver,
                  annotations(device.annotations(), ImmutableSet.of(AnnotationKeys.DRIVER)));
        }
    }
}