Java IpPrefix.valueOf方法代码示例

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
@Override
public boolean isValid() {
    for (JsonNode node : array) {
        if (!hasOnlyFields((ObjectNode) node, NAME, IPS, MAC, VLAN)) {
            return false;
        }

        ObjectNode obj = (ObjectNode) node;

        if (!(isString(obj, NAME, FieldPresence.OPTIONAL) &&
                isMacAddress(obj, MAC, FieldPresence.OPTIONAL) &&
                isIntegralNumber(obj, VLAN, FieldPresence.OPTIONAL, 0, VlanId.MAX_VLAN))) {
            return false;
        }


        for (JsonNode ipNode : node.path(IPS)) {
            if (!ipNode.isTextual() || IpPrefix.valueOf(ipNode.asText()) == null) {
                return false;
            }
        }
    }
    return true;
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
/**
 * Creates a forwarding objective builder for multicast.
 *
 * @param mcastIp multicast group
 * @param assignedVlan assigned VLAN ID
 * @param nextId next ID of the L3 multicast group
 * @return forwarding objective builder
 */
private ForwardingObjective.Builder fwdObjBuilder(IpAddress mcastIp,
        VlanId assignedVlan, int nextId) {
    TrafficSelector.Builder sbuilder = DefaultTrafficSelector.builder();
    IpPrefix mcastPrefix = IpPrefix.valueOf(mcastIp, IpPrefix.MAX_INET_MASK_LENGTH);
    sbuilder.matchEthType(Ethernet.TYPE_IPV4);
    sbuilder.matchIPDst(mcastPrefix);
    TrafficSelector.Builder metabuilder = DefaultTrafficSelector.builder();
    metabuilder.matchVlanId(assignedVlan);

    ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder();
    fwdBuilder.withSelector(sbuilder.build())
            .withMeta(metabuilder.build())
            .nextStep(nextId)
            .withFlag(ForwardingObjective.Flag.SPECIFIC)
            .fromApp(srManager.appId)
            .withPriority(SegmentRoutingService.DEFAULT_PRIORITY);
    return fwdBuilder;
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
/** Ip address parser decoder.*/
public ExtPrefix.Builder parseIpArrayToPrefix(JsonNode array) {

    ExtPrefix.Builder resultBuilder = new DefaultExtPrefix.Builder();
    String ip;
    IpPrefix prefix;
    IpAddress ipAddr;

    Iterator<JsonNode> itr =  array.iterator();
    while (itr.hasNext()) {
        ip = itr.next().asText();
        ipAddr = IpAddress.valueOf(ip);
        prefix = IpPrefix.valueOf(ipAddr, 32);
        resultBuilder.setPrefix(prefix);
    }

    return resultBuilder;
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
@Override
protected void execute() {
    SubnetService service = get(SubnetService.class);
    if (id == null || networkId == null || tenantId == null) {
        print("id,networkId,tenantId can not be null");
        return;
    }
    Subnet subnet = new DefaultSubnet(SubnetId.subnetId(id), subnetName,
                                      TenantNetworkId.networkId(networkId),
                                      TenantId.tenantId(tenantId), ipVersion,
                                      cidr == null ? null : IpPrefix.valueOf(cidr),
                                      gatewayIp == null ? null : IpAddress.valueOf(gatewayIp),
                                      dhcpEnabled, shared, hostRoutes,
                                      ipV6AddressMode == null ? null : Mode.valueOf(ipV6AddressMode),
                                      ipV6RaMode == null ? null : Mode.valueOf(ipV6RaMode),
                                      allocationPools);

    Set<Subnet> subnetsSet = Sets.newHashSet(subnet);
    service.createSubnets(subnetsSet);
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
/**
 * Changes hostRoutes JsonNode to a collection of the hostRoutes.
 *
 * @param hostRoutes the hostRoutes json node
 * @return a collection of hostRoutes
 */
public Iterable<HostRoute> jsonNodeToHostRoutes(JsonNode hostRoutes) {
    checkNotNull(hostRoutes, JSON_NOT_NULL);
    ConcurrentMap<Integer, HostRoute> hostRouteMaps = Maps
            .newConcurrentMap();
    Integer i = 0;
    for (JsonNode node : hostRoutes) {
        IpAddress nexthop = IpAddress.valueOf(node.get("nexthop").asText());
        IpPrefix destination = IpPrefix.valueOf(node.get("destination")
                .asText());
        HostRoute hostRoute = new DefaultHostRoute(nexthop, destination);
        hostRouteMaps.putIfAbsent(i, hostRoute);
        i++;
    }
    return Collections.unmodifiableCollection(hostRouteMaps.values());
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
@Override
public IpPrefix read(Kryo kryo, Input input,
        Class<IpPrefix> type) {
    int octLen = input.readInt();
    checkArgument(octLen <= IpAddress.INET6_BYTE_LENGTH);
    byte[] octs = new byte[octLen];
    input.readBytes(octs);
    int prefLen = input.readInt();
    // Use the address size to decide whether it is IPv4 or IPv6 address
    if (octLen == IpAddress.INET_BYTE_LENGTH) {
        return IpPrefix.valueOf(IpAddress.Version.INET, octs, prefLen);
    }
    if (octLen == IpAddress.INET6_BYTE_LENGTH) {
        return IpPrefix.valueOf(IpAddress.Version.INET6, octs, prefLen);
    }
    return null;    // Shouldn't be reached
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
private FlowClassifier createFlowClassifier(FlowClassifierId id) {
    final String name = "FlowClassifier1";
    final String description = "FlowClassifier1";
    final String ethType = "IPv4";
    final String protocol = "tcp";
    final int minSrcPortRange = 5;
    final int maxSrcPortRange = 10;
    final int minDstPortRange = 5;
    final int maxDstPortRange = 10;
    final TenantId tenantId = TenantId.tenantId("1");
    final IpPrefix srcIpPrefix = IpPrefix.valueOf("0.0.0.0/0");
    final IpPrefix dstIpPrefix = IpPrefix.valueOf("10.10.10.10/0");
    final VirtualPortId virtualSrcPort = id1;
    final VirtualPortId virtualDstPort = id2;

    DefaultFlowClassifier.Builder flowClassifierBuilder = new DefaultFlowClassifier.Builder();
    final FlowClassifier flowClassifier = flowClassifierBuilder.setFlowClassifierId(id)
            .setTenantId(tenantId).setName(name).setDescription(description).setEtherType(ethType)
            .setProtocol(protocol).setMinSrcPortRange(minSrcPortRange).setMaxSrcPortRange(maxSrcPortRange)
            .setMinDstPortRange(minDstPortRange).setMaxDstPortRange(maxDstPortRange).setSrcIpPrefix(srcIpPrefix)
            .setDstIpPrefix(dstIpPrefix).setSrcPort(virtualSrcPort).setDstPort(virtualDstPort).build();
    return flowClassifier;
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
/**
 * Converts byte array of prefix value to IpPrefix object.
 *
 * @param value byte array of prefix value
 * @param length prefix length in bits
 * @return object of IpPrefix
 */
public static IpPrefix bytesToPrefix(byte[] value, int length) {
    if (value.length != IPV4_SIZE) {
        value = Arrays.copyOf(value, IPV4_SIZE);
    }
    IpPrefix ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, length);
    return ipPrefix;
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
@Override
protected void execute() {
    RouteAdminService service = AbstractShellCommand.get(RouteAdminService.class);

    IpPrefix prefix = IpPrefix.valueOf(prefixString);
    IpAddress nextHop = IpAddress.valueOf(nextHopString);

    service.withdraw(Collections.singleton(new Route(Route.Source.STATIC, prefix, nextHop)));
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
@Override
protected void execute() {
    RouteAdminService service = AbstractShellCommand.get(RouteAdminService.class);

    IpPrefix prefix = IpPrefix.valueOf(prefixString);
    IpAddress nextHop = IpAddress.valueOf(nextHopString);

    service.update(Collections.singleton(new Route(Route.Source.STATIC, prefix, nextHop)));
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
@Override
// TODO remove this when XOS provides this information
public VtnService service(VtnServiceId serviceId, OpenStackAccess osAccess) {
    checkNotNull(osAccess);

    OSClient osClient = getOpenStackClient(osAccess);
    Network osNet = osClient.networking().network().get(serviceId.id());
    if (osNet == null) {
        log.warn("Failed to get OpenStack network {}", serviceId);
        return null;
    }

    // assumes all cord service networks has single subnet
    Subnet osSubnet = osNet.getNeutronSubnets().stream()
            .findFirst().orElse(null);
    if (osSubnet == null) {
        log.warn("Failed to get OpenStack subnet of network {}", serviceId);
        return null;
    }

    return new VtnService(serviceId,
                          osNet.getName(),
                          serviceType(osNet.getName()),
                          networkType(osNet.getName()),
                          Long.parseLong(osNet.getProviderSegID()),
                          IpPrefix.valueOf(osSubnet.getCidr()),
                          IpAddress.valueOf(osSubnet.getGateway()),
                          providerServices(serviceId),
                          tenantServices(serviceId));
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
private void registerDhcpInfo(OpenstackPort openstackPort) {
    checkNotNull(openstackPort);
    checkArgument(!openstackPort.fixedIps().isEmpty());

    OpenstackSubnet openstackSubnet = openstackService.subnets().stream()
            .filter(n -> n.networkId().equals(openstackPort.networkId()))
            .findFirst().orElse(null);
    if (openstackSubnet == null) {
        log.warn("Failed to find subnet for {}", openstackPort);
        return;
    }

    Ip4Address ipAddress = openstackPort.fixedIps().values().stream().findFirst().get();
    IpPrefix subnetPrefix = IpPrefix.valueOf(openstackSubnet.cidr());
    Ip4Address broadcast = Ip4Address.makeMaskedAddress(
            ipAddress,
            subnetPrefix.prefixLength());

    // TODO: supports multiple DNS servers
    Ip4Address domainServer = openstackSubnet.dnsNameservers().isEmpty() ?
            DNS_SERVER_IP : openstackSubnet.dnsNameservers().get(0);

    IpAssignment ipAssignment = IpAssignment.builder()
            .ipAddress(ipAddress)
            .leasePeriod(DHCP_INFINITE_LEASE)
            .timestamp(new Date())
            .subnetMask(Ip4Address.makeMaskPrefix(subnetPrefix.prefixLength()))
            .broadcast(broadcast)
            .domainServer(domainServer)
            .assignmentStatus(Option_RangeNotEnforced)
            .routerAddress(Ip4Address.valueOf(openstackSubnet.gatewayIp()))
            .build();

    dhcpService.setStaticMapping(openstackPort.macAddress(), ipAssignment);
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
/**
 * Converts a CIDR string literal to an interface IP address.
 * E.g. 10.0.0.1/24
 *
 * @param value an IP address value in string form
 * @return an interface IP address
 * @throws IllegalArgumentException if the argument is invalid
 */
public static InterfaceIpAddress valueOf(String value) {
    String[] splits = value.split("/");
    checkArgument(splits.length == 2, "Invalid IP address and prefix length format");

    // NOTE: IpPrefix will mask-out the bits after the prefix length.
    IpPrefix subnet = IpPrefix.valueOf(value);
    IpAddress addr = IpAddress.valueOf(splits[0]);
    return new InterfaceIpAddress(addr, subnet);
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
private void pushGlobalNodeLabel(DeviceId deviceId, LabelResourceId labelId,
        IpPrefix ipPrefix, PcepFlowType type, boolean isBos) throws PcepParseException {

    checkNotNull(deviceId);
    checkNotNull(labelId);
    checkNotNull(type);

    PcepClient pc = getPcepClient(deviceId);
    if (pc == null) {
        log.error("PCEP client not found");
        return;
    }

    LinkedList<PcepLabelUpdate> labelUpdateList = new LinkedList<>();

    if (ipPrefix == null) {
        // Pushing self node label to device.
        ipPrefix = IpPrefix.valueOf(pc.getPccId().ipAddress(), 32);
    }

    PcepFecObjectIPv4 fecObject = pc.factory().buildFecObjectIpv4()
                                  .setNodeID(ipPrefix.address().getIp4Address().toInt())
                                  .build();

    boolean bSFlag = false;
    if (pc.labelDbSyncStatus() == IN_SYNC && !isBos) {
        // Need to set sync flag in all messages till sync completes.
        bSFlag = true;
    }

    PcepSrpObject srpObj = getSrpObject(pc, type, bSFlag);

    //Global NODE-SID as label object
    PcepLabelObject labelObject = pc.factory().buildLabelObject()
                                  .setLabel((int) labelId.labelId())
                                  .build();

    PcepLabelMap labelMap = new PcepLabelMap();
    labelMap.setFecObject(fecObject);
    labelMap.setLabelObject(labelObject);
    labelMap.setSrpObject(srpObj);

    labelUpdateList.add(pc.factory().buildPcepLabelUpdateObject()
                        .setLabelMap(labelMap)
                        .build());

    PcepLabelUpdateMsg labelMsg = pc.factory().buildPcepLabelUpdateMsg()
                                  .setPcLabelUpdateList(labelUpdateList)
                                  .build();

    pc.sendMessage(labelMsg);

    if (isBos) {
        // Sync is completed.
        pc.setLabelDbSyncStatus(SYNCED);
    }
}
 

import org.onlab.packet.IpPrefix; //导入方法依赖的package包/类
/**
 * Routes packet reactively.
 *
 * @param dstIpAddress the destination IP address of a packet
 * @param srcIpAddress the source IP address of a packet
 * @param srcConnectPoint the connect point where a packet comes from
 * @param srcMacAddress the source MAC address of a packet
 */
private void packetReactiveProcessor(IpAddress dstIpAddress,
                                    IpAddress srcIpAddress,
                                    ConnectPoint srcConnectPoint,
                                    MacAddress srcMacAddress) {
    checkNotNull(dstIpAddress);
    checkNotNull(srcIpAddress);
    checkNotNull(srcConnectPoint);
    checkNotNull(srcMacAddress);

    //
    // Step1: Try to update the existing intent first if it exists.
    //
    IpPrefix ipPrefix = null;
    Route route = null;
    if (config.isIpAddressLocal(dstIpAddress)) {
        if (dstIpAddress.isIp4()) {
            ipPrefix = IpPrefix.valueOf(dstIpAddress,
                    Ip4Address.BIT_LENGTH);
        } else {
            ipPrefix = IpPrefix.valueOf(dstIpAddress,
                    Ip6Address.BIT_LENGTH);
        }
    } else {
        // Get IP prefix from BGP route table
        route = routeService.longestPrefixMatch(dstIpAddress);
        if (route != null) {
            ipPrefix = route.prefix();
        }
    }
    if (ipPrefix != null
            && intentRequestListener.mp2pIntentExists(ipPrefix)) {
        intentRequestListener.updateExistingMp2pIntent(ipPrefix,
                srcConnectPoint);
        return;
    }

    //
    // Step2: There is no existing intent for the destination IP address.
    // Check whether it is necessary to create a new one. If necessary then
    // create a new one.
    //
    TrafficType trafficType =
            trafficTypeClassifier(srcConnectPoint, dstIpAddress);

    switch (trafficType) {
    case HOST_TO_INTERNET:
        // If the destination IP address is outside the local SDN network.
        // The Step 1 has already handled it. We do not need to do anything here.
        intentRequestListener.setUpConnectivityHostToInternet(srcIpAddress,
                ipPrefix, route.nextHop());
        break;
    case INTERNET_TO_HOST:
        intentRequestListener.setUpConnectivityInternetToHost(dstIpAddress);
        break;
    case HOST_TO_HOST:
        intentRequestListener.setUpConnectivityHostToHost(dstIpAddress,
                srcIpAddress, srcMacAddress, srcConnectPoint);
        break;
    case INTERNET_TO_INTERNET:
        log.trace("This is transit traffic, "
                + "the intent should be preinstalled already");
        break;
    case DROP:
        // TODO here should setUpDropPacketIntent(...);
        // We need a new type of intent here.
        break;
    case UNKNOWN:
        log.trace("This is unknown traffic, so we do nothing");
        break;
    default:
        break;
    }
}