Java IpPrefix类代码示例

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
/**
 * As per the OFDPA 2.0 TTP, packets are sent out of ports by using
 * a chain of groups. The broadcast Next Objective passed in by the application
 * has to be broken up into a group chain comprising of an
 * L2 Flood group whose buckets point to L2 Interface groups.
 *
 * @param nextObj  the nextObjective of type BROADCAST
 */
private void processBroadcastNextObjective(NextObjective nextObj) {
    VlanId assignedVlan = Ofdpa2Pipeline.readVlanFromSelector(nextObj.meta());
    if (assignedVlan == null) {
        log.warn("VLAN ID required by broadcast next obj is missing. Abort.");
        Ofdpa2Pipeline.fail(nextObj, ObjectiveError.BADPARAMS);
        return;
    }

    List<GroupInfo> groupInfos = prepareL2InterfaceGroup(nextObj, assignedVlan);

    IpPrefix ipDst = Ofdpa2Pipeline.readIpDstFromSelector(nextObj.meta());
    if (ipDst != null) {
        if (ipDst.isMulticast()) {
            createL3MulticastGroup(nextObj, assignedVlan, groupInfos);
        } else {
            log.warn("Broadcast NextObj with non-multicast IP address {}", nextObj);
            Ofdpa2Pipeline.fail(nextObj, ObjectiveError.BADPARAMS);
            return;
        }
    } else {
        createL2FloodGroup(nextObj, assignedVlan, groupInfos);
    }
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
@Override
public void programRouteRules(DeviceId deviceId, SegmentationId l3Vni,
                              IpAddress dstVmIP, SegmentationId dstVni,
                              MacAddress dstVmGwMac, MacAddress dstVmMac,
                              Operation type) {
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(IP_TYPE)
            .matchTunnelId(Long.parseLong(l3Vni.segmentationId()))
            .matchIPDst(IpPrefix.valueOf(dstVmIP, PREFIX_LENGTH)).build();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    treatment.setEthSrc(dstVmGwMac)
            .setEthDst(dstVmMac)
            .add(Instructions.modTunnelId(Long.parseLong(dstVni
                         .segmentationId())));
    ForwardingObjective.Builder objective = DefaultForwardingObjective
            .builder().withTreatment(treatment.build())
            .withSelector(selector).fromApp(appId).withFlag(Flag.SPECIFIC)
            .withPriority(L3FWD_PRIORITY);
    if (type.equals(Objective.Operation.ADD)) {
        log.debug("RouteRules-->ADD");
        flowObjectiveService.forward(deviceId, objective.add());
    } else {
        log.debug("RouteRules-->REMOVE");
        flowObjectiveService.forward(deviceId, objective.remove());
    }
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
@Override
public void programUserdataClassifierRules(DeviceId deviceId,
                                           IpPrefix ipPrefix,
                                           IpAddress dstIp,
                                           MacAddress dstmac,
                                           SegmentationId actionVni,
                                           Objective.Operation type) {
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4).matchIPSrc(ipPrefix)
            .matchIPDst(IpPrefix.valueOf(dstIp, 32)).build();
    TrafficTreatment treatment = DefaultTrafficTreatment.builder()
            .setTunnelId(Long.parseLong(actionVni.segmentationId()))
            .setEthDst(dstmac).build();
    ForwardingObjective.Builder objective = DefaultForwardingObjective
            .builder().withTreatment(treatment).withSelector(selector)
            .fromApp(appId).withFlag(Flag.SPECIFIC)
            .withPriority(USERDATA_CLASSIFIER_PRIORITY);
    if (type.equals(Objective.Operation.ADD)) {
        log.debug("UserdataClassifierRules-->ADD");
        flowObjectiveService.forward(deviceId, objective.add());
    } else {
        log.debug("UserdataClassifierRules-->REMOVE");
        flowObjectiveService.forward(deviceId, objective.remove());
    }
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
@Override
public void programSnatSameSegmentUploadControllerRules(DeviceId deviceId,
                                                        SegmentationId matchVni,
                                                        IpAddress srcIP,
                                                        IpAddress dstIP,
                                                        IpPrefix prefix,
                                                        Operation type) {

    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4)
            .matchTunnelId(Long.parseLong(matchVni.segmentationId()))
            .matchIPSrc(IpPrefix.valueOf(srcIP, PREFIC_LENGTH))
            .matchIPDst(IpPrefix.valueOf(dstIP, prefix.prefixLength()))
            .build();
    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    treatment.add(Instructions.createOutput(PortNumber.CONTROLLER));
    ForwardingObjective.Builder objective = DefaultForwardingObjective
            .builder().withTreatment(treatment.build())
            .withSelector(selector).fromApp(appId).withFlag(Flag.SPECIFIC)
            .withPriority(SNAT_SAME_SEG_CON_PRIORITY);
    if (type.equals(Objective.Operation.ADD)) {
        flowObjectiveService.forward(deviceId, objective.add());
    } else {
        flowObjectiveService.forward(deviceId, objective.remove());
    }
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
@Override
public void programSnatSameSegmentRules(DeviceId deviceId, SegmentationId matchVni,
                         IpAddress srcIP, IpAddress dstIP, MacAddress ethDst,
                         MacAddress ethSrc, IpAddress ipSrc,
                         SegmentationId actionVni, Objective.Operation type) {
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4)
            .matchTunnelId(Long.parseLong(matchVni.segmentationId()))
            .matchIPSrc(IpPrefix.valueOf(srcIP, PREFIC_LENGTH))
            .matchIPDst(IpPrefix.valueOf(dstIP, PREFIC_LENGTH)).build();

    TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
    treatment.setEthDst(ethDst).setEthSrc(ethSrc).setIpSrc(ipSrc)
            .setTunnelId(Long.parseLong(actionVni.segmentationId()));
    ForwardingObjective.Builder objective = DefaultForwardingObjective
            .builder().withTreatment(treatment.build())
            .withSelector(selector).fromApp(appId).withFlag(Flag.SPECIFIC)
            .withPriority(SNAT_SAME_SEG_PRIORITY);
    if (type.equals(Objective.Operation.ADD)) {
        flowObjectiveService.forward(deviceId, objective.add());
    } else {
        flowObjectiveService.forward(deviceId, objective.remove());
    }
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
WideCommunityTarget processWideCommTarget(ExtTarget flow) {
    ExtPrefix localSpeaker;
    ExtPrefix remoteSpeaker;
    ListIterator<IpPrefix> pfxItr = null;
    ListIterator<IpPrefix> pfxItr1 = null;
    List<BgpValueType> wcIpv4 = null;
    ExtTarget target = flow;
    WideCommunityIpV4Neighbour wcIpV4Neighbour = null;
    WideCommunityTarget wcTarget = null;
    localSpeaker = target.localSpeaker();
    remoteSpeaker = target.remoteSpeaker();
    wcIpV4Neighbour = new WideCommunityIpV4Neighbour();

    pfxItr = localSpeaker.prefix().listIterator();
    pfxItr1 = remoteSpeaker.prefix().listIterator();
    while (pfxItr.hasNext()) {
        wcIpV4Neighbour.add(pfxItr.next().address(), pfxItr1.next().address());
    }

    wcIpv4 = new ArrayList<>();
    wcIpv4.add(wcIpV4Neighbour);
    wcTarget = new WideCommunityTarget(wcIpv4);
    return wcTarget;
}
 

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包/类
@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 new VTN service with the specified entities.
 *
 * @param id service id
 * @param name user friendly name
 * @param serviceType service type
 * @param networkType network type
 * @param vni vni of this service network
 * @param subnet service network subnet range
 * @param serviceIp service ip for indirect service access
 * @param providerServices provider services
 * @param tenantServices tenant services
 */
public VtnService(VtnServiceId id,
                  String name,
                  ServiceType serviceType,
                  NetworkType networkType,
                  long vni,
                  IpPrefix subnet,
                  IpAddress serviceIp,
                  Set<VtnServiceId> providerServices,
                  Set<VtnServiceId> tenantServices) {
    this.id = checkNotNull(id);
    this.name = name;
    this.serviceType = serviceType;
    this.networkType = networkType;
    this.vni = vni;
    this.subnet = checkNotNull(subnet);
    this.serviceIp = checkNotNull(serviceIp);
    this.providerServices = providerServices == null ? Sets.newHashSet() : providerServices;
    this.tenantServices = tenantServices == null ? Sets.newHashSet() : tenantServices;
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
/**
 * Active MulticastForwardingIntent.
 */
@Activate
public void activate() {
    appId = coreService.registerApplication("org.onosproject.mfwd");

    mcastIntentManager = new McastIntentManager();
    mcastRouteManager.addListener(mcastIntentManager);

    packetService.addProcessor(processor, PacketProcessor.director(2));

    // Build a traffic selector for all multicast traffic
    TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
    selector.matchEthType(Ethernet.TYPE_IPV4);
    selector.matchIPDst(IpPrefix.IPV4_MULTICAST_PREFIX);

    packetService.requestPackets(selector.build(), PacketPriority.REACTIVE, appId);

    log.info("Started");
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
/**
 * Finds the best route entry among all BGP Sessions.
 *
 * @param prefix the prefix of the route
 * @return the best route if found, otherwise null
 */
private BgpRouteEntry findBestBgpRoute(IpPrefix prefix) {
    BgpRouteEntry bestRoute = null;

    // Iterate across all BGP Sessions and select the best route
    for (BgpSession bgpSession : bgpSessionManager.getBgpSessions()) {
        BgpRouteEntry route = bgpSession.findBgpRoute(prefix);
        if (route == null) {
            continue;
        }
        if ((bestRoute == null) || route.isBetterThan(bestRoute)) {
            bestRoute = route;
        }
    }
    return bestRoute;
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
public MockFlowClassifier(FlowClassifierId flowClassifierId, TenantId tenantId, String name,
                          String description, String etherType, String protocol, int priority,
                          int minSrcPortRange, int maxSrcPortRange, int minDstPortRange, int maxDstPortRange,
                          IpPrefix srcIpPrefix, IpPrefix dstIpPrefix, VirtualPortId srcPort,
                          VirtualPortId dstPort) {
    this.flowClassifierId = flowClassifierId;
    this.tenantId = tenantId;
    this.name = name;
    this.description = description;
    this.etherType = etherType;
    this.protocol = protocol;
    this.priority = priority;
    this.minSrcPortRange = minSrcPortRange;
    this.maxSrcPortRange = maxSrcPortRange;
    this.minDstPortRange = minDstPortRange;
    this.maxDstPortRange = maxDstPortRange;
    this.srcIpPrefix = srcIpPrefix;
    this.dstIpPrefix = dstIpPrefix;
    this.srcPort = srcPort;
    this.dstPort = dstPort;
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
private ForwardingObjective.Builder generateRibForwardingObj(IpPrefix prefix,
                                                             Integer nextId) {
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4)
            .matchIPDst(prefix)
            .build();

    int priority = prefix.prefixLength() * PRIORITY_MULTIPLIER + PRIORITY_OFFSET;

    ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
            .fromApp(routerAppId)
            .makePermanent()
            .withSelector(selector)
            .withPriority(priority)
            .withFlag(ForwardingObjective.Flag.SPECIFIC);

    if (nextId == null) {
        // Route withdraws are not specified with next hops. Generating
        // dummy treatment as there is no equivalent nextId info.
        fwdBuilder.withTreatment(DefaultTrafficTreatment.builder().build());
    } else {
        fwdBuilder.nextStep(nextId);
    }
    return fwdBuilder;
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
/**
 * Creates a new forwarding objective with the given parameters.
 *
 * @param prefix IP prefix
 * @param add whether to create an add objective or a remove objective
 * @return new forwarding objective
 */
private ForwardingObjective createForwardingObjective(IpPrefix prefix,
                                                      boolean add) {
    TrafficSelector selector = DefaultTrafficSelector.builder()
            .matchEthType(Ethernet.TYPE_IPV4)
            .matchIPDst(prefix)
            .build();

    int priority = prefix.prefixLength() * 5 + 100;
    ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
            .fromApp(APPID)
            .makePermanent()
            .withSelector(selector)
            .withPriority(priority)
            .withFlag(ForwardingObjective.Flag.SPECIFIC);

    if (add) {
        fwdBuilder.nextStep(NEXT_ID);
    } else {
        fwdBuilder.withTreatment(DefaultTrafficTreatment.builder().build());
    }

    return add ? fwdBuilder.add() : fwdBuilder.remove();
}
 

import org.onlab.packet.IpPrefix; //导入依赖的package包/类
/**
 * Tests adding a IPv4 route entry.
 */
@Test
public void testIpv4RouteAdd() {
    // Construct a route entry
    IpPrefix prefix = Ip4Prefix.valueOf("1.1.1.0/24");
    IpAddress nextHopIp = Ip4Address.valueOf("192.168.10.1");

    RouteEntry routeEntry = new RouteEntry(prefix, nextHopIp);

    // Expected FIB entry
    FibEntry fibEntry = new FibEntry(prefix, nextHopIp,
            MacAddress.valueOf("00:00:00:00:00:01"));

    fibListener.update(Collections.singletonList(new FibUpdate(
            FibUpdate.Type.UPDATE, fibEntry)), Collections.emptyList());

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.UPDATE, routeEntry)));

    verify(fibListener);
}