예제 #1
0
    /**
     * Add an entry to the cache. If there's already an entry then for this host then the entry will
     * be replaced.
     */
    public Cache put(String host, Object address) {
      int policy = getPolicy();
      if (policy == InetAddressCachePolicy.NEVER) {
        return this;
      }

      // purge any expired entries

      if (policy != InetAddressCachePolicy.FOREVER) {

        // As we iterate in insertion order we can
        // terminate when a non-expired entry is found.
        LinkedList expired = new LinkedList();
        Iterator i = cache.keySet().iterator();
        long now = System.currentTimeMillis();
        while (i.hasNext()) {
          String key = (String) i.next();
          CacheEntry entry = (CacheEntry) cache.get(key);

          if (entry.expiration >= 0 && entry.expiration < now) {
            expired.add(key);
          } else {
            break;
          }
        }

        i = expired.iterator();
        while (i.hasNext()) {
          cache.remove(i.next());
        }
      }

      // create new entry and add it to the cache
      // -- as a HashMap replaces existing entries we
      //    don't need to explicitly check if there is
      //    already an entry for this host.
      long expiration;
      if (policy == InetAddressCachePolicy.FOREVER) {
        expiration = -1;
      } else {
        expiration = System.currentTimeMillis() + (policy * 1000);
      }
      CacheEntry entry = new CacheEntry(address, expiration);
      cache.put(host, entry);
      return this;
    }
예제 #2
0
    /**
     * Query the cache for the specific host. If found then return its CacheEntry, or null if not
     * found.
     */
    public CacheEntry get(String host) {
      int policy = getPolicy();
      if (policy == InetAddressCachePolicy.NEVER) {
        return null;
      }
      CacheEntry entry = (CacheEntry) cache.get(host);

      // check if entry has expired
      if (entry != null && policy != InetAddressCachePolicy.FOREVER) {
        if (entry.expiration >= 0 && entry.expiration < System.currentTimeMillis()) {
          cache.remove(host);
          entry = null;
        }
      }

      return entry;
    }
예제 #3
0
  /**
   * Returns the address of the local host. This is achieved by retrieving the name of the host from
   * the system, then resolving that name into an <code>InetAddress</code>.
   *
   * <p>Note: The resolved address may be cached for a short period of time.
   *
   * <p>If there is a security manager, its <code>checkConnect</code> method is called with the
   * local host name and <code>-1</code> as its arguments to see if the operation is allowed. If the
   * operation is not allowed, an InetAddress representing the loopback address is returned.
   *
   * @return the address of the local host.
   * @exception UnknownHostException if the local host name could not be resolved into an address.
   * @see SecurityManager#checkConnect
   * @see java.net.InetAddress#getByName(java.lang.String)
   */
  public static InetAddress getLocalHost() throws UnknownHostException {

    SecurityManager security = System.getSecurityManager();
    try {
      String local = impl.getLocalHostName();

      if (security != null) {
        security.checkConnect(local, -1);
      }

      if (local.equals("localhost")) {
        return impl.loopbackAddress();
      }

      InetAddress ret = null;
      synchronized (cacheLock) {
        long now = System.currentTimeMillis();
        if (cachedLocalHost != null) {
          if ((now - cacheTime) < maxCacheTime) // Less than 5s old?
          ret = cachedLocalHost;
          else cachedLocalHost = null;
        }

        // we are calling getAddressFromNameService directly
        // to avoid getting localHost from cache
        if (ret == null) {
          InetAddress[] localAddrs;
          try {
            localAddrs = (InetAddress[]) InetAddress.getAddressFromNameService(local, null);
          } catch (UnknownHostException uhe) {
            throw new UnknownHostException(local + ": " + uhe.getMessage());
          }
          cachedLocalHost = localAddrs[0];
          cacheTime = now;
          ret = localAddrs[0];
        }
      }
      return ret;
    } catch (java.lang.SecurityException e) {
      return impl.loopbackAddress();
    }
  }