ProxyTest

// 2012-09-10 johnpfeiffer requires httpcore-4.2 , httpclient-4.2 , commons-logging-1.1.1
// TODO: add Annotation based validation

import java.io.IOException;
import java.net.URL;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

public class ProxyTest
{
    protected static final String CLASSVERSION = "0.28";
    private static final int PORTMAX = 65536;
    private URL targetUrl;
    private String proxyServer;
    private int proxyServerPort;
    private String response;

    public static class Builder
    {
        private URL targetUrl;
        private String proxyServer;
        private int proxyServerPort = -1;

        public Builder targetUrl( URL targetUrl )
        {
            this.targetUrl = targetUrl;
            return this;
        }

        public Builder proxyServer( String proxyServer )
        {
            this.proxyServer = proxyServer;
            return this;
        }

        public Builder proxyServerPort( int proxyServerPort )
        {
            this.proxyServerPort = proxyServerPort;
            return this;
        }

        public ProxyTest build()
        {
            ProxyTest proxyTest = new ProxyTest( this ); // object may exist in an incomplete or illegal state
            ProxyTestValidator( proxyTest );
            return proxyTest;
        }

        private void ProxyTestValidator( ProxyTest proxyTest )
        {
            if(  this.targetUrl == null )
            {
                throw new IllegalArgumentException( "ERROR: targetUrl cannot be null" );
            }
            if(  this.proxyServer == null )
            {
                throw new IllegalArgumentException( "ERROR: proxyServer cannot be null" );
            }
            if( this.proxyServer.isEmpty() )
            {
                throw new IllegalArgumentException( "ERROR: proxyServer cannot be empty" );
            }
            if( this.proxyServerPort < 0 )
            {
                throw new IllegalArgumentException( "ERROR: proxyServerPort cannot be undefined" );
            }
            if( targetUrl.getPort() == -1 )
            {
                throw new IllegalArgumentException( "ERROR: targetURL port must be configured, positive integer between 0 and " + PORTMAX );
            }
            if( targetUrl.getPort() > PORTMAX )
            {
                throw new IllegalArgumentException( "ERROR: targetURL port must be a positive integer between 0 and " + PORTMAX );
            }


        }
    }

    private ProxyTest( Builder builder )
    {
        this.proxyServer = builder.proxyServer;
        this.proxyServerPort = builder.proxyServerPort;
        this.targetUrl = builder.targetUrl;
    }

    String getVersion()
    {
        return CLASSVERSION;
    }

    void Connect() throws ClientProtocolException , IOException
    {
        StringBuilder responseBuilder = new StringBuilder();
        String NEWLINE = System.getProperty( "line.separator" );
        HttpHost proxy = new HttpHost( proxyServer , proxyServerPort , "http" );
        DefaultHttpClient httpclient = new DefaultHttpClient();
        try
        {
            httpclient.getParams().setParameter( ConnRoutePNames.DEFAULT_PROXY , proxy );
            HttpHost target = new HttpHost( targetUrl.getHost() , targetUrl.getPort() , targetUrl.getProtocol() );
            HttpGet req = new HttpGet( targetUrl.getPath() );
            responseBuilder.append( "Connecting to " +  targetUrl.getHost() + ":" +  targetUrl.getPort()  + " via " + proxy + NEWLINE + "...retrivieving " + targetUrl.getPath() + NEWLINE );
            HttpResponse rsp = httpclient.execute( target , req );
            HttpEntity entity = rsp.getEntity();
            responseBuilder.append( "----------------------------------------" + NEWLINE );
            responseBuilder.append( rsp.getStatusLine() + NEWLINE );
            Header[] headers = rsp.getAllHeaders();
            for( int i = 0 ; i < headers.length ; i++ )
            {
                responseBuilder.append( headers[i] + NEWLINE );
            }
            responseBuilder.append( "----------------------------------------" + NEWLINE );

            if( entity != null )
            {
                responseBuilder.append( EntityUtils.toString( entity ) );
            }

        }finally
        {
            httpclient.getConnectionManager().shutdown();
        }
        response = responseBuilder.toString();
    }

    String getResponse()
    {
        return response;
    }

} // end class