Java Ipv4Range類代碼示例

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
@Transactional
public void transferInIpv4Block(final String range) {
    final AuthoritativeResource resources = resourceDataDao.load(source);

    final Iterable<Ipv4Range> overlaps = containsOrOverlaps(resources, range);
    if (isEmpty(overlaps)) {
        authoritativeResourceDao.create(source, formatIpv4Resource(range));
    } else {
        final Ipv4Range ipv4Range = Ipv4Range.parse(range);

        for (Ipv4Range overlap : overlaps) {
            if (overlap.contains(ipv4Range)) {
                // found parent which completely overlaps range, no need to create a new one
                break;
            } else {
                for (Ipv4Range nonOverlap : ipv4Range.exclude(overlap)) {
                    // create new entry for non-overlapping range
                    authoritativeResourceDao.create(source, nonOverlap.toStringInRangeNotation());
                }
            }
        }
    }
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
@Override
public List<ActionRequest> doTransfer(final Transfer<Ipv4Range> transfer, final Optional<RpslObject> precedingObject, final RpslObject originalObject, final Optional<RpslObject> followingObject) {
    final List<ActionRequest> requests = Lists.newArrayList();

    final Ipv4Range originalRange = Ipv4Range.parse(originalObject.getKey().toString());
    final List<Ipv4Range> whatIsLeft = originalRange.exclude(transfer.getResource());

    final List<RpslAttribute> originalObjectAttributes = originalObject.getAttributes();

    for (Ipv4Range range : whatIsLeft) {
        final RpslObjectBuilder whatIsLeftRpslObjectBuilder = new RpslObjectBuilder(Lists.newArrayList(originalObjectAttributes));

        for (RpslAttribute rpslAttribute : originalObjectAttributes) {
            if (rpslAttribute.getType() == AttributeType.INETNUM) {
                final RpslAttribute newRange = new RpslAttribute(AttributeType.INETNUM, formatInetnum(range));
                whatIsLeftRpslObjectBuilder.replaceAttribute(rpslAttribute, newRange);
            }
        }

        requests.add(new ActionRequest(whatIsLeftRpslObjectBuilder.get(), Action.CREATE));
    }

    return doNextTransferStep(transfer, precedingObject, originalObject, followingObject, requests);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
@Override
public List<ActionRequest> doTransfer(final Transfer<Ipv4Range> transfer, final Optional<RpslObject> precedingObject, final RpslObject originalObject, final Optional<RpslObject> followingObject) {
    final List<ActionRequest> requests = Lists.newArrayList();

    final Ipv4Range resource = transfer.getResource();

    if (shouldMergeWithObject(precedingObject, resource) && shouldMergeWithObject(followingObject, resource)) {
        requests.addAll(merge(precedingObject.get(), followingObject.get(), resource));
    } else if (shouldMergeWithObject(precedingObject, resource)) {
        requests.addAll(merge(precedingObject.get(), resource));
    } else if (shouldMergeWithObject(followingObject, resource)) {
        requests.addAll(merge(followingObject.get(), resource));
    } else {
        requests.add(createObject(transfer));
    }

    return doNextTransferStep(transfer, precedingObject, originalObject, followingObject, requests);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private boolean shouldMergeWithObject(final Optional<RpslObject> rpslObject, final Ipv4Range resource) {
    if (!rpslObject.isPresent()) {
        return false;
    }

    final Ipv4Range rangeObject = Ipv4Range.parse(rpslObject.get().getKey().toString());
    if (!rangeObject.isConsecutive(resource)) {
        return false;
    }

    final Ipv4Range mergedRange = resource.merge(rangeObject);

    final Ipv4 startLowerBoundForPrefix = mergedRange.start().lowerBoundForPrefix(8);
    final Ipv4 endLowerBoundForPrefix = mergedRange.end().lowerBoundForPrefix(8);

    return startLowerBoundForPrefix.equals(endLowerBoundForPrefix);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private List<ActionRequest> merge(final RpslObject precedingObject, final RpslObject followingObject, final Ipv4Range resource) {
    final List<ActionRequest> requests = Lists.newArrayList();

    Preconditions.checkArgument(precedingObject != null);
    Preconditions.checkArgument(followingObject != null);
    Preconditions.checkArgument(resource != null);

    final Ipv4Range precedingRange = Ipv4Range.parse(precedingObject.getKey().toString());
    final Ipv4Range followingRange = Ipv4Range.parse(followingObject.getKey().toString());

    final Ipv4Range mergedRange = precedingRange.merge(resource).merge(followingRange);

    final RpslObject inetnum = RpslObject.parse(String.format(TEMPLATE, mergedRange.toStringInRangeNotation(), source));

    requests.add(new ActionRequest(precedingObject, Action.DELETE));
    requests.add(new ActionRequest(followingObject, Action.DELETE));
    requests.add(new ActionRequest(inetnum, Action.CREATE));

    return requests;
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
public AuthoritativeResource load(final String source) {
    final SortedRangeSet<Asn, AsnRange> autNums = new SortedRangeSet<>();
    final SortedRangeSet<Ipv4, Ipv4Range> inetnums = new SortedRangeSet<>();
    final SortedRangeSet<Ipv6, Ipv6Range> inet6nums = new SortedRangeSet<>();

    jdbcTemplate.query("SELECT resource FROM authoritative_resource WHERE source = ?", new RowCallbackHandler() {
        @Override
        public void processRow(ResultSet rs) throws SQLException {
            String resource = rs.getString(1);
            if (resource.startsWith("AS")) {
                autNums.add(resource.contains("-") ? AsnRange.parse(resource) : Asn.parse(resource).asRange());
            } else if (resource.indexOf(':') >= 0) {
                inet6nums.add(Ipv6Range.parse(resource));
            } else {
                inetnums.add(Ipv4Range.parse(resource));
            }
        }

    }, source);
    return new AuthoritativeResource(autNums, inetnums, inet6nums);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
public static void loadFromFile(InputStream inputStream){
    try {
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String line;
        while ((line = br.readLine()) != null) {
            set.add(Ipv4Range.parse(line.trim()));
        }
        inputStream.close();
    } catch (IOException e) {
        // Ignore
    }
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private Iterable<Ipv4Range> containsOrOverlaps(final AuthoritativeResource resources, final String range) {
    final Ipv4Range ipv4Range = Ipv4Range.parse(range);
    return Iterables.filter(extractIpv4Resources(resources), new Predicate<Ipv4Range>() {
        @Override
        public boolean apply(final Ipv4Range input) {
            return input.contains(ipv4Range) || input.overlaps(ipv4Range);
        }
    });
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private SortedRangeSet<Ipv4, Ipv4Range> extractIpv4Resources(final AuthoritativeResource resources) {
    final SortedRangeSet<Ipv4, Ipv4Range> results = new SortedRangeSet<>();
    for (String resource : resources.getResources()) {
        if (IPV4_PATTERN.matcher(resource).matches()) {
            results.add(Ipv4Range.parse(resource));
        }
    }

    return results;
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
@Override
public List<ActionRequest> doTransfer(final Transfer<Ipv4Range> transfer, final Optional<RpslObject> precedingObject, final RpslObject originalObject, final Optional<RpslObject> followingObject) {
    final List<ActionRequest> requests = Lists.newArrayList();

    requests.add(new ActionRequest(originalObject, Action.DELETE));

    return doNextTransferStep(transfer, precedingObject, originalObject, followingObject, requests);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private List<ActionRequest> planOutgoingTransfer(final String inetnum) {
    final List<ActionRequest> requests = Lists.newArrayList();

    final Collection<RpslObject> searchResults = searchInetnumObject(inetnum, QueryFlag.ALL_LESS);
    validateSearchResults(inetnum, searchResults);
    final RpslObject matchingObject = Iterables.getLast(searchResults);

    if (InetnumTransfer.isNonRipeResource(matchingObject)) {
        // no transfer tasks to be performed
        LOGGER.warn("Inetnum {} is already non-RIPE", inetnum);
    } else {
        final Ipv4Range range = Ipv4Range.parse(inetnum);
        if (isExactMatch(range, matchingObject)) {
            throw new BadRequestException(inetnum + " is an exact match and cannot be transferred out");
        }

        final Optional<RpslObject> preceding = getPrecedingRpslObject(range);
        final Optional<RpslObject> following = getFollowingRpslObject(range);

        final Transfer transfer = InetnumTransfer.buildOutgoing(inetnum);
        requests.addAll(transferOutPipeline.doTransfer(transfer, preceding, matchingObject, following));
    }

    logSteps(requests);

    return requests;
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private Optional<RpslObject> getPrecedingRpslObject(final Ipv4Range range) {
    if (!range.start().hasPrevious()) {
        return Optional.absent();
    }

    final Ipv4 previous = range.start().previous();
    final Collection<RpslObject> parents = searchInetnumObject(previous.toString(), QueryFlag.ONE_LESS);
    return getNeighbour(parents);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private Optional<RpslObject> getFollowingRpslObject(final Ipv4Range range) {
    if (!range.end().hasNext()) {
        return Optional.absent();
    }

    final Ipv4 next = range.end().next();
    final Collection<RpslObject> parents = searchInetnumObject(next.toString(), QueryFlag.ONE_LESS);
    return getNeighbour(parents);
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
private Ipv4Range parseRangeOrSingleAddress(final CIString pkey) {
    // use whois-common library to parse input
    // to keep backwards compatibility
    // so that 10/8 is parsed as 10.0.0.0/8
    final Ipv4Resource ipv4Resource = Ipv4Resource.parse(pkey);
    return Ipv4Range.from(ipv4Resource.begin()).to(ipv4Resource.end());
}
 

import net.ripe.commons.ip.Ipv4Range; //導入依賴的package包/類
public Iterable<String> findInetnumOverlaps(AuthoritativeResource other) {
    return Iterables.transform(this.inetRanges.intersection(other.inetRanges), new Function<Ipv4Range, String>() {
        @Override
        public String apply(final Ipv4Range input) {
            return input.toStringInRangeNotation();
        }
    });
}