Ejemplo n.º 1
0
 public void testTeredoAddress_nullServer() {
   InetAddresses.TeredoInfo info = new InetAddresses.TeredoInfo(null, null, 80, 1000);
   assertEquals(InetAddresses.forString("0.0.0.0"), info.getServer());
   assertEquals(InetAddresses.forString("0.0.0.0"), info.getClient());
   assertEquals(80, info.getPort());
   assertEquals(1000, info.getFlags());
 }
  /**
   * Returns a {@code HostSpecifier} built from the provided {@code specifier}, which is already
   * known to be valid. If the {@code specifier} might be invalid, use {@link #from(String)}
   * instead.
   *
   * <p>The specifier must be in one of these formats:
   *
   * <ul>
   *   <li>A domain name, like {@code google.com}
   *   <li>A IPv4 address string, like {@code 127.0.0.1}
   *   <li>An IPv6 address string with or without brackets, like {@code [2001:db8::1]} or {@code
   *       2001:db8::1}
   * </ul>
   *
   * @throws IllegalArgumentException if the specifier is not valid.
   */
  public static HostSpecifier fromValid(String specifier) {
    // Verify that no port was specified, and strip optional brackets from
    // IPv6 literals.
    final HostAndPort parsedHost = HostAndPort.fromString(specifier);
    Preconditions.checkArgument(!parsedHost.hasPort());
    final String host = parsedHost.getHostText();

    // Try to interpret the specifier as an IP address.  Note we build
    // the address rather than using the .is* methods because we want to
    // use InetAddresses.toUriString to convert the result to a string in
    // canonical form.
    InetAddress addr = null;
    try {
      addr = InetAddresses.forString(host);
    } catch (IllegalArgumentException e) {
      // It is not an IPv4 or IPv6 literal
    }

    if (addr != null) {
      return new HostSpecifier(InetAddresses.toUriString(addr));
    }

    // It is not any kind of IP address; must be a domain name or invalid.

    // TODO(user): different versions of this for different factories?
    final InternetDomainName domain = InternetDomainName.from(host);

    if (domain.hasPublicSuffix()) {
      return new HostSpecifier(domain.name());
    }

    throw new IllegalArgumentException(
        "Domain name does not have a recognized public suffix: " + host);
  }
Ejemplo n.º 3
0
 public void testToUriStringIPv6() {
   // Unfortunately the InetAddress.toString() method for IPv6 addresses
   // does not collapse contiguous shorts of zeroes with the :: abbreviation.
   String ipStr = "3ffe::1";
   InetAddress ip = InetAddresses.forString(ipStr);
   assertEquals("[3ffe::1]", InetAddresses.toUriString(ip));
 }
Ejemplo n.º 4
0
 public void testForStringIPv6Input() throws UnknownHostException {
   String ipStr = "3ffe::1";
   InetAddress ipv6Addr = null;
   // Shouldn't hit DNS, because it's an IP string literal.
   ipv6Addr = InetAddress.getByName(ipStr);
   assertEquals(ipv6Addr, InetAddresses.forString(ipStr));
   assertTrue(InetAddresses.isInetAddress(ipStr));
 }
Ejemplo n.º 5
0
 public void test3ff31() {
   try {
     InetAddresses.forString("3ffe:::1");
     fail("IllegalArgumentException expected");
   } catch (IllegalArgumentException expected) {
     // expected behavior
   }
   assertFalse(InetAddresses.isInetAddress("016.016.016.016"));
 }
Ejemplo n.º 6
0
  public void testConvertDottedQuadToHex() throws UnknownHostException {
    String[] ipStrings = {
      "7::0.128.0.127", "7::0.128.0.128", "7::128.128.0.127", "7::0.128.128.127"
    };

    for (String ipString : ipStrings) {
      // Shouldn't hit DNS, because it's an IP string literal.
      InetAddress ipv6Addr = InetAddress.getByName(ipString);
      assertEquals(ipv6Addr, InetAddresses.forString(ipString));
      assertTrue(InetAddresses.isInetAddress(ipString));
    }
  }
Ejemplo n.º 7
0
  public void testIsMaximum() throws UnknownHostException {
    InetAddress address = InetAddress.getByName("255.255.255.254");
    assertFalse(InetAddresses.isMaximum(address));

    address = InetAddress.getByName("255.255.255.255");
    assertTrue(InetAddresses.isMaximum(address));

    address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe");
    assertFalse(InetAddresses.isMaximum(address));

    address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
    assertTrue(InetAddresses.isMaximum(address));
  }
Ejemplo n.º 8
0
  public void testForStringIPv6EightColons() throws UnknownHostException {
    String[] eightColons = {
      "::7:6:5:4:3:2:1", "::7:6:5:4:3:2:0", "7:6:5:4:3:2:1::", "0:6:5:4:3:2:1::",
    };

    for (int i = 0; i < eightColons.length; i++) {
      InetAddress ipv6Addr = null;
      // Shouldn't hit DNS, because it's an IP string literal.
      ipv6Addr = InetAddress.getByName(eightColons[i]);
      assertEquals(ipv6Addr, InetAddresses.forString(eightColons[i]));
      assertTrue(InetAddresses.isInetAddress(eightColons[i]));
    }
  }
Ejemplo n.º 9
0
  public void testTeredoAddresses() {
    String[] nonTeredoAddresses = {
      "::1.2.3.4", "3ffe::1", "::", "::1",
    };

    for (int i = 0; i < nonTeredoAddresses.length; i++) {
      InetAddress ip = InetAddresses.forString(nonTeredoAddresses[i]);
      assertFalse(InetAddresses.isTeredoAddress((Inet6Address) ip));
      try {
        InetAddresses.getTeredoInfo((Inet6Address) ip);
        fail("IllegalArgumentException expected for '" + nonTeredoAddresses[i] + "'");
      } catch (IllegalArgumentException expected) {
        // expected behavior
      }
    }

    String validTeredoAddress = "2001:0000:4136:e378:8000:63bf:3fff:fdd2";
    String serverStr = "65.54.227.120";
    String clientStr = "192.0.2.45";
    int port = 40000;
    int flags = 0x8000;

    InetAddress ip = InetAddresses.forString(validTeredoAddress);
    assertTrue(InetAddresses.isTeredoAddress((Inet6Address) ip));
    InetAddresses.TeredoInfo teredo = InetAddresses.getTeredoInfo((Inet6Address) ip);

    InetAddress server = InetAddresses.forString(serverStr);
    assertEquals(server, teredo.getServer());

    InetAddress client = InetAddresses.forString(clientStr);
    assertEquals(client, teredo.getClient());

    assertEquals(port, teredo.getPort());
    assertEquals(flags, teredo.getFlags());
  }
Ejemplo n.º 10
0
  /**
   * Get all predefined all floating IPs defined in cartridge definition.
   *
   * @param array of {@link NetworkInterface}
   * @return list of predefined floating IPs
   */
  public List<String> getAllPredefinedFloatingIPs(NetworkInterface[] networkInterfaces) {
    String nwInterfacesNullMsg = "Input NetworkInterface array cannot be null";
    assertNotNull(networkInterfaces, nwInterfacesNullMsg);

    List<String> allPredefinedFloatingIPs = new ArrayList<String>();
    for (NetworkInterface networkInterface : networkInterfaces) {
      // if no floating networks defined, skip it
      if (null == networkInterface.getFloatingNetworks()) {
        continue;
      }
      FloatingNetwork[] floatingNetworks =
          networkInterface.getFloatingNetworks().getFloatingNetworks();
      if (floatingNetworks == null || floatingNetworks.length == 0) {
        continue;
      }

      for (FloatingNetwork floatingNetwork : floatingNetworks) {
        String floatingIP = floatingNetwork.getFloatingIP();
        // we are giving more priority to network uuid over fixed floating IPs
        // so if both network uuid and floating IPs defined, we are not going to assign those
        // floating IPs
        // so these can be assigned to some other interfaces
        // hence excluding from predefined floating IPs list
        String networkUuid = floatingNetwork.getNetworkUuid();
        if (networkUuid == null || networkUuid.isEmpty()) {
          if (floatingIP != null && InetAddresses.isInetAddress(floatingIP)) {
            allPredefinedFloatingIPs.add(floatingIP);
          }
        }
      }
    }
    return allPredefinedFloatingIPs;
  }
  private boolean isValid() {
    if (myUseHTTPProxyRb.isSelected()) {
      String host = getText(myProxyHostTextField);
      if (host == null) {
        return false;
      }

      try {
        HostAndPort parsedHost = HostAndPort.fromString(host);
        if (parsedHost.hasPort()) {
          return false;
        }
        host = parsedHost.getHostText();

        try {
          InetAddresses.forString(host);
          return true;
        } catch (IllegalArgumentException e) {
          // it is not an IPv4 or IPv6 literal
        }

        InternetDomainName.from(host);
      } catch (IllegalArgumentException e) {
        return false;
      }

      if (myProxyAuthCheckBox.isSelected()) {
        return !StringUtil.isEmptyOrSpaces(myProxyLoginTextField.getText())
            && myProxyPasswordTextField.getPassword().length > 0;
      }
    }
    return true;
  }
Ejemplo n.º 12
0
  public void testCompatIPv4Addresses() {
    String[] nonCompatAddresses = {
      "3ffe::1", "::", "::1",
    };

    for (int i = 0; i < nonCompatAddresses.length; i++) {
      InetAddress ip = InetAddresses.forString(nonCompatAddresses[i]);
      assertFalse(InetAddresses.isCompatIPv4Address((Inet6Address) ip));
      try {
        InetAddresses.getCompatIPv4Address((Inet6Address) ip);
        fail("IllegalArgumentException expected for '" + nonCompatAddresses[i] + "'");
      } catch (IllegalArgumentException expected) {
        // expected behavior
      }
    }

    String[] validCompatAddresses = {
      "::1.2.3.4", "::102:304",
    };
    String compatStr = "1.2.3.4";
    InetAddress compat = InetAddresses.forString(compatStr);

    for (int i = 0; i < validCompatAddresses.length; i++) {
      InetAddress ip = InetAddresses.forString(validCompatAddresses[i]);
      assertTrue("checking '" + validCompatAddresses[i] + "'", ip instanceof Inet6Address);
      assertTrue(
          "checking '" + validCompatAddresses[i] + "'",
          InetAddresses.isCompatIPv4Address((Inet6Address) ip));
      assertEquals(
          "checking '" + validCompatAddresses[i] + "'",
          compat,
          InetAddresses.getCompatIPv4Address((Inet6Address) ip));
    }
  }
Ejemplo n.º 13
0
  public void testFromLittleEndianByteArray() throws UnknownHostException {
    assertEquals(
        InetAddresses.fromLittleEndianByteArray(new byte[] {1, 2, 3, 4}),
        InetAddress.getByAddress(new byte[] {4, 3, 2, 1}));

    assertEquals(
        InetAddresses.fromLittleEndianByteArray(
            new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}),
        InetAddress.getByAddress(
            new byte[] {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}));

    try {
      InetAddresses.fromLittleEndianByteArray(new byte[3]);
      fail("expected exception");
    } catch (UnknownHostException expected) {
      // success
    }
  }
Ejemplo n.º 14
0
 @Override
 public boolean apply(String input) {
   try {
     // Note we can do this, as InetAddress is now on the white list
     return (InetAddresses.forString(input) instanceof Inet4Address);
   } catch (IllegalArgumentException e) {
     // could be a hostname
     return true;
   }
 }
Ejemplo n.º 15
0
 /**
  * Converts an IPv6 string literal (e.g., "1111:2222::8888") into an IP address.
  *
  * @param value an IPv6 address value in string form
  * @return an IPv6 address
  * @throws IllegalArgumentException if the argument is invalid
  */
 public static Ip6Address valueOf(String value) {
   InetAddress inetAddress = null;
   try {
     inetAddress = InetAddresses.forString(value);
   } catch (IllegalArgumentException e) {
     final String msg = "Invalid IP address string: " + value;
     throw new IllegalArgumentException(msg);
   }
   return valueOf(inetAddress);
 }
Ejemplo n.º 16
0
 public InetAddress getInetAddress() {
   if (!fields.containsKey("gl2_remote_ip")) {
     return null;
   }
   final String ipAddr = (String) fields.get("gl2_remote_ip");
   try {
     return InetAddresses.forString(ipAddr);
   } catch (IllegalArgumentException ignored) {
     return null;
   }
 }
Ejemplo n.º 17
0
  private static InetAddress parseInetAddress(String addrStr) {
    if (addrStr == null || addrStr.isEmpty()) {
      return null;
    }

    try {
      return InetAddresses.forString(addrStr);
    } catch (IllegalArgumentException e) {
      log.error(String.format("Failed to parse Inet address string: %s", addrStr), e);
      return null;
    }
  }
  private String getConsumerEndpoint(String endpoint) {
    if (Strings.isNullOrEmpty(endpoint)) {
      Optional<InetAddress> address = getOneControlInetAddress();
      if (!address.isPresent()) {
        logger.warn("Could not determine MTOSI/OneControl consumer end point");
        return getEndPoint(InetAddresses.forString("127.0.0.1"));
      }
      return getEndPoint(address.get());
    }

    return endpoint;
  }
  @Override
  public IpAddress evaluate(FunctionArgs args, EvaluationContext context) {
    final String ipString = String.valueOf(ipParam.required(args, context));

    try {
      final InetAddress inetAddress = InetAddresses.forString(ipString);
      return new IpAddress(inetAddress);
    } catch (IllegalArgumentException e) {
      final Optional<String> defaultValue = defaultParam.optional(args, context);
      if (!defaultValue.isPresent()) {
        return new IpAddress(ANYV4);
      }
      try {
        return new IpAddress(InetAddresses.forString(defaultValue.get()));
      } catch (IllegalFormatException e1) {
        log.warn(
            "Parameter `default` for to_ip() is not a valid IP address: {}", defaultValue.get());
        throw e1;
      }
    }
  }
Ejemplo n.º 20
0
  public void testIncrementIPv6() throws UnknownHostException {
    InetAddress addressV6_66_0 = InetAddress.getByName("2001:db8::6600");
    InetAddress addressV6_66_ff = InetAddress.getByName("2001:db8::66ff");
    InetAddress addressV6_67_0 = InetAddress.getByName("2001:db8::6700");

    InetAddress address = addressV6_66_0;
    for (int i = 0; i < 255; i++) {
      address = InetAddresses.increment(address);
    }
    assertEquals(addressV6_66_ff, address);

    address = InetAddresses.increment(address);
    assertEquals(addressV6_67_0, address);

    InetAddress addressV6_ffffff = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
    address = addressV6_ffffff;
    try {
      address = InetAddresses.increment(address);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }
Ejemplo n.º 21
0
  public void testIncrementIPv4() throws UnknownHostException {
    InetAddress address_66_0 = InetAddress.getByName("172.24.66.0");
    InetAddress address_66_255 = InetAddress.getByName("172.24.66.255");
    InetAddress address_67_0 = InetAddress.getByName("172.24.67.0");

    InetAddress address = address_66_0;
    for (int i = 0; i < 255; i++) {
      address = InetAddresses.increment(address);
    }
    assertEquals(address_66_255, address);

    address = InetAddresses.increment(address);
    assertEquals(address_67_0, address);

    InetAddress address_ffffff = InetAddress.getByName("255.255.255.255");
    address = address_ffffff;
    try {
      address = InetAddresses.increment(address);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }
Ejemplo n.º 22
0
 private String findPublicHostname() {
   try {
     return InetAddress.getLocalHost().getHostName().toLowerCase();
   } catch (UnknownHostException e) {
     // Java 7u5 and later on MacOS sometimes throws this unless the local hostname is in DNS
     // or hosts file. The exception message is the hostname followed by a colon and an error
     // message.
     final Matcher matcher = HOST_EXCEPTION_MESSAGE_PATTERN.matcher(e.getMessage());
     if (matcher.matches()) {
       return matcher.group(1).toLowerCase();
     }
     return InetAddresses.toUriString(internalIp);
   }
 }
Ejemplo n.º 23
0
  public void testDecrementIPv6() throws UnknownHostException {
    InetAddress addressV6660 = InetAddress.getByName("2001:db8::6600");
    InetAddress addressV666ff = InetAddress.getByName("2001:db8::66ff");
    InetAddress addressV6670 = InetAddress.getByName("2001:db8::6700");

    InetAddress address = addressV6670;
    address = InetAddresses.decrement(address);

    assertEquals(addressV666ff, address);

    for (int i = 0; i < 255; i++) {
      address = InetAddresses.decrement(address);
    }
    assertEquals(addressV6660, address);

    InetAddress addressV6000000 = InetAddress.getByName("0:0:0:0:0:0:0:0");
    address = addressV6000000;
    try {
      address = InetAddresses.decrement(address);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }
Ejemplo n.º 24
0
  public void testDecrementIPv4() throws UnknownHostException {
    InetAddress address660 = InetAddress.getByName("172.24.66.0");
    InetAddress address66255 = InetAddress.getByName("172.24.66.255");
    InetAddress address670 = InetAddress.getByName("172.24.67.0");

    InetAddress address = address670;
    address = InetAddresses.decrement(address);

    assertEquals(address66255, address);

    for (int i = 0; i < 255; i++) {
      address = InetAddresses.decrement(address);
    }
    assertEquals(address660, address);

    InetAddress address0000 = InetAddress.getByName("0.0.0.0");
    address = address0000;
    try {
      address = InetAddresses.decrement(address);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }
Ejemplo n.º 25
0
  /**
   * Tests the SMTP settings from the initial setup form, rendering the result as JSON.
   *
   * @param setup the initial setup form.
   */
  @Restrictions({
    @Restrict({"SYSTEM_ADMIN", "SECURITY_ADMIN"}),
    @Restrict({"RESTRICTED_SYSTEM_ADMIN", "RESTRICTED_SECURITY_ADMIN"})
  })
  public static void testSmtpSettings(SetupForm setup) {
    setup.validateSmtp();
    Validation.required("setup.smtpTo", setup.smtpTo);
    Validation.email("setup.smtpTo", setup.smtpTo);
    if (Validation.hasErrors()) {
      renderJSON(ValidationResponse.collectErrors());
    }

    MailSettingsValidator.Settings settings = new MailSettingsValidator.Settings();

    if (StringUtils.isNotEmpty(setup.nameservers)
        && !InetAddresses.isInetAddress(setup.smtpServer)) {
      Set<String> ips = Sets.newHashSet(setup.nameservers.split(","));

      try {
        settings.server = DnsUtils.getHostIpAddress(ips, setup.smtpServer).getHostAddress();
      } catch (ViPRException e) {
        renderJSON(ValidationResponse.invalid(e.getMessage()));
      }
    } else {
      settings.server = setup.smtpServer;
    }
    settings.port = ConfigProperties.getPort(setup.smtpPort, setup.smtpEnableTls);
    settings.username = setup.smtpUsername;
    settings.password = PasswordUtil.decryptedValue(setup.smtpPassword);
    settings.channel = StringUtils.equals("yes", setup.smtpEnableTls) ? "starttls" : "clear";
    settings.authType = setup.smtpAuthType;
    settings.fromAddress = setup.smtpFrom;

    try {
      MailSettingsValidator.validate(settings, setup.smtpTo);
    } catch (RuntimeException e) {
      Logger.error(e, "Failed to send email");
      Validation.addError(null, "setup.testEmail.failure", e.getMessage());
      if (StringUtils.isEmpty(setup.nameservers)) {
        Validation.addError(null, "setup.smtpServer.invalidEmptyNameserver");
      }
    }

    if (Validation.hasErrors()) {
      renderJSON(ValidationResponse.collectErrors());
    } else {
      renderJSON(ValidationResponse.valid(MessagesUtils.get("setup.testEmail.success")));
    }
  }
public class IpAddressConversion extends AbstractFunction<IpAddress> {

  public static final String NAME = "to_ip";
  private static final InetAddress ANYV4 = InetAddresses.forString("0.0.0.0");

  private final ParameterDescriptor<Object, Object> ipParam;
  private final ParameterDescriptor<String, String> defaultParam;

  public IpAddressConversion() {
    ipParam = ParameterDescriptor.object("ip").description("Value to convert").build();
    defaultParam =
        ParameterDescriptor.string("default")
            .optional()
            .description("Used when 'ip' is null or malformed, defaults to '0.0.0.0'")
            .build();
  }

  @Override
  public IpAddress evaluate(FunctionArgs args, EvaluationContext context) {
    final String ipString = String.valueOf(ipParam.required(args, context));

    try {
      final InetAddress inetAddress = InetAddresses.forString(ipString);
      return new IpAddress(inetAddress);
    } catch (IllegalArgumentException e) {
      final Optional<String> defaultValue = defaultParam.optional(args, context);
      if (!defaultValue.isPresent()) {
        return new IpAddress(ANYV4);
      }
      try {
        return new IpAddress(InetAddresses.forString(defaultValue.get()));
      } catch (IllegalFormatException e1) {
        log.warn(
            "Parameter `default` for to_ip() is not a valid IP address: {}", defaultValue.get());
        throw e1;
      }
    }
  }

  @Override
  public FunctionDescriptor<IpAddress> descriptor() {
    return FunctionDescriptor.<IpAddress>builder()
        .name(NAME)
        .returnType(IpAddress.class)
        .params(of(ipParam, defaultParam))
        .description("Converts a value to an IPAddress using its string representation")
        .build();
  }
}
Ejemplo n.º 27
0
public class UniqueIscsiTargetBuilder implements Builder<UniqueIscsiTarget> {
  private static final Random random = new Random();

  private String uuid = UUID.randomUUID().toString();
  private String storageIpAddress = InetAddresses.fromInteger(random.nextInt()).getHostAddress();
  private String storageAgentUrl = "http://" + randomAlphabetic(4) + ".example.com";
  private IscsiTarget iscsiTarget = IscsiTargetBuilder.anIscsiTarget().build();

  public static UniqueIscsiTargetBuilder aUniqueIscsiTarget() {
    return new UniqueIscsiTargetBuilder();
  }

  @Override
  public UniqueIscsiTarget build() {
    return new UniqueIscsiTarget(uuid, storageIpAddress, storageAgentUrl, iscsiTarget);
  }
}
Ejemplo n.º 28
0
  @Override
  public Session toManagementSession() {
    SessionBuilder builder = new SessionBuilder();

    builder.setSessionId(getSessionId());
    IpAddress address;
    InetAddress address1 = InetAddresses.forString(header.getAddress());
    if (address1 instanceof Inet4Address) {
      address = new IpAddress(new Ipv4Address(header.getAddress()));
    } else {
      address = new IpAddress(new Ipv6Address(header.getAddress()));
    }
    builder.setSourceHost(new Host(address));

    Preconditions.checkState(DateAndTime.PATTERN_CONSTANTS.size() == 1);
    String formattedDateTime = dateFormatter.format(loginTime);

    Matcher matcher = dateTimePattern.matcher(formattedDateTime);
    Preconditions.checkState(
        matcher.matches(),
        "Formatted datetime %s does not match pattern %s",
        formattedDateTime,
        dateTimePattern);
    builder.setLoginTime(new DateAndTime(formattedDateTime));

    builder.setInBadRpcs(new ZeroBasedCounter32(inRpcFail));
    builder.setInRpcs(new ZeroBasedCounter32(inRpcSuccess));
    builder.setOutRpcErrors(new ZeroBasedCounter32(outRpcError));

    builder.setUsername(header.getUserName());
    builder.setTransport(getTransportForString(header.getTransport()));

    builder.setOutNotifications(new ZeroBasedCounter32(outNotification));

    builder.setKey(new SessionKey(getSessionId()));

    Session1Builder builder1 = new Session1Builder();
    builder1.setSessionIdentifier(header.getSessionIdentifier());
    builder.addAugmentation(Session1.class, builder1.build());

    return builder.build();
  }
Ejemplo n.º 29
0
  public NodeInfo(
      String environment,
      String pool,
      String nodeId,
      InetAddress nodeIp,
      String location,
      String binarySpec,
      String configSpec) {
    Preconditions.checkNotNull(environment, "environment is null");
    Preconditions.checkNotNull(pool, "pool is null");
    Preconditions.checkArgument(
        environment.matches(NodeConfig.ENV_REGEXP),
        String.format("environment '%s' is invalid", environment));
    Preconditions.checkArgument(
        pool.matches(NodeConfig.POOL_REGEXP), String.format("pool '%s' is invalid", pool));

    this.environment = environment;
    this.pool = pool;

    if (nodeId != null) {
      this.nodeId = nodeId;
    } else {
      this.nodeId = UUID.randomUUID().toString();
    }

    if (location != null) {
      this.location = location;
    } else {
      this.location = "/" + this.nodeId;
    }

    this.binarySpec = binarySpec;
    this.configSpec = configSpec;

    if (nodeIp != null) {
      this.publicIp = nodeIp;
      this.bindIp = nodeIp;
    } else {
      this.publicIp = findPublicIp();
      this.bindIp = InetAddresses.fromInteger(0);
    }
  }
Ejemplo n.º 30
0
 public static long ipToLong(String ip) throws ElasticsearchIllegalArgumentException {
   try {
     if (!InetAddresses.isInetAddress(ip)) {
       throw new ElasticsearchIllegalArgumentException(
           "failed to parse ip [" + ip + "], not a valid ip address");
     }
     String[] octets = pattern.split(ip);
     if (octets.length != 4) {
       throw new ElasticsearchIllegalArgumentException(
           "failed to parse ip [" + ip + "], not a valid ipv4 address (4 dots)");
     }
     return (Long.parseLong(octets[0]) << 24)
         + (Integer.parseInt(octets[1]) << 16)
         + (Integer.parseInt(octets[2]) << 8)
         + Integer.parseInt(octets[3]);
   } catch (Exception e) {
     if (e instanceof ElasticsearchIllegalArgumentException) {
       throw (ElasticsearchIllegalArgumentException) e;
     }
     throw new ElasticsearchIllegalArgumentException("failed to parse ip [" + ip + "]", e);
   }
 }