plugins/org.eclipse.oomph.setup.sync/src/org/eclipse/oomph/setup/internal/sync/RemoteDataProvider.java - oomph/org.eclipse.oomph - Git at Google

 /*
  * Copyright (c) 2015 Eike Stepper (Berlin, Germany) and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Eike Stepper - initial API and implementation
  */
 package org.eclipse.oomph.setup.internal.sync;

 import org.eclipse.oomph.util.IOUtil;
 import org.eclipse.oomph.util.PropertiesUtil;
 import org.eclipse.oomph.util.StringUtil;

 import org.apache.http.Header;
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpResponse;
 import org.apache.http.StatusLine;
 import org.apache.http.auth.Credentials;
 import org.apache.http.client.fluent.Executor;
 import org.apache.http.client.fluent.Request;
 import org.apache.http.client.fluent.Response;
 import org.apache.http.entity.mime.MultipartEntityBuilder;
 import org.apache.http.entity.mime.content.FileBody;
 import org.apache.http.util.EntityUtils;

 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.lang.reflect.Field;
 import java.net.URI;
 import java.util.List;

 /**
  * @author Eike Stepper
  */
 public class RemoteDataProvider implements DataProvider
 {
   private static final String USER_AGENT_ID = PropertiesUtil.getProperty("oomph.setup.sync.user_agent_id", "oomph/sync");

   private static final boolean DEBUG = PropertiesUtil.isProperty("oomph.setup.sync.debug");

   private static final String BASE_VERSION_HEADER = "X-Base-Version";

   private static final String VERSION_HEADER = "X-Version";

   private static final int OK = 200;

   private static final int NOT_MODIFIED = 304;

   private static final int BAD_REQUEST = 400;

   private static final int AUTHORIZATION_REQUIRED = 401;

   private static final int FORBIDDEN = 403;

   private static final int NOT_FOUND = 404;

   private static final int CONFLICT = 409;

   private final URI uri;

   private final Executor executor;

   public RemoteDataProvider(URI serviceURI, Executor executor)
   {
     uri = serviceURI;
     this.executor = executor;
   }

   public RemoteDataProvider(URI serviceURI, Credentials credentials)
   {
     this(serviceURI, Executor.newInstance().auth(credentials));
   }

   public Location getLocation()
   {
     return Location.REMOTE;
   }

   public URI getURI()
   {
     return uri;
   }

   public boolean update(File file) throws IOException, NotFoundException
   {
     HttpEntity responseEntity = null;

     try
     {
       String baseVersion = SyncUtil.getDigest(file);
       Request request = configureRequest(Request.Get(uri), baseVersion);

       HttpResponse response = sendRequest(request);
       responseEntity = response.getEntity();

       int status = getStatus(response);
       if (status == NOT_FOUND)
       {
         throw new NotFoundException(uri);
       }

       if (status == NOT_MODIFIED)
       {
         return false;
       }

       if (status == OK)
       {
         saveContent(responseEntity, file);
         return true;
       }

       throw BadResponseException.create(uri, response.getStatusLine());
     }
     catch (NotFoundException ex)
     {
       throw ex;
     }
     catch (IOException ex)
     {
       if (DEBUG && responseEntity != null)
       {
         responseEntity.writeTo(System.out);
       }

       throw ex;
     }
     finally
     {
       if (responseEntity != null)
       {
         EntityUtils.consume(responseEntity);
       }
     }
   }

   public void post(File file, String baseVersion) throws IOException, NotCurrentException
   {
     HttpEntity responseEntity = null;

     try
     {
       String version = SyncUtil.getDigest(file);

       HttpEntity requestEntity = MultipartEntityBuilder.create().addPart("userfile", new FileBody(file)).build();
       Request request = configureRequest(Request.Post(uri), baseVersion).addHeader(VERSION_HEADER, version).body(requestEntity);

       HttpResponse response = sendRequest(request);
       responseEntity = response.getEntity();
       int status = getStatus(response);

       if (status == CONFLICT)
       {
         saveContent(responseEntity, file);
         throw new NotCurrentException(uri);
       }

       if (status == OK)
       {
         return;
       }

       throw BadResponseException.create(uri, response.getStatusLine());
     }
     catch (IOException ex)
     {
       if (DEBUG && responseEntity != null)
       {
         responseEntity.writeTo(System.out);
       }

       throw ex;
     }
   }

   public boolean delete() throws IOException
   {
     Request request = configureRequest(Request.Delete(uri), null);
     HttpResponse response = sendRequest(request);

     int status = getStatus(response);
     if (status == NOT_FOUND)
     {
       return false;
     }

     return true;
   }

   @Override
   public String toString()
   {
     return getClass().getSimpleName() + "[" + getURI() + "]";
   }

   private Request configureRequest(Request request, String baseVersion)
   {
     return request //
         .viaProxy(SyncUtil.getProxyHost(uri)) //
         .connectTimeout(3000) //
         .staleConnectionCheck(true) //
         .socketTimeout(10000) //
         .addHeader(BASE_VERSION_HEADER, StringUtil.safe(baseVersion)) //
         .addHeader("User-Agent", USER_AGENT_ID);
   }

   private HttpResponse sendRequest(Request request) throws IOException
   {
     long start = 0;
     if (DEBUG)
     {
       try
       {
         start = System.currentTimeMillis();
         StringBuilder builder = new StringBuilder();
         builder.append(request);
         builder.append('\n');

         Field f1 = Request.class.getDeclaredField("request");
         f1.setAccessible(true);
         Object o1 = f1.get(request);

         Field f2 = Class.forName("org.apache.http.message.AbstractHttpMessage").getDeclaredField("headergroup");
         f2.setAccessible(true);
         Object o2 = f2.get(o1);

         Field f3 = o2.getClass().getDeclaredField("headers");
         f3.setAccessible(true);
         @SuppressWarnings("unchecked")
         List<Header> o3 = (List<Header>)f3.get(o2);

         for (Header header : o3)
         {
           builder.append("   ");
           builder.append(header);
           builder.append('\n');
         }

         System.out.print(builder);
       }
       catch (Throwable ex)
       {
         ex.printStackTrace();
       }
     }

     Response result = SyncUtil.proxyAuthentication(executor, uri).execute(request);
     HttpResponse response = result.returnResponse();

     if (DEBUG)
     {
       try
       {
         StringBuilder builder = new StringBuilder();
         builder.append(response.getStatusLine());
         builder.append('\n');

         for (Header header : response.getAllHeaders())
         {
           builder.append("   ");
           builder.append(header);
           builder.append('\n');
         }

         if (start != 0)
         {
           long millis = System.currentTimeMillis() - start;
           builder.append("Took: ");
           builder.append(millis);
           builder.append(" millis");
           builder.append('\n');
         }

         builder.append('\n');
         System.out.print(builder);
       }
       catch (Throwable ex)
       {
         ex.printStackTrace();
       }
     }

     return response;
   }

   private int getStatus(HttpResponse response) throws IOException
   {
     StatusLine statusLine = response.getStatusLine();
     if (statusLine == null)
     {
       throw new BadResponseException(uri, "No status returned");
     }

     int status = statusLine.getStatusCode();
     if (status == BAD_REQUEST)
     {
       throw new BadRequestException(uri);
     }

     if (status == FORBIDDEN)
     {
       throw new ForbiddenException(uri);
     }

     if (status == AUTHORIZATION_REQUIRED)
     {
       throw new AuthorizationRequiredException(uri);
     }

     return status;
   }

   private static void saveContent(HttpEntity entity, File file) throws IOException
   {
     file.getParentFile().mkdirs();

     InputStream content = null;
     OutputStream out = null;

     try
     {
       content = entity.getContent();
       out = new BufferedOutputStream(new FileOutputStream(file));

       IOUtil.copy(content, out);
     }
     finally
     {
       IOUtil.closeSilent(out);
       IOUtil.closeSilent(content);
     }
   }

   /**
    * @author Eike Stepper
    */
   public static class BadRequestException extends IOException
   {
     private static final long serialVersionUID = 1L;

     public BadRequestException(URI uri)
     {
       super("Bad request: " + uri);
     }
   }

   /**
    * @author Eike Stepper
    */
   public static class ForbiddenException extends IOException
   {
     private static final long serialVersionUID = 1L;

     public ForbiddenException(URI uri)
     {
       super("Forbidden: " + uri);
     }
   }

   /**
    * @author Eike Stepper
    */
   public static class AuthorizationRequiredException extends IOException
   {
     private static final long serialVersionUID = 1L;

     public AuthorizationRequiredException(URI uri)
     {
       super("Forbidden: " + uri);
     }
   }

   /**
    * @author Eike Stepper
    */
   public static class BadResponseException extends IOException
   {
     private static final long serialVersionUID = 1L;

     public BadResponseException(URI uri, String statusLine)
     {
       super("Bad response: " + uri + (StringUtil.isEmpty(statusLine) ? "" : " --> " + statusLine));
     }

     private static BadResponseException create(URI uri, StatusLine statusLine)
     {
       return new BadResponseException(uri, statusLine == null ? null : statusLine.toString());
     }
   }
 }
	/*
	* Copyright (c) 2015 Eike Stepper (Berlin, Germany) and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Eike Stepper - initial API and implementation
	*/
	package org.eclipse.oomph.setup.internal.sync;

	import org.eclipse.oomph.util.IOUtil;
	import org.eclipse.oomph.util.PropertiesUtil;
	import org.eclipse.oomph.util.StringUtil;

	import org.apache.http.Header;
	import org.apache.http.HttpEntity;
	import org.apache.http.HttpResponse;
	import org.apache.http.StatusLine;
	import org.apache.http.auth.Credentials;
	import org.apache.http.client.fluent.Executor;
	import org.apache.http.client.fluent.Request;
	import org.apache.http.client.fluent.Response;
	import org.apache.http.entity.mime.MultipartEntityBuilder;
	import org.apache.http.entity.mime.content.FileBody;
	import org.apache.http.util.EntityUtils;

	import java.io.BufferedOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.lang.reflect.Field;
	import java.net.URI;
	import java.util.List;

	/**
	* @author Eike Stepper
	*/
	public class RemoteDataProvider implements DataProvider
	{
	private static final String USER_AGENT_ID = PropertiesUtil.getProperty("oomph.setup.sync.user_agent_id", "oomph/sync");

	private static final boolean DEBUG = PropertiesUtil.isProperty("oomph.setup.sync.debug");

	private static final String BASE_VERSION_HEADER = "X-Base-Version";

	private static final String VERSION_HEADER = "X-Version";

	private static final int OK = 200;

	private static final int NOT_MODIFIED = 304;

	private static final int BAD_REQUEST = 400;

	private static final int AUTHORIZATION_REQUIRED = 401;

	private static final int FORBIDDEN = 403;

	private static final int NOT_FOUND = 404;

	private static final int CONFLICT = 409;

	private final URI uri;

	private final Executor executor;

	public RemoteDataProvider(URI serviceURI, Executor executor)
	{
	uri = serviceURI;
	this.executor = executor;
	}

	public RemoteDataProvider(URI serviceURI, Credentials credentials)
	{
	this(serviceURI, Executor.newInstance().auth(credentials));
	}

	public Location getLocation()
	{
	return Location.REMOTE;
	}

	public URI getURI()
	{
	return uri;
	}

	public boolean update(File file) throws IOException, NotFoundException
	{
	HttpEntity responseEntity = null;

	try
	{
	String baseVersion = SyncUtil.getDigest(file);
	Request request = configureRequest(Request.Get(uri), baseVersion);

	HttpResponse response = sendRequest(request);
	responseEntity = response.getEntity();

	int status = getStatus(response);
	if (status == NOT_FOUND)
	{
	throw new NotFoundException(uri);
	}

	if (status == NOT_MODIFIED)
	{
	return false;
	}

	if (status == OK)
	{
	saveContent(responseEntity, file);
	return true;
	}

	throw BadResponseException.create(uri, response.getStatusLine());
	}
	catch (NotFoundException ex)
	{
	throw ex;
	}
	catch (IOException ex)
	{
	if (DEBUG && responseEntity != null)
	{
	responseEntity.writeTo(System.out);
	}

	throw ex;
	}
	finally
	{
	if (responseEntity != null)
	{
	EntityUtils.consume(responseEntity);
	}
	}
	}

	public void post(File file, String baseVersion) throws IOException, NotCurrentException
	{
	HttpEntity responseEntity = null;

	try
	{
	String version = SyncUtil.getDigest(file);

	HttpEntity requestEntity = MultipartEntityBuilder.create().addPart("userfile", new FileBody(file)).build();
	Request request = configureRequest(Request.Post(uri), baseVersion).addHeader(VERSION_HEADER, version).body(requestEntity);

	HttpResponse response = sendRequest(request);
	responseEntity = response.getEntity();
	int status = getStatus(response);

	if (status == CONFLICT)
	{
	saveContent(responseEntity, file);
	throw new NotCurrentException(uri);
	}

	if (status == OK)
	{
	return;
	}

	throw BadResponseException.create(uri, response.getStatusLine());
	}
	catch (IOException ex)
	{
	if (DEBUG && responseEntity != null)
	{
	responseEntity.writeTo(System.out);
	}

	throw ex;
	}
	}

	public boolean delete() throws IOException
	{
	Request request = configureRequest(Request.Delete(uri), null);
	HttpResponse response = sendRequest(request);

	int status = getStatus(response);
	if (status == NOT_FOUND)
	{
	return false;
	}

	return true;
	}

	@Override
	public String toString()
	{
	return getClass().getSimpleName() + "[" + getURI() + "]";
	}

	private Request configureRequest(Request request, String baseVersion)
	{
	return request //
	.viaProxy(SyncUtil.getProxyHost(uri)) //
	.connectTimeout(3000) //
	.staleConnectionCheck(true) //
	.socketTimeout(10000) //
	.addHeader(BASE_VERSION_HEADER, StringUtil.safe(baseVersion)) //
	.addHeader("User-Agent", USER_AGENT_ID);
	}

	private HttpResponse sendRequest(Request request) throws IOException
	{
	long start = 0;
	if (DEBUG)
	{
	try
	{
	start = System.currentTimeMillis();
	StringBuilder builder = new StringBuilder();
	builder.append(request);
	builder.append('\n');

	Field f1 = Request.class.getDeclaredField("request");
	f1.setAccessible(true);
	Object o1 = f1.get(request);

	Field f2 = Class.forName("org.apache.http.message.AbstractHttpMessage").getDeclaredField("headergroup");
	f2.setAccessible(true);
	Object o2 = f2.get(o1);

	Field f3 = o2.getClass().getDeclaredField("headers");
	f3.setAccessible(true);
	@SuppressWarnings("unchecked")
	List<Header> o3 = (List<Header>)f3.get(o2);

	for (Header header : o3)
	{
	builder.append(" ");
	builder.append(header);
	builder.append('\n');
	}

	System.out.print(builder);
	}
	catch (Throwable ex)
	{
	ex.printStackTrace();
	}
	}

	Response result = SyncUtil.proxyAuthentication(executor, uri).execute(request);
	HttpResponse response = result.returnResponse();

	if (DEBUG)
	{
	try
	{
	StringBuilder builder = new StringBuilder();
	builder.append(response.getStatusLine());
	builder.append('\n');

	for (Header header : response.getAllHeaders())
	{
	builder.append(" ");
	builder.append(header);
	builder.append('\n');
	}

	if (start != 0)
	{
	long millis = System.currentTimeMillis() - start;
	builder.append("Took: ");
	builder.append(millis);
	builder.append(" millis");
	builder.append('\n');
	}

	builder.append('\n');
	System.out.print(builder);
	}
	catch (Throwable ex)
	{
	ex.printStackTrace();
	}
	}

	return response;
	}

	private int getStatus(HttpResponse response) throws IOException
	{
	StatusLine statusLine = response.getStatusLine();
	if (statusLine == null)
	{
	throw new BadResponseException(uri, "No status returned");
	}

	int status = statusLine.getStatusCode();
	if (status == BAD_REQUEST)
	{
	throw new BadRequestException(uri);
	}

	if (status == FORBIDDEN)
	{
	throw new ForbiddenException(uri);
	}

	if (status == AUTHORIZATION_REQUIRED)
	{
	throw new AuthorizationRequiredException(uri);
	}

	return status;
	}

	private static void saveContent(HttpEntity entity, File file) throws IOException
	{
	file.getParentFile().mkdirs();

	InputStream content = null;
	OutputStream out = null;

	try
	{
	content = entity.getContent();
	out = new BufferedOutputStream(new FileOutputStream(file));

	IOUtil.copy(content, out);
	}
	finally
	{
	IOUtil.closeSilent(out);
	IOUtil.closeSilent(content);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static class BadRequestException extends IOException
	{
	private static final long serialVersionUID = 1L;

	public BadRequestException(URI uri)
	{
	super("Bad request: " + uri);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static class ForbiddenException extends IOException
	{
	private static final long serialVersionUID = 1L;

	public ForbiddenException(URI uri)
	{
	super("Forbidden: " + uri);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static class AuthorizationRequiredException extends IOException
	{
	private static final long serialVersionUID = 1L;

	public AuthorizationRequiredException(URI uri)
	{
	super("Forbidden: " + uri);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static class BadResponseException extends IOException
	{
	private static final long serialVersionUID = 1L;

	public BadResponseException(URI uri, String statusLine)
	{
	super("Bad response: " + uri + (StringUtil.isEmpty(statusLine) ? "" : " --> " + statusLine));
	}

	private static BadResponseException create(URI uri, StatusLine statusLine)
	{
	return new BadResponseException(uri, statusLine == null ? null : statusLine.toString());
	}
	}
	}