Example usage for org.apache.commons.net.util SubnetUtils SubnetUtils

List of usage examples for org.apache.commons.net.util SubnetUtils SubnetUtils

Introduction

In this page you can find the example usage for org.apache.commons.net.util SubnetUtils SubnetUtils.

Prototype

public SubnetUtils(String cidrNotation) 

Source Link

Document

Constructor that takes a CIDR-notation string, e.g.

Usage

From source file:org.apache.sling.discovery.base.connectors.ping.wl.WildcardHelperTest.java

@Test
public void testNullValues() {

    SubnetUtils s = new SubnetUtils("1.2.3.4/10");
    s = new SubnetUtils("1.2.3.4", "255.255.0.0");

    try {//from   w  ww.  ja v  a  2  s. c  om
        WildcardHelper.wildcardAsRegex(null);
        fail("should complain");
    } catch (IllegalArgumentException iae) {
        // ok
    }
    try {
        WildcardHelper.matchesWildcard(null, "foo");
        fail("should complain");
    } catch (IllegalArgumentException iae) {
        // ok
    }
    try {
        WildcardHelper.matchesWildcard("foo", null);
        fail("should complain");
    } catch (IllegalArgumentException iae) {
        // ok
    }
}

From source file:org.calrissian.mango.domain.CidrValueRangeIPv4.java

public CidrValueRangeIPv4(String cidrString) {

    SubnetUtils utils = new SubnetUtils(cidrString);
    SubnetUtils.SubnetInfo info = utils.getInfo();

    setStart(new IPv4(info.getNetworkAddress()));
    setStop(new IPv4(info.getBroadcastAddress()));
}

From source file:org.cloudifysource.esc.driver.provisioning.jclouds.DefaultProvisioningDriver.java

private void initIPFilters(final Cloud cloud) {
    final ComputeTemplate template = cloud.getCloudCompute().getTemplates().get(cloudTemplateName);

    final String privateCidr = (String) template.getCustom().get(PRIVATE_IP_CIDR);
    if (!StringUtils.isBlank(privateCidr)) {
        this.privateSubnetInfo = new SubnetUtils(privateCidr).getInfo();
    }// w  w  w  .j a v a  2s .c o  m

    final String privateRegex = (String) template.getCustom().get(PRIVATE_IP_REGEX);
    if (!StringUtils.isBlank(privateRegex)) {
        this.privateIpPattern = Pattern.compile(privateRegex);
    }

    final String publicCidr = (String) template.getCustom().get(PUBLIC_IP_CIDR);
    if (!StringUtils.isBlank(publicCidr)) {
        this.publicSubnetInfo = new SubnetUtils(publicCidr).getInfo();
    }

    final String publicRegex = (String) template.getCustom().get(PUBLIC_IP_REGEX);
    if (!StringUtils.isBlank(publicRegex)) {
        this.publicIpPattern = Pattern.compile(publicRegex);
    }

}

From source file:org.dasein.cloud.openstack.nova.os.compute.NovaServer.java

protected @Nullable VirtualMachine toVirtualMachine(@Nullable JSONObject server,
        @Nonnull Iterable<IpAddress> ipv4, @Nonnull Iterable<IpAddress> ipv6, @Nonnull Iterable<VLAN> networks)
        throws JSONException, InternalException, CloudException {
    if (server == null) {
        return null;
    }/*ww  w. j  a v  a2s . c om*/
    VirtualMachine vm = new VirtualMachine();
    String description = null;

    //        vm.setCurrentState(VmState.RUNNING);
    vm.setArchitecture(Architecture.I64);
    vm.setClonable(false);
    vm.setCreationTimestamp(-1L);
    vm.setImagable(false);
    vm.setLastBootTimestamp(-1L);
    vm.setLastPauseTimestamp(-1L);
    vm.setPausable(false);
    vm.setPersistent(true);
    vm.setPlatform(Platform.UNKNOWN);
    vm.setRebootable(true);
    vm.setProviderOwnerId(getTenantId());

    if (getCloudProvider().equals(OpenStackProvider.RACKSPACE)) {
        vm.setPersistent(false);
    }

    if (server.has("id")) {
        vm.setProviderVirtualMachineId(server.getString("id"));
    } else
        return null;
    if (server.has("name")) {
        vm.setName(server.getString("name"));
    }
    if (server.has("description") && !server.isNull("description")) {
        description = server.getString("description");
    }
    if (server.has("kernel_id")) {
        vm.setProviderKernelImageId(server.getString("kernel_id"));
    }
    if (server.has("ramdisk_id")) {
        vm.setProviderRamdiskImageId(server.getString("ramdisk_id"));
    }
    JSONObject md = (server.has("metadata") && !server.isNull("metadata")) ? server.getJSONObject("metadata")
            : null;

    Map<String, String> map = new HashMap<String, String>();
    boolean imaging = false;

    if (md != null) {
        if (md.has("org.dasein.description") && vm.getDescription() == null) {
            description = md.getString("org.dasein.description");
        } else if (md.has("Server Label")) {
            description = md.getString("Server Label");
        }
        if (md.has("org.dasein.platform")) {
            try {
                vm.setPlatform(Platform.valueOf(md.getString("org.dasein.platform")));
            } catch (Throwable ignore) {
                // ignore
            }
        }
        String[] keys = JSONObject.getNames(md);

        if (keys != null) {
            for (String key : keys) {
                String value = md.getString(key);

                if (value != null) {
                    map.put(key, value);
                }
            }
        }
    }
    if (server.has("OS-EXT-STS:task_state") && !server.isNull("OS-EXT-STS:task_state")) {
        String t = server.getString("OS-EXT-STS:task_state");

        map.put("OS-EXT-STS:task_state", t);
        imaging = t.equalsIgnoreCase("image_snapshot");
    }
    if (description == null) {
        if (vm.getName() == null) {
            vm.setName(vm.getProviderVirtualMachineId());
        }
        vm.setDescription(vm.getName());
    } else {
        vm.setDescription(description);
    }
    if (server.has("hostId")) {
        map.put("host", server.getString("hostId"));
    }
    vm.setTags(map);
    if (server.has("image") && !server.isNull("image")) {
        try {
            JSONObject img = server.getJSONObject("image");

            if (img.has("id")) {
                vm.setProviderMachineImageId(img.getString("id"));
            }
        } catch (JSONException ex) {
            logger.error("Unable to parse the image object");
            try {
                server.getString("image");
                logger.error(
                        "Image object has been returned as a string from cloud " + server.getString("image"));
            } catch (JSONException ignore) {
            }
        }
    }
    if (server.has("flavor")) {
        JSONObject f = server.getJSONObject("flavor");

        if (f.has("id")) {
            vm.setProductId(f.getString("id"));
        }
    } else if (server.has("flavorId")) {
        vm.setProductId(server.getString("flavorId"));
    }
    if (server.has("adminPass")) {
        vm.setRootPassword(server.getString("adminPass"));
    }
    if (server.has("key_name")) {
        vm.setProviderShellKeyIds(server.getString("key_name"));
    }
    if (server.has("status")) {
        String s = server.getString("status").toLowerCase();

        if (s.equals("active")) {
            vm.setCurrentState(VmState.RUNNING);
        } else if (s.startsWith("build")) {
            vm.setCurrentState(VmState.PENDING);
        } else if (s.equals("deleted")) {
            vm.setCurrentState(VmState.TERMINATED);
        } else if (s.equals("suspended")) {
            vm.setCurrentState(VmState.SUSPENDED);
        } else if (s.equalsIgnoreCase("paused")) {
            vm.setCurrentState(VmState.PAUSED);
        } else if (s.equalsIgnoreCase("stopped") || s.equalsIgnoreCase("shutoff")) {
            vm.setCurrentState(VmState.STOPPED);
        } else if (s.equalsIgnoreCase("stopping")) {
            vm.setCurrentState(VmState.STOPPING);
        } else if (s.equalsIgnoreCase("pausing")) {
            vm.setCurrentState(VmState.PAUSING);
        } else if (s.equalsIgnoreCase("suspending")) {
            vm.setCurrentState(VmState.SUSPENDING);
        } else if (s.equals("error")) {
            vm.setCurrentState(VmState.ERROR);
        } else if (s.equals("reboot") || s.equals("hard_reboot")) {
            vm.setCurrentState(VmState.REBOOTING);
        } else {
            logger.warn("toVirtualMachine(): Unknown server state: " + s);
            vm.setCurrentState(VmState.PENDING);
        }
    }
    if (vm.getCurrentState() == null && imaging) {
        vm.setCurrentState(VmState.PENDING);
    }
    if (server.has("created")) {
        vm.setCreationTimestamp(NovaOpenStack.parseTimestamp(server.getString("created")));
    }
    if (server.has("addresses")) {
        JSONObject addrs = server.getJSONObject("addresses");
        String[] names = JSONObject.getNames(addrs);

        if (names != null && names.length > 0) {
            List<RawAddress> pub = new ArrayList<RawAddress>();
            List<RawAddress> priv = new ArrayList<RawAddress>();

            for (String name : names) {
                JSONArray arr = addrs.getJSONArray(name);

                String subnet = null;
                for (int i = 0; i < arr.length(); i++) {
                    RawAddress addr = null;
                    String type = null;

                    if (getMinorVersion() == 0 && getMajorVersion() == 1) {
                        addr = new RawAddress(arr.getString(i).trim(), IPVersion.IPV4);
                    } else {
                        JSONObject a = arr.getJSONObject(i);
                        type = a.optString("OS-EXT-IPS:type");

                        if (a.has("version") && a.getInt("version") == 4 && a.has("addr")) {
                            subnet = a.getString("addr");
                            addr = new RawAddress(a.getString("addr"), IPVersion.IPV4);
                        } else if (a.has("version") && a.getInt("version") == 6 && a.has("addr")) {
                            subnet = a.getString("addr");
                            addr = new RawAddress(a.getString("addr"), IPVersion.IPV6);
                        }
                    }
                    if (addr != null) {
                        if ("public".equalsIgnoreCase(name) || "internet".equalsIgnoreCase(name)) {
                            pub.add(addr);
                        } else if ("floating".equalsIgnoreCase(type)) {
                            pub.add(addr);
                        } else if ("fixed".equalsIgnoreCase(type)) {
                            priv.add(addr);
                        } else if (addr.isPublicIpAddress()) {
                            pub.add(addr);
                        } else {
                            priv.add(addr);
                        }
                    }
                }
                if (vm.getProviderVlanId() == null) { // && !name.equals("public") && !name.equals("private") && !name.equals("nova_fixed") ) {
                    for (VLAN network : networks) {
                        if (network.getName().equals(name)) {
                            vm.setProviderVlanId(network.getProviderVlanId());
                            //get subnet
                            NetworkServices services = getProvider().getNetworkServices();
                            VLANSupport support = services.getVlanSupport();
                            Iterable<Subnet> subnets = support.listSubnets(network.getProviderVlanId());
                            for (Subnet sub : subnets) {
                                try {
                                    SubnetUtils utils = new SubnetUtils(sub.getCidr());

                                    if (utils.getInfo().isInRange(subnet)) {
                                        vm.setProviderSubnetId(sub.getProviderSubnetId());
                                        break;
                                    }
                                } catch (IllegalArgumentException arg) {
                                    logger.warn("Couldn't match against an invalid CIDR: " + sub.getCidr());
                                    continue;
                                }
                            }
                            break;
                        }
                    }
                }
            }
            vm.setPublicAddresses(pub.toArray(new RawAddress[pub.size()]));
            vm.setPrivateAddresses(priv.toArray(new RawAddress[priv.size()]));
        }
        RawAddress[] raw = vm.getPublicAddresses();

        if (raw != null) {
            for (RawAddress addr : vm.getPublicAddresses()) {
                if (addr.getVersion().equals(IPVersion.IPV4)) {
                    for (IpAddress a : ipv4) {
                        if (a.getRawAddress().getIpAddress().equals(addr.getIpAddress())) {
                            vm.setProviderAssignedIpAddressId(a.getProviderIpAddressId());
                            break;
                        }
                    }
                } else if (addr.getVersion().equals(IPVersion.IPV6)) {
                    for (IpAddress a : ipv6) {
                        if (a.getRawAddress().getIpAddress().equals(addr.getIpAddress())) {
                            vm.setProviderAssignedIpAddressId(a.getProviderIpAddressId());
                            break;
                        }
                    }
                }
            }
        }
        if (vm.getProviderAssignedIpAddressId() == null) {
            for (IpAddress addr : ipv4) {
                String serverId = addr.getServerId();

                if (serverId != null && serverId.equals(vm.getProviderVirtualMachineId())) {
                    vm.setProviderAssignedIpAddressId(addr.getProviderIpAddressId());
                    break;
                }
            }
            if (vm.getProviderAssignedIpAddressId() == null) {
                for (IpAddress addr : ipv6) {
                    String serverId = addr.getServerId();

                    if (serverId != null && addr.getServerId().equals(vm.getProviderVirtualMachineId())) {
                        vm.setProviderAssignedIpAddressId(addr.getProviderIpAddressId());
                        break;
                    }
                }
            }
        }
        if (vm.getProviderAssignedIpAddressId() == null) {
            for (IpAddress addr : ipv6) {
                if (addr.getServerId().equals(vm.getProviderVirtualMachineId())) {
                    vm.setProviderAssignedIpAddressId(addr.getProviderIpAddressId());
                    break;
                }
            }
        }
    }
    vm.setProviderRegionId(getRegionId());
    vm.setProviderDataCenterId(vm.getProviderRegionId() + "-a");
    vm.setTerminationTimestamp(-1L);
    if (vm.getName() == null) {
        vm.setName(vm.getProviderVirtualMachineId());
    }
    if (vm.getDescription() == null) {
        vm.setDescription(vm.getName());
    }

    if (Platform.UNKNOWN.equals(vm.getPlatform())) {
        vm.setPlatform(getPlatform(vm.getName(), vm.getDescription(), vm.getProviderMachineImageId()));
    }
    vm.setImagable(vm.getCurrentState() == null);
    vm.setRebootable(vm.getCurrentState() == null);

    if (getCloudProvider().equals(OpenStackProvider.RACKSPACE)) {
        //Rackspace does not support the concept for firewalls in servers
        vm.setProviderFirewallIds(null);
    } else {
        Iterable<String> fwIds = listFirewalls(vm.getProviderVirtualMachineId(), server);
        int count = 0;

        //noinspection UnusedDeclaration
        for (String id : fwIds) {
            count++;
        }
        String[] ids = new String[count];
        int i = 0;

        for (String id : fwIds) {
            ids[i++] = id;
        }
        vm.setProviderFirewallIds(ids);
    }
    return vm;
}

From source file:org.eclipse.smarthome.binding.mqtt.internal.discovery.NetworkDiscoveryService.java

/**
 * Return a list of IP v4 addresses to be scanned for the discovery
 *//*from  www .  j  av a 2  s .c  o  m*/
protected List<String> getScannableIPs() {
    return NetUtil.getAllInterfaceAddresses().stream().filter(i -> i.getAddress() instanceof Inet4Address)
            .map(interfaceIP -> Arrays.asList(
                    new SubnetUtils(interfaceIP.getAddress().getHostAddress()).getInfo().getAllAddresses())
                    .subList(0, MAX_IPS_PER_INTERFACE))
            .flatMap(List::stream).collect(Collectors.toList());
}

From source file:org.inria.myriads.snoozenode.database.api.impl.memory.GroupLeaderMemoryRepository.java

/**
 * Generates the address pool./*from   w  ww  .  j  av a 2  s  . c o m*/
 * 
 * @param virtualMachineSubnets     The virtual machine subnet
 * @return                          The list of IP addresses
 */
protected List<String> generateAddressPool(String[] virtualMachineSubnets) {
    log_.debug("Generating address pool");
    List<String> addressPool = new ArrayList<String>();
    for (String virtualMachineSubnet : virtualMachineSubnets) {
        if (!virtualMachineSubnet.equals("")) {
            SubnetUtils subnetUtils = new SubnetUtils(virtualMachineSubnet);
            SubnetInfo subnetInfo = subnetUtils.getInfo();
            addressPool.addAll(Arrays.asList(subnetInfo.getAllAddresses()));
        }
    }

    return addressPool;
}

From source file:org.openbaton.clients.interfaces.client.openstack.OpenstackClient.java

private static String translateToNAT(String floatingIp) throws UnknownHostException {

    Properties natRules = new Properties();
    try {/* w w w  . ja  va 2 s. c  om*/
        File file = new File("/etc/openbaton/plugin/openstack/nat-translation-rules.properties");
        if (file.exists()) {
            natRules.load(new FileInputStream(file));
        } else {
            natRules.load(OpenstackClient.class.getResourceAsStream("/nat-translation-rules.properties"));
        }
    } catch (IOException e) {
        log.warn("no translation rules!");
        return floatingIp;
    }

    for (Map.Entry<Object, Object> entry : natRules.entrySet()) {
        String fromCidr = (String) entry.getKey();
        String toCidr = (String) entry.getValue();
        log.debug("cidr is: " + fromCidr);
        SubnetUtils utilsFrom = new SubnetUtils(fromCidr);
        SubnetUtils utilsTo = new SubnetUtils(toCidr);

        SubnetUtils.SubnetInfo subnetInfoFrom = utilsFrom.getInfo();
        SubnetUtils.SubnetInfo subnetInfoTo = utilsTo.getInfo();
        InetAddress floatingIpNetAddr = InetAddress.getByName(floatingIp);
        if (subnetInfoFrom.isInRange(floatingIp)) { //translation!

            log.debug("From networkMask " + subnetInfoFrom.getNetmask());
            log.debug("To networkMask " + subnetInfoTo.getNetmask());
            if (!subnetInfoFrom.getNetmask().equals(subnetInfoTo.getNetmask())) {
                log.error("Not translation possible, netmasks are different");
                return floatingIp;
            }
            byte[] host = new byte[4];
            for (int i = 0; i < floatingIpNetAddr.getAddress().length; i++) {
                byte value = (byte) (floatingIpNetAddr.getAddress()[i]
                        | InetAddress.getByName(subnetInfoFrom.getNetmask()).getAddress()[i]);
                if (value == -1) {
                    host[i] = 0;
                } else {
                    host[i] = value;
                }
            }

            byte[] netaddress = InetAddress.getByName(subnetInfoTo.getNetworkAddress()).getAddress();
            String[] result = new String[4];
            for (int i = 0; i < netaddress.length; i++) {
                int intValue = new Byte((byte) (netaddress[i] | Byte.valueOf(host[i]))).intValue();
                if (intValue < 0) {
                    intValue = intValue & 0xFF;
                }
                result[i] = String.valueOf(intValue);
            }

            return StringUtils.join(result, ".");
        }
    }
    return floatingIp;
}

From source file:org.openbmp.db_rest.resources.Orr.java

/**
 * Lookup the IGP metric for the prefix (e.g. next hop) passed
 *
 * @param prefix            IP in print form (this is the next-hop)
 * @param igpMap            IGP RIB map/* w ww .ja  va 2s. c o  m*/
 *
 * @return null if no match, otherwise the column def list that matches is returned
 */
List<DbColumnDef> getIgpPrefixMetric(String prefix, Map<String, List<DbColumnDef>> igpMap) {
    List<DbColumnDef> found_cols = null;

    System.out.println("Lookup IGP metric cost for prefix " + prefix);

    for (Map.Entry<String, List<DbColumnDef>> row : igpMap.entrySet()) {
        // Prefix,PrefixLen,LocalPref,ASPath_Count,Origin,MED,NH
        List<DbColumnDef> cols = row.getValue();

        SubnetUtils subU = new SubnetUtils(cols.get(0).getValue() + '/' + cols.get(1).getValue());
        subU.setInclusiveHostCount(true);

        if (subU.getInfo().isInRange(prefix)) {
            System.out.println("    Found matching prefix, metric is " + cols.get(6).getValue());
            found_cols = cols;
            break;
        }
    }

    return found_cols;
}

From source file:org.opendaylight.controller.networkconfig.neutron.NeutronSubnet.java

public boolean isValidCIDR() {
    try {/* w  w  w.j  a va  2 s.co  m*/
        SubnetUtils util = new SubnetUtils(cidr);
        SubnetInfo info = util.getInfo();
        if (!info.getNetworkAddress().equals(info.getAddress())) {
            return false;
        }
    } catch (Exception e) {
        return false;
    }
    return true;
}

From source file:org.opendaylight.controller.networkconfig.neutron.NeutronSubnet.java

public boolean initDefaults() {
    if (enableDHCP == null) {
        enableDHCP = true;/* w  w  w.j a  v  a2s.  c o  m*/
    }
    if (ipVersion == null) {
        ipVersion = 4;
    }
    gatewayIPAssigned = false;
    dnsNameservers = new ArrayList<String>();
    if (hostRoutes == null) {
        hostRoutes = new ArrayList<NeutronSubnet_HostRoute>();
    }
    if (allocationPools == null) {
        allocationPools = new ArrayList<NeutronSubnet_IPAllocationPool>();
        try {
            SubnetUtils util = new SubnetUtils(cidr);
            SubnetInfo info = util.getInfo();
            if (gatewayIP == null || ("").equals(gatewayIP)) {
                gatewayIP = info.getLowAddress();
            }
            if (allocationPools.size() < 1) {
                NeutronSubnet_IPAllocationPool source = new NeutronSubnet_IPAllocationPool(info.getLowAddress(),
                        info.getHighAddress());
                allocationPools = source.splitPool(gatewayIP);
            }
        } catch (Exception e) {
            return false;
        }
    }
    return true;
}