Fixed ICE-6680 - WS transports are now provided by a separate IceWS plugin

13 files changed, 268 insertions, 113 deletions

diff --git a/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactory.java b/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactory.java
index 02bb8b44a2f..480052c3ad2 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactory.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactory.java
@@ -11,11 +11,12 @@ package IceInternal;
 
 public interface EndpointFactory
 {
+    void initialize();
     short type();
     String protocol();
     EndpointI create(java.util.ArrayList<String> args, boolean oaEndpoint);
     EndpointI read(Ice.InputStream s);
     void destroy();
 
-    EndpointFactory clone(ProtocolInstance instance, EndpointFactory delegate);
+    EndpointFactory clone(ProtocolInstance instance);
 }
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryManager.java b/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryManager.java
index b7b38abf5bb..be7bff93731 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryManager.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryManager.java
@@ -16,11 +16,18 @@ public final class EndpointFactoryManager
         _instance = instance;
     }
 
+    public void initialize()
+    {
+        for(EndpointFactory f : _factories)
+        {
+            f.initialize();
+        }
+    }
+
     public synchronized void add(EndpointFactory factory)
     {
-        for(int i = 0; i < _factories.size(); i++)
+        for(EndpointFactory f : _factories)
         {
-            EndpointFactory f = _factories.get(i);
             if(f.type() == factory.type())
             {
                 assert(false);
@@ -31,9 +38,8 @@ public final class EndpointFactoryManager
 
     public synchronized EndpointFactory get(short type)
     {
-        for(int i = 0; i < _factories.size(); i++)
+        for(EndpointFactory f : _factories)
         {
-            EndpointFactory f = _factories.get(i);
             if(f.type() == type)
             {
                 return f;
@@ -70,9 +76,8 @@ public final class EndpointFactoryManager
 
         EndpointFactory factory = null;
 
-        for(int i = 0; i < _factories.size(); i++)
+        for(EndpointFactory f : _factories)
         {
-            EndpointFactory f = _factories.get(i);
             if(f.protocol().equals(protocol))
             {
                 factory = f;
@@ -158,7 +163,13 @@ public final class EndpointFactoryManager
         {
             e = factory.read(s);
         }
-        else
+        //
+        // If the factory failed to read the endpoint, return an opaque endpoint. This can
+        // occur if for example the factory delegates to another factory and this factory
+        // isn't available. In this case, the factory needs to make sure the stream position
+        // is preserved for reading the opaque endpoint.
+        //
+        if(e == null)
         {
             e = new OpaqueEndpointI(type, s);
         }
@@ -170,9 +181,8 @@ public final class EndpointFactoryManager
 
     void destroy()
     {
-        for(int i = 0; i < _factories.size(); i++)
+        for(EndpointFactory f : _factories)
         {
-            EndpointFactory f = _factories.get(i);
             f.destroy();
         }
         _factories.clear();
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryWithUnderlying.java b/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryWithUnderlying.java
new file mode 100644
index 00000000000..25c938e4b67
--- /dev/null
+++ b/java-compat/src/Ice/src/main/java/IceInternal/EndpointFactoryWithUnderlying.java
@@ -0,0 +1,92 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+package IceInternal;
+
+//
+// The endpoint factory with underlying create endpoints that delegate to an underlying
+// endpoint (e.g.: the SSL/WS endpoints are endpoints with underlying endpoints).
+//
+abstract public class EndpointFactoryWithUnderlying implements EndpointFactory
+{
+    public EndpointFactoryWithUnderlying(ProtocolInstance instance, short type)
+    {
+        _instance = instance;
+        _type = type;
+    }
+
+    public void initialize()
+    {
+        //
+        // Get the endpoint factory for the underlying type and clone it with
+        // our protocol instance.
+        //
+        EndpointFactory factory = _instance.getEndpointFactory(_type);
+        if(factory != null)
+        {
+            _underlying = factory.clone(_instance);
+            _underlying.initialize();
+        }
+    }
+
+    public short type()
+    {
+        return _instance.type();
+    }
+
+    public String protocol()
+    {
+        return _instance.protocol();
+    }
+
+    public EndpointI create(java.util.ArrayList<String> args, boolean oaEndpoint)
+    {
+        if(_underlying == null)
+        {
+            return null; // Can't create an endpoint without underlying factory.
+        }
+        return createWithUnderlying(_underlying.create(args, oaEndpoint), args, oaEndpoint);
+    }
+
+    public EndpointI read(Ice.InputStream s)
+    {
+        if(_underlying == null)
+        {
+            return null; // Can't create an endpoint without underlying factory.
+        }
+        return readWithUnderlying(_underlying.read(s), s);
+    }
+
+    public void destroy()
+    {
+        if(_underlying != null)
+        {
+            _underlying.destroy();
+        }
+        _instance = null;
+    }
+
+    public EndpointFactory clone(ProtocolInstance instance)
+    {
+        return cloneWithUnderlying(instance, _type);
+    }
+
+    abstract public EndpointFactory cloneWithUnderlying(ProtocolInstance instance, short type);
+
+    abstract protected EndpointI createWithUnderlying(EndpointI underlying,
+                                                      java.util.ArrayList<String> args,
+                                                      boolean oaEndpoint);
+
+    abstract protected EndpointI readWithUnderlying(EndpointI underlying, Ice.InputStream s);
+
+    protected ProtocolInstance _instance;
+
+    private final short _type;
+    private EndpointFactory _underlying;
+}
\ No newline at end of file
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/Instance.java b/java-compat/src/Ice/src/main/java/IceInternal/Instance.java
index cc774088796..b77c2cb527d 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/Instance.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/Instance.java
@@ -1086,6 +1086,12 @@ public final class Instance implements Ice.ClassResolver
             ProtocolInstance udpProtocolInstance = new ProtocolInstance(this, Ice.UDPEndpointType.value, "udp", false);
             _endpointFactoryManager.add(new UdpEndpointFactory(udpProtocolInstance));
 
+            ProtocolInstance wsProtocolInstance = new ProtocolInstance(this, Ice.WSEndpointType.value, "ws", false);
+            _endpointFactoryManager.add(new WSEndpointFactory(wsProtocolInstance, Ice.TCPEndpointType.value));
+
+            ProtocolInstance wssProtocolInstance = new ProtocolInstance(this, Ice.WSSEndpointType.value, "wss", true);
+            _endpointFactoryManager.add(new WSEndpointFactory(wssProtocolInstance, Ice.SSLEndpointType.value));
+
             _pluginManager = new Ice.PluginManagerI(communicator, this);
 
             if(_initData.valueFactoryManager == null)
@@ -1169,20 +1175,10 @@ public final class Instance implements Ice.ClassResolver
         pluginManagerImpl.loadPlugins(args);
 
         //
-        // Add WS and WSS endpoint factories if TCP/SSL factories are installed.
+        // Initialize the endpoint factories once all the plugins are loaded. This gives
+        // the opportunity for the endpoint factories to find underyling factories.
         //
-        final EndpointFactory tcpFactory = _endpointFactoryManager.get(Ice.TCPEndpointType.value);
-        if(tcpFactory != null)
-        {
-            final ProtocolInstance instance = new ProtocolInstance(this, Ice.WSEndpointType.value, "ws", false);
-            _endpointFactoryManager.add(new WSEndpointFactory(instance, tcpFactory.clone(instance, null)));
-        }
-        final EndpointFactory sslFactory = _endpointFactoryManager.get(Ice.SSLEndpointType.value);
-        if(sslFactory != null)
-        {
-            final ProtocolInstance instance = new ProtocolInstance(this, Ice.WSSEndpointType.value, "wss", true);
-            _endpointFactoryManager.add(new WSEndpointFactory(instance, sslFactory.clone(instance, null)));
-        }
+        _endpointFactoryManager.initialize();
 
         //
         // Create Admin facets, if enabled.
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/ProtocolInstance.java b/java-compat/src/Ice/src/main/java/IceInternal/ProtocolInstance.java
index b564ec9875b..a6a3ca4bb3f 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/ProtocolInstance.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/ProtocolInstance.java
@@ -38,6 +38,11 @@ public class ProtocolInstance
         return _logger;
     }
 
+    public EndpointFactory getEndpointFactory(short type)
+    {
+        return _instance.endpointFactoryManager().get(type);
+    }
+
     public String protocol()
     {
         return _protocol;
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/TcpEndpointFactory.java b/java-compat/src/Ice/src/main/java/IceInternal/TcpEndpointFactory.java
index 349abfa5419..f4264eba043 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/TcpEndpointFactory.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/TcpEndpointFactory.java
@@ -17,6 +17,12 @@ final class TcpEndpointFactory implements EndpointFactory
     }
 
     @Override
+    public void initialize()
+    {
+        // Nothing to do.
+    }
+
+    @Override
     public short type()
     {
         return _instance.type();
@@ -49,7 +55,7 @@ final class TcpEndpointFactory implements EndpointFactory
     }
 
     @Override
-    public EndpointFactory clone(ProtocolInstance instance, EndpointFactory delegate)
+    public EndpointFactory clone(ProtocolInstance instance)
     {
         return new TcpEndpointFactory(instance);
     }
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/UdpEndpointFactory.java b/java-compat/src/Ice/src/main/java/IceInternal/UdpEndpointFactory.java
index 571a4d76088..f604d725281 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/UdpEndpointFactory.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/UdpEndpointFactory.java
@@ -17,6 +17,12 @@ final class UdpEndpointFactory implements EndpointFactory
     }
 
     @Override
+    public void initialize()
+    {
+        // Nothing to do.
+    }
+
+    @Override
     public short type()
     {
         return _instance.type();
@@ -49,7 +55,7 @@ final class UdpEndpointFactory implements EndpointFactory
     }
 
     @Override
-    public EndpointFactory clone(ProtocolInstance instance, EndpointFactory delegate)
+    public EndpointFactory clone(ProtocolInstance instance)
     {
         return new UdpEndpointFactory(instance);
     }
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/UnderlyingEndpointFactory.java b/java-compat/src/Ice/src/main/java/IceInternal/UnderlyingEndpointFactory.java
new file mode 100644
index 00000000000..1581f98983c
--- /dev/null
+++ b/java-compat/src/Ice/src/main/java/IceInternal/UnderlyingEndpointFactory.java
@@ -0,0 +1,90 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+package IceInternal;
+
+//
+// The underlying endpoint factory creates endpoints with a factory of the given
+// type. If this factory is of the EndpointFactoryWithUnderlying type, it will
+// delegate to the given underlying factory (this is used by IceIAP/IceBT plugins
+// for the BTS/iAPS endpoint factories).
+//
+public class UnderlyingEndpointFactory implements EndpointFactory
+{
+    public UnderlyingEndpointFactory(ProtocolInstance instance, short type, short underlying)
+    {
+        _instance = instance;
+        _type = type;
+        _underlying = underlying;
+    }
+
+    public void initialize()
+    {
+        //
+        // Get the endpoint factory of the given endpoint type. If it's a factory that
+        // delegates to an underlying endpoint, clone it and instruct it to delegate to
+        // our underlying factory.
+        //
+        EndpointFactory factory = _instance.getEndpointFactory(_type);
+        if(factory != null && factory instanceof EndpointFactoryWithUnderlying)
+        {
+            EndpointFactoryWithUnderlying f = (EndpointFactoryWithUnderlying)factory;
+            _factory = f.cloneWithUnderlying(_instance, _underlying);
+            _factory.initialize();
+        }
+    }
+
+    public short type()
+    {
+        return _instance.type();
+    }
+
+    public String protocol()
+    {
+        return _instance.protocol();
+    }
+
+    public EndpointI create(java.util.ArrayList<String> args, boolean oaEndpoint)
+    {
+        if(_factory == null)
+        {
+            return null;
+        }
+        return _factory.create(args, oaEndpoint);
+    }
+
+    public EndpointI read(Ice.InputStream s)
+    {
+        if(_factory == null)
+        {
+            return null;
+        }
+        return _factory.read(s);
+    }
+
+    public void destroy()
+    {
+        if(_factory != null)
+        {
+            _factory.destroy();
+        }
+        _instance = null;
+    }
+
+    public EndpointFactory clone(ProtocolInstance instance)
+    {
+        return new UnderlyingEndpointFactory(instance, _type, _underlying);
+    }
+
+    protected ProtocolInstance _instance;
+
+    private final short _type;
+    private final short _underlying;
+    private EndpointFactory _factory;
+}
\ No newline at end of file
diff --git a/java-compat/src/Ice/src/main/java/IceInternal/WSEndpointFactory.java b/java-compat/src/Ice/src/main/java/IceInternal/WSEndpointFactory.java
index 66c8aa8ce7a..45d6f72f07b 100644
--- a/java-compat/src/Ice/src/main/java/IceInternal/WSEndpointFactory.java
+++ b/java-compat/src/Ice/src/main/java/IceInternal/WSEndpointFactory.java
@@ -9,51 +9,28 @@
 
 package IceInternal;
 
-final public class WSEndpointFactory implements EndpointFactory
+final public class WSEndpointFactory extends EndpointFactoryWithUnderlying
 {
-    public WSEndpointFactory(ProtocolInstance instance, EndpointFactory delegate)
+    public WSEndpointFactory(ProtocolInstance instance, short type)
     {
-        _instance = instance;
-        _delegate = delegate;
+        super(instance, type);
     }
 
     @Override
-    public short type()
+    public EndpointFactory cloneWithUnderlying(ProtocolInstance instance, short underlying)
     {
-        return _instance.type();
+        return new WSEndpointFactory(instance, underlying);
     }
 
     @Override
-    public String protocol()
+    public EndpointI createWithUnderlying(EndpointI underlying, java.util.ArrayList<String> args, boolean oaEndpoint)
     {
-        return _instance.protocol();
+        return new WSEndpoint(_instance, underlying, args);
     }
 
     @Override
-    public EndpointI create(java.util.ArrayList<String> args, boolean oaEndpoint)
+    public EndpointI readWithUnderlying(EndpointI underlying, Ice.InputStream s)
     {
-        return new WSEndpoint(_instance, _delegate.create(args, oaEndpoint), args);
+        return new WSEndpoint(_instance, underlying, s);
     }
-
-    @Override
-    public EndpointI read(Ice.InputStream s)
-    {
-        return new WSEndpoint(_instance, _delegate.read(s), s);
-    }
-
-    @Override
-    public void destroy()
-    {
-        _delegate.destroy();
-        _instance = null;
-    }
-
-    @Override
-    public EndpointFactory clone(ProtocolInstance instance, EndpointFactory delegate)
-    {
-        return new WSEndpointFactory(instance, delegate);
-    }
-
-    private ProtocolInstance _instance;
-    private EndpointFactory _delegate;
 }
diff --git a/java-compat/src/Ice/src/main/java/IceSSL/EndpointFactoryI.java b/java-compat/src/Ice/src/main/java/IceSSL/EndpointFactoryI.java
index e7ce776b605..eef066e4340 100644
--- a/java-compat/src/Ice/src/main/java/IceSSL/EndpointFactoryI.java
+++ b/java-compat/src/Ice/src/main/java/IceSSL/EndpointFactoryI.java
@@ -9,52 +9,34 @@
 
 package IceSSL;
 
-final class EndpointFactoryI implements IceInternal.EndpointFactory
+final class EndpointFactoryI extends IceInternal.EndpointFactoryWithUnderlying
 {
-    EndpointFactoryI(Instance instance, IceInternal.EndpointFactory delegate)
+    EndpointFactoryI(Instance instance, short type)
     {
+        super(instance, type);
         _instance = instance;
-        _delegate = delegate;
     }
 
     @Override
-    public short type()
+    public IceInternal.EndpointFactory cloneWithUnderlying(IceInternal.ProtocolInstance instance,
+                                                           short underlying)
     {
-        return _instance.type();
+        return new EndpointFactoryI(new Instance(_instance.engine(), instance.type(), instance.protocol()), underlying);
     }
 
     @Override
-    public String protocol()
+    public IceInternal.EndpointI createWithUnderlying(IceInternal.EndpointI underlying,
+                                                      java.util.ArrayList<String> args,
+                                                      boolean oaEndpoint)
     {
-        return _instance.protocol();
+        return new EndpointI(_instance, underlying);
     }
 
     @Override
-    public IceInternal.EndpointI create(java.util.ArrayList<String> args, boolean oaEndpoint)
+    public IceInternal.EndpointI readWithUnderlying(IceInternal.EndpointI underlying, Ice.InputStream s)
     {
-        return new EndpointI(_instance, _delegate.create(args, oaEndpoint));
-    }
-
-    @Override
-    public IceInternal.EndpointI read(Ice.InputStream s)
-    {
-        return new EndpointI(_instance, _delegate.read(s));
-    }
-
-    @Override
-    public void destroy()
-    {
-        _delegate.destroy();
-        _instance = null;
-    }
-
-    @Override
-    public IceInternal.EndpointFactory clone(IceInternal.ProtocolInstance inst, IceInternal.EndpointFactory delegate)
-    {
-        Instance instance = new Instance(_instance.engine(), inst.type(), inst.protocol());
-        return new EndpointFactoryI(instance, delegate != null ? delegate : _delegate.clone(instance, null));
+        return new EndpointI(_instance, underlying);
     }
 
     private Instance _instance;
-    private IceInternal.EndpointFactory _delegate;
 }
diff --git a/java-compat/src/Ice/src/main/java/IceSSL/PluginI.java b/java-compat/src/Ice/src/main/java/IceSSL/PluginI.java
index 3e35fb7235e..22e3b1fc83c 100644
--- a/java-compat/src/Ice/src/main/java/IceSSL/PluginI.java
+++ b/java-compat/src/Ice/src/main/java/IceSSL/PluginI.java
@@ -21,22 +21,8 @@ class PluginI implements Plugin
         // in initialize, because the communicator may need to interpret
         // proxies before the plug-in is fully initialized.
         //
-
-        // SSL based on TCP
-        IceInternal.EndpointFactory tcp = facade.getEndpointFactory(Ice.TCPEndpointType.value);
-        if(tcp != null)
-        {
-            Instance instance = new Instance(_engine, Ice.SSLEndpointType.value, "ssl");
-            facade.addEndpointFactory(new EndpointFactoryI(instance, tcp.clone(instance, null)));
-        }
-
-        // SSL based on Bluetooth
-        IceInternal.EndpointFactory bluetooth = facade.getEndpointFactory(Ice.BTEndpointType.value);
-        if(bluetooth != null)
-        {
-            Instance instance = new Instance(_engine, Ice.BTSEndpointType.value, "bts");
-            facade.addEndpointFactory(new EndpointFactoryI(instance, bluetooth.clone(instance, null)));
-        }
+        Instance instance = new Instance(_engine, Ice.SSLEndpointType.value, "ssl");
+        facade.addEndpointFactory(new EndpointFactoryI(instance, Ice.TCPEndpointType.value));
     }
 
     @Override
diff --git a/java-compat/src/IceBT/src/main/java/IceBT/EndpointFactoryI.java b/java-compat/src/IceBT/src/main/java/IceBT/EndpointFactoryI.java
index 5c71a954f2e..247aa6806f2 100644
--- a/java-compat/src/IceBT/src/main/java/IceBT/EndpointFactoryI.java
+++ b/java-compat/src/IceBT/src/main/java/IceBT/EndpointFactoryI.java
@@ -17,6 +17,12 @@ final class EndpointFactoryI implements IceInternal.EndpointFactory
     }
 
     @Override
+    public void initialize()
+    {
+        // Nothing to do.
+    }
+
+    @Override
     public short type()
     {
         return _instance.type();
@@ -50,7 +56,7 @@ final class EndpointFactoryI implements IceInternal.EndpointFactory
     }
 
     @Override
-    public IceInternal.EndpointFactory clone(IceInternal.ProtocolInstance inst, IceInternal.EndpointFactory del)
+    public IceInternal.EndpointFactory clone(IceInternal.ProtocolInstance inst)
     {
         return new EndpointFactoryI(new Instance(_instance.communicator(), inst.type(), inst.protocol()));
     }
diff --git a/java-compat/src/IceBT/src/main/java/IceBT/PluginI.java b/java-compat/src/IceBT/src/main/java/IceBT/PluginI.java
index 3880e3522ad..3c035a135d1 100644
--- a/java-compat/src/IceBT/src/main/java/IceBT/PluginI.java
+++ b/java-compat/src/IceBT/src/main/java/IceBT/PluginI.java
@@ -9,26 +9,24 @@
 
 package IceBT;
 
+import IceInternal.UnderlyingEndpointFactory;
+
 class PluginI implements Ice.Plugin
 {
     public PluginI(Ice.Communicator communicator)
     {
-        final IceInternal.ProtocolPluginFacade facade = IceInternal.Util.getProtocolPluginFacade(communicator);
+        final IceInternal.ProtocolPluginFacade f = IceInternal.Util.getProtocolPluginFacade(communicator);
 
         //
         // Register the endpoint factory. We have to do this now, rather than
         // in initialize, because the communicator may need to interpret
         // proxies before the plug-in is fully initialized.
         //
-        EndpointFactoryI factory = new EndpointFactoryI(new Instance(communicator, Ice.BTEndpointType.value, "bt"));
-        facade.addEndpointFactory(factory);
+        Instance bt = new Instance(communicator, Ice.BTEndpointType.value, "bt");
+        f.addEndpointFactory(new EndpointFactoryI(bt));
 
-        IceInternal.EndpointFactory sslFactory = facade.getEndpointFactory(Ice.SSLEndpointType.value);
-        if(sslFactory != null)
-        {
-            Instance instance = new Instance(communicator, Ice.BTSEndpointType.value, "bts");
-            facade.addEndpointFactory(sslFactory.clone(instance, new EndpointFactoryI(instance)));
-        }
+        Instance bts = new Instance(communicator, Ice.BTSEndpointType.value, "bts");
+        f.addEndpointFactory(new UnderlyingEndpointFactory(bts, Ice.SSLEndpointType.value, Ice.BTEndpointType.value));
     }
 
     @Override