Java VirtualNetworkService.get方法代码示例

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
public VirtualNetworkGroupManager(VirtualNetworkService manager, NetworkId networkId) {
    super(manager, networkId, GroupEvent.class);

    store = serviceDirectory.get(VirtualNetworkGroupStore.class);
    deviceService = manager.get(networkId, DeviceService.class);

    providerRegistryService =
            serviceDirectory.get(VirtualProviderRegistryService.class);
    innerProviderService = new InternalGroupProviderService();
    providerRegistryService.registerProviderService(networkId(), innerProviderService);

    this.storeDelegate = new InternalStoreDelegate();
    store.setDelegate(networkId, this.storeDelegate);

    log.info("Started");
}
 

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
@Override
protected void execute() {
    CoreService coreService = get(CoreService.class);

    VirtualNetworkService vnetservice = get(VirtualNetworkService.class);
    DeviceService deviceService = vnetservice.get(NetworkId.networkId(networkId),
                                                  DeviceService.class);
    FlowRuleService service = vnetservice.get(NetworkId.networkId(networkId),
                                              FlowRuleService.class);
    contentFilter = new StringFilter(filter, StringFilter.Strategy.AND);

    compilePredicate();

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

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

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
private DefaultOFSwitch(DatapathId dpid, OFSwitchCapabilities capabilities,
                        NetworkId networkId, DeviceId deviceId,
                        ServiceDirectory serviceDirectory) {
    this.dpId = dpid;
    this.capabilities = capabilities;
    this.networkId = networkId;
    this.deviceId = deviceId;
    this.ofSwitchService = serviceDirectory.get(OFSwitchService.class);
    this.driverService = serviceDirectory.get(DriverService.class);
    this.virtualNetworkAdminService = serviceDirectory.get(VirtualNetworkAdminService.class);
    VirtualNetworkService virtualNetworkService = serviceDirectory.get(VirtualNetworkService.class);
    this.flowRuleService = virtualNetworkService.get(networkId, FlowRuleService.class);
    this.groupService = virtualNetworkService.get(networkId, GroupService.class);
    this.meterService = virtualNetworkService.get(networkId, MeterService.class);

    log = LoggerFactory.getLogger(OFAgent.TRACER_LOG_TENANT_ID_PREFIX + virtualNetworkService.getTenantId(networkId)
                                          + " " + getClass().getSimpleName() + " : " + dpid);
}
 

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
/**
 * Creates a new virtual network path service object.
 *
 * @param virtualNetworkManager virtual network manager service
 * @param networkId a virtual network identifier
 */

public VirtualNetworkPathManager(VirtualNetworkService virtualNetworkManager,
                                 NetworkId networkId) {
    this.networkId = networkId;

    topologyService = virtualNetworkManager.get(networkId(), TopologyService.class);
    hostService = virtualNetworkManager.get(networkId(), HostService.class);
}
 

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
public VirtualNetworkFlowObjectiveManager(VirtualNetworkService manager,
                                          NetworkId networkId) {
    super(manager, networkId);

    deviceService = manager.get(networkId(), DeviceService.class);
    flowRuleService = manager.get(networkId(), FlowRuleService.class);

    executorService = newFixedThreadPool(4, groupedThreads("onos/virtual/objective-installer", "%d", log));

    virtualFlowObjectiveStore =
            serviceDirectory.get(VirtualNetworkFlowObjectiveStore.class);
    delegate = new InternalStoreDelegate();
    virtualFlowObjectiveStore.setDelegate(networkId(), delegate);
    flowObjectiveStore = new StoreConvertor();
}
 

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
@Override
protected void execute() {
    VirtualNetworkService service = get(VirtualNetworkService.class);
    IntentService virtualNetworkIntentService = service.get(NetworkId.networkId(networkId), IntentService.class);

    ConnectPoint ingress = ConnectPoint.deviceConnectPoint(ingressDeviceString);
    ConnectPoint egress = ConnectPoint.deviceConnectPoint(egressDeviceString);

    TrafficSelector selector = buildTrafficSelector();
    TrafficTreatment treatment = buildTrafficTreatment();

    List<Constraint> constraints = buildConstraints();

    Intent intent = VirtualNetworkIntent.builder()
            .networkId(NetworkId.networkId(networkId))
            .appId(appId())
            .key(key())
            .selector(selector)
            .treatment(treatment)
            .ingressPoint(ingress)
            .egressPoint(egress)
            .constraints(constraints)
            .priority(priority())
            .build();
    virtualNetworkIntentService.submit(intent);
    print("Virtual intent submitted:\n%s", intent.toString());
}
 

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
@Override
protected void execute() {
    VirtualNetworkService vnetService = get(VirtualNetworkService.class);
    MastershipAdminService mastershipAdminService = vnetService
            .get(NetworkId.networkId(networkId), MastershipAdminService.class);
    mastershipAdminService.balanceRoles();
}
 

import org.onosproject.incubator.net.virtual.VirtualNetworkService; //导入方法依赖的package包/类
@Override
protected void execute() {
    VirtualNetworkService service = get(VirtualNetworkService.class);
    PacketService virtualPacketService = service.get(NetworkId.networkId(networkId), PacketService.class);

    if (command == null) {
        print("Command is not defined");
        return;
    }

    if (command.equals("getRequests")) {
        getRequests(virtualPacketService);
        return;
    }

    TrafficSelector selector = buildTrafficSelector();
    PacketPriority packetPriority = PacketPriority.CONTROL; //TODO allow user to specify
    Optional<DeviceId> optionalDeviceId = null;
    if (!isNullOrEmpty(deviceIdString)) {
        optionalDeviceId = Optional.of(DeviceId.deviceId(deviceIdString));
    }

    if (command.equals("requestPackets")) {
        if (optionalDeviceId != null) {
            virtualPacketService.requestPackets(selector, packetPriority, appId(), optionalDeviceId);
        } else {
            virtualPacketService.requestPackets(selector, packetPriority, appId());
        }
        print("Virtual packet requested:\n%s", selector);
        return;
    }

   if (command.equals("cancelPackets")) {
        if (optionalDeviceId != null) {
            virtualPacketService.cancelPackets(selector, packetPriority, appId(), optionalDeviceId);
        } else {
            virtualPacketService.cancelPackets(selector, packetPriority, appId());
        }
        print("Virtual packet cancelled:\n%s", selector);
        return;
    }

    print("Unsupported command %s", command);
}