Java VirtualPort类代码示例

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
public void onOvsDetected(Device device) {
    if (device == null) {
        log.error("The device is null");
        return;
    }
    if (!mastershipService.isLocalMaster(device.id())) {
        return;
    }
    // Create tunnel out flow rules
    applyTunnelOut(device, Objective.Operation.ADD);
    // apply L3 arp flows
    Iterable<RouterInterface> interfaces = routerInterfaceService
            .getRouterInterfaces();
    interfaces.forEach(routerInf -> {
        VirtualPort gwPort = virtualPortService.getPort(routerInf.portId());
        if (gwPort == null) {
            gwPort = VtnData.getPort(vPortStore, routerInf.portId());
        }
        applyL3ArpFlows(device.id(), gwPort, Objective.Operation.ADD);
    });
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
public void onOvsVanished(Device device) {
    if (device == null) {
        log.error("The device is null");
        return;
    }
    if (!mastershipService.isLocalMaster(device.id())) {
        return;
    }
    // Remove Tunnel out flow rules
    applyTunnelOut(device, Objective.Operation.REMOVE);
    // apply L3 arp flows
    Iterable<RouterInterface> interfaces = routerInterfaceService
            .getRouterInterfaces();
    interfaces.forEach(routerInf -> {
        VirtualPort gwPort = virtualPortService.getPort(routerInf.portId());
        if (gwPort == null) {
            gwPort = VtnData.getPort(vPortStore, routerInf.portId());
        }
        applyL3ArpFlows(device.id(), gwPort, Objective.Operation.REMOVE);
    });
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
public void onRouterInterfaceDetected(VtnRscEventFeedback l3Feedback) {
    Objective.Operation operation = Objective.Operation.ADD;
    RouterInterface routerInf = l3Feedback.routerInterface();
    VirtualPort gwPort = virtualPortService.getPort(routerInf.portId());
    vPortStore.put(gwPort.portId(), gwPort);
    Iterable<RouterInterface> interfaces = routerInterfaceService
            .getRouterInterfaces();
    Set<RouterInterface> interfacesSet = Sets.newHashSet(interfaces).stream()
            .filter(r -> r.tenantId().equals(routerInf.tenantId()))
            .filter(r -> r.routerId().equals(routerInf.routerId()))
            .collect(Collectors.toSet());
    TenantRouter tenantRouter = TenantRouter
            .tenantRouter(routerInf.tenantId(), routerInf.routerId());
    if (routerInfFlagOfTenantRouter.get(tenantRouter) != null) {
        programRouterInterface(routerInf, operation);
    } else {
        if (interfacesSet.size() >= SUBNET_NUM) {
            programInterfacesSet(interfacesSet, operation);
        }
    }
    // apply L3 arp flows
    applyL3ArpFlows(null, gwPort, operation);
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
private void sendNorthSouthL3Flows(DeviceId deviceId, FloatingIp floatingIp,
                                   IpAddress dstVmGwIp,
                                   MacAddress dstVmGwMac,
                                   SegmentationId l3vni,
                                   TenantNetwork vmNetwork,
                                   VirtualPort vmPort, Host host,
                                   Objective.Operation operation) {
    l3ForwardService
            .programRouteRules(deviceId, l3vni, floatingIp.fixedIp(),
                               vmNetwork.segmentationId(), dstVmGwMac,
                               vmPort.macAddress(), operation);
    classifierService.programL3InPortClassifierRules(deviceId,
                                                     host.location().port(),
                                                     host.mac(), dstVmGwMac,
                                                     l3vni, operation);
    classifierService.programArpClassifierRules(deviceId, host.location()
            .port(), dstVmGwIp, vmNetwork.segmentationId(), operation);
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
private List getGwIpAndMac(VirtualPort port) {
    List list = new ArrayList();
    MacAddress gwMac = null;
    SubnetId subnetId = null;
    IpAddress gwIp = null;
    Iterator<FixedIp> fixips = port.fixedIps().iterator();
    if (fixips.hasNext()) {
        FixedIp fixip = fixips.next();
        subnetId = fixip.subnetId();
        gwIp = subnetService.getSubnet(subnetId).gatewayIp();
        FixedIp fixedGwIp = FixedIp.fixedIp(fixip.subnetId(), gwIp);
        VirtualPort gwPort = virtualPortService.getPort(fixedGwIp);
        if (gwPort == null) {
            gwPort = VtnData.getPort(vPortStore, fixedGwIp);
        }
        gwMac = gwPort.macAddress();
    }
    list.add(gwIp);
    list.add(gwMac);
    return list;
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
private DeviceId getDeviceIdOfFloatingIP(FloatingIp floatingIp) {
    VirtualPortId vmPortId = floatingIp.portId();
    VirtualPort vmPort = virtualPortService.getPort(vmPortId);
    if (vmPort == null) {
        vmPort = VtnData.getPort(vPortStore, vmPortId);
    }
    Set<Host> hostSet = hostService.getHostsByMac(vmPort.macAddress());
    Host host = null;
    for (Host h : hostSet) {
        String ifaceid = h.annotations().value(IFACEID);
        if (ifaceid != null && ifaceid.equals(vmPortId.portId())) {
            host = h;
            break;
        }
    }
    if (host == null) {
        return null;
    } else {
        return host.location().deviceId();
    }
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
/**
 * Get VirtualPort.
 *
 * @param vPortStore EventuallyConsistentMap of VirtualPort
 * @param fixedIP FixedIp of the VirtualPort
 * @return VirtualPort
 */
public static VirtualPort getPort(EventuallyConsistentMap<VirtualPortId, VirtualPort> vPortStore,
                                  FixedIp fixedIP) {
    if (vPortStore != null) {
        List<VirtualPort> vPorts = new ArrayList<>();
        vPortStore.values().stream().forEach(p -> {
            Iterator<FixedIp> fixedIps = p.fixedIps().iterator();
            while (fixedIps.hasNext()) {
                if (fixedIps.next().equals(fixedIP)) {
                    vPorts.add(p);
                    break;
                }
            }
        });
        if (vPorts.size() == 0) {
            return null;
        }
        return vPorts.get(0);
    }
    return null;
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的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.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
public MacAddress getGatewayMac(HostId hostId) {
    checkNotNull(hostId, "hostId cannot be null");
    Host host = hostService.getHost(hostId);
    String ifaceId = host.annotations().value(IFACEID);
    VirtualPortId hPortId = VirtualPortId.portId(ifaceId);
    VirtualPort hPort = virtualPortService.getPort(hPortId);
    SubnetId subnetId = hPort.fixedIps().iterator().next().subnetId();
    Subnet subnet = subnetService.getSubnet(subnetId);
    IpAddress gatewayIp = subnet.gatewayIp();
    Iterable<VirtualPort> virtualPorts = virtualPortService.getPorts();
    MacAddress macAddress = null;
    for (VirtualPort port : virtualPorts) {
        Set<FixedIp> fixedIpSet = port.fixedIps();
        for (FixedIp fixedIp : fixedIpSet) {
            if (fixedIp.ip().equals(gatewayIp)) {
                macAddress = port.macAddress();
            }
        }
    }
    return macAddress;
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
public VirtualPort getPort(FixedIp fixedIP) {
    checkNotNull(fixedIP, FIXEDIP_NOT_NULL);
    List<VirtualPort> vPorts = new ArrayList<>();
    vPortStore.values().stream().forEach(p -> {
        Iterator<FixedIp> fixedIps = p.fixedIps().iterator();
        while (fixedIps.hasNext()) {
            if (fixedIps.next().equals(fixedIP)) {
                vPorts.add(p);
                break;
            }
        }
    });
    if (vPorts.size() == 0) {
        return null;
    }
    return vPorts.get(0);
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
public boolean updatePorts(Iterable<VirtualPort> vPorts) {
    checkNotNull(vPorts, VIRTUALPORT_NOT_NULL);
    for (VirtualPort vPort : vPorts) {
        vPortStore.put(vPort.portId(), vPort);
        if (!vPortStore.containsKey(vPort.portId())) {
            log.debug("The virtualPort is not exist whose identifier is {}",
                      vPort.portId().toString());
            return false;
        }

        vPortStore.put(vPort.portId(), vPort);

        if (!vPort.equals(vPortStore.get(vPort.portId()))) {
            log.debug("The virtualPort is updated failed whose  identifier is {}",
                      vPort.portId().toString());
            return false;
        }
    }
    return true;
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
private void createExGwPort(TenantNetwork network, Subnet subnet, FixedIp fixedGwIp) {
    VirtualPortService service = get(VirtualPortService.class);
    Map<String, String> strMap = Maps.newHashMap();
    VirtualPort virtualPort = new DefaultVirtualPort(VirtualPortId.portId("externalgateway-update-id"),
                                                     network.id(),
                                                     false, strMap,
                                                     VirtualPort.State.DOWN,
                                                     MacAddress.valueOf(macAddress),
                                                     subnet.tenantId(),
                                                     DeviceId.deviceId(""),
                                                     Sets.newHashSet(fixedGwIp),
                                                     BindingHostId.bindingHostId(""),
                                                     Sets.newHashSet(),
                                                     Sets.newHashSet());
    Set<VirtualPort> virtualPorts = Sets.newHashSet(virtualPort);
    service.createPorts(virtualPorts);
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
private void updateExGwPort(VirtualPort exgwPort) {
    VirtualPortService service = get(VirtualPortService.class);
    Map<String, String> strMap = Maps.newHashMap();
    strMap.putIfAbsent("name", exgwPort.name());
    strMap.putIfAbsent("deviceOwner", exgwPort.deviceOwner());
    strMap.putIfAbsent("bindingvnicType", exgwPort.bindingVnicType());
    strMap.putIfAbsent("bindingvifType", exgwPort.bindingVifType());
    strMap.putIfAbsent("bindingvnicDetails", exgwPort.bindingVifDetails());
    VirtualPort virtualPort = new DefaultVirtualPort(exgwPort.portId(),
                                                     exgwPort.networkId(),
                                                     false, strMap,
                                                     VirtualPort.State.DOWN,
                                                     MacAddress.valueOf(macAddress),
                                                     exgwPort.tenantId(),
                                                     exgwPort.deviceId(),
                                                     exgwPort.fixedIps(),
                                                     exgwPort.bindingHostId(),
                                                     Sets.newHashSet(exgwPort
                                                            .allowedAddressPairs()),
                                                     Sets.newHashSet(exgwPort
                                                            .securityGroups()));
    Set<VirtualPort> virtualPorts = Sets.newHashSet(virtualPort);
    service.updatePorts(virtualPorts);
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
protected void execute() {
    Map<String, String> strMap = Maps.newHashMap();
    strMap.putIfAbsent("name", name);
    strMap.putIfAbsent("deviceOwner", deviceOwner);
    strMap.putIfAbsent("bindingvnicType", bindingvnicType);
    strMap.putIfAbsent("bindingvifType", bindingvifType);
    strMap.putIfAbsent("bindingvnicDetails", bindingvnicDetails);
    VirtualPortService service = get(VirtualPortService.class);
    VirtualPort virtualPort = new DefaultVirtualPort(VirtualPortId.portId(id),
                                   TenantNetworkId.networkId(networkId),
                                   false, strMap, VirtualPort.State.ACTIVE,
                                   MacAddress.valueOf(macAddress),
                                   TenantId.tenantId(tenantId),
                                   DeviceId.deviceId(deviceId), Sets.newHashSet(fixedIp),
                                   BindingHostId.bindingHostId(bindingHostId),
                                   allowedAddressPairs, securityGroups);
    Set<VirtualPort> virtualPorts = Sets.newHashSet(virtualPort);
    service.createPorts(virtualPorts);
}
 

import org.onosproject.vtnrsc.VirtualPort; //导入依赖的package包/类
@Override
protected void execute() {
    VirtualPortService service = get(VirtualPortService.class);
    Map<String, String> strMap = Maps.newHashMap();
    strMap.putIfAbsent("name", name);
    strMap.putIfAbsent("deviceOwner", deviceOwner);
    strMap.putIfAbsent("bindingvnicType", bindingvnicType);
    strMap.putIfAbsent("bindingvifType", bindingvifType);
    strMap.putIfAbsent("bindingvnicDetails", bindingvnicDetails);
    VirtualPort virtualPort = new DefaultVirtualPort(VirtualPortId.portId(id),
                                                     TenantNetworkId.networkId(networkId),
                                                     false, strMap, VirtualPort.State.ACTIVE,
                                                     MacAddress.valueOf(macAddress),
                                                     TenantId.tenantId(tenantId),
                                                     DeviceId.deviceId(deviceId), Sets.newHashSet(fixedIp),
                                                     BindingHostId.bindingHostId(bindingHostId),
                                                     allowedAddressPairs, securityGroups);
    Set<VirtualPort> virtualPorts = Sets.newHashSet(virtualPort);
    service.updatePorts(virtualPorts);
}