Added Transient Name Server JSE Corba host. Adjusted existing bindings and integration tests and removed 'provideNameServer' flag from binding.corba configuration

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@685180 13f79535-47bb-0310-9956-ffa450edef68

3 files changed, 225 insertions, 24 deletions

diff --git a/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/CorbaHost.java b/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/CorbaHost.java
index 17e9566e17..01a27ba371 100644
--- a/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/CorbaHost.java
+++ b/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/CorbaHost.java
@@ -52,20 +52,4 @@ public interface CorbaHost {
      * @throws CorbaHostException
      */
     Object lookup(String uri) throws CorbaHostException;
-
-    /**
-     * Provides name server under given port.
-     * 
-     * @param port
-     * @throws CorbaHostException
-     */
-    void createLocalNameServer(int port) throws CorbaHostException;
-
-    /**
-     * Stops name server but only if every client released previously created NS.
-     * 
-     * @param port
-     * @throws CorbaHostException
-     */
-    void releaseLocalNameServer(int port) throws CorbaHostException;
 }
diff --git a/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/ExtensibleCorbaHost.java b/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/ExtensibleCorbaHost.java
index 1c36fca57d..12112fea04 100644
--- a/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/ExtensibleCorbaHost.java
+++ b/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/ExtensibleCorbaHost.java
@@ -51,12 +51,4 @@ public class ExtensibleCorbaHost implements CorbaHost {
         return hosts.getCorbaHosts().get(0);
     }
 
-    public void createLocalNameServer(int port) throws CorbaHostException {
-        getCorbaHost().createLocalNameServer(port);
-    }
-    
-    public void releaseLocalNameServer(int port) throws CorbaHostException {
-        getCorbaHost().releaseLocalNameServer(port);
-    }
-
 }
diff --git a/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/SocketUtil.java b/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/SocketUtil.java
new file mode 100755
index 0000000000..b076e023da
--- /dev/null
+++ b/java/sca/modules/host-corba/src/main/java/org/apache/tuscany/sca/host/corba/SocketUtil.java
@@ -0,0 +1,225 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.corba;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Class partially copied from eclipse wst project
+ * (http://repo1.maven.org/maven2/org/eclipse/wst/server/core/1.0.205-v20070829b/).
+ * Finally we should use jar from maven dependency. Problem described in
+ * http://www.fornax-platform.org/cp/display/fornax/2.+Hello+World+Tutorial+(CSC)?replyToComment=2098#comment-2098
+ * needs to be fixed.
+ */
+public class SocketUtil {
+
+    protected static final Object lock = new Object();
+
+    private static Set<String> localHostCache;
+    private static Set<String> notLocalHostCache = new HashSet<String>();
+    private static Map<String, CacheThread> threadMap = new HashMap<String, CacheThread>();
+
+    private static Set<InetAddress> addressCache;
+
+    static class CacheThread extends Thread {
+        private Set<InetAddress> currentAddresses;
+        private Set<String> addressList;
+        private String host;
+        private Set<String> nonAddressList;
+        private Map threadMap2;
+
+        public CacheThread(String host,
+                           Set<InetAddress> currentAddresses,
+                           Set<String> addressList,
+                           Set<String> nonAddressList,
+                           Map threadMap2) {
+            super("Caching localhost information");
+            this.host = host;
+            this.currentAddresses = currentAddresses;
+            this.addressList = addressList;
+            this.nonAddressList = nonAddressList;
+            this.threadMap2 = threadMap2;
+        }
+
+        public void run() {
+            if (currentAddresses != null) {
+                Iterator iter2 = currentAddresses.iterator();
+                while (iter2.hasNext()) {
+                    InetAddress addr = (InetAddress)iter2.next();
+                    String hostname = addr.getHostName();
+                    String hostname2 = addr.getCanonicalHostName();
+                    synchronized (lock) {
+                        if (hostname != null && !addressList.contains(hostname))
+                            addressList.add(hostname);
+                        if (hostname2 != null && !addressList.contains(hostname2))
+                            addressList.add(hostname2);
+                    }
+                }
+            }
+
+            try {
+                InetAddress[] addrs = InetAddress.getAllByName(host);
+                int length = addrs.length;
+                for (int j = 0; j < length; j++) {
+                    InetAddress addr = addrs[0];
+                    String hostname = addr.getHostName();
+                    String hostname2 = addr.getCanonicalHostName();
+                    synchronized (lock) {
+                        if (addr.isLoopbackAddress()) {
+                            if (hostname != null && !addressList.contains(hostname))
+                                addressList.add(hostname);
+                            if (hostname2 != null && !addressList.contains(hostname2))
+                                addressList.add(hostname2);
+                        } else {
+                            if (hostname != null && !nonAddressList.contains(hostname))
+                                nonAddressList.add(hostname);
+                            if (hostname2 != null && !nonAddressList.contains(hostname2))
+                                nonAddressList.add(hostname2);
+                        }
+                    }
+                }
+            } catch (UnknownHostException e) {
+                synchronized (lock) {
+                    if (host != null && !nonAddressList.contains(host))
+                        nonAddressList.add(host);
+                }
+            }
+            synchronized (lock) {
+                threadMap2.remove(host);
+            }
+        }
+    }
+
+    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 iter = currentAddresses.iterator();
+                    while (iter.hasNext()) {
+                        InetAddress addr = (InetAddress)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;
+    }
+
+}