示例#1
0
  public static String getIPAddress(boolean useIPv4) throws SocketException {
    List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
    for (NetworkInterface intf : interfaces) {
      List<InetAddress> addrs = Collections.list(intf.getInetAddresses());
      for (InetAddress addr : addrs) {
        if (!addr.isLoopbackAddress()) {
          String sAddr = addr.getHostAddress().toUpperCase();
          boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr);

          if (useIPv4) {
            if (isIPv4) return sAddr;
          } else {
            if (!isIPv4) {
              if (sAddr.startsWith("fe80")
                  || sAddr.startsWith("FE80")) // skipping link-local addresses
              continue;
              int delim = sAddr.indexOf('%'); // drop ip6 port suffix
              return delim < 0 ? sAddr : sAddr.substring(0, delim);
            }
          }
        }
      }
    }

    return "";
  }
示例#2
0
  /**
   * Prefer something other than loopback.
   *
   * @return
   * @throws SocketException
   * @throws UnknownHostException
   */
  public static InetAddress getInetAddress() throws SocketException, UnknownHostException {

    // try to use eth0 if found
    NetworkInterface eth0 = NetworkInterface.getByName("eth0");
    if (eth0 != null) {
      Enumeration<InetAddress> addresses = eth0.getInetAddresses();
      for (InetAddress address : Collections.list(addresses)) {
        if (address instanceof Inet4Address) {
          return address;
        }
      }
    }

    // something other than eth0 or loopback
    Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
    for (NetworkInterface iface : Collections.list(interfaces)) {
      Enumeration<InetAddress> addresses = iface.getInetAddresses();
      for (InetAddress address : Collections.list(addresses)) {
        if (address instanceof Inet4Address && !address.isLoopbackAddress()) {
          return address;
        }
      }
    }

    // default, probably loopback
    return InetAddress.getLocalHost();
  }
示例#3
0
  public static String getLocalIpAddress2() {
    String networkIp = null;
    try {
      List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
      for (NetworkInterface iface : interfaces) {
        if (iface.getDisplayName().equals("eth0")) {
          List<InetAddress> addresses = Collections.list(iface.getInetAddresses());
          for (InetAddress address : addresses) {
            if (address instanceof Inet4Address) {
              networkIp = address.getHostAddress();
            }
          }
        } else if (iface.getDisplayName().equals("wlan0")) {
          List<InetAddress> addresses = Collections.list(iface.getInetAddresses());
          for (InetAddress address : addresses) {
            if (address instanceof Inet4Address) {
              networkIp = address.getHostAddress();
            }
          }
        }
      }
    } catch (SocketException e) {
      e.printStackTrace();
    }

    return networkIp;
  }
示例#4
0
 /**
  * Get IP address from first non-localhost interface
  *
  * @param ipv4 true=return ipv4, false=return ipv6
  * @return address or empty string
  */
 public static String getIPAddress(boolean useIPv4) {
   try {
     List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
     for (NetworkInterface intf : interfaces) {
       List<InetAddress> addrs = Collections.list(intf.getInetAddresses());
       for (InetAddress addr : addrs) {
         if (!addr.isLoopbackAddress()) {
           String sAddr = addr.getHostAddress().toUpperCase();
           boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr);
           if (useIPv4) {
             if (isIPv4) return sAddr;
           } else {
             if (!isIPv4) {
               int delim = sAddr.indexOf('%'); // drop ip6 port
               // suffix
               return delim < 0 ? sAddr : sAddr.substring(0, delim);
             }
           }
         }
       }
     }
   } catch (Exception ex) {
   } // for now eat exceptions
   return "";
 }
  private NetworkInterface GetExternalNetworkInterface() {
    try {
      // iterate over the network interfaces known to java
      Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
      OUTER:
      for (NetworkInterface interface_ : Collections.list(interfaces)) {
        // we shouldn't care about loopback addresses
        if (interface_.isLoopback()) continue;

        // if you don't expect the interface to be up you can skip this
        // though it would question the usability of the rest of the code
        if (!interface_.isUp()) continue;

        // iterate over the addresses associated with the interface
        Enumeration<InetAddress> addresses = interface_.getInetAddresses();
        for (InetAddress address : Collections.list(addresses)) {
          // look only for ipv4 addresses
          if (address instanceof Inet6Address) continue;

          // use a timeout big enough for your needs
          if (!address.isReachable(3000)) continue;

          return interface_;
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
  public static Set<String> getIpAddresses() {
    if (_ipAddresses == null) {
      _ipAddresses = new HashSet<String>();

      try {
        List<NetworkInterface> networkInterfaces =
            Collections.list(NetworkInterface.getNetworkInterfaces());

        for (NetworkInterface networkInterface : networkInterfaces) {
          List<InetAddress> inetAddresses = Collections.list(networkInterface.getInetAddresses());

          for (InetAddress inetAddress : inetAddresses) {
            if (inetAddress.isLinkLocalAddress()
                || inetAddress.isLoopbackAddress()
                || !(inetAddress instanceof Inet4Address)) {

              continue;
            }

            _ipAddresses.add(inetAddress.getHostAddress());
          }
        }
      } catch (Exception e) {
        _log.error("Unable to read local server's IP addresses");

        _log.error(e, e);
      }
    }

    return new HashSet<String>(_ipAddresses);
  }
示例#7
0
  private static InetAddress findPublicIp() {
    // Check if local host address is a good v4 address
    InetAddress localAddress;
    try {
      localAddress = InetAddress.getLocalHost();
      if (isGoodV4Address(localAddress)) {
        return localAddress;
      }
    } catch (UnknownHostException ignored) {
      throw new AssertionError("Could not get local ip address");
    }

    // check all up network interfaces for a good v4 address
    for (NetworkInterface networkInterface : getGoodNetworkInterfaces()) {
      for (InetAddress address : Collections.list(networkInterface.getInetAddresses())) {
        if (isGoodV4Address(address)) {
          return address;
        }
      }
    }
    // check all up network interfaces for a good v6 address
    for (NetworkInterface networkInterface : getGoodNetworkInterfaces()) {
      for (InetAddress address : Collections.list(networkInterface.getInetAddresses())) {
        if (isGoodV6Address(address)) {
          return address;
        }
      }
    }
    // just return the local host address
    // it is most likely that this is a disconnected developer machine
    return localAddress;
  }
示例#8
0
  private static void displayInterfaceInformation(final NetworkInterface networkInterface)
      throws SocketException {
    LOG.trace(MessageFormat.format("Display name: %s%n", networkInterface.getDisplayName()));
    LOG.trace(MessageFormat.format("Name: %s%n", networkInterface.getName()));
    Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
    for (InetAddress inetAddress : Collections.list(inetAddresses)) {
      LOG.trace(MessageFormat.format("InetAddress: %s%n", inetAddress));
    }

    LOG.trace(MessageFormat.format("Parent: %s%n", networkInterface.getParent()));
    LOG.trace(MessageFormat.format("Up? %s%n", networkInterface.isUp()));
    LOG.trace(MessageFormat.format("Loopback? %s%n", networkInterface.isLoopback()));
    LOG.trace(MessageFormat.format("PointToPoint? %s%n", networkInterface.isPointToPoint()));
    LOG.trace(MessageFormat.format("Supports multicast? %s%n", networkInterface.isVirtual()));
    LOG.trace(MessageFormat.format("Virtual? %s%n", networkInterface.isVirtual()));
    LOG.trace(
        MessageFormat.format(
            "Hardware address: %s%n", Arrays.toString(networkInterface.getHardwareAddress())));
    LOG.trace(MessageFormat.format("MTU: %s%n", networkInterface.getMTU()));

    List<InterfaceAddress> interfaceAddresses = networkInterface.getInterfaceAddresses();
    for (InterfaceAddress addr : interfaceAddresses) {
      LOG.trace(MessageFormat.format("InterfaceAddress: %s%n", addr.getAddress()));
    }
    LOG.trace(MessageFormat.format("%n", null));
    Enumeration<NetworkInterface> subInterfaces = networkInterface.getSubInterfaces();
    for (NetworkInterface aNetworkInterface : Collections.list(subInterfaces)) {
      LOG.trace(MessageFormat.format("%nSubInterface%n", null));
      displayInterfaceInformation(aNetworkInterface);
    }
    LOG.trace(MessageFormat.format("%n", null));
  }
示例#9
0
 /**
  * Returns a hash that should be consistent for any individual swarm client (as long as it has a
  * persistent IP) and should be unique to that client.
  *
  * @param remoteFsRoot the file system root should be part of the hash (to support multiple swarm
  *     clients from the same machine)
  * @return our best effort at a consistent hash
  */
 public static String hash(File remoteFsRoot) {
   StringBuilder buf = new StringBuilder();
   try {
     buf.append(remoteFsRoot.getCanonicalPath()).append('\n');
   } catch (IOException e) {
     buf.append(remoteFsRoot.getAbsolutePath()).append('\n');
   }
   try {
     for (NetworkInterface ni : Collections.list(NetworkInterface.getNetworkInterfaces())) {
       for (InetAddress ia : Collections.list(ni.getInetAddresses())) {
         if (ia instanceof Inet4Address) {
           buf.append(ia.getHostAddress()).append('\n');
         } else if (ia instanceof Inet6Address) {
           buf.append(ia.getHostAddress()).append('\n');
         }
       }
       byte[] hardwareAddress = ni.getHardwareAddress();
       if (hardwareAddress != null) {
         buf.append(Arrays.toString(hardwareAddress));
       }
     }
   } catch (SocketException e) {
     // oh well we tried
   }
   return DigestUtils.md5Hex(buf.toString()).substring(0, 8);
 }
示例#10
0
    public Enumeration<String> getInitParameterNames() {
      Set<String> result = Sets.newLinkedHashSet();

      result.addAll(Collections.list(filterConfig.getInitParameterNames()));
      result.addAll(Collections.list(filterConfig.getServletContext().getInitParameterNames()));

      return Iterators.asEnumeration(result.iterator());
    }
示例#11
0
 @Override
 public Enumeration<URL> findResources(String name) throws IOException {
   final HashSet<URL> urls = new HashSet<>();
   for (PomClassLoader cl : parents) {
     urls.addAll(Collections.list(cl.findResources(name)));
   }
   urls.addAll(Collections.list(super.findResources(name)));
   return Collections.enumeration(urls);
 }
示例#12
0
 private static List<TestFailure> createTestFailures(
     @NotNull InMemoryJavaGenerationHandler generationHandler, List<SModel> models) {
   List<TestFailure> testFailures = new ArrayList<TestFailure>();
   junit.framework.TestResult result = new junit.framework.TestResult();
   invokeTests(generationHandler, models, result, null);
   testFailures.addAll(Collections.list(result.failures()));
   testFailures.addAll(Collections.list(result.errors()));
   return testFailures;
 }
示例#13
0
  /**
   * Returns an enumeration describing the available options.
   *
   * @return an enumeration of all the available options.
   */
  public Enumeration<Option> listOptions() {

    Vector<Option> result = new Vector<Option>();

    result.addElement(
        new Option("\tThe complexity constant C.\n" + "\t(default 1)", "C", 1, "-C <double>"));

    result.addElement(
        new Option(
            "\tWhether to 0=normalize/1=standardize/2=neither.\n" + "\t(default 0=normalize)",
            "N",
            1,
            "-N"));

    result.addElement(
        new Option(
            "\tOptimizer class used for solving quadratic optimization problem\n"
                + "\t(default "
                + RegSMOImproved.class.getName()
                + ")",
            "I",
            1,
            "-I <classname and parameters>"));

    result.addElement(
        new Option(
            "\tThe Kernel to use.\n"
                + "\t(default: weka.classifiers.functions.supportVector.PolyKernel)",
            "K",
            1,
            "-K <classname and parameters>"));

    result.addAll(Collections.list(super.listOptions()));

    result.addElement(
        new Option(
            "",
            "",
            0,
            "\nOptions specific to optimizer ('-I') "
                + getRegOptimizer().getClass().getName()
                + ":"));

    result.addAll(Collections.list(((OptionHandler) getRegOptimizer()).listOptions()));

    result.addElement(
        new Option(
            "",
            "",
            0,
            "\nOptions specific to kernel ('-K') " + getKernel().getClass().getName() + ":"));

    result.addAll(Collections.list(((OptionHandler) getKernel()).listOptions()));

    return result.elements();
  }
示例#14
0
 public DirectoryServer(int port) throws Exception {
   super("Directory Server", false);
   boolean connected = false;
   try {
     udp_socket = new DatagramSocket(port);
     System.out.println("The DirectoryServer UDP socket was bound to port: " + port);
   } catch (SocketException e) {
     udp_socket = new DatagramSocket();
     System.out.println(
         "The DirectoryServer UDP socket was bound to port: " + udp_socket.getLocalPort());
   }
   udp_socket.setSoTimeout(Server.TIMEOUT_Server);
   dsu = new DirectoryServerUDP(this);
   if (Application.db_dir == null) {
     db_dir = getDirDB(Application.CURRENT_DATABASE_DIR() + Application.DIRECTORY_FILE);
     Application.db_dir = db_dir;
   } else db_dir = Application.db_dir;
   do {
     try {
       if (port <= 0) port = Server.getRandomPort();
       ss = new ServerSocket(port);
       connected = true;
     } catch (Exception e) {
       e.printStackTrace();
       connected = false;
       port = Server.getRandomPort();
     }
   } while (!connected);
   System.out.println("Got port: " + ss.getLocalPort());
   /*
   System.out.println("Got net: "+ss.getInetAddress());
   System.out.println("Got sock: "+ss.getLocalSocketAddress());
   System.out.println("Got obj: "+ss);
    */
   Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
   for (NetworkInterface netint : Collections.list(nets)) {
     out.printf("Display name: %s\n", netint.getDisplayName());
     out.printf(
         "Name: %s (loopback: %s; p2p:%s; up: %s, v: %s, m:%s)\n",
         netint.getName(),
         "" + netint.isLoopback(),
         "" + netint.isPointToPoint(),
         "" + netint.isUp(),
         "" + netint.isVirtual(),
         "" + netint.supportsMulticast());
     Enumeration<InetAddress> inetAddresses = netint.getInetAddresses();
     for (InetAddress inetAddress : Collections.list(inetAddresses)) {
       out.printf("inetAddress: %s\n", inetAddress);
     }
   }
   initAcceptedInets();
 }
  @Override
  public Enumeration<URL> getResources(final String name) throws IOException {
    if (!getState().isAvailable()) {
      return null;
    }

    if ("META-INF/services/javax.servlet.ServletContainerInitializer".equals(name)) {
      final Collection<URL> list = new ArrayList<>(Collections.list(super.getResources(name)));
      final Iterator<URL> it = list.iterator();
      while (it.hasNext()) {
        final URL next = it.next();
        final File file = Files.toFile(next);
        if (!file.isFile() && NewLoaderLogic.skip(next)) {
          it.remove();
        }
      }
      return Collections.enumeration(list);
    }
    if ("META-INF/services/javax.websocket.ContainerProvider".equals(name)) {
      final Collection<URL> list = new ArrayList<>(Collections.list(super.getResources(name)));
      final Iterator<URL> it = list.iterator();
      while (it.hasNext()) {
        final URL next = it.next();
        final File file = Files.toFile(next);
        if (!file.isFile() && NewLoaderLogic.skip(next)) {
          it.remove();
        }
      }
      return Collections.enumeration(list);
    }
    if ("META-INF/faces-config.xml".equals(name)) { // mojarra workaround
      try {
        if (WebBeansContext.currentInstance() == null
            && Boolean.parseBoolean(
                SystemInstance.get().getProperty("tomee.jsf.ignore-owb", "true"))) {
          final Collection<URL> list = new HashSet<>(Collections.list(super.getResources(name)));
          final Iterator<URL> it = list.iterator();
          while (it.hasNext()) {
            final String fileName = Files.toFile(it.next()).getName();
            if (fileName.startsWith("openwebbeans-" /*jsf|el22*/) && fileName.endsWith(".jar")) {
              it.remove();
            }
          }
          return Collections.enumeration(list);
        }
      } catch (final Throwable th) {
        // no-op
      }
    }
    return URLClassLoaderFirst.filterResources(name, super.getResources(name));
  }
示例#16
0
  public String detectPPP() {
    try {
      List<String> linkPPP = new ArrayList<String>();
      List<String> linkDSL = new ArrayList<String>();
      Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();

      // System.out.println("NETS VALUES"+" "+nets);

      // System.out.println("INITIALY VALUES"+" "+linkPPP);

      for (NetworkInterface netInf : Collections.list(nets)) {
        // System.out.println("netInf VALUES"+" "+netInf);

        if (!netInf.isLoopback()) {
          if (netInf.isPointToPoint()) {
            // System.out.println("in point to point");
            // System.out.println("netInf VALUES"+" "+netInf);
            Enumeration<InetAddress> inetAdd = netInf.getInetAddresses();
            // System.out.println("inetAdd VALUES"+" "+inetAdd);
            for (InetAddress inet : Collections.list(inetAdd)) {
              // System.out.println("inet vales in the ineer loop"+" "+inet);
              // System.out.println("linkPPP vales before add in the ineer loop"+" "+linkPPP);
              linkPPP.add(inet.getHostAddress()); // 				
              // System.out.println("linkPPP vales after add in the ineer loop"+" "+linkPPP);
              // System.out.println("IP:"+" "+inet.getHostAddress());
            }
          } else {
            Enumeration<InetAddress> inetAdd = netInf.getInetAddresses();
            for (InetAddress inet : Collections.list(inetAdd)) {
              linkDSL.add(inet.getHostAddress());
            }
          }
        }
      }
      // System.out.println("FINAL VALUE of linkPPP"+" "+linkPPP.get(0));
      // System.out.println("FINAL VALUES DSL"+" "+linkDSL);
      int i = linkPPP.size();
      if (i != 0) {
        // System.out.println("linkPPP"+" "+linkPPP.get(i-1));
        return linkPPP.get(i - 1) + ",y";
        // return linkPPP.get(0)+",y";
      } else if (linkDSL.size() != 0) return linkDSL.get(i - 1) + ",n";
      // return linkDSL.get(0)+",n";
      else return "127.0.0.1,n";
    } catch (SocketException e) {
      // e.printStackTrace();
      System.err.println("exception in ");
    }

    return "127.0.0.1,n";
  }
  private List<String> getServerInterfaces() {

    List<String> bindInterfaces = new ArrayList<String>();

    String interfaceName = JiveGlobals.getXMLProperty("network.interface");
    String bindInterface = null;
    if (interfaceName != null) {
      if (interfaceName.trim().length() > 0) {
        bindInterface = interfaceName;
      }
    }

    int adminPort = JiveGlobals.getXMLProperty("adminConsole.port", 9090);
    int adminSecurePort = JiveGlobals.getXMLProperty("adminConsole.securePort", 9091);

    if (bindInterface == null) {
      try {
        Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
        for (NetworkInterface netInterface : Collections.list(nets)) {
          Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
          for (InetAddress address : Collections.list(addresses)) {
            if ("127.0.0.1".equals(address.getHostAddress())) {
              continue;
            }
            if (address.getHostAddress().startsWith("0.")) {
              continue;
            }
            Socket socket = new Socket();
            InetSocketAddress remoteAddress =
                new InetSocketAddress(address, adminPort > 0 ? adminPort : adminSecurePort);
            try {
              socket.connect(remoteAddress);
              bindInterfaces.add(address.getHostAddress());
              break;
            } catch (IOException e) {
              // Ignore this address. Let's hope there is more addresses to validate
            }
          }
        }
      } catch (SocketException e) {
        // We failed to discover a valid IP address where the admin console is running
        return null;
      }
    } else {
      bindInterfaces.add(bindInterface);
    }

    return bindInterfaces;
  }
示例#18
0
  private DatagramSocket sendDiscoveryBroadcast() throws Exception {
    final Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();

    for (NetworkInterface networkInterface : Collections.list(nets)) {
      final Enumeration<InetAddress> addresses = networkInterface.getInetAddresses();

      for (InetAddress interfaceAddress : Collections.list(addresses)) {
        if (!interfaceAddress.isLoopbackAddress() && interfaceAddress instanceof Inet4Address) {
          return sendDiscoveryBroadcast(interfaceAddress);
        }
      }
    }

    throw new Exception("no service found");
  }
 private static InetAddress getLinkLocalAddress(String networkInterfaceName)
     throws SocketException {
   Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
   for (NetworkInterface networkInterface : Collections.list(networkInterfaces)) {
     if (networkInterfaceName == null || networkInterfaceName.equals(networkInterface.getName())) {
       Enumeration<InetAddress> ips = networkInterface.getInetAddresses();
       for (InetAddress ip : Collections.list(ips)) {
         if (ip.isLinkLocalAddress()) {
           return ip;
         }
       }
     }
   }
   return null;
 }
 public static Optional<InetAddress> getLocalAddress() {
   try {
     List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
     for (NetworkInterface intf : interfaces) {
       List<InetAddress> addrs = Collections.list(intf.getInetAddresses());
       for (InetAddress addr : addrs) {
         if (!addr.isLoopbackAddress() && addr instanceof Inet4Address) {
           return Optional.fromNullable(addr);
         }
       }
     }
     return Optional.absent();
   } catch (Exception ex) {
     return Optional.absent();
   }
 }
示例#21
0
  @Override
  public Enumeration<URL> getResources(String name) throws IOException {
    List<URL> urls = new ArrayList<URL>();

    for (ClassLoader classLoader : getClassLoaders()) {
      urls.addAll(Collections.list(_getResources(classLoader, name)));
    }

    ClassLoader parentClassLoader = _parentClassLoaderReference.get();

    if (parentClassLoader != null) {
      urls.addAll(Collections.list(_getResources(parentClassLoader, name)));
    }

    return Collections.enumeration(urls);
  }
示例#22
0
  static {
    try {

      InetAddress addr = InetAddress.getLocalHost();
      HOST_NAME = addr.getHostName();
      Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
      for (NetworkInterface netint : Collections.list(nets)) {
        if (null != netint.getHardwareAddress()) {
          List<InterfaceAddress> list = netint.getInterfaceAddresses();
          for (InterfaceAddress interfaceAddress : list) {
            InetAddress ip = interfaceAddress.getAddress();
            if (ip instanceof Inet4Address) {
              HOST_IP += interfaceAddress.getAddress().toString();
            }
          }
        }
      }
      HOST_IP = HOST_IP.replaceAll("null", "");
    } catch (Exception e) {
      System.out.println("获取服务器IP出错");
    }

    try {
      osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();

      TotalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
    } catch (Exception e) {
      System.out.println("获取系统信息失败");
      e.printStackTrace();
    }
  }
示例#23
0
  public static <E, F> void addRange(Dictionary<E, F> destino, Dictionary<E, F> valores) {
    List<E> keys = Collections.list(valores.keys());

    for (E key : keys) {
      destino.put(key, valores.get(key));
    }
  }
  @Override
  public Enumeration getHeaders(String name) {

    ArrayList list = new ArrayList<String>();
    // Never override the parent Request
    if (!name.equalsIgnoreCase("content-type")) {
      list = Collections.list(b.request.getHeaders(name));
    }

    if (name.equalsIgnoreCase("content-type")) {
      String s = getContentType();
      if (s != null) {
        list.add(s);
      }
    } else {
      if (b.headers.get(name) != null) {
        list.add(b.headers.get(name));
      }

      if (isNotNoOps()) {
        if (list.size() == 0 && name.startsWith(X_ATMOSPHERE)) {
          if (attributeWithoutException(b.request, name) != null) {
            list.add(attributeWithoutException(b.request, name));
          }
        }
      }
    }
    return Collections.enumeration(list);
  }
示例#25
0
  static void dumpToFile(
      String name1,
      String name2,
      OutputStream ostream,
      Hashtable<String, PkgEntry> tbl1,
      Hashtable<String, PkgEntry> tbl2) {

    List<String> keyList = new ArrayList<String>();
    for (String x : Collections.list(tbl1.keys())) {
      keyList.add(x);
    }
    Collections.sort(keyList);
    PrintWriter pw = null;
    pw = new PrintWriter(new OutputStreamWriter(ostream));
    pw.printf("\t%s\t%s\n", name1, name2);
    long sum1 = 0L;
    long sum2 = 0L;
    for (String x : keyList) {
      pw.printf("%s\t%s\t%s\n", x, tbl1.get(x).getSize() / 1024, tbl2.get(x).getSize() / 1024);
      sum1 += tbl1.get(x).getSize();
      sum2 += tbl2.get(x).getSize();
    }
    pw.printf("Total\t%s\t%s\n", sum1 / 1024, sum2 / 1024);
    pw.flush();
  }
示例#26
0
  public static void load(Properties properties, String s) throws IOException {

    if (Validator.isNotNull(s)) {
      s = UnicodeFormatter.toString(s);

      s = StringUtil.replace(s, "\\u003d", "=");
      s = StringUtil.replace(s, "\\u000a", "\n");
      s = StringUtil.replace(s, "\\u0021", "!");
      s = StringUtil.replace(s, "\\u0023", "#");
      s = StringUtil.replace(s, "\\u0020", " ");
      s = StringUtil.replace(s, "\\u005c", "\\");

      properties.load(new UnsyncByteArrayInputStream(s.getBytes()));

      List<String> propertyNames =
          Collections.list((Enumeration<String>) properties.propertyNames());

      for (int i = 0; i < propertyNames.size(); i++) {
        String key = propertyNames.get(i);

        String value = properties.getProperty(key);

        // Trim values because it may leave a trailing \r in certain
        // Windows environments. This is a known case for loading SQL
        // scripts in SQL Server.

        if (value != null) {
          value = value.trim();

          properties.setProperty(key, value);
        }
      }
    }
  }
示例#27
0
 static ArrayList<String> getZipFileEntryNames(ZipFile z) {
   ArrayList<String> out = new ArrayList<String>();
   for (ZipEntry ze : Collections.list(z.entries())) {
     out.add(ze.getName());
   }
   return out;
 }
示例#28
0
 /**
  * Copy the given Enumeration into a String array. The Enumeration must contain String elements
  * only.
  *
  * @param enumeration the Enumeration to copy
  * @return the String array ({@code null} if the passed-in Enumeration was {@code null})
  */
 public static String[] toStringArray(Enumeration<String> enumeration) {
   if (enumeration == null) {
     return null;
   }
   List<String> list = Collections.list(enumeration);
   return list.toArray(new String[list.size()]);
 }
示例#29
0
  protected boolean jarUpToDate(String source, String target, boolean verbose) {
    JarFile targetJar, sourceJar;

    try {
      targetJar = new JarFile(target);
    } catch (IOException e) {
      if (verbose) err.println(target + " does not exist yet");
      return false;
    }
    try {
      sourceJar = new JarFile(source);
    } catch (IOException e) {
      return true;
    }

    for (JarEntry entry : Collections.list(sourceJar.entries())) {
      JarEntry other = (JarEntry) targetJar.getEntry(entry.getName());
      if (other == null) {
        if (verbose) err.println(target + " lacks the file " + entry.getName());
        return false;
      }
      if (entry.getTime() > other.getTime()) {
        if (verbose) err.println(target + " is not " + "up-to-date because of " + entry.getName());
        return false;
      }
    }
    try {
      targetJar.close();
      sourceJar.close();
    } catch (IOException e) {
    }

    return true;
  }
  /**
   * Returns an enumeration describing the available options.
   *
   * @return an enumeration of all the available options.
   */
  @Override
  public Enumeration<Option> listOptions() {

    Vector<Option> newVector = new Vector<Option>(2);

    newVector.addElement(
        new Option(
            "\tSkips the determination of sizes (train/test/clusterer)\n"
                + "\t(default: sizes are determined)",
            "no-size",
            0,
            "-no-size"));
    newVector.addElement(
        new Option(
            "\tThe full class name of the density based clusterer.\n" + "\teg: weka.clusterers.EM",
            "W",
            1,
            "-W <class name>"));

    if ((m_clusterer != null) && (m_clusterer instanceof OptionHandler)) {
      newVector.addElement(
          new Option(
              "",
              "",
              0,
              "\nOptions specific to clusterer " + m_clusterer.getClass().getName() + ":"));
      newVector.addAll(Collections.list(((OptionHandler) m_clusterer).listOptions()));
    }
    return newVector.elements();
  }