public static boolean isLocalhost()

in modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/SocketUtil.java [119:224]
86 lines of code
27 McCabe index (conditional complexity)

    public static boolean isLocalhost(final String host) {
        if (host == null || host.equals(""))
            return false;

        if ("localhost".equals(host) || "127.0.0.1".equals(host))
            return true;

        // check simple cases
        try {
            InetAddress localHostaddr = InetAddress.getLocalHost();
            if (localHostaddr.getHostName().equals(host) || host.equals(localHostaddr.getCanonicalHostName())
                || localHostaddr.getHostAddress().equals(host))
                return true;
        } catch (Exception e) {

        }

        // check for current thread and wait if necessary
        boolean currentThread = false;
        try {
            Thread t = null;
            synchronized (lock) {
                t = threadMap.get(host);
            }
            if (t != null && t.isAlive()) {
                currentThread = true;
                t.join(30);
            }
        } catch (Exception e) {

        }

        // check if cache is still ok
        boolean refreshedCache = false;
        try {
            // get network interfaces
            final Set<InetAddress> currentAddresses = new HashSet<InetAddress>();
            currentAddresses.add(InetAddress.getLocalHost());
            Enumeration<?> nis = NetworkInterface.getNetworkInterfaces();
            while (nis.hasMoreElements()) {
                NetworkInterface inter = (NetworkInterface)nis.nextElement();
                Enumeration<InetAddress> ias = inter.getInetAddresses();
                while (ias.hasMoreElements())
                    currentAddresses.add(ias.nextElement());
            }

            // check if cache is empty or old and refill it if necessary
            if (addressCache == null || !addressCache.containsAll(currentAddresses)
                || !currentAddresses.containsAll(addressCache)) {
                CacheThread cacheThread = null;
                refreshedCache = true;

                synchronized (lock) {
                    addressCache = currentAddresses;
                    notLocalHostCache = new HashSet<String>();
                    localHostCache = new HashSet<String>(currentAddresses.size() * 3);

                    Iterator<InetAddress> iter = currentAddresses.iterator();
                    while (iter.hasNext()) {
                        InetAddress addr = iter.next();
                        String a = addr.getHostAddress();
                        if (a != null && !localHostCache.contains(a))
                            localHostCache.add(a);
                    }

                    cacheThread = new CacheThread(host, currentAddresses, localHostCache, notLocalHostCache, threadMap);
                    threadMap.put(host, cacheThread);
                    cacheThread.setDaemon(true);
                    cacheThread.setPriority(Thread.NORM_PRIORITY - 1);
                    cacheThread.start();
                }
                cacheThread.join(200);
            }
        } catch (Exception e) {
        }

        synchronized (lock) {
            if (localHostCache.contains(host))
                return true;
            if (notLocalHostCache.contains(host))
                return false;
        }

        // if the cache hasn't been cleared, maybe we still need to lookup the
        // host
        if (!refreshedCache && !currentThread) {
            try {
                CacheThread cacheThread = null;
                synchronized (lock) {
                    cacheThread = new CacheThread(host, null, localHostCache, notLocalHostCache, threadMap);
                    threadMap.put(host, cacheThread);
                    cacheThread.setDaemon(true);
                    cacheThread.setPriority(Thread.NORM_PRIORITY - 1);
                    cacheThread.start();
                }
                cacheThread.join(75);

                synchronized (lock) {
                    if (localHostCache.contains(host))
                        return true;
                }
            } catch (Exception e) {
            }
        }
        return false;
    }