// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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 com.cloud.bridge.service.controller.s3;
import java.util.Calendar;
import org.apache.axis2.AxisFault;
import org.apache.log4j.Logger;
import com.amazon.s3.AccessControlList;
import com.amazon.s3.AccessControlPolicy;
import com.amazon.s3.AmazonS3SkeletonInterface;
import com.amazon.s3.CanonicalUser;
import com.amazon.s3.CopyObject;
import com.amazon.s3.CopyObjectResponse;
import com.amazon.s3.CopyObjectResult;
import com.amazon.s3.CreateBucket;
import com.amazon.s3.CreateBucketResponse;
import com.amazon.s3.CreateBucketResult;
import com.amazon.s3.DeleteBucket;
import com.amazon.s3.DeleteBucketResponse;
import com.amazon.s3.DeleteObject;
import com.amazon.s3.DeleteObjectResponse;
import com.amazon.s3.GetBucketAccessControlPolicy;
import com.amazon.s3.GetBucketAccessControlPolicyResponse;
import com.amazon.s3.GetBucketLoggingStatus;
import com.amazon.s3.GetBucketLoggingStatusResponse;
import com.amazon.s3.GetObject;
import com.amazon.s3.GetObjectAccessControlPolicy;
import com.amazon.s3.GetObjectAccessControlPolicyResponse;
import com.amazon.s3.GetObjectExtended;
import com.amazon.s3.GetObjectExtendedResponse;
import com.amazon.s3.GetObjectResponse;
import com.amazon.s3.GetObjectResult;
import com.amazon.s3.Grant;
import com.amazon.s3.Grantee;
import com.amazon.s3.Group;
import com.amazon.s3.ListAllMyBuckets;
import com.amazon.s3.ListAllMyBucketsEntry;
import com.amazon.s3.ListAllMyBucketsList;
import com.amazon.s3.ListAllMyBucketsResponse;
import com.amazon.s3.ListAllMyBucketsResult;
import com.amazon.s3.ListBucket;
import com.amazon.s3.ListBucketResponse;
import com.amazon.s3.ListBucketResult;
import com.amazon.s3.ListEntry;
import com.amazon.s3.MetadataDirective;
import com.amazon.s3.MetadataEntry;
import com.amazon.s3.Permission;
import com.amazon.s3.PrefixEntry;
import com.amazon.s3.PutObject;
import com.amazon.s3.PutObjectInline;
import com.amazon.s3.PutObjectInlineResponse;
import com.amazon.s3.PutObjectResponse;
import com.amazon.s3.PutObjectResult;
import com.amazon.s3.SetBucketAccessControlPolicy;
import com.amazon.s3.SetBucketAccessControlPolicyResponse;
import com.amazon.s3.SetBucketLoggingStatus;
import com.amazon.s3.SetBucketLoggingStatusResponse;
import com.amazon.s3.SetObjectAccessControlPolicy;
import com.amazon.s3.SetObjectAccessControlPolicyResponse;
import com.amazon.s3.Status;
import com.amazon.s3.StorageClass;
import com.cloud.bridge.model.SAcl;
import com.cloud.bridge.service.core.s3.S3AccessControlList;
import com.cloud.bridge.service.core.s3.S3AccessControlPolicy;
import com.cloud.bridge.service.core.s3.S3CanonicalUser;
import com.cloud.bridge.service.core.s3.S3ConditionalHeaders;
import com.cloud.bridge.service.core.s3.S3CopyObjectRequest;
import com.cloud.bridge.service.core.s3.S3CopyObjectResponse;
import com.cloud.bridge.service.core.s3.S3CreateBucketRequest;
import com.cloud.bridge.service.core.s3.S3CreateBucketResponse;
import com.cloud.bridge.service.core.s3.S3DeleteBucketRequest;
import com.cloud.bridge.service.core.s3.S3DeleteObjectRequest;
import com.cloud.bridge.service.core.s3.S3Engine;
import com.cloud.bridge.service.core.s3.S3GetBucketAccessControlPolicyRequest;
import com.cloud.bridge.service.core.s3.S3GetObjectAccessControlPolicyRequest;
import com.cloud.bridge.service.core.s3.S3GetObjectRequest;
import com.cloud.bridge.service.core.s3.S3GetObjectResponse;
import com.cloud.bridge.service.core.s3.S3Grant;
import com.cloud.bridge.service.core.s3.S3ListAllMyBucketsEntry;
import com.cloud.bridge.service.core.s3.S3ListAllMyBucketsRequest;
import com.cloud.bridge.service.core.s3.S3ListAllMyBucketsResponse;
import com.cloud.bridge.service.core.s3.S3ListBucketObjectEntry;
import com.cloud.bridge.service.core.s3.S3ListBucketPrefixEntry;
import com.cloud.bridge.service.core.s3.S3ListBucketRequest;
import com.cloud.bridge.service.core.s3.S3ListBucketResponse;
import com.cloud.bridge.service.core.s3.S3MetaDataEntry;
import com.cloud.bridge.service.core.s3.S3PutObjectInlineRequest;
import com.cloud.bridge.service.core.s3.S3PutObjectInlineResponse;
import com.cloud.bridge.service.core.s3.S3Response;
import com.cloud.bridge.service.core.s3.S3SetBucketAccessControlPolicyRequest;
import com.cloud.bridge.service.core.s3.S3SetObjectAccessControlPolicyRequest;
import com.cloud.bridge.service.exception.InternalErrorException;
/*
* Implementation of S3 service requests as operations defined by the interface, com.amazon.s3.AmazonS3SkeletonInterface.
* The operations dispatched from this class are of the form of SOAP operations which define business logic to be executed by the request.
* The methods required for S3 services in accordance with the skeleton are either implementations of the following
* getBucketLoggingStatus
* copyObject
* getBucketAccessControlPolicy
* listBucket
* putObject
* createBucket
* listAllMyBuckets
* getObject
* deleteBucket
* setBucketLoggingStatus
* getObjectAccessControlPolicy
* deleteObject
* setBucketAccessControlPolicy
* setObjectAccessControlPolicy
* putObjectInline
* getObjectExtended
* or throw and Axis2 fault otherwise.
* These skeleton methods can be used as the implementation of services to satisfy SOAP calls, but also to provide the output
* to be serialized by the AXIOM XML processor.
*
* */
public class S3SerializableServiceImplementation implements AmazonS3SkeletonInterface {
protected final static Logger logger = Logger.getLogger(S3SerializableServiceImplementation.class);
private S3Engine engine;
public S3SerializableServiceImplementation(S3Engine engine) {
this.engine = engine;
}
public GetBucketLoggingStatusResponse getBucketLoggingStatus(GetBucketLoggingStatus getBucketLoggingStatus) {
throw new UnsupportedOperationException("Unsupported API");
}
public SetBucketLoggingStatusResponse setBucketLoggingStatus(SetBucketLoggingStatus setBucketLoggingStatus) {
throw new UnsupportedOperationException("Unsupported API");
}
public CopyObjectResponse copyObject(CopyObject copyObject) throws AxisFault {
S3CopyObjectRequest request = new S3CopyObjectRequest();
request.setSourceBucketName(copyObject.getSourceBucket());
request.setSourceKey(copyObject.getSourceKey());
request.setDestinationBucketName(copyObject.getDestinationBucket());
request.setDestinationKey(copyObject.getDestinationKey());
MetadataDirective mdd = copyObject.getMetadataDirective();
if (null != mdd)
request.setDataDirective(mdd.getValue());
request.setMetaEntries(toEngineMetaEntries(copyObject.getMetadata()));
request.setAcl(toEngineAccessControlList(copyObject.getAccessControlList()));
S3ConditionalHeaders conds = new S3ConditionalHeaders();
conds.setModifiedSince(copyObject.getCopySourceIfModifiedSince());
conds.setUnModifiedSince(copyObject.getCopySourceIfUnmodifiedSince());
conds.setMatch(copyObject.getCopySourceIfMatch());
conds.setNoneMatch(copyObject.getCopySourceIfNoneMatch());
request.setConditions(conds);
return toCopyObjectResponse(engine.handleRequest(request));
}
public GetBucketAccessControlPolicyResponse getBucketAccessControlPolicy(GetBucketAccessControlPolicy getBucketAccessControlPolicy) {
// TODO - after authentication, we should setup user context
return toGetBucketAccessControlPolicyResponse(engine.handleRequest(toEngineGetBucketAccessControlPolicyRequest(getBucketAccessControlPolicy)));
}
private S3GetBucketAccessControlPolicyRequest toEngineGetBucketAccessControlPolicyRequest(GetBucketAccessControlPolicy getBucketAccessControlPolicy) {
S3GetBucketAccessControlPolicyRequest request = new S3GetBucketAccessControlPolicyRequest();
request.setAccessKey(getBucketAccessControlPolicy.getAWSAccessKeyId());
request.setRequestTimestamp(getBucketAccessControlPolicy.getTimestamp());
request.setSignature(getBucketAccessControlPolicy.getSignature());
request.setBucketName(getBucketAccessControlPolicy.getBucket());
return request;
}
public static GetBucketAccessControlPolicyResponse toGetBucketAccessControlPolicyResponse(S3AccessControlPolicy policy) {
GetBucketAccessControlPolicyResponse response = new GetBucketAccessControlPolicyResponse();
response.setGetBucketAccessControlPolicyResponse(toAccessControlPolicy(policy));
return response;
}
public SetBucketAccessControlPolicyResponse setBucketAccessControlPolicy(SetBucketAccessControlPolicy setBucketAccessControlPolicy) {
S3SetBucketAccessControlPolicyRequest request = new S3SetBucketAccessControlPolicyRequest();
request.setAccessKey(setBucketAccessControlPolicy.getAWSAccessKeyId());
request.setRequestTimestamp(setBucketAccessControlPolicy.getTimestamp());
request.setSignature(setBucketAccessControlPolicy.getSignature());
request.setBucketName(setBucketAccessControlPolicy.getBucket());
request.setAcl(toEngineAccessControlList(setBucketAccessControlPolicy.getAccessControlList()));
SetBucketAccessControlPolicyResponse response = new SetBucketAccessControlPolicyResponse();
return response;
}
public ListBucketResponse listBucket(ListBucket listBucket) {
// after authentication, we should setup user context
return toListBucketResponse(engine.listBucketContents(toEngineListBucketRequest(listBucket), false));
}
private S3ListBucketRequest toEngineListBucketRequest(ListBucket listBucket) {
S3ListBucketRequest request = new S3ListBucketRequest();
request.setAccessKey(listBucket.getAWSAccessKeyId());
request.setRequestTimestamp(listBucket.getTimestamp());
request.setSignature(listBucket.getSignature());
request.setBucketName(listBucket.getBucket());
request.setDelimiter(listBucket.getDelimiter());
request.setMarker(listBucket.getMarker());
request.setMaxKeys(listBucket.getMaxKeys());
request.setPrefix(listBucket.getPrefix());
return request;
}
public static ListBucketResponse toListBucketResponse(S3ListBucketResponse engineResponse) {
ListBucketResponse response = new ListBucketResponse();
ListBucketResult result = new ListBucketResult();
result.setName(engineResponse.getBucketName());
result.setDelimiter(engineResponse.getDelimiter());
result.setPrefix(engineResponse.getPrefix());
result.setMarker(engineResponse.getMarker());
result.setMaxKeys(engineResponse.getMaxKeys());
result.setIsTruncated(engineResponse.isTruncated());
result.setNextMarker(engineResponse.getNextMarker());
result.setCommonPrefixes(toPrefixEntry(engineResponse.getCommonPrefixes()));
result.setContents(toListEntry(engineResponse.getContents()));
response.setListBucketResponse(result);
return response;
}
private static PrefixEntry[] toPrefixEntry(S3ListBucketPrefixEntry[] engineEntries) {
if (engineEntries != null) {
PrefixEntry[] entries = new PrefixEntry[engineEntries.length];
for (int i = 0; i < engineEntries.length; i++) {
entries[i] = new PrefixEntry();
entries[i].setPrefix(engineEntries[i].getPrefix());
}
return entries;
}
return null;
}
private static ListEntry[] toListEntry(S3ListBucketObjectEntry[] engineEntries) {
if (engineEntries != null) {
ListEntry[] entries = new ListEntry[engineEntries.length];
for (int i = 0; i < engineEntries.length; i++) {
entries[i] = new ListEntry();
entries[i].setETag(engineEntries[i].getETag());
entries[i].setKey(engineEntries[i].getKey());
entries[i].setLastModified(engineEntries[i].getLastModified());
entries[i].setSize(engineEntries[i].getSize());
entries[i].setStorageClass(StorageClass.STANDARD);
CanonicalUser owner = new CanonicalUser();
owner.setID(engineEntries[i].getOwnerCanonicalId());
owner.setDisplayName(engineEntries[i].getOwnerDisplayName());
entries[i].setOwner(owner);
}
return entries;
}
return null;
}
public PutObjectResponse putObject(PutObject putObject) {
//TODO : fill this with the necessary business logic
throw new UnsupportedOperationException("Please implement " + this.getClass().getName() + "#putObject");
}
public CreateBucketResponse createBucket(CreateBucket createBucket) {
return toCreateBucketResponse(engine.handleRequest(toEngineCreateBucketRequest(createBucket)));
}
private S3CreateBucketRequest toEngineCreateBucketRequest(CreateBucket createBucket) {
S3CreateBucketRequest request = new S3CreateBucketRequest();
request.setAccessKey(createBucket.getAWSAccessKeyId());
request.setRequestTimestamp(createBucket.getTimestamp());
request.setSignature(createBucket.getSignature());
request.setBucketName(createBucket.getBucket());
request.setAcl(toEngineAccessControlList(createBucket.getAccessControlList()));
return request;
}
private CreateBucketResponse toCreateBucketResponse(S3CreateBucketResponse engineResponse) {
CreateBucketResponse response = new CreateBucketResponse();
CreateBucketResult result = new CreateBucketResult();
result.setBucketName(engineResponse.getBucketName());
response.setCreateBucketReturn(result);
return response;
}
public ListAllMyBucketsResponse listAllMyBuckets(ListAllMyBuckets listAllMyBuckets) {
return toListAllMyBucketsResponse(engine.handleRequest(toEngineListAllMyBucketsRequest(listAllMyBuckets)));
}
private S3ListAllMyBucketsRequest toEngineListAllMyBucketsRequest(ListAllMyBuckets listAllMyBuckets) {
S3ListAllMyBucketsRequest request = new S3ListAllMyBucketsRequest();
request.setAccessKey(listAllMyBuckets.getAWSAccessKeyId());
request.setRequestTimestamp(listAllMyBuckets.getTimestamp());
request.setSignature(listAllMyBuckets.getSignature());
return request;
}
public static ListAllMyBucketsResponse toListAllMyBucketsResponse(S3ListAllMyBucketsResponse engineResponse) {
ListAllMyBucketsResponse response = new ListAllMyBucketsResponse();
ListAllMyBucketsResult result = new ListAllMyBucketsResult();
ListAllMyBucketsEntry[] entries = null;
S3CanonicalUser ownerEngine = engineResponse.getOwner();
CanonicalUser owner = new CanonicalUser();
owner.setID(ownerEngine.getID());
owner.setDisplayName(ownerEngine.getDisplayName());
result.setOwner(owner);
S3ListAllMyBucketsEntry[] engineEntries = engineResponse.getBuckets();
if (engineEntries != null) {
entries = new ListAllMyBucketsEntry[engineEntries.length];
for (int i = 0; i < engineEntries.length; i++) {
entries[i] = new ListAllMyBucketsEntry();
entries[i].setName(engineEntries[i].getName());
entries[i].setCreationDate(engineEntries[i].getCreationDate()); //setTimeZone(TimeZone.getTimeZone("Z"));
}
ListAllMyBucketsList list = new ListAllMyBucketsList();
list.setBucket(entries);
result.setBuckets(list);
}
response.setListAllMyBucketsResponse(result);
return response;
}
public DeleteBucketResponse deleteBucket(DeleteBucket deleteBucket) {
return toDeleteBucketResponse(engine.handleRequest(toEngineDeleteBucketRequest(deleteBucket)));
}
private S3DeleteBucketRequest toEngineDeleteBucketRequest(DeleteBucket deleteBucket) {
S3DeleteBucketRequest request = new S3DeleteBucketRequest();
request.setAccessKey(deleteBucket.getAWSAccessKeyId());
request.setRequestTimestamp(deleteBucket.getTimestamp());
request.setSignature(deleteBucket.getSignature());
request.setBucketName(deleteBucket.getBucket());
return request;
}
private DeleteBucketResponse toDeleteBucketResponse(S3Response engineResponse) {
DeleteBucketResponse response = new DeleteBucketResponse();
Status status = new Status();
status.setCode(engineResponse.getResultCode());
status.setDescription(engineResponse.getResultDescription());
response.setDeleteBucketResponse(status);
return response;
}
public GetObjectResponse getObject(com.amazon.s3.GetObject getObject) {
return toGetObjectResponse(engine.handleRequest(toEngineGetObjectRequest(getObject)));
}
public GetObjectExtendedResponse getObjectExtended(GetObjectExtended getObjectExtended) {
return toGetObjectExtendedResponse(engine.handleRequest(toEngineGetObjectRequest(getObjectExtended)));
}
private S3GetObjectRequest toEngineGetObjectRequest(GetObject getObject) {
S3GetObjectRequest request = new S3GetObjectRequest();
request.setAccessKey(getObject.getAWSAccessKeyId());
request.setRequestTimestamp(getObject.getTimestamp());
request.setSignature(getObject.getSignature());
request.setBucketName(getObject.getBucket());
request.setKey(getObject.getKey());
request.setReturnData(getObject.getGetData());
request.setReturnMetadata(getObject.getGetMetadata());
request.setInlineData(getObject.getInlineData());
return request;
}
private S3GetObjectRequest toEngineGetObjectRequest(GetObjectExtended getObjectExtended) {
S3GetObjectRequest request = new S3GetObjectRequest();
request.setAccessKey(getObjectExtended.getAWSAccessKeyId());
request.setRequestTimestamp(getObjectExtended.getTimestamp());
request.setSignature(getObjectExtended.getSignature());
request.setBucketName(getObjectExtended.getBucket());
request.setKey(getObjectExtended.getKey());
request.setReturnData(getObjectExtended.getGetData());
request.setReturnMetadata(getObjectExtended.getGetMetadata());
request.setInlineData(getObjectExtended.getInlineData());
S3ConditionalHeaders conds = new S3ConditionalHeaders();
conds.setModifiedSince(getObjectExtended.getIfModifiedSince());
conds.setUnModifiedSince(getObjectExtended.getIfUnmodifiedSince());
conds.setMatch(getObjectExtended.getIfMatch());
conds.setNoneMatch(getObjectExtended.getIfNoneMatch());
request.setConditions(conds);
request.setByteRangeStart(getObjectExtended.getByteRangeStart());
request.setByteRangeEnd(getObjectExtended.getByteRangeEnd());
request.setReturnCompleteObjectOnConditionFailure(getObjectExtended.getReturnCompleteObjectOnConditionFailure());
return request;
}
private GetObjectResponse toGetObjectResponse(S3GetObjectResponse engineResponse) {
GetObjectResponse response = new GetObjectResponse();
int resultCode = engineResponse.getResultCode();
GetObjectResult result = new GetObjectResult();
Status param1 = new Status();
param1.setCode(resultCode);
param1.setDescription(engineResponse.getResultDescription());
result.setStatus(param1);
if (200 == resultCode) {
result.setData(engineResponse.getData());
result.setETag(engineResponse.getETag());
result.setMetadata(toMetadataEntry(engineResponse.getMetaEntries()));
result.setLastModified(engineResponse.getLastModified());
} else {
result.setETag("");
result.setLastModified(Calendar.getInstance());
}
response.setGetObjectResponse(result);
return response;
}
private GetObjectExtendedResponse toGetObjectExtendedResponse(S3GetObjectResponse engineResponse) {
GetObjectExtendedResponse response = new GetObjectExtendedResponse();
int resultCode = engineResponse.getResultCode();
GetObjectResult result = new GetObjectResult();
Status param1 = new Status();
param1.setCode(resultCode);
param1.setDescription(engineResponse.getResultDescription());
result.setStatus(param1);
if (200 == resultCode || 206 == resultCode) {
result.setData(engineResponse.getData());
result.setETag(engineResponse.getETag());
result.setMetadata(toMetadataEntry(engineResponse.getMetaEntries()));
result.setLastModified(engineResponse.getLastModified());
} else {
result.setETag("");
result.setLastModified(Calendar.getInstance());
}
response.setGetObjectResponse(result);
return response;
}
private MetadataEntry[] toMetadataEntry(S3MetaDataEntry[] engineEntries) {
if (engineEntries != null) {
MetadataEntry[] entries = new MetadataEntry[engineEntries.length];
for (int i = 0; i < engineEntries.length; i++) {
entries[i] = new MetadataEntry();
entries[i].setName(engineEntries[i].getName());
entries[i].setValue(engineEntries[i].getValue());
}
return entries;
}
return null;
}
public GetObjectAccessControlPolicyResponse getObjectAccessControlPolicy(GetObjectAccessControlPolicy getObjectAccessControlPolicy) {
return toGetObjectAccessControlPolicyResponse(engine.handleRequest(toEngineGetObjectAccessControlPolicyRequest(getObjectAccessControlPolicy)));
}
private S3GetObjectAccessControlPolicyRequest toEngineGetObjectAccessControlPolicyRequest(GetObjectAccessControlPolicy getObjectAccessControlPolicy) {
S3GetObjectAccessControlPolicyRequest request = new S3GetObjectAccessControlPolicyRequest();
request.setAccessKey(getObjectAccessControlPolicy.getAWSAccessKeyId());
request.setRequestTimestamp(getObjectAccessControlPolicy.getTimestamp());
request.setSignature(getObjectAccessControlPolicy.getSignature());
request.setBucketName(getObjectAccessControlPolicy.getBucket());
request.setKey(getObjectAccessControlPolicy.getKey());
return request;
}
public static GetObjectAccessControlPolicyResponse toGetObjectAccessControlPolicyResponse(S3AccessControlPolicy policy) {
GetObjectAccessControlPolicyResponse response = new GetObjectAccessControlPolicyResponse();
response.setGetObjectAccessControlPolicyResponse(toAccessControlPolicy(policy));
return response;
}
private static AccessControlPolicy toAccessControlPolicy(S3AccessControlPolicy enginePolicy) {
AccessControlPolicy policy = new AccessControlPolicy();
CanonicalUser owner = new CanonicalUser();
owner.setID(enginePolicy.getOwner().getID());
owner.setDisplayName(enginePolicy.getOwner().getDisplayName());
policy.setOwner(owner);
AccessControlList acl = new AccessControlList();
acl.setGrant(toGrants(enginePolicy.getGrants()));
policy.setAccessControlList(acl);
return policy;
}
public DeleteObjectResponse deleteObject(DeleteObject deleteObject) {
return toDeleteObjectResponse(engine.handleRequest(toEngineDeleteObjectRequest(deleteObject)));
}
private S3DeleteObjectRequest toEngineDeleteObjectRequest(DeleteObject deleteObject) {
S3DeleteObjectRequest request = new S3DeleteObjectRequest();
request.setAccessKey(deleteObject.getAWSAccessKeyId());
request.setRequestTimestamp(deleteObject.getTimestamp());
request.setSignature(deleteObject.getSignature());
request.setBucketName(deleteObject.getBucket());
request.setKey(deleteObject.getKey());
return request;
}
private DeleteObjectResponse toDeleteObjectResponse(S3Response engineResponse) {
DeleteObjectResponse response = new DeleteObjectResponse();
Status status = new Status();
status.setCode(engineResponse.getResultCode());
status.setDescription(engineResponse.getResultDescription());
response.setDeleteObjectResponse(status);
return response;
}
public SetObjectAccessControlPolicyResponse setObjectAccessControlPolicy(SetObjectAccessControlPolicy setObjectAccessControlPolicy) {
S3SetObjectAccessControlPolicyRequest request = new S3SetObjectAccessControlPolicyRequest();
request.setAccessKey(setObjectAccessControlPolicy.getAWSAccessKeyId());
request.setRequestTimestamp(setObjectAccessControlPolicy.getTimestamp());
request.setSignature(setObjectAccessControlPolicy.getSignature());
request.setBucketName(setObjectAccessControlPolicy.getBucket());
request.setKey(setObjectAccessControlPolicy.getKey());
request.setAcl(toEngineAccessControlList(setObjectAccessControlPolicy.getAccessControlList()));
engine.handleRequest(request);
SetObjectAccessControlPolicyResponse response = new SetObjectAccessControlPolicyResponse();
return response;
}
public PutObjectInlineResponse putObjectInline(PutObjectInline putObjectInline) {
return toPutObjectInlineResponse(engine.handleRequest(toEnginePutObjectInlineRequest(putObjectInline)));
}
private S3PutObjectInlineRequest toEnginePutObjectInlineRequest(PutObjectInline putObjectInline) {
S3PutObjectInlineRequest request = new S3PutObjectInlineRequest();
request.setAccessKey(putObjectInline.getAWSAccessKeyId());
request.setRequestTimestamp(putObjectInline.getTimestamp());
request.setSignature(putObjectInline.getSignature());
request.setBucketName(putObjectInline.getBucket());
request.setContentLength(putObjectInline.getContentLength());
request.setKey(putObjectInline.getKey());
request.setData(putObjectInline.getData());
request.setMetaEntries(toEngineMetaEntries(putObjectInline.getMetadata()));
request.setAcl(toEngineAccessControlList(putObjectInline.getAccessControlList()));
return request;
}
private S3MetaDataEntry[] toEngineMetaEntries(MetadataEntry[] metaEntries) {
if (metaEntries != null) {
S3MetaDataEntry[] engineMetaEntries = new S3MetaDataEntry[metaEntries.length];
for (int i = 0; i < metaEntries.length; i++) {
engineMetaEntries[i] = new S3MetaDataEntry();
engineMetaEntries[i].setName(metaEntries[i].getName());
engineMetaEntries[i].setValue(metaEntries[i].getValue());
}
return engineMetaEntries;
}
return null;
}
private S3AccessControlList toEngineAccessControlList(AccessControlList acl) {
if (acl == null)
return null;
S3AccessControlList engineAcl = new S3AccessControlList();
Grant[] grants = acl.getGrant();
if (grants != null) {
for (Grant grant : grants) {
S3Grant engineGrant = new S3Grant();
Grantee grantee = grant.getGrantee();
if (grantee instanceof CanonicalUser) {
engineGrant.setGrantee(SAcl.GRANTEE_USER);
engineGrant.setCanonicalUserID(((CanonicalUser)grantee).getID());
} else if (grantee instanceof Group) {
Group temp = (Group)grantee;
String uri = temp.getURI();
if (uri.equalsIgnoreCase("http://acs.amazonaws.com/groups/global/AllUsers")) {
// -> this allows all public unauthenticated access based on permission given
engineGrant.setGrantee(SAcl.GRANTEE_ALLUSERS);
engineGrant.setCanonicalUserID("*");
} else if (uri.equalsIgnoreCase("http://acs.amazonaws.com/groups/global/Authenticated")) {
// -> this allows any authenticated user access based on permission given
engineGrant.setGrantee(SAcl.GRANTEE_AUTHENTICATED);
engineGrant.setCanonicalUserID("A");
} else
throw new UnsupportedOperationException("Unsupported grantee group URI: " + uri);
} else
throw new UnsupportedOperationException("Unsupported grantee type: " + grantee.getClass().getCanonicalName());
Permission permission = grant.getPermission();
String permissionValue = permission.getValue();
if (permissionValue.equalsIgnoreCase("READ")) {
engineGrant.setPermission(SAcl.PERMISSION_READ);
} else if (permissionValue.equalsIgnoreCase("WRITE")) {
engineGrant.setPermission(SAcl.PERMISSION_WRITE);
} else if (permissionValue.equalsIgnoreCase("READ_ACP")) {
engineGrant.setPermission(SAcl.PERMISSION_READ_ACL);
} else if (permissionValue.equalsIgnoreCase("WRITE_ACP")) {
engineGrant.setPermission(SAcl.PERMISSION_WRITE_ACL);
} else if (permissionValue.equalsIgnoreCase("FULL_CONTROL")) {
engineGrant.setPermission(SAcl.PERMISSION_FULL);
} else {
throw new UnsupportedOperationException("Unsupported permission: " + permissionValue);
}
engineAcl.addGrant(engineGrant);
}
}
return engineAcl;
}
private static Grant[] toGrants(S3Grant[] engineGrants) {
Grantee grantee = null;
Grant[] grants = null;
if (engineGrants != null && 0 < engineGrants.length) {
grants = new Grant[engineGrants.length];
for (int i = 0; i < engineGrants.length; i++) {
grants[i] = new Grant();
switch (engineGrants[i].getGrantee()) {
case SAcl.GRANTEE_USER:
grantee = new CanonicalUser();
((CanonicalUser)grantee).setID(engineGrants[i].getCanonicalUserID());
((CanonicalUser)grantee).setDisplayName("TODO");
grants[i].setGrantee(grantee);
break;
case SAcl.GRANTEE_ALLUSERS:
grantee = new Group();
((Group)grantee).setURI("http://acs.amazonaws.com/groups/global/AllUsers");
grants[i].setGrantee(grantee);
break;
case SAcl.GRANTEE_AUTHENTICATED:
grantee = new Group();
((Group)grantee).setURI("http://acs.amazonaws.com/groups/global/Authenticated");
grants[i].setGrantee(grantee);
break;
default:
throw new InternalErrorException("Unsupported grantee type");
}
switch (engineGrants[i].getPermission()) {
case SAcl.PERMISSION_READ:
grants[i].setPermission(Permission.READ);
break;
case SAcl.PERMISSION_WRITE:
grants[i].setPermission(Permission.WRITE);
break;
case SAcl.PERMISSION_READ_ACL:
grants[i].setPermission(Permission.READ_ACP);
break;
case SAcl.PERMISSION_WRITE_ACL:
grants[i].setPermission(Permission.WRITE_ACP);
break;
case SAcl.PERMISSION_FULL:
grants[i].setPermission(Permission.FULL_CONTROL);
break;
}
}
return grants;
}
return null;
}
private PutObjectInlineResponse toPutObjectInlineResponse(S3PutObjectInlineResponse engineResponse) {
PutObjectInlineResponse response = new PutObjectInlineResponse();
PutObjectResult result = new PutObjectResult();
result.setETag(engineResponse.getETag());
result.setLastModified(engineResponse.getLastModified());
response.setPutObjectInlineResponse(result);
return response;
}
public static CopyObjectResponse toCopyObjectResponse(S3CopyObjectResponse engineResponse) throws AxisFault {
CopyObjectResponse response = new CopyObjectResponse();
int resultCode = engineResponse.getResultCode();
CopyObjectResult result = new CopyObjectResult();
if (300 <= resultCode) {
String description = engineResponse.getResultDescription();
throw new AxisFault("" + resultCode, (null == description ? "" : description));
}
result.setETag("\"" + engineResponse.getETag() + "\"");
result.setLastModified(engineResponse.getLastModified());
response.setCopyObjectResult(result);
return response;
}
}