org.globus.gsi.jsse.SSLConfiguratorTest.java Source code

Introduction

Here is the source code for org.globus.gsi.jsse.SSLConfiguratorTest.java

Source

/*
 * Copyright 1999-2010 University of Chicago
 *
 * Licensed 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.globus.gsi.jsse;

import static org.junit.Assert.assertEquals;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.globus.gsi.jsse.GlobusSSLConfigurationException;
import org.globus.gsi.jsse.SSLConfigurator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.security.Security;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import org.globus.gsi.provider.GlobusProvider;
import org.globus.gsi.stores.ResourceSigningPolicyStore;
import org.globus.gsi.stores.Stores;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class SSLConfiguratorTest {

    private static SSLSocket sslsocket;
    private static SSLServerSocket serverSocket;
    private CountDownLatch latch = new CountDownLatch(1);
    private StringBuilder builder = new StringBuilder();

    @BeforeClass
    public static void setup() throws Exception {
        Security.addProvider(new GlobusProvider());
    }

    @Test
    public void testConfig() throws Exception {

        SSLConfigurator config = new SSLConfigurator();

        config.setCrlLocationPattern(null);
        config.setCrlStoreType(GlobusProvider.CERTSTORE_TYPE);
        config.setCredentialStoreLocation("classpath:/configuratorTest/mykeystore.properties");
        config.setCredentialStorePassword("password");
        config.setCredentialStoreType(GlobusProvider.KEYSTORE_TYPE);
        config.setTrustAnchorStoreLocation("classpath:/configuratorTest/mytruststore.properties");
        config.setTrustAnchorStorePassword("password");
        config.setTrustAnchorStoreType(GlobusProvider.KEYSTORE_TYPE);

        ResourceSigningPolicyStore policyStore = Stores
                .getSigningPolicyStore("classpath:/configuratorTest/TestCA1.signing_policy");

        config.setPolicyStore(policyStore);

        serverSocket = startServer(config);
        latch.await();
        sslsocket = runClient(config);
        OutputStream outputstream = sslsocket.getOutputStream();
        OutputStreamWriter outputstreamwriter = new OutputStreamWriter(outputstream);
        BufferedWriter bufferedwriter = new BufferedWriter(outputstreamwriter);
        bufferedwriter.write("hello");
        bufferedwriter.flush();
    }

    private SSLSocket runClient(SSLConfigurator config) throws IOException, GlobusSSLConfigurationException {
        SSLSocketFactory sslsocketfactory = config.createFactory();

        return (SSLSocket) sslsocketfactory.createSocket("localhost", 9991);
    }

    @AfterClass
    public static void stop() throws Exception {
        serverSocket.close();
        sslsocket.close();
    }

    Log logger = LogFactory.getLog(SSLConfiguratorTest.class);

    private SSLServerSocket startServer(SSLConfigurator config)
            throws GlobusSSLConfigurationException, IOException {
        SSLServerSocketFactory sslserversocketfactory = config.createServerFactory();
        final SSLServerSocket sslserversocket = (SSLServerSocket) sslserversocketfactory.createServerSocket(9991);

        ExecutorService executor = Executors.newFixedThreadPool(1);
        executor.execute(new Runnable() {
            /**
             * When an object implementing interface <code>Runnable</code> is
             * used to create a thread, starting the thread causes the object's
             * <code>run</code> method to be called in that separately executing
             * thread.
             * <p/>
             * The general contract of the method <code>run</code> is that it
             * may take any action whatsoever.
             *
             * @see Thread#run()
             */
            public void run() {
                latch.countDown();
                try {
                    SSLSocket sslsocket = (SSLSocket) sslserversocket.accept();
                    InputStream inputstream = sslsocket.getInputStream();
                    InputStreamReader inputstreamreader = new InputStreamReader(inputstream);
                    BufferedReader bufferedreader = new BufferedReader(inputstreamreader);
                    String line;
                    while ((line = bufferedreader.readLine()) != null) {
                        builder.append(line);
                    }
                    assertEquals(builder.toString().trim(), "hello");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        return sslserversocket;
    }
}