~ubuntu-core-dev/eucalyptus/ubuntu

/*******************************************************************************

 *Copyright (c) 2009  Eucalyptus Systems, Inc.

 * 

 *  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, only version 3 of the License.

 * 

 * 

 *  This file 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, see <http://www.gnu.org/licenses/>.

 * 

 *  Please contact Eucalyptus Systems, Inc., 130 Castilian

 *  Dr., Goleta, CA 93101 USA or visit <http://www.eucalyptus.com/licenses/>

 *  if you need additional information or have any questions.

 * 

 *  This file may incorporate work covered under the following copyright and

 *  permission notice:

 * 

 *    Software License Agreement (BSD License)

 * 

 *    Copyright (c) 2008, Regents of the University of California

 *    All rights reserved.

 * 

 *    Redistribution and use of this software in source and binary forms, with

 *    or without modification, are permitted provided that the following

 *    conditions are met:

 * 

 *      Redistributions of source code must retain the above copyright notice,

 *      this list of conditions and the following disclaimer.

 * 

 *      Redistributions in binary form must reproduce the above copyright

 *      notice, this list of conditions and the following disclaimer in the

 *      documentation and/or other materials provided with the distribution.

 * 

 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 *    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

 *    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

 *    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER

 *    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 *    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 *    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 *    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 *    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 *    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 *    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. USERS OF

 *    THIS SOFTWARE ACKNOWLEDGE THE POSSIBLE PRESENCE OF OTHER OPEN SOURCE

 *    LICENSED MATERIAL, COPYRIGHTED MATERIAL OR PATENTED MATERIAL IN THIS

 *    SOFTWARE, AND IF ANY SUCH MATERIAL IS DISCOVERED THE PARTY DISCOVERING

 *    IT MAY INFORM DR. RICH WOLSKI AT THE UNIVERSITY OF CALIFORNIA, SANTA

 *    BARBARA WHO WILL THEN ASCERTAIN THE MOST APPROPRIATE REMEDY, WHICH IN

 *    THE REGENTS’ DISCRETION MAY INCLUDE, WITHOUT LIMITATION, REPLACEMENT

 *    OF THE CODE SO IDENTIFIED, LICENSING OF THE CODE SO IDENTIFIED, OR

 *    WITHDRAWAL OF THE CODE CAPABILITY TO THE EXTENT NEEDED TO COMPLY WITH

 *    ANY SUCH LICENSES OR RIGHTS.

 *******************************************************************************/

package com.eucalyptus.ws.handlers;

import java.io.ByteArrayOutputStream;

import java.io.UnsupportedEncodingException;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.lang.reflect.ParameterizedType;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

import org.apache.axiom.om.OMElement;

import org.apache.commons.httpclient.util.DateUtil;

import org.apache.log4j.Logger;

import org.apache.tools.ant.util.DateUtils;

import org.apache.xml.dtm.ref.DTMNodeList;

import org.jboss.netty.buffer.ChannelBuffer;

import org.jboss.netty.buffer.ChannelBuffers;

import org.jboss.netty.channel.ChannelEvent;

import org.jboss.netty.channel.ChannelHandlerContext;

import org.jboss.netty.channel.Channels;

import org.jboss.netty.channel.DownstreamMessageEvent;

import org.jboss.netty.channel.MessageEvent;

import org.jboss.netty.handler.codec.http.DefaultHttpResponse;

import org.jboss.netty.handler.codec.http.HttpChunk;

import org.jboss.netty.handler.codec.http.HttpHeaders;

import org.jboss.netty.handler.codec.http.HttpResponse;

import org.jboss.netty.handler.codec.http.HttpResponseStatus;

import org.jboss.netty.handler.codec.http.HttpVersion;

import com.eucalyptus.auth.User;

import com.eucalyptus.auth.util.Hashes;

import com.eucalyptus.util.HoldMe;

import com.eucalyptus.util.LogUtil;

import com.eucalyptus.util.StorageProperties;

import com.eucalyptus.util.WalrusProperties;

import com.eucalyptus.util.WalrusUtil;

import com.eucalyptus.ws.BindingException;

import com.eucalyptus.ws.InvalidOperationException;

import com.eucalyptus.ws.MappingHttpRequest;

import com.eucalyptus.ws.MappingHttpResponse;

import com.eucalyptus.ws.binding.Binding;

import com.eucalyptus.ws.binding.BindingManager;

import com.eucalyptus.ws.util.WalrusBucketLogger;

import com.eucalyptus.ws.util.XMLParser;

import com.google.common.collect.Lists;

import edu.ucsb.eucalyptus.annotation.HttpEmbedded;

import edu.ucsb.eucalyptus.annotation.HttpParameterMapping;

import edu.ucsb.eucalyptus.cloud.BucketLogData;

import edu.ucsb.eucalyptus.msgs.AccessControlListType;

import edu.ucsb.eucalyptus.msgs.AccessControlPolicyType;

import edu.ucsb.eucalyptus.msgs.CanonicalUserType;

import edu.ucsb.eucalyptus.msgs.EucalyptusErrorMessageType;

import edu.ucsb.eucalyptus.msgs.EucalyptusMessage;

import edu.ucsb.eucalyptus.msgs.Grant;

import edu.ucsb.eucalyptus.msgs.Grantee;

import edu.ucsb.eucalyptus.msgs.Group;

import edu.ucsb.eucalyptus.msgs.LoggingEnabled;

import edu.ucsb.eucalyptus.msgs.MetaDataEntry;

import edu.ucsb.eucalyptus.msgs.TargetGrants;

import edu.ucsb.eucalyptus.msgs.WalrusDataGetRequestType;

import edu.ucsb.eucalyptus.msgs.WalrusDataRequestType;

import edu.ucsb.eucalyptus.msgs.WalrusRequestType;

import edu.ucsb.eucalyptus.msgs.PutObjectResponseType;

import edu.ucsb.eucalyptus.util.WalrusDataMessage;

import edu.ucsb.eucalyptus.util.WalrusDataMessenger;

import edu.ucsb.eucalyptus.util.WalrusDataQueue;

import groovy.lang.GroovyObject;

public class WalrusRESTBinding extends RestfulMarshallingHandler {

	private static Logger LOG = Logger.getLogger( WalrusRESTBinding.class );

	private static final String SERVICE = "service";

	private static final String BUCKET = "bucket";

	private static final String OBJECT = "object";

	private static final Map<String, String> operationMap = populateOperationMap();

	private static WalrusDataMessenger putMessenger;

	public static final int DATA_MESSAGE_SIZE = 102400;

	private String key;

	private String randomKey;

	private WalrusDataQueue<WalrusDataMessage> putQueue;

	@Override

	public void handleUpstream( final ChannelHandlerContext channelHandlerContext, final ChannelEvent channelEvent ) throws Exception {

		LOG.trace( LogUtil.dumpObject( channelEvent ) );

		if ( channelEvent instanceof MessageEvent ) {

			final MessageEvent msgEvent = ( MessageEvent ) channelEvent;

			try {

				this.incomingMessage( channelHandlerContext, msgEvent );

			} catch ( Throwable e ) {

				LOG.error( e, e );

				Channels.fireExceptionCaught( channelHandlerContext, e );

				return;

			} 

		} else if (channelEvent.toString().contains("DISCONNECTED") || 

				channelEvent.toString().contains("CLOSED")) {

			if(key != null && randomKey != null) {

				putMessenger.removeQueue(key, randomKey);

				putQueue = null;

			}

		}

		channelHandlerContext.sendUpstream( channelEvent );

	}

	@Override

	public void incomingMessage( ChannelHandlerContext ctx, MessageEvent event ) throws Exception {

		if ( event.getMessage( ) instanceof MappingHttpRequest ) {

			MappingHttpRequest httpRequest = ( MappingHttpRequest ) event.getMessage( );

			namespace = "http://s3.amazonaws.com/doc/" + WalrusProperties.NAMESPACE_VERSION;

			// TODO: get real user data here too

			EucalyptusMessage msg = (EucalyptusMessage) this.bind( "admin", true, httpRequest );

			httpRequest.setMessage( msg );

			if(msg instanceof WalrusDataGetRequestType) {

				WalrusDataGetRequestType getObject = (WalrusDataGetRequestType) msg;

				getObject.setChannel(ctx.getChannel());

			}

			if(msg instanceof WalrusDataRequestType) {

				String expect = httpRequest.getHeader(HttpHeaders.Names.EXPECT);

				if(expect != null) {

					if(expect.equals("100-continue")) {

						HttpResponse response = new DefaultHttpResponse( HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE );

						DownstreamMessageEvent newEvent = new DownstreamMessageEvent( ctx.getChannel( ), event.getFuture(), response, null );

						ctx.sendDownstream( newEvent );

					}

				}

			}

		} else if(event.getMessage() instanceof HttpChunk) {

			if(putQueue != null) {

				HttpChunk httpChunk = (HttpChunk) event.getMessage();

				handleHttpChunk(httpChunk);

			}

		}

	}

	@Override

	public void outgoingMessage( ChannelHandlerContext ctx, MessageEvent event ) throws Exception {

		if ( event.getMessage( ) instanceof MappingHttpResponse ) {

			MappingHttpResponse httpResponse = ( MappingHttpResponse ) event.getMessage( );

			EucalyptusMessage msg = (EucalyptusMessage) httpResponse.getMessage( );

			Binding binding;

			if(!(msg instanceof EucalyptusErrorMessageType)) {

				if(msg instanceof PutObjectResponseType) {

					if(putQueue != null) {

						putQueue = null;

					}

				}

				binding = BindingManager.getBinding( BindingManager.sanitizeNamespace( namespace ) );

			} else {

				binding = BindingManager.getBinding( BindingManager.sanitizeNamespace( "http://msgs.eucalyptus.ucsb.edu" ) );

				if(putQueue != null) {

					putQueue = null;

				}

			}

			if(msg != null) {

				OMElement omMsg = binding.toOM( msg );

				ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

				HoldMe.canHas.lock(); 

				try {

					omMsg.serialize( byteOut );

				} finally {

					HoldMe.canHas.unlock();

				}

				byte[] req = byteOut.toByteArray();

				ChannelBuffer buffer = ChannelBuffers.copiedBuffer( req );

				httpResponse.addHeader( HttpHeaders.Names.CONTENT_LENGTH, String.valueOf(buffer.readableBytes() ) );

				httpResponse.addHeader( HttpHeaders.Names.CONTENT_TYPE, "application/xml" );

				httpResponse.setContent( buffer );

			}

		}

	}

	private static Map<String, String> populateOperationMap() {

		Map<String, String> newMap = new HashMap<String, String>();

		//Service operations

		newMap.put(SERVICE + WalrusProperties.HTTPVerb.GET.toString(), "ListAllMyBuckets");

		//Bucket operations

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.acl.toString(), "GetBucketAccessControlPolicy");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.PUT.toString() + WalrusProperties.OperationParameter.acl.toString(), "SetRESTBucketAccessControlPolicy");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString(), "ListBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.prefix.toString(), "ListBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.maxkeys.toString(), "ListBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.marker.toString(), "ListBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.delimiter.toString(), "ListBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.PUT.toString(), "CreateBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.DELETE.toString(), "DeleteBucket");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.location.toString(), "GetBucketLocation");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.logging.toString(), "GetBucketLoggingStatus");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.PUT.toString() + WalrusProperties.OperationParameter.logging.toString(), "SetBucketLoggingStatus");

		//Object operations

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.acl.toString(), "GetObjectAccessControlPolicy");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.PUT.toString() + WalrusProperties.OperationParameter.acl.toString(), "SetRESTObjectAccessControlPolicy");

		newMap.put(BUCKET + WalrusProperties.HTTPVerb.POST.toString(), "PostObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.PUT.toString(), "PutObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.PUT.toString() + WalrusProperties.COPY_SOURCE.toString(), "CopyObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.GET.toString(), "GetObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.GET.toString() + WalrusProperties.OperationParameter.torrent.toString(), "GetObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.DELETE.toString(), "DeleteObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.HEAD.toString(), "GetObject");

		newMap.put(OBJECT + WalrusProperties.HTTPVerb.GET.toString() + "extended", "GetObjectExtended");

		return newMap;

	}

	@Override

	public Object bind( final String userId, final boolean admin, final MappingHttpRequest httpRequest ) throws Exception {

		String servicePath = httpRequest.getServicePath();

		Map bindingArguments = new HashMap();

		final String operationName = getOperation(httpRequest, bindingArguments);

		if(operationName == null)

			throw new InvalidOperationException("Could not determine operation name for " + servicePath);

		Map<String, String> params = httpRequest.getParameters();

		OMElement msg;

		EucalyptusMessage eucaMsg;

		Map<String, String> fieldMap;

		Class targetType;

		try

		{

			//:: try to create the target class :://

			targetType = Class.forName( "edu.ucsb.eucalyptus.msgs.".concat( operationName ).concat( "Type" ) );

			//:: get the map of parameters to fields :://

			fieldMap = this.buildFieldMap( targetType );

			//:: get an instance of the message :://

			eucaMsg =  (EucalyptusMessage) targetType.newInstance();

		}

		catch ( Exception e )

		{

			throw new BindingException( "Failed to construct message of type " + operationName );

		}

		addLogData(eucaMsg, bindingArguments);

		//TODO: Refactor this to be more general

		List<String> failedMappings = populateObject( eucaMsg, fieldMap, params);

		populateObjectFromBindingMap(eucaMsg, fieldMap, httpRequest, bindingArguments);

		User user = httpRequest.getUser();

		setRequiredParams (eucaMsg, user);

		if ( !failedMappings.isEmpty() || !params.isEmpty() )

		{

			StringBuilder errMsg = new StringBuilder( "Failed to bind the following fields:\n" );

			for ( String f : failedMappings )

				errMsg.append( f ).append( '\n' );

			for ( Map.Entry<String, String> f : params.entrySet() )

				errMsg.append( f.getKey() ).append( " = " ).append( f.getValue() ).append( '\n' );

			throw new BindingException( errMsg.toString() );

		}

		LOG.info(eucaMsg.toString());

		try

		{

			Binding binding = BindingManager.getBinding( BindingManager.sanitizeNamespace( "http://msgs.eucalyptus.ucsb.edu" ) );

			msg = binding.toOM( eucaMsg );

		}

		catch ( RuntimeException e )

		{

			throw new BindingException( "Failed to build a valid message: " + e.getMessage() );

		}

		return eucaMsg;

	}

	private void addLogData(EucalyptusMessage eucaMsg,

			Map bindingArguments) {

		if(eucaMsg instanceof WalrusRequestType) {

			String operation = (String) bindingArguments.remove("Operation");

			if(operation != null) {

				WalrusRequestType request = (WalrusRequestType) eucaMsg;

				BucketLogData logData = WalrusBucketLogger.getInstance().makeLogEntry(UUID.randomUUID().toString());

				logData.setOperation("REST." + operation);

				request.setLogData(logData);

			}

		}

	}

	private void setRequiredParams(final GroovyObject msg, User user) {

		if(user != null) {

			msg.setProperty("accessKeyID", user.getQueryId());

		}

		msg.setProperty("timeStamp", new Date());

	}

	private static String[] getTarget(String operationPath) {

		operationPath = operationPath.replaceAll("/{2,}", "/");

		if(operationPath.startsWith("/"))

			operationPath = operationPath.substring(1);

		return operationPath.split("/");

	}

	private String getOperation(MappingHttpRequest httpRequest, Map operationParams) throws BindingException {

		String[] target = null;

		String path = getOperationPath(httpRequest);

		boolean walrusInternalOperation = false;

		String targetHost = httpRequest.getHeader(HttpHeaders.Names.HOST);

		if(targetHost.contains(".walrus")) {

			String bucket = targetHost.substring(0, targetHost.indexOf(".walrus"));

			path = "/" + bucket + path;

		}

		if(path.length() > 0) {

			target = getTarget(path);

		}

		String verb = httpRequest.getMethod().getName();

		String operationKey = "";

		Map<String, String> params = httpRequest.getParameters();

		String operationName = null;

		long contentLength = 0;

		String contentLengthString = httpRequest.getHeader(WalrusProperties.CONTENT_LEN);

		if(contentLengthString != null) {

			contentLength = Long.parseLong(contentLengthString);

		}

		if(httpRequest.containsHeader(StorageProperties.EUCALYPTUS_OPERATION)) {

			String value = httpRequest.getHeader(StorageProperties.EUCALYPTUS_OPERATION);

			for(WalrusProperties.WalrusInternalOperations operation: WalrusProperties.WalrusInternalOperations.values()) {

				if(value.toLowerCase().equals(operation.toString().toLowerCase())) {

					operationName = operation.toString();

					walrusInternalOperation = true;

					break;

				}

			}

			if(!walrusInternalOperation) {

				for(WalrusProperties.StorageOperations operation: WalrusProperties.StorageOperations.values()) {

					if(value.toLowerCase().equals(operation.toString().toLowerCase())) {

						operationName = operation.toString();

						walrusInternalOperation = true;

						if(httpRequest.containsHeader(StorageProperties.StorageParameters.EucaSnapSize.toString())) {

							operationParams.put("SnapshotSize", httpRequest.getAndRemoveHeader(StorageProperties.StorageParameters.EucaSnapSize.toString()));

						}

						break;

					}

				}

			}

		}

		if(target == null) {

			//target = service

			operationKey = SERVICE + verb;

		} else if(target.length < 2) {

			//target = bucket

			if(!target[0].equals("")) {

				operationKey = BUCKET + verb;

				operationParams.put("Bucket", target[0]);

				operationParams.put("Operation", verb.toUpperCase() + "." + "BUCKET");

				if(verb.equals(WalrusProperties.HTTPVerb.POST.toString())) {

					//TODO: handle POST.

					Map formFields = httpRequest.getFormFields();

					String objectKey = null;

					String file = (String) formFields.get(WalrusProperties.FormField.file.toString());

					String authenticationHeader = "";

					if(formFields.containsKey(WalrusProperties.FormField.key.toString())) {

						objectKey = (String) formFields.get(WalrusProperties.FormField.key.toString());

						objectKey = objectKey.replaceAll("\\$\\{filename\\}", file);

						operationParams.put("Key", objectKey);

					}

					if(formFields.containsKey(WalrusProperties.FormField.acl.toString())) {

						String acl = (String) formFields.get(WalrusProperties.FormField.acl.toString());

						httpRequest.addHeader(WalrusProperties.AMZ_ACL, acl);

					}

					if(formFields.containsKey(WalrusProperties.FormField.redirect.toString())) {

						String successActionRedirect = (String) formFields.get(WalrusProperties.FormField.redirect.toString());

						operationParams.put("SuccessActionRedirect", successActionRedirect);

					}

					if(formFields.containsKey(WalrusProperties.FormField.success_action_redirect.toString())) {

						String successActionRedirect = (String) formFields.get(WalrusProperties.FormField.success_action_redirect.toString());

						operationParams.put("SuccessActionRedirect", successActionRedirect);

					}

					if(formFields.containsKey(WalrusProperties.FormField.success_action_status.toString())) {

						Integer successActionStatus = Integer.parseInt((String)formFields.get(WalrusProperties.FormField.success_action_status.toString()));

						if(successActionStatus == 200 || successActionStatus == 201)

							operationParams.put("SuccessActionStatus", successActionStatus);

						else

							operationParams.put("SuccessActionStatus", 204);

					} else {

						operationParams.put("SuccessActionStatus", 204);

					}

					if(formFields.containsKey(WalrusProperties.CONTENT_TYPE)) {

						operationParams.put("ContentType", formFields.get(WalrusProperties.CONTENT_TYPE));

					}

					key = target[0] + "." + objectKey;

					randomKey = key + "." + Hashes.getRandom(10);

					if(contentLengthString != null)

						operationParams.put("ContentLength", (new Long(contentLength).toString()));

					operationParams.put(WalrusProperties.Headers.RandomKey.toString(), randomKey);

					putQueue = getWriteMessenger().interruptAllAndGetQueue(key, randomKey);

					handleFirstChunk(httpRequest, (ChannelBuffer)formFields.get(WalrusProperties.IGNORE_PREFIX + "FirstDataChunk"), contentLength);

				} else if(WalrusProperties.HTTPVerb.PUT.toString().equals(verb) && 

						params.containsKey(WalrusProperties.OperationParameter.logging.toString())) {

					//read logging params

					getTargetBucketParams(operationParams, httpRequest);

				}

			} else {

				operationKey = SERVICE + verb;

			}

		} else {

			//target = object

			operationKey = OBJECT + verb;

			String objectKey="";

			String splitOn = "";

			for(int i = 1; i < target.length; ++i) {

				objectKey += splitOn + target[i];

				splitOn = "/";

			}

			try {

				objectKey = WalrusUtil.URLdecode(objectKey);

			} catch (UnsupportedEncodingException e) {

				throw new BindingException("Unable to get key: " + e.getMessage());

			}

			operationParams.put("Bucket", target[0]);

			operationParams.put("Key", objectKey);

			operationParams.put("Operation", verb.toUpperCase() + "." + "OBJECT");

			if(!params.containsKey(WalrusProperties.OperationParameter.acl.toString())) {

				if (verb.equals(WalrusProperties.HTTPVerb.PUT.toString())) {

					if(httpRequest.containsHeader(WalrusProperties.COPY_SOURCE.toString())) {

						String copySource = httpRequest.getHeader(WalrusProperties.COPY_SOURCE.toString());

						String[] sourceTarget = getTarget(copySource);

						String sourceObjectKey = "";

						String sourceSplitOn = "";

						if(sourceTarget.length > 1) {

							for(int i = 1; i < sourceTarget.length; ++i) {

								sourceObjectKey += sourceSplitOn + sourceTarget[i];

								sourceSplitOn = "/";

							}

							try {

								sourceObjectKey = WalrusUtil.URLdecode(sourceObjectKey);

							} catch (UnsupportedEncodingException e) {

								throw new BindingException("Unable to get source key: " + e.getMessage());

							}

							operationParams.put("SourceBucket", sourceTarget[0]);

							operationParams.put("SourceObject", sourceObjectKey);

							operationParams.put("DestinationBucket", operationParams.remove("Bucket"));

							operationParams.put("DestinationObject", operationParams.remove("Key"));

							String metaDataDirective = httpRequest.getHeader(WalrusProperties.METADATA_DIRECTIVE.toString());

							if(metaDataDirective != null) {

								operationParams.put("MetadataDirective", metaDataDirective);

							}

							AccessControlListType accessControlList;

							if(contentLength > 0) {

								accessControlList = null;

								accessControlList = getAccessControlList(httpRequest);

							} else {

								accessControlList = new AccessControlListType();

							}

							operationParams.put("AccessControlList", accessControlList);

							operationKey += WalrusProperties.COPY_SOURCE.toString();

							Set<String> headerNames = httpRequest.getHeaderNames();

							for(String key : headerNames) {

								for(WalrusProperties.CopyHeaders header: WalrusProperties.CopyHeaders.values()) {

									if(key.replaceAll("-", "").equals(header.toString().toLowerCase())) {

										String value = httpRequest.getHeader(key);

										parseExtendedHeaders(operationParams, header.toString(), value);

									}

								}

							}

						} else {

							throw new BindingException("Malformed COPY request");

						}

					} else {

						//handle PUTs

						key = target[0] + "." + objectKey;

						randomKey = key + "." + Hashes.getRandom(10);

						String contentType = httpRequest.getHeader(WalrusProperties.CONTENT_TYPE);

						if(contentType != null)

							operationParams.put("ContentType", contentType);

						String contentDisposition = httpRequest.getHeader("Content-Disposition");

						if(contentDisposition != null)

							operationParams.put("ContentDisposition", contentDisposition);

						if(contentLengthString != null)

							operationParams.put("ContentLength", (new Long(contentLength).toString()));

						operationParams.put(WalrusProperties.Headers.RandomKey.toString(), randomKey);

						putQueue = getWriteMessenger().interruptAllAndGetQueue(key, randomKey);

						handleFirstChunk(httpRequest, contentLength);

					}

				} else if(verb.equals(WalrusProperties.HTTPVerb.GET.toString())) {

					if(!walrusInternalOperation) {

						if(params.containsKey("torrent")) {

							operationParams.put("GetTorrent", Boolean.TRUE);

						} else {

							operationParams.put("GetData", Boolean.TRUE);

							operationParams.put("InlineData", Boolean.FALSE);

							operationParams.put("GetMetaData", Boolean.TRUE);

						}

						Set<String> headerNames = httpRequest.getHeaderNames();

						boolean isExtendedGet = false;

						for(String key : headerNames) {

							for(WalrusProperties.ExtendedGetHeaders header: WalrusProperties.ExtendedGetHeaders.values()) {

								if(key.replaceAll("-", "").equals(header.toString())) {

									String value = httpRequest.getHeader(key);

									isExtendedGet = true;

									parseExtendedHeaders(operationParams, header.toString(), value);

								}

							}

						}

						if(isExtendedGet) {

							operationKey += "extended";

							//only supported through SOAP

							operationParams.put("ReturnCompleteObjectOnConditionFailure", Boolean.FALSE);

						}

					} 

					if(params.containsKey(WalrusProperties.GetOptionalParameters.IsCompressed.toString())) {

						Boolean isCompressed = Boolean.parseBoolean(params.remove(WalrusProperties.GetOptionalParameters.IsCompressed.toString()));

						operationParams.put("IsCompressed", isCompressed);

					}

				} else if(verb.equals(WalrusProperties.HTTPVerb.HEAD.toString())) {