inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-08-07 17:49:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge DM-DM_deployment to HEAD

Browse Source 
17716 : Copied alfresco/HEAD to alfresco/BRANCHES/DEV/BRIAN/DM-DM_deployment.
  17721 : Moved alfresco/BRANCHES/DEV/BRIAN/DM-DM_deployment to alfresco/BRANCHES/DEV/DM-DM_deployment.
  17809 : Bare Bones of TransferService.
  17813 : more bones
  17824 : bootstrap of the transfer spaces
  17826 : Added username, path, and a getter for the password.
  17832 : createTransferTarget, getTransferTargets() working.
  17836 : transfer target 
    - duplicate name detection
    - delete transfer target by name
    - get transfer target by name
    - TransferException added along with transfer-service.properties
  17840 : transfer target
   - enable / disable
   - update properties
  17851 : Added the notion of a transmitter for the transfer service, and an HttpClient implementation of it.
  17852 : Added the web script needed for the receiving end of a transfer, along with a command processor for clients to 
check availability of the service and credentials.
  17856 : Added a Mockito-based test for HttpClientTransmitterImpl
  17857 : Corrected javadoc for test class
  17858 : Added test for overriding SSL socket factory
  17859 : Wired up the transfer service to the transfer transmitter.
  17896 : Rework to spring for app:transferDefinitions it's now app:transfer_definitio
    - Add throws clauses to TransferService
    - Bare bones of interface for begin and sendManifest
  17944 : Work in progress on manifest file
  17947 : added parent and child associations to the snapshot.
  17956 : Now has the parent path implemented and introduces the TransferManifestNodeFactory.
  17965 : Added content, MLText and collections.
  17978 : addition of source and target peer associations.
  17982 : Fixing parentNode information.
  18008 : XML Manifest Reader checkpoint. (Still incomplete but lots working)
  18040 : ParentPath is transmitted, fixes for source and target assocs.
  18048 : SAIL-30: Initial commit of functionality for begin, sendManifest, and sendContent parts of the transfer process
  18049 : Fix for parse of Locale type.
  18054 : Added TransferManifestNodeHelper and more tests
  18066 : Work in progress check in
   - Implemented the content chunker
 - sketched out more interfaces on TransferTransmitter.
 - Please note that the chunker is not yet connected to the manifest file, that will come next.
r18069 : Wired up manifest reader to content chunker.
r18089 : Fiest cut of callback interface for review.
r18091 : added hashCode implementation which was missing from ContentData
r18095 : Start of the server-side commit. Note that this is an interim commit - not tested.
r18096 : Initial entry of a ContentData implementation of HttpClient's "Part"
r18155 : Work in progress check in.
    TransferEvent - incomplete
    HttpClientTransmitter - first cut complete (not tested)
    Server side - first cut complete (not tested)
  18156 : TransferMessage missing from last check in.
  18166 : check in command processors
  18167 : Work primarily on the transfer commit operation
  18170 : corrected spring errors.
  18176 : Further testing and fixing of transfer commit
  18206 : Work in progress.
  18236 : Work in progress - generally adding debug logging and sorting out exception handlers.
  18240 : Fix to call "end" correctly after exception is thrown with "commit"
  18242 : Aligning the manifest part names.
  18243 : PostSnapshot calls the correct method on the receiver service.
  18267 : First node has transferred.
  18274 : Fixing abort to call end, debug statements, formatting code brackest
  18275 : First code to handle updates. Also improved error messages passed back to client
  18289 : Checked in work in progress.  Content upload not working.
  18290 : Update to ensure file type.
  18300 : Added more log output and some of the error messages.
  18301 : Work in progress
  18302 : Added log output
  18307 : Added a noddy transfer action
  18315 : Sprint 2 complete - transfer and update one node.
  18354 : Now the manifest file has deleted nodes.
 - Adding copyright headers
  18384 : Plumbing for unit tests on one box.
  18416 : First end to end unit test working.   (one node create and update)
  18421 : Added path based update test and many send test.
  18458 : Added the functionality to transfer deleted and restored nodes.
  18481 : Implementation of transferAsync
  18491 : SAIL-32, SAIL-35
   - Added node crawler for DM-DM Transfer F6 and F9.
  18620 : Basic transfer report implementation

git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@18858 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Mark Rogers
2010-02-25 20:07:09 +00:00
parent e0f29a76e4
commit af1a735c98
93 changed files with 12954 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

569
source/java/org/alfresco/repo/transfer/HttpClientTransmitterImpl.java Normal file
View File

@@ -0,0 +1,569 @@
/*
* Copyright (C) 2009-2010 Alfresco Software Limited.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* As a special exception to the terms and conditions of version 2.0 of
* the GPL, you may redistribute this Program in connection with Free/Libre
* and Open Source Software ("FLOSS") applications as described in Alfresco's
* FLOSS exception. You should have received a copy of the text describing
* the FLOSS exception, and it is also available here:
* http://www.alfresco.com/legal/licensing"
*/
package org.alfresco.repo.transfer;
import java.io.File;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.alfresco.service.cmr.repository.ContentData;
import org.alfresco.service.cmr.repository.ContentService;
import org.alfresco.service.cmr.transfer.TransferException;
import org.alfresco.service.cmr.transfer.TransferTarget;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpState;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.multipart.FilePart;
import org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity;
import org.apache.commons.httpclient.methods.multipart.Part;
import org.apache.commons.httpclient.protocol.DefaultProtocolSocketFactory;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
import org.apache.commons.httpclient.protocol.SSLProtocolSocketFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONArray;
import org.json.JSONObject;
/**
* HTTP implementation of TransferTransmitter.
*
* Sends data via HTTP to the server.
*
* @author brian
*/
public class HttpClientTransmitterImpl implements TransferTransmitter
{
private static final Log log = LogFactory.getLog(HttpClientTransmitterImpl.class);
private static final String MSG_UNSUPPORTED_PROTOCOL = "transfer_service.comms.unsupported_protocol";
private static final String MSG_UNSUCCESSFUL_RESPONSE = "transfer_service.comms.unsuccessful_response";
private static final String MSG_HTTP_REQUEST_FAILED = "transfer_service.comms.http_request_failed";
private static final int DEFAULT_HTTP_PORT = 80;
private static final int DEFAULT_HTTPS_PORT = 443;
private static final String HTTP_SCHEME_NAME = "http"; // lowercase is important
private static final String HTTPS_SCHEME_NAME = "https"; // lowercase is important
private HttpClient httpClient = null;
private Protocol httpProtocol = new Protocol(HTTP_SCHEME_NAME, new DefaultProtocolSocketFactory(), DEFAULT_HTTP_PORT);
private Protocol httpsProtocol = new Protocol(HTTPS_SCHEME_NAME, (ProtocolSocketFactory) new SSLProtocolSocketFactory(), DEFAULT_HTTPS_PORT);
private Map<String,Protocol> protocolMap = null;
private ContentService contentService;
public HttpClientTransmitterImpl()
{
protocolMap = new TreeMap<String,Protocol>();
protocolMap.put(HTTP_SCHEME_NAME, httpProtocol);
protocolMap.put(HTTPS_SCHEME_NAME, httpsProtocol);
httpClient = new HttpClient();
httpClient.setHttpConnectionManager(new MultiThreadedHttpConnectionManager());
}
public void init()
{
}
/**
* By default this class uses the standard SSLProtocolSocketFactory, but this method allows this to be overridden.
* Useful if, for example, one wishes to permit support of self-signed certificates on the target.
* @param socketFactory
*/
public void setHttpsSocketFactory(ProtocolSocketFactory socketFactory)
{
protocolMap.put(HTTPS_SCHEME_NAME, new Protocol(HTTPS_SCHEME_NAME, socketFactory, DEFAULT_HTTPS_PORT));
}
/**
* By default, this class uses a plain HttpClient instance with the only non-default
* option being the multi-threaded connection manager.
* Use this method to replace this with your own HttpClient instance configured how you wish
* @param httpClient
*/
public void setHttpClient(HttpClient httpClient)
{
this.httpClient = httpClient;
}
/* (non-Javadoc)
* @see org.alfresco.repo.transfer.Transmitter#verifyTarget(org.alfresco.service.cmr.transfer.TransferTarget)
*/
public void verifyTarget(TransferTarget target) throws TransferException
{
HttpMethod verifyRequest = new PostMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
verifyRequest.setPath(target.getEndpointPath() + "/test");
try
{
int response = httpClient.executeMethod(hostConfig, verifyRequest, httpState);
checkResponseStatus("verifyTarget", response, verifyRequest);
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"verifyTraget", target.toString(), e.toString()}, e);
}
}
finally
{
verifyRequest.releaseConnection();
}
}
/**
* @param response
*/
private void checkResponseStatus(String methodName, int response, HttpMethod method)
{
if (response != 200)
{
String errorId = null;
String[] errorParams = null;
try {
log.error("Received \"unsuccessful\" response code from target server: " + response);
String errorPayload = method.getResponseBodyAsString();
JSONObject errorObj = new JSONObject(errorPayload);
errorId = errorObj.getString("errorId");
JSONArray errorParamArray = errorObj.getJSONArray("errorParams");
int length = errorParamArray.length();
errorParams = new String[length];
for (int i = 0; i < length; ++i)
{
errorParams[i] = errorParamArray.getString(i);
}
} catch (Exception ex) {
throw new TransferException(MSG_UNSUCCESSFUL_RESPONSE, new Object[] {methodName, response});
}
throw new TransferException(errorId, errorParams);
}
}
/**
* Get the HTTPState for a transfer target
* @param target
* @return
*/
private HttpState getHttpState(TransferTarget target)
{
HttpState httpState = new HttpState();
httpState.setCredentials(new AuthScope(target.getEndpointHost(), target.getEndpointPort(),
AuthScope.ANY_REALM),
new UsernamePasswordCredentials(target.getUsername(), new String(target.getUsername())));
return httpState;
}
/**
* @param target
* @return
*/
private HostConfiguration getHostConfig(TransferTarget target)
{
String requiredProtocol = target.getEndpointProtocol();
if (requiredProtocol == null)
{
throw new TransferException(MSG_UNSUPPORTED_PROTOCOL, new Object[] {target.getEndpointProtocol()});
}
Protocol protocol = protocolMap.get(requiredProtocol.toLowerCase().trim());
if (protocol == null) {
log.error("Unsupported protocol: " + target.getEndpointProtocol());
throw new TransferException(MSG_UNSUPPORTED_PROTOCOL, new Object[] {target.getEndpointProtocol()});
}
HostConfiguration hostConfig = new HostConfiguration();
hostConfig.setHost(target.getEndpointHost(), target.getEndpointPort(), protocol);
return hostConfig;
}
public Transfer begin(TransferTarget target) throws TransferException
{
HttpMethod beginRequest = new PostMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
beginRequest.setPath(target.getEndpointPath() + "/begin");
try
{
int responseStatus = httpClient.executeMethod(hostConfig, beginRequest, httpState);
checkResponseStatus("begin", responseStatus, beginRequest);
//If we get here then we've received a 200 response
//We're expecting the transfer id encoded in a JSON object...
JSONObject response = new JSONObject(beginRequest.getResponseBodyAsString());
String transferId = response.getString("transferId");
if(log.isDebugEnabled())
{
log.debug("begin transfer transferId:" + transferId +", target:" + target);
}
Transfer transfer = new Transfer();
transfer.setTransferId(transferId);
transfer.setTransferTarget(target);
return transfer;
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[] {"begin", target.toString(), e.toString()}, e);
}
}
finally
{
beginRequest.releaseConnection();
}
}
public DeltaList sendManifest(Transfer transfer, File manifest) throws TransferException
{
TransferTarget target = transfer.getTransferTarget();
PostMethod postSnapshotRequest = new PostMethod();
MultipartRequestEntity requestEntity;
if(log.isDebugEnabled())
{
log.debug("does manifest exist? " + manifest.exists());
log.debug("sendManifest file : " + manifest.getAbsoluteFile());
}
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
try
{
postSnapshotRequest.setPath(target.getEndpointPath() + "/post-snapshot");
//Put the transferId on the query string
postSnapshotRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
//TODO encapsulate the name of the manifest part
//And add the manifest file as a "part"
Part file = new FilePart(TransferCommons.PART_NAME_MANIFEST, manifest);
requestEntity = new MultipartRequestEntity(new Part[] {file}, postSnapshotRequest.getParams());
postSnapshotRequest.setRequestEntity(requestEntity);
int responseStatus = httpClient.executeMethod(hostConfig, postSnapshotRequest, httpState);
checkResponseStatus("sendManifest", responseStatus, postSnapshotRequest);
return null;
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"sendManifest", target.toString(), e.toString()}, e);
}
}
finally
{
postSnapshotRequest.releaseConnection();
}
}
public void abort(Transfer transfer) throws TransferException
{
TransferTarget target = transfer.getTransferTarget();
HttpMethod abortRequest = new PostMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
abortRequest.setPath(target.getEndpointPath() + "/abort");
//Put the transferId on the query string
abortRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
try
{
int responseStatus = httpClient.executeMethod(hostConfig, abortRequest, httpState);
checkResponseStatus("abort", responseStatus, abortRequest);
//If we get here then we've received a 200 response
//We're expecting the transfer id encoded in a JSON object...
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"abort", target.toString(), e.toString()}, e);
}
}
finally
{
abortRequest.releaseConnection();
}
}
public void commit(Transfer transfer) throws TransferException
{
TransferTarget target = transfer.getTransferTarget();
HttpMethod commitRequest = new PostMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
commitRequest.setPath(target.getEndpointPath() + "/commit");
//Put the transferId on the query string
commitRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
try
{
int responseStatus = httpClient.executeMethod(hostConfig, commitRequest, httpState);
checkResponseStatus("commit", responseStatus, commitRequest);
//If we get here then we've received a 200 response
//We're expecting the transfer id encoded in a JSON object...
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.error(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"commit", target.toString(), e.toString()}, e);
}
}
finally
{
commitRequest.releaseConnection();
}
}
public void prepare(Transfer transfer) throws TransferException
{
TransferTarget target = transfer.getTransferTarget();
HttpMethod prepareRequest = new PostMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
prepareRequest.setPath(target.getEndpointPath() + "/prepare");
//Put the transferId on the query string
prepareRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
try
{
int responseStatus = httpClient.executeMethod(hostConfig, prepareRequest, httpState);
checkResponseStatus("prepare", responseStatus, prepareRequest);
//If we get here then we've received a 200 response
//We're expecting the transfer id encoded in a JSON object...
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"prepare", target.toString(), e.toString()}, e);
}
}
finally
{
prepareRequest.releaseConnection();
}
}
/**
*
*/
public void sendContent(Transfer transfer, Set<ContentData> data) throws TransferException
{
if(log.isDebugEnabled())
{
log.debug("send content to transfer:" + transfer);
}
TransferTarget target = transfer.getTransferTarget();
PostMethod postContentRequest = new PostMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
try
{
postContentRequest.setPath(target.getEndpointPath() + "/post-content");
//Put the transferId on the query string
postContentRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
//Put the transferId on the query string
postContentRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
Part[] parts = new Part[data.size()];
int index = 0;
for(ContentData content : data)
{
// TODO Encapsulate the URL to FileName algorithm
String contentUrl = content.getContentUrl();
String fileName = TransferCommons.URLToPartName(contentUrl);
log.debug("content partName: " + fileName);
parts[index++] = new ContentDataPart(getContentService(), fileName, content);
}
MultipartRequestEntity requestEntity = new MultipartRequestEntity(parts, postContentRequest.getParams());
postContentRequest.setRequestEntity(requestEntity);
int responseStatus = httpClient.executeMethod(hostConfig, postContentRequest, httpState);
checkResponseStatus("sendContent", responseStatus, postContentRequest);
if(log.isDebugEnabled())
{
log.debug("sent content");
}
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"sendContent", target.toString(), e.toString()}, e);
}
}
finally
{
postContentRequest.releaseConnection();
}
} // end of sendContent
/**
*
*/
public Set<TransferMessage> getMessages(Transfer transfer)
{
// TODO How to signal last message ? return null rather than empty
Set<TransferMessage> messages = new HashSet<TransferMessage>();
TransferTarget target = transfer.getTransferTarget();
HttpMethod messagesRequest = new GetMethod();
try
{
HostConfiguration hostConfig = getHostConfig(target);
HttpState httpState = getHttpState(target);
messagesRequest.setPath(target.getEndpointPath() + "/messages");
//Put the transferId on the query string
messagesRequest.setQueryString(
new NameValuePair[] {new NameValuePair("transferId", transfer.getTransferId())});
try
{
int responseStatus = httpClient.executeMethod(hostConfig, messagesRequest, httpState);
checkResponseStatus("getMessages", responseStatus, messagesRequest);
//If we get here then we've received a 200 response
//We're expecting the transfer id encoded in a JSON object...
JSONObject lookupResult = new JSONObject(messagesRequest.getResponseBodyAsString());
JSONArray data = lookupResult.getJSONArray("data");
for(int i = 0; i < data.length(); i++)
{
JSONObject obj = data.getJSONObject(i);
String message = obj.getString("message");
//TODO Need some sort of TransferMessage impl
// messages.add(new TransferMessageImpl());
}
return messages;
}
catch (RuntimeException e)
{
throw e;
}
catch (Exception e)
{
String error = "Failed to execute HTTP request to target";
log.debug(error, e);
throw new TransferException(MSG_HTTP_REQUEST_FAILED, new Object[]{"getMessages", target.toString(), e.toString()}, e);
}
}
finally
{
messagesRequest.releaseConnection();
}
}
public void setContentService(ContentService contentService)
{
this.contentService = contentService;
}
public ContentService getContentService()
{
return contentService;
}
} // end of class