Introducing DefaultSslContextProvider.

Change-Id: I713ce8d6360e4619c88e0b567546fbf1260878c4

Author: pavelbucek

core-client/src/main/java/org/glassfish/jersey/client/JerseyClient.java

@@ -43,20 +43,24 @@
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.net.URI;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLContext;
 import javax.ws.rs.core.Configuration;
 import javax.ws.rs.core.Link;
 import javax.ws.rs.core.UriBuilder;
 
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+
 import org.glassfish.jersey.SslConfigurator;
 import org.glassfish.jersey.client.internal.LocalizationMessages;
+import org.glassfish.jersey.client.spi.DefaultSslContextProvider;
+import org.glassfish.jersey.internal.ServiceFinder;
 import org.glassfish.jersey.internal.util.collection.UnsafeValue;
 import org.glassfish.jersey.internal.util.collection.Values;
 
@@ -72,7 +76,15 @@
 public class JerseyClient implements javax.ws.rs.client.Client, Initializable<JerseyClient> {
     private static final Logger LOG = Logger.getLogger(JerseyClient.class.getName());
 
+    private static final DefaultSslContextProvider DEFAULT_SSL_CONTEXT_PROVIDER = new DefaultSslContextProvider() {
+        @Override
+        public SSLContext getDefaultSslContext() {
+            return SslConfigurator.getDefaultContext();
+        }
+    };
+
     private final AtomicBoolean closedFlag = new AtomicBoolean(false);
+    private final boolean isDefaultSslContext;
     private final ClientConfig config;
     private final HostnameVerifier hostnameVerifier;
     private final UnsafeValue<SSLContext, IllegalStateException> sslContext;
@@ -83,7 +95,7 @@ public class JerseyClient implements javax.ws.rs.client.Client, Initializable<Je
     /**
      * Client instance shutdown hook.
      */
-    static interface ShutdownHook {
+    interface ShutdownHook {
         /**
          * Invoked when the client instance is closed.
          */
@@ -94,7 +106,7 @@ static interface ShutdownHook {
      * Create a new Jersey client instance using a default configuration.
      */
     protected JerseyClient() {
-        this(null, (UnsafeValue<SSLContext, IllegalStateException>) null, null);
+        this(null, (UnsafeValue<SSLContext, IllegalStateException>) null, null, null);
     }
 
     /**
@@ -107,7 +119,24 @@ protected JerseyClient() {
     protected JerseyClient(final Configuration config,
                            final SSLContext sslContext,
                            final HostnameVerifier verifier) {
-        this(config, Values.<SSLContext, IllegalStateException>unsafe(sslContext), verifier);
+
+        this(config, sslContext, verifier, null);
+    }
+
+    /**
+     * Create a new Jersey client instance.
+     *
+     * @param config                    jersey client configuration.
+     * @param sslContext                jersey client SSL context.
+     * @param verifier                  jersey client host name verifier.
+     * @param defaultSslContextProvider default SSL context provider.
+     */
+    protected JerseyClient(final Configuration config,
+                           final SSLContext sslContext,
+                           final HostnameVerifier verifier,
+                           final DefaultSslContextProvider defaultSslContextProvider) {
+        this(config, sslContext == null ? null : Values.<SSLContext, IllegalStateException>unsafe(sslContext), verifier,
+             defaultSslContextProvider);
     }
 
     /**
@@ -120,18 +149,49 @@ protected JerseyClient(final Configuration config,
     protected JerseyClient(final Configuration config,
                            final UnsafeValue<SSLContext, IllegalStateException> sslContextProvider,
                            final HostnameVerifier verifier) {
-        this.config = config == null ? new ClientConfig(this) : new ClientConfig(this, config);
-        this.sslContext = Values.lazy(sslContextProvider != null ? sslContextProvider : createSslContextProvider());
-        this.hostnameVerifier = verifier;
+        this(config, sslContextProvider, verifier, null);
     }
 
-    private UnsafeValue<SSLContext, IllegalStateException> createSslContextProvider() {
-        return new UnsafeValue<SSLContext, IllegalStateException>() {
-            @Override
-            public SSLContext get() {
-                return SslConfigurator.getDefaultContext();
+    /**
+     * Create a new Jersey client instance.
+     *
+     * @param config                    jersey client configuration.
+     * @param sslContextProvider        jersey client SSL context provider. Non {@code null} provider is expected to
+     *                                  return non-default value.
+     * @param verifier                  jersey client host name verifier.
+     * @param defaultSslContextProvider default SSL context provider.
+     */
+    protected JerseyClient(final Configuration config,
+                           final UnsafeValue<SSLContext, IllegalStateException> sslContextProvider,
+                           final HostnameVerifier verifier,
+                           final DefaultSslContextProvider defaultSslContextProvider) {
+        this.config = config == null ? new ClientConfig(this) : new ClientConfig(this, config);
+
+        if (sslContextProvider == null) {
+            this.isDefaultSslContext = true;
+
+            if (defaultSslContextProvider != null) {
+                this.sslContext = createLazySslContext(defaultSslContextProvider);
+            } else {
+                final DefaultSslContextProvider lookedUpSslContextProvider;
+
+                final Iterator<DefaultSslContextProvider> iterator =
+                        ServiceFinder.find(DefaultSslContextProvider.class).iterator();
+
+                if (iterator.hasNext()) {
+                    lookedUpSslContextProvider = iterator.next();
+                } else {
+                    lookedUpSslContextProvider = DEFAULT_SSL_CONTEXT_PROVIDER;
+                }
+
+                this.sslContext = createLazySslContext(lookedUpSslContextProvider);
             }
-        };
+        } else {
+            this.isDefaultSslContext = false;
+            this.sslContext = Values.lazy(sslContextProvider);
+        }
+
+        this.hostnameVerifier = verifier;
     }
 
     @Override
@@ -145,7 +205,7 @@ private void release() {
         Reference<ShutdownHook> listenerRef;
         while ((listenerRef = shutdownHooks.pollFirst()) != null) {
             JerseyClient.ShutdownHook listener = listenerRef.get();
-            if (listener != null){
+            if (listener != null) {
                 try {
                     listener.onShutdown();
                 } catch (Throwable t) {
@@ -155,6 +215,15 @@ private void release() {
         }
     }
 
+    private UnsafeValue<SSLContext, IllegalStateException> createLazySslContext(final DefaultSslContextProvider provider) {
+        return Values.lazy(new UnsafeValue<SSLContext, IllegalStateException>() {
+            @Override
+            public SSLContext get() {
+                return provider.getDefaultSslContext();
+            }
+        });
+    }
+
     /**
      * Register a new client shutdown hook.
      *
@@ -204,6 +273,16 @@ void checkNotClosed() {
         checkState(!closedFlag.get(), LocalizationMessages.CLIENT_INSTANCE_CLOSED());
     }
 
+    /**
+     * Get information about used {@link SSLContext}.
+     *
+     * @return {@code true} when used {@code SSLContext} is acquired from {@link SslConfigurator#getDefaultContext()},
+     * {@code false} otherwise.
+     */
+    public boolean isDefaultSslContext() {
+        return isDefaultSslContext;
+    }
+
     @Override
     public JerseyWebTarget target(final String uri) {
         checkNotClosed();

core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java

@@ -72,6 +72,7 @@
 import org.glassfish.jersey.client.ClientRequest;
 import org.glassfish.jersey.client.ClientResponse;
 import org.glassfish.jersey.client.HttpUrlConnectorProvider;
+import org.glassfish.jersey.client.JerseyClient;
 import org.glassfish.jersey.client.RequestEntityProcessing;
 import org.glassfish.jersey.client.spi.AsyncConnectorCallback;
 import org.glassfish.jersey.client.spi.Connector;
@@ -317,7 +318,7 @@ public void close() {
      * @param client client associated with this client runtime.
      * @param uc     http connection to be secured.
      */
-    protected void secureConnection(final Client client, final HttpURLConnection uc) {
+    protected void secureConnection(final JerseyClient client, final HttpURLConnection uc) {
         if (uc instanceof HttpsURLConnection) {
             HttpsURLConnection suc = (HttpsURLConnection) uc;
 

core-client/src/main/java/org/glassfish/jersey/client/spi/DefaultSslContextProvider.java

@@ -0,0 +1,65 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * http://glassfish.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+
+package org.glassfish.jersey.client.spi;
+
+import javax.net.ssl.SSLContext;
+
+import org.glassfish.jersey.SslConfigurator;
+
+/**
+ * Default {@link SSLContext} provider.
+ * <p/>
+ * Can be used to override {@link SslConfigurator#getDefaultContext()}.
+ *
+ * @author Pavel Bucek (pavel.bucek at oracle.com)
+ */
+public interface DefaultSslContextProvider {
+
+    /**
+     * Get default {@code SSLContext}.
+     * <p/>
+     * Returned instance is expected to be configured to container default values.
+     *
+     * @return default SSL context.
+     * @throws IllegalStateException when there is a problem with creating or obtaining default SSL context.
+     */
+    SSLContext getDefaultSslContext();
+}