core/src/test/java/org/jclouds/http/BaseJettyTest.java - jclouds - Git at Google

 /**
  *
  * Copyright (C) 2009 Cloud Conscious, LLC. <info@cloudconscious.com>
  *
  * ====================================================================
  * 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.jclouds.http;

 import java.io.IOException;
 import java.net.URI;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import javax.inject.Singleton;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.ws.rs.core.HttpHeaders;

 import org.jclouds.PropertiesBuilder;
 import org.jclouds.concurrent.internal.SyncProxy;
 import org.jclouds.lifecycle.Closer;
 import org.jclouds.rest.ConfiguresRestClient;
 import org.jclouds.rest.RestClientFactory;
 import org.jclouds.rest.RestContext;
 import org.jclouds.rest.RestContextBuilder;
 import org.jclouds.rest.internal.RestContextImpl;
 import org.jclouds.rest.internal.RestAnnotationProcessorTest.Localhost;
 import org.jclouds.util.Utils;
 import org.mortbay.jetty.Handler;
 import org.mortbay.jetty.Request;
 import org.mortbay.jetty.Server;
 import org.mortbay.jetty.handler.AbstractHandler;
 import org.testng.annotations.AfterTest;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Optional;
 import org.testng.annotations.Parameters;

 import com.google.common.collect.Maps;
 import com.google.inject.AbstractModule;
 import com.google.inject.Injector;
 import com.google.inject.Module;
 import com.google.inject.Provides;
 import com.google.inject.TypeLiteral;

 public abstract class BaseJettyTest {

    public static final class IntegrationContextBuilder extends
             RestContextBuilder<IntegrationTestAsyncClient, IntegrationTestClient> {
       private final int testPort;

       public IntegrationContextBuilder(Properties properties, int testPort) {
          super(new TypeLiteral<IntegrationTestAsyncClient>() {
          }, new TypeLiteral<IntegrationTestClient>() {
          }, properties);
          this.testPort = testPort;
       }

       @Override
       protected void addContextModule(List<Module> modules) {
          modules.add(new JettyContextModule(testPort));
       }

       @Override
       protected void addClientModule(List<Module> modules) {
          modules.add(new RestIntegrationTestClientModule());
       }
    }

    @ConfiguresRestClient
    @RequiresHttp
    public static class RestIntegrationTestClientModule extends AbstractModule {
       @Override
       protected void configure() {

       }

       @Provides
       @Singleton
       public IntegrationTestAsyncClient provideAsyncClient(RestClientFactory factory) {
          return factory.create(IntegrationTestAsyncClient.class);
       }

       @Provides
       @Singleton
       public IntegrationTestClient provideClient(IntegrationTestAsyncClient client)
                throws IllegalArgumentException, SecurityException, NoSuchMethodException {
          return SyncProxy.create(IntegrationTestClient.class, client);
       }
    }

    public static class JettyContextModule extends AbstractModule {
       private final int testPort;

       private JettyContextModule(int testPort) {
          this.testPort = testPort;
       }

       @Override
       protected void configure() {
          bind(URI.class).annotatedWith(Localhost.class).toInstance(
                   URI.create("http://localhost:" + testPort));
       }

       @SuppressWarnings( { "unchecked" })
       @Provides
       @Singleton
       RestContext<IntegrationTestAsyncClient, IntegrationTestClient> provideContext(Closer closer,
                IntegrationTestAsyncClient aclient, IntegrationTestClient client,
                @Localhost URI endPoint) {
          return new RestContextImpl(closer, aclient, client, endPoint, System
                   .getProperty("user.name"));
       }
    }

    protected static final String XML = "<foo><bar>whoppers</bar></foo>";
    protected static final String XML2 = "<foo><bar>chubbs</bar></foo>";

    protected Server server = null;
    protected IntegrationTestClient client;
    protected Injector injector;
    private AtomicInteger cycle = new AtomicInteger(0);
    private Server server2;
    protected RestContext<IntegrationTestAsyncClient, IntegrationTestClient> context;
    private int testPort;
    static final Pattern actionPattern = Pattern.compile("/objects/(.*)/action/([a-z]*);?(.*)");

    @BeforeTest
    @Parameters( { "test-jetty-port" })
    public void setUpJetty(@Optional("8123") final int testPort) throws Exception {
       this.testPort = testPort;
       Handler server1Handler = new AbstractHandler() {
          public void handle(String target, HttpServletRequest request,
                   HttpServletResponse response, int dispatch) throws IOException, ServletException {
             if (failIfNoContentLength(request, response)) {
                return;
             } else if (target.indexOf("redirect") > 0) {
                response.sendRedirect("http://localhost:" + (testPort + 1));
             } else if (request.getMethod().equals("PUT")) {
                if (request.getContentLength() > 0) {
                   response.setStatus(HttpServletResponse.SC_OK);
                   response.getWriter().println(
                            Utils.toStringAndClose(request.getInputStream()) + "PUT");
                } else {
                   response.sendError(500, "no content");
                }
             } else if (request.getMethod().equals("POST")) {
                if (redirectEveryTwentyRequests(request, response))
                   return;
                if (failEveryTenRequests(request, response))
                   return;
                if (request.getContentLength() > 0) {
                   response.setStatus(HttpServletResponse.SC_OK);
                   response.getWriter().println(
                            Utils.toStringAndClose(request.getInputStream()) + "POST");
                } else {
                   handleAction(request, response);
                }
             } else if (request.getHeader("range") != null) {
                response.sendError(404, "no content");
             } else if (request.getHeader("test") != null) {
                response.setContentType("text/plain");
                response.setStatus(HttpServletResponse.SC_OK);
                response.getWriter().println("test");
             } else {
                if (failEveryTenRequests(request, response))
                   return;
                response.setContentType("text/xml");
                response.setStatus(HttpServletResponse.SC_OK);
                response.getWriter().println(XML);
             }
             ((Request) request).setHandled(true);
          }

       };

       server = new Server(testPort);
       server.setHandler(server1Handler);
       server.start();

       Handler server2Handler = new AbstractHandler() {
          public void handle(String target, HttpServletRequest request,
                   HttpServletResponse response, int dispatch) throws IOException, ServletException {
             if (request.getMethod().equals("PUT")) {
                if (request.getContentLength() > 0) {
                   response.setStatus(HttpServletResponse.SC_OK);
                   response.getWriter().println(
                            Utils.toStringAndClose(request.getInputStream()) + "PUTREDIRECT");
                }
             } else if (request.getMethod().equals("POST")) {
                if (request.getContentLength() > 0) {
                   response.setStatus(HttpServletResponse.SC_OK);
                   response.getWriter().println(
                            Utils.toStringAndClose(request.getInputStream()) + "POST");
                } else {
                   handleAction(request, response);
                }
             } else {
                response.setContentType("text/xml");
                response.setStatus(HttpServletResponse.SC_OK);
                response.getWriter().println(XML2);
             }
             ((Request) request).setHandled(true);
          }
       };

       server2 = new Server(testPort + 1);
       server2.setHandler(server2Handler);
       server2.start();

       final Properties properties = new PropertiesBuilder() {

          @Override
          public PropertiesBuilder withCredentials(String account, String key) {
             return null;
          }

          @Override
          public PropertiesBuilder withEndpoint(URI endpoint) {
             return null;
          }

       }.build();
       addConnectionProperties(properties);
       context = newBuilder(testPort, properties, createConnectionModule()).buildContext();
       client = context.getApi();
       assert client != null;

       assert client.newStringBuffer() != null;
    }

    public static RestContextBuilder<IntegrationTestAsyncClient, IntegrationTestClient> newBuilder(
             final int testPort, final Properties properties, Module connectionModule) {
       return new IntegrationContextBuilder(properties, testPort).withModules(connectionModule);
    }

    @AfterTest
    public void tearDownJetty() throws Exception {
       context.close();
       server2.stop();
       server.stop();
    }

    protected abstract void addConnectionProperties(Properties props);

    protected abstract Module createConnectionModule();

    /**
     * Fails every 10 requests.
     *
     * @param request
     * @param response
     * @return
     * @throws IOException
     */
    protected boolean failEveryTenRequests(HttpServletRequest request, HttpServletResponse response)
             throws IOException {
       if (cycle.incrementAndGet() % 10 == 0) {
          response.sendError(500);
          ((Request) request).setHandled(true);
          return true;
       }
       return false;
    }

    protected boolean redirectEveryTwentyRequests(HttpServletRequest request,
             HttpServletResponse response) throws IOException {
       if (cycle.incrementAndGet() % 20 == 0) {
          response.sendRedirect("http://localhost:" + (testPort + 1));
          ((Request) request).setHandled(true);
          return true;
       }
       return false;
    }

    protected boolean failIfNoContentLength(HttpServletRequest request, HttpServletResponse response)
             throws IOException {
       if (request.getHeader(HttpHeaders.CONTENT_LENGTH) == null) {
          response.sendError(500);
          ((Request) request).setHandled(true);
          return true;
       }
       return false;
    }

    private void handleAction(HttpServletRequest request, HttpServletResponse response)
             throws IOException {
       final Matcher matcher = actionPattern.matcher(request.getRequestURI());
       boolean matchFound = matcher.find();
       if (matchFound) {
          String objectId = matcher.group(1);
          String action = matcher.group(2);
          Map<String, String> options = Maps.newHashMap();
          if (matcher.groupCount() == 3) {
             String optionsGroup = matcher.group(3);
             for (String entry : optionsGroup.split(";")) {
                if (entry.indexOf('=') >= 0) {
                   String[] keyValue = entry.split("=");
                   options.put(keyValue[0], keyValue[1]);
                }
             }
          }
          response.setStatus(HttpServletResponse.SC_OK);
          response.getWriter().println(objectId + "->" + action + ":" + options);
       } else {
          response.sendError(500, "no content");
       }
    }
 }
	/**
	*
	* Copyright (C) 2009 Cloud Conscious, LLC. <info@cloudconscious.com>
	*
	* ====================================================================
	* 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.jclouds.http;

	import java.io.IOException;
	import java.net.URI;
	import java.util.List;
	import java.util.Map;
	import java.util.Properties;
	import java.util.concurrent.atomic.AtomicInteger;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import javax.inject.Singleton;
	import javax.servlet.ServletException;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	import javax.ws.rs.core.HttpHeaders;

	import org.jclouds.PropertiesBuilder;
	import org.jclouds.concurrent.internal.SyncProxy;
	import org.jclouds.lifecycle.Closer;
	import org.jclouds.rest.ConfiguresRestClient;
	import org.jclouds.rest.RestClientFactory;
	import org.jclouds.rest.RestContext;
	import org.jclouds.rest.RestContextBuilder;
	import org.jclouds.rest.internal.RestContextImpl;
	import org.jclouds.rest.internal.RestAnnotationProcessorTest.Localhost;
	import org.jclouds.util.Utils;
	import org.mortbay.jetty.Handler;
	import org.mortbay.jetty.Request;
	import org.mortbay.jetty.Server;
	import org.mortbay.jetty.handler.AbstractHandler;
	import org.testng.annotations.AfterTest;
	import org.testng.annotations.BeforeTest;
	import org.testng.annotations.Optional;
	import org.testng.annotations.Parameters;

	import com.google.common.collect.Maps;
	import com.google.inject.AbstractModule;
	import com.google.inject.Injector;
	import com.google.inject.Module;
	import com.google.inject.Provides;
	import com.google.inject.TypeLiteral;

	public abstract class BaseJettyTest {

	public static final class IntegrationContextBuilder extends
	RestContextBuilder<IntegrationTestAsyncClient, IntegrationTestClient> {
	private final int testPort;

	public IntegrationContextBuilder(Properties properties, int testPort) {
	super(new TypeLiteral<IntegrationTestAsyncClient>() {
	}, new TypeLiteral<IntegrationTestClient>() {
	}, properties);
	this.testPort = testPort;
	}

	@Override
	protected void addContextModule(List<Module> modules) {
	modules.add(new JettyContextModule(testPort));
	}

	@Override
	protected void addClientModule(List<Module> modules) {
	modules.add(new RestIntegrationTestClientModule());
	}
	}

	@ConfiguresRestClient
	@RequiresHttp
	public static class RestIntegrationTestClientModule extends AbstractModule {
	@Override
	protected void configure() {

	}

	@Provides
	@Singleton
	public IntegrationTestAsyncClient provideAsyncClient(RestClientFactory factory) {
	return factory.create(IntegrationTestAsyncClient.class);
	}

	@Provides
	@Singleton
	public IntegrationTestClient provideClient(IntegrationTestAsyncClient client)
	throws IllegalArgumentException, SecurityException, NoSuchMethodException {
	return SyncProxy.create(IntegrationTestClient.class, client);
	}
	}

	public static class JettyContextModule extends AbstractModule {
	private final int testPort;

	private JettyContextModule(int testPort) {
	this.testPort = testPort;
	}

	@Override
	protected void configure() {
	bind(URI.class).annotatedWith(Localhost.class).toInstance(
	URI.create("http://localhost:" + testPort));
	}

	@SuppressWarnings( { "unchecked" })
	@Provides
	@Singleton
	RestContext<IntegrationTestAsyncClient, IntegrationTestClient> provideContext(Closer closer,
	IntegrationTestAsyncClient aclient, IntegrationTestClient client,
	@Localhost URI endPoint) {
	return new RestContextImpl(closer, aclient, client, endPoint, System
	.getProperty("user.name"));
	}
	}

	protected static final String XML = "<foo><bar>whoppers</bar></foo>";
	protected static final String XML2 = "<foo><bar>chubbs</bar></foo>";

	protected Server server = null;
	protected IntegrationTestClient client;
	protected Injector injector;
	private AtomicInteger cycle = new AtomicInteger(0);
	private Server server2;
	protected RestContext<IntegrationTestAsyncClient, IntegrationTestClient> context;
	private int testPort;
	static final Pattern actionPattern = Pattern.compile("/objects/(.)/action/([a-z]);?(.*)");

	@BeforeTest
	@Parameters( { "test-jetty-port" })
	public void setUpJetty(@Optional("8123") final int testPort) throws Exception {
	this.testPort = testPort;
	Handler server1Handler = new AbstractHandler() {
	public void handle(String target, HttpServletRequest request,
	HttpServletResponse response, int dispatch) throws IOException, ServletException {
	if (failIfNoContentLength(request, response)) {
	return;
	} else if (target.indexOf("redirect") > 0) {
	response.sendRedirect("http://localhost:" + (testPort + 1));
	} else if (request.getMethod().equals("PUT")) {
	if (request.getContentLength() > 0) {
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(
	Utils.toStringAndClose(request.getInputStream()) + "PUT");
	} else {
	response.sendError(500, "no content");
	}
	} else if (request.getMethod().equals("POST")) {
	if (redirectEveryTwentyRequests(request, response))
	return;
	if (failEveryTenRequests(request, response))
	return;
	if (request.getContentLength() > 0) {
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(
	Utils.toStringAndClose(request.getInputStream()) + "POST");
	} else {
	handleAction(request, response);
	}
	} else if (request.getHeader("range") != null) {
	response.sendError(404, "no content");
	} else if (request.getHeader("test") != null) {
	response.setContentType("text/plain");
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println("test");
	} else {
	if (failEveryTenRequests(request, response))
	return;
	response.setContentType("text/xml");
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(XML);
	}
	((Request) request).setHandled(true);
	}

	};

	server = new Server(testPort);
	server.setHandler(server1Handler);
	server.start();

	Handler server2Handler = new AbstractHandler() {
	public void handle(String target, HttpServletRequest request,
	HttpServletResponse response, int dispatch) throws IOException, ServletException {
	if (request.getMethod().equals("PUT")) {
	if (request.getContentLength() > 0) {
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(
	Utils.toStringAndClose(request.getInputStream()) + "PUTREDIRECT");
	}
	} else if (request.getMethod().equals("POST")) {
	if (request.getContentLength() > 0) {
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(
	Utils.toStringAndClose(request.getInputStream()) + "POST");
	} else {
	handleAction(request, response);
	}
	} else {
	response.setContentType("text/xml");
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(XML2);
	}
	((Request) request).setHandled(true);
	}
	};

	server2 = new Server(testPort + 1);
	server2.setHandler(server2Handler);
	server2.start();

	final Properties properties = new PropertiesBuilder() {

	@Override
	public PropertiesBuilder withCredentials(String account, String key) {
	return null;
	}

	@Override
	public PropertiesBuilder withEndpoint(URI endpoint) {
	return null;
	}

	}.build();
	addConnectionProperties(properties);
	context = newBuilder(testPort, properties, createConnectionModule()).buildContext();
	client = context.getApi();
	assert client != null;

	assert client.newStringBuffer() != null;
	}

	public static RestContextBuilder<IntegrationTestAsyncClient, IntegrationTestClient> newBuilder(
	final int testPort, final Properties properties, Module connectionModule) {
	return new IntegrationContextBuilder(properties, testPort).withModules(connectionModule);
	}

	@AfterTest
	public void tearDownJetty() throws Exception {
	context.close();
	server2.stop();
	server.stop();
	}

	protected abstract void addConnectionProperties(Properties props);

	protected abstract Module createConnectionModule();

	/**
	* Fails every 10 requests.
	*
	* @param request
	* @param response
	* @return
	* @throws IOException
	*/
	protected boolean failEveryTenRequests(HttpServletRequest request, HttpServletResponse response)
	throws IOException {
	if (cycle.incrementAndGet() % 10 == 0) {
	response.sendError(500);
	((Request) request).setHandled(true);
	return true;
	}
	return false;
	}

	protected boolean redirectEveryTwentyRequests(HttpServletRequest request,
	HttpServletResponse response) throws IOException {
	if (cycle.incrementAndGet() % 20 == 0) {
	response.sendRedirect("http://localhost:" + (testPort + 1));
	((Request) request).setHandled(true);
	return true;
	}
	return false;
	}

	protected boolean failIfNoContentLength(HttpServletRequest request, HttpServletResponse response)
	throws IOException {
	if (request.getHeader(HttpHeaders.CONTENT_LENGTH) == null) {
	response.sendError(500);
	((Request) request).setHandled(true);
	return true;
	}
	return false;
	}

	private void handleAction(HttpServletRequest request, HttpServletResponse response)
	throws IOException {
	final Matcher matcher = actionPattern.matcher(request.getRequestURI());
	boolean matchFound = matcher.find();
	if (matchFound) {
	String objectId = matcher.group(1);
	String action = matcher.group(2);
	Map<String, String> options = Maps.newHashMap();
	if (matcher.groupCount() == 3) {
	String optionsGroup = matcher.group(3);
	for (String entry : optionsGroup.split(";")) {
	if (entry.indexOf('=') >= 0) {
	String[] keyValue = entry.split("=");
	options.put(keyValue[0], keyValue[1]);
	}
	}
	}
	response.setStatus(HttpServletResponse.SC_OK);
	response.getWriter().println(objectId + "->" + action + ":" + options);
	} else {
	response.sendError(500, "no content");
	}
	}
	}