// 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.

* The CRUD control actions to be invoked from S3BucketAction or S3ObjectAction.

*/

    protected final static Logger logger = Logger.getLogger(S3Engine.class);

    protected final SHostDao shostDao = ComponentLocator.inject(SHostDaoImpl.class);

    protected final MHostDao mhostDao = ComponentLocator.inject(MHostDaoImpl.class);

    protected final static BucketPolicyDao bPolicy = ComponentLocator.inject(BucketPolicyDaoImpl.class);

    protected final BucketPolicyDao bPolicyDao = ComponentLocator.inject(BucketPolicyDaoImpl.class);

    protected final SBucketDao bucketDao = ComponentLocator.inject(SBucketDaoImpl.class); 

    protected final SAclDao aclDao = ComponentLocator.inject(SAclDaoImpl.class);

    protected final static SAclDao saclDao = ComponentLocator.inject(SAclDaoImpl.class);

    protected final SObjectDao objectDao = ComponentLocator.inject(SObjectDaoImpl.class);

    protected final SObjectItemDao itemDao = ComponentLocator.inject(SObjectItemDaoImpl.class);

    protected final SMetaDao metaDao = ComponentLocator.inject(SMetaDaoImpl.class);

    protected final MHostMountDao mountDao = ComponentLocator.inject(MHostMountDaoImpl.class);

    private final int LOCK_ACQUIRING_TIMEOUT_SECONDS = 10;    // ten seconds

    private final Map<Integer, S3BucketAdapter> bucketAdapters = new HashMap<Integer, S3BucketAdapter>();

   

    public S3Engine() {

      bucketAdapters.put(SHost.STORAGE_HOST_TYPE_LOCAL, new S3FileSystemBucketAdapter());

        bucketAdapters.put(SHost.STORAGE_HOST_TYPE_CASTOR, new S3CAStorBucketAdapter());

    }

   

   

    /**

     * Return a S3CopyObjectResponse which represents an object being copied from source

     * to destination bucket.   

     * Called from S3ObjectAction when copying an object.

     * This can be treated as first a GET followed by a PUT of the object the user wants to copy.

     */

   

  public S3CopyObjectResponse handleRequest(S3CopyObjectRequest request)

  {

    S3CopyObjectResponse response = new S3CopyObjectResponse();

   

    // [A] Get the object we want to copy

    S3GetObjectRequest getRequest = new S3GetObjectRequest();

    getRequest.setBucketName(request.getSourceBucketName());

    getRequest.setKey(request.getSourceKey());

    getRequest.setVersion(request.getVersion());

    getRequest.setConditions( request.getConditions());

    getRequest.setInlineData( true );

    getRequest.setReturnData( true );

    if ( MetadataDirective.COPY == request.getDirective())

         getRequest.setReturnMetadata( true );

    else getRequest.setReturnMetadata( false );   

     

    //-> before we do anything verify the permissions on a copy basis

    String  destinationBucketName = request.getDestinationBucketName();

    String  destinationKeyName = request.getDestinationKey();

    S3PolicyContext context = new S3PolicyContext( PolicyActions.PutObject, destinationBucketName );

    context.setKeyName( destinationKeyName );

    context.setEvalParam( ConditionKeys.MetaData, request.getDirective().toString());

    context.setEvalParam( ConditionKeys.CopySource, "/" + request.getSourceBucketName() + "/" + request.getSourceKey());

    if (PolicyAccess.DENY == verifyPolicy( context ))

            throw new PermissionDeniedException( "Access Denied - bucket policy DENY result" );

           

      S3GetObjectResponse originalObject = handleRequest(getRequest);  

      int resultCode = originalObject.getResultCode();

      if (200 != resultCode) {

        response.setResultCode( resultCode );

        response.setResultDescription( originalObject.getResultDescription());

        return response;

      }

           

      response.setCopyVersion( originalObject.getVersion());

     

      // [B] Put the object into the destination bucket

      S3PutObjectInlineRequest putRequest = new S3PutObjectInlineRequest();

      putRequest.setBucketName(request.getDestinationBucketName()) ;

      putRequest.setKey(destinationKeyName);

    if ( MetadataDirective.COPY == request.getDirective())

       putRequest.setMetaEntries(originalObject.getMetaEntries());

    else putRequest.setMetaEntries(request.getMetaEntries()); 

      putRequest.setAcl(request.getAcl());                    // -> if via a SOAP call

      putRequest.setCannedAccess(request.getCannedAccess());  // -> if via a REST call

      putRequest.setContentLength(originalObject.getContentLength());

      putRequest.setData(originalObject.getData());

      S3PutObjectInlineResponse putResp = handleRequest(putRequest); 

      response.setResultCode( putResp.resultCode );

      response.setResultDescription( putResp.getResultDescription());

    response.setETag( putResp.getETag());

    response.setLastModified( putResp.getLastModified());

    response.setPutVersion( putResp.getVersion());

    return response;

  }

    public S3CreateBucketResponse handleRequest(S3CreateBucketRequest request)

    {

      S3CreateBucketResponse response = new S3CreateBucketResponse();

    String cannedAccessPolicy = request.getCannedAccess();

      String bucketName = request.getBucketName();

      response.setBucketName( bucketName );

      Transaction txn= null;

    verifyBucketName( bucketName, false );

  

    S3PolicyContext context = new S3PolicyContext( PolicyActions.CreateBucket,  bucketName );

    context.setEvalParam( ConditionKeys.Acl, cannedAccessPolicy );

    if (PolicyAccess.DENY == verifyPolicy( context ))

            throw new PermissionDeniedException( "Access Denied - bucket policy DENY result" );

        OrderedPair<SHostVO, String> shost_storagelocation_pair = null;

        boolean success = false;

        try {

            txn = Transaction.open(Transaction.AWSAPI_DB);

            if (bucketDao.getByName(request.getBucketName()) != null)

                throw new ObjectAlreadyExistsException("Bucket already exists");

            shost_storagelocation_pair = allocBucketStorageHost(

                    request.getBucketName(), null);

            SBucketVO sbucket = new SBucketVO(request.getBucketName(),

                    DateHelper.currentGMTTime(), UserContext.current()

                            .getCanonicalUserId(),

                    shost_storagelocation_pair.getFirst());

            shost_storagelocation_pair.getFirst().getBuckets().add(sbucket);

            // bucketDao.save(sbucket);

            sbucket = bucketDao.persist(sbucket);

            S3AccessControlList acl = request.getAcl();

            if (null != cannedAccessPolicy)

                setCannedAccessControls(cannedAccessPolicy, "SBucket",

                        sbucket.getId(), sbucket);

            else if (null != acl)

                aclDao.save("SBucket", sbucket.getId(), acl);

            else

                setSingleAcl("SBucket", sbucket.getId(), SAcl.PERMISSION_FULL);

            success = true;

        } finally {

            if (!success && shost_storagelocation_pair != null) {

                S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(shost_storagelocation_pair

                        .getFirst());

                bucketAdapter.deleteContainer(

                        shost_storagelocation_pair.getSecond(),

                        request.getBucketName());

            }

            txn.rollback();

            txn.close();

        }

    return response;

    }

   

    /**

     * Return a S3Response which represents the effect of an object being deleted from its bucket.   

     * Called from S3BucketAction when deleting an object.

     */

   

    public S3Response handleRequest( S3DeleteBucketRequest request )

    {

        S3Response response  = new S3Response();

    //

    String bucketName = request.getBucketName();

    SBucketVO sbucket   = bucketDao.getByName(bucketName);

   

    Transaction txn = null;

    if ( sbucket != null )

    { 

        txn = Transaction.open(Transaction.AWSAPI_DB);

        txn.start();

        S3PolicyContext context = new S3PolicyContext( PolicyActions.DeleteBucket, bucketName );

        switch( verifyPolicy( context ))

        {

            case ALLOW:

                // The bucket policy can give users permission to delete a

                // bucket whereas ACLs cannot

                break;

            case DENY:

                throw new PermissionDeniedException(

                        "Access Denied - bucket policy DENY result");

            case DEFAULT_DENY:

            default:

                // Irrespective of what the ACLs say, only the owner can delete

                // a bucket

                String client = UserContext.current().getCanonicalUserId();

                if (!client.equals(sbucket.getOwnerCanonicalId())) {

                    throw new PermissionDeniedException(

                            "Access Denied - only the owner can delete a bucket");

                }

                break;

            }

       

       // Delete the file from its storage location

       OrderedPair<SHostVO, String> host_storagelocation_pair = getBucketStorageHost(sbucket);

       S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(host_storagelocation_pair.getFirst());

       bucketAdapter.deleteContainer(host_storagelocation_pair.getSecond(), request.getBucketName());

     

       // Cascade-deleting can delete related SObject/SObjectItem objects, but not SAcl, SMeta and policy objects.

       // To delete SMeta & SAcl objects:

       // (1)Get all the objects in the bucket,

       // (2)then all the items in each object,

       // (3) then all meta & acl data for each item

       Set<SObjectVO> objectsInBucket = sbucket.getObjectsInBucket();

       Iterator<SObjectVO> it = objectsInBucket.iterator();

       while( it.hasNext())

       {

         SObjectVO oneObject = (SObjectVO)it.next();

        Set<SObjectItemVO> itemsInObject = oneObject.getItems();

        Iterator<SObjectItemVO> is = itemsInObject.iterator();

        while( is.hasNext())

        {

                    SObjectItemVO oneItem = (SObjectItemVO) is.next();

                    deleteMetaData(oneItem.getId());

                    deleteObjectAcls("SObjectItem", oneItem.getId());

        }       

       }

        

       // Delete all the policy state associated with the bucket

       try {

                ServiceProvider.getInstance().deleteBucketPolicy(bucketName);

                bPolicyDao.deletePolicy(bucketName);

       } catch( Exception e ) {

           logger.error("When deleting a bucket we must try to delete its policy: ", e);

       }

      

       deleteBucketAcls( sbucket.getId());

       bucketDao.remove(sbucket.getId());

      

 

       response.setResultCode(204);

       response.setResultDescription("OK");

      

       txn.close();

    }

    else

    {    response.setResultCode(404);

       response.setResultDescription("Bucket does not exist");

    }

      return response;

    }

   

    /**

     * Return a S3ListBucketResponse which represents a list of up to 1000 objects contained ins  the bucket.   

     * Called from S3BucketAction for GETting objects and for GETting object versions.

     */

   

    public S3ListBucketResponse listBucketContents(S3ListBucketRequest request, boolean includeVersions)

    {

      S3ListBucketResponse response = new S3ListBucketResponse();

    String bucketName = request.getBucketName();

    String prefix = request.getPrefix();

    if (prefix == null) prefix = StringHelper.EMPTY_STRING;

    String marker = request.getMarker();

    if (marker == null)  marker = StringHelper.EMPTY_STRING;

     

    String delimiter = request.getDelimiter();

    int maxKeys = request.getMaxKeys();

    if(maxKeys <= 0) maxKeys = 1000;

   

    //

    SBucketVO sbucket = bucketDao.getByName(bucketName);

    if (sbucket == null) throw new NoSuchObjectException("Bucket " + bucketName + " does not exist");

    PolicyActions action = (includeVersions ? PolicyActions.ListBucketVersions : PolicyActions.ListBucket);

    S3PolicyContext context = new S3PolicyContext( action, bucketName );

    context.setEvalParam( ConditionKeys.MaxKeys, new String( "" + maxKeys ));

    context.setEvalParam( ConditionKeys.Prefix, prefix );

    context.setEvalParam( ConditionKeys.Delimiter, delimiter );

    verifyAccess( context, "SBucket", sbucket.getId(), SAcl.PERMISSION_READ );

   

    // Wen execting the query, request one more item so that we know how to set isTruncated flag

    List<SObjectVO> l = null;

   

    if ( includeVersions )

        l = objectDao.listAllBucketObjects( sbucket, prefix, marker, maxKeys+1 );

    else l = objectDao.listBucketObjects( sbucket, prefix, marker, maxKeys+1 );

   

    response.setBucketName(bucketName);

    response.setMarker(marker);

    response.setMaxKeys(maxKeys);

    response.setPrefix(prefix);

    response.setDelimiter(delimiter);

    if (null != l ) {

        response.setTruncated(l.size() > maxKeys);

        if(l.size() > maxKeys) {

          response.setNextMarker(l.get(l.size() - 1).getNameKey());

        }

    }

    // If needed - SOAP response does not support versioning

    response.setContents( composeListBucketContentEntries(l, prefix, delimiter, maxKeys, includeVersions, request.getVersionIdMarker()));

    response.setCommonPrefixes( composeListBucketPrefixEntries(l, prefix, delimiter, maxKeys));

    return response;

    }

   

    /**

     * Return a S3ListAllMyBucketResponse which represents a list of all buckets owned by the requester.   

     * Called from S3BucketAction for GETting all buckets.

     * To check on bucket policies defined we have to (look for and) evaluate the policy on each

     * bucket the user owns.

     */

    public S3ListAllMyBucketsResponse handleRequest(S3ListAllMyBucketsRequest request)

    {

      S3ListAllMyBucketsResponse response = new S3ListAllMyBucketsResponse();    

     

      // "...you can only list buckets for which you are the owner."

      List<SBucketVO> buckets = bucketDao.listBuckets(UserContext.current().getCanonicalUserId());

      S3CanonicalUser owner = new S3CanonicalUser();

      owner.setID(UserContext.current().getCanonicalUserId());

      owner.setDisplayName("");

      response.setOwner(owner);

     

      if (buckets != null)

      {

        S3ListAllMyBucketsEntry[] entries = new S3ListAllMyBucketsEntry[buckets.size()];

        int i = 0;

        for(SBucketVO bucket : buckets)

        { 

          String bucketName = bucket.getName();

          S3PolicyContext context = new S3PolicyContext( PolicyActions.ListAllMyBuckets, bucketName );

          verifyAccess( context, "SBucket", bucket.getId(), SAcl.PERMISSION_PASS );

      

          entries[i] = new S3ListAllMyBucketsEntry();

          entries[i].setName(bucketName);

          entries[i].setCreationDate(DateHelper.toCalendar(bucket.getCreateTime()));

          i++;

        }      

        response.setBuckets(entries);

      }    

      return response;

    }

   

    /**

     * Return an S3Response representing the result of PUTTING the ACL of a given bucket.

     * Called from S3BucketAction to PUT its ACL.

     */

   

    public S3Response handleRequest(S3SetBucketAccessControlPolicyRequest request)

    {

      S3Response response = new S3Response(); 

      String bucketName = request.getBucketName();

      SBucketVO sbucket = bucketDao.getByName(bucketName);

      if(sbucket == null) {

        response.setResultCode(404);

        response.setResultDescription("Bucket does not exist");

        return response;

      }

     

      S3PolicyContext context = new S3PolicyContext( PolicyActions.PutBucketAcl, bucketName );

      verifyAccess( context, "SBucket", sbucket.getId(), SAcl.PERMISSION_WRITE_ACL );

      aclDao.save("SBucket", sbucket.getId(), request.getAcl());

    

      response.setResultCode(200);

      response.setResultDescription("OK");

      return response;

    }

   

   

    /**

     * Return a S3AccessControlPolicy representing the ACL of a given bucket.

     * Called from S3BucketAction to GET its ACL.

     */

   

    public S3AccessControlPolicy handleRequest(S3GetBucketAccessControlPolicyRequest request)

    {

      S3AccessControlPolicy policy = new S3AccessControlPolicy();    

      String bucketName = request.getBucketName();

      SBucketVO sbucket = bucketDao.getByName( bucketName );

      if (sbucket == null)

        throw new NoSuchObjectException("Bucket " + bucketName + " does not exist");

     

      S3CanonicalUser owner = new S3CanonicalUser();

      owner.setID(sbucket.getOwnerCanonicalId());

      owner.setDisplayName("");

      policy.setOwner(owner);

     

      S3PolicyContext context = new S3PolicyContext( PolicyActions.GetBucketAcl, bucketName );

      verifyAccess( context, "SBucket", sbucket.getId(), SAcl.PERMISSION_READ_ACL );

      List<SAclVO> grants = aclDao.listGrants("SBucket", sbucket.getId());

      policy.setGrants(S3Grant.toGrants(grants));   

      return policy;

    }

   

    /**

     * This method should be called if a multipart upload is aborted OR has completed successfully and

     * the individual parts have to be cleaned up.

     * Called from S3ObjectAction when executing at completion or when aborting multipart upload.

     * @param bucketName

     * @param uploadId

     * @param verifyPermissiod - If false then do not check the user's permission to clean up the state

     */

    public int freeUploadParts(String bucketName, int uploadId, boolean verifyPermission) {

 

  // -> we need to look up the final bucket to figure out which mount

  // point to use to save the part in

  // SBucketDao bucketDao = new SBucketDao();

  SBucketVO bucket = bucketDao.getByName(bucketName);

  if (bucket == null) {

      logger.error("initiateMultipartUpload failed since " + bucketName

        + " does not exist");

      return 404;

  }

  OrderedPair<SHostVO, String> host_storagelocation_pair = getBucketStorageHost(bucket);

  S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(host_storagelocation_pair.getFirst());

  try {

      MultipartLoadDao uploadDao = new MultipartLoadDao();

      OrderedPair<String, String> exists = uploadDao.multipartExits(uploadId);

     

      if (null == exists) {

    logger.error("initiateMultipartUpload failed since multipart upload"

      + uploadId + " does not exist");

    return 404;

      }

      // -> the multipart initiator or bucket owner can do this action by

      // default

      if (verifyPermission) {

    String initiator = uploadDao.getInitiator(uploadId);

    if (null == initiator

      || !initiator.equals(UserContext.current()

        .getAccessKey())) {

        // -> write permission on a bucket allows a PutObject /

        // DeleteObject action on any object in the bucket

        S3PolicyContext context = new S3PolicyContext(

          PolicyActions.AbortMultipartUpload, bucketName);

        context.setKeyName(exists.getSecond());

        verifyAccess(context, "SBucket", bucket.getId(),

          SAcl.PERMISSION_WRITE);

    }

      }

      // -> first get a list of all the uploaded files and delete one by

      // one

      S3MultipartPart[] parts = uploadDao.getParts(uploadId, 10000, 0);

      for (int i = 0; i < parts.length; i++) {

    bucketAdapter.deleteObject(host_storagelocation_pair.getSecond(), ServiceProvider.getInstance()

      .getMultipartDir(), parts[i].getPath());

      }

      uploadDao.deleteUpload(uploadId);

      return 204;

  } catch (PermissionDeniedException e) {

      logger.error("freeUploadParts failed due to [" + e.getMessage()

        + "]", e);

      throw e;

  } catch (Exception e) {

      logger.error("freeUploadParts failed due to [" + e.getMessage()

        + "]", e);

      return 500;

  }

  }

    /**

     * The initiator must have permission to write to the bucket in question in order to initiate

     * a multipart upload.  Also check to make sure the special folder used to store parts of

     * a multipart exists for this bucket.

     * Called from S3ObjectAction during many stages of multipart upload.

     */

    public S3PutObjectInlineResponse initiateMultipartUpload(S3PutObjectInlineRequest request)

    {

      S3PutObjectInlineResponse response = new S3PutObjectInlineResponse(); 

    String bucketName = request.getBucketName();

    String nameKey = request.getKey();

    // -> does the bucket exist and can we write to it?

    SBucketVO bucket = bucketDao.getByName(bucketName);

    if (bucket == null) {

      logger.error( "initiateMultipartUpload failed since " + bucketName + " does not exist" );

      response.setResultCode(404);

    }

     

    S3PolicyContext context = new S3PolicyContext( PolicyActions.PutObject, bucketName );

    context.setKeyName( nameKey );

    context.setEvalParam( ConditionKeys.Acl, request.getCannedAccess());

    verifyAccess( context, "SBucket", bucket.getId(), SAcl.PERMISSION_WRITE );

    createUploadFolder( bucketName );

        try {

          MultipartLoadDao uploadDao = new MultipartLoadDao();

          int uploadId = uploadDao.initiateUpload( UserContext.current().getAccessKey(), bucketName, nameKey, request.getCannedAccess(), request.getMetaEntries());

          response.setUploadId( uploadId );

          response.setResultCode(200);

         

        } catch( Exception e ) {

            logger.error("initiateMultipartUpload exception: ", e);

          response.setResultCode(500);

        }

        return response;

    }

    /**

     * Save the object fragment in a special (i.e., hidden) directory inside the same mount point as

     * the bucket location that the final object will be stored in.

     * Called from S3ObjectAction during many stages of multipart upload.

     * @param request

     * @param uploadId

     * @param partNumber

     * @return S3PutObjectInlineResponse

     */

    public S3PutObjectInlineResponse saveUploadPart(S3PutObjectInlineRequest request, int uploadId, int partNumber)

    {

      S3PutObjectInlineResponse response = new S3PutObjectInlineResponse(); 

    String bucketName = request.getBucketName();

    // -> we need to look up the final bucket to figure out which mount point to use to save the part in

    //SBucketDao bucketDao = new SBucketDao();

    SBucketVO bucket = bucketDao.getByName(bucketName);

    if (bucket == null) {

      logger.error( "saveUploadedPart failed since " + bucketName + " does not exist" );

      response.setResultCode(404);

    }

    S3PolicyContext context = new S3PolicyContext( PolicyActions.PutObject, bucketName );

    context.setKeyName( request.getKey());

    verifyAccess( context, "SBucket", bucket.getId(), SAcl.PERMISSION_WRITE );

   

    OrderedPair<SHostVO, String> host_storagelocation_pair = getBucketStorageHost(bucket);   

    S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(host_storagelocation_pair.getFirst());

    String itemFileName = new String( uploadId + "-" + partNumber );

    InputStream is = null;

    try {

        is = request.getDataInputStream();

        String md5Checksum = bucketAdapter.saveObject(is, host_storagelocation_pair.getSecond(), ServiceProvider.getInstance().getMultipartDir(), itemFileName);

        response.setETag(md5Checksum);

              MultipartLoadDao uploadDao = new MultipartLoadDao();

              uploadDao.savePart(uploadId, partNumber, md5Checksum, itemFileName,(int) request.getContentLength());

              response.setResultCode(200);

             

    } catch (IOException e) {

      logger.error("UploadPart failed due to " + e.getMessage(), e);

      response.setResultCode(500);

    } catch (OutOfStorageException e) {

      logger.error("UploadPart failed due to " + e.getMessage(), e);

      response.setResultCode(500);

    } catch (Exception e) {

      logger.error("UploadPart failed due to " + e.getMessage(), e); 

      response.setResultCode(500);

    } finally {

      if(is != null) {

        try {

          is.close();

        } catch (IOException e) {

          logger.error("UploadPart unable to close stream from data handler.", e);

        }

      }

    }

     

    return response;

    }

   

    /**

     * Create the real object represented by all the parts of the multipart upload.      

     * Called from S3ObjectAction at completion of multipart upload.

     * @param httpResp - Servlet response handle to return the headers of the response (including version header)

     * @param request - Normal parameters needed to create a new object (including metadata)

     * @param parts - List of files that make up the multipart

     * @param outputStream - Response output stream

     * N.B. - This method can be long-lasting

     * We are required to keep the connection alive by returning whitespace characters back periodically.

     */

   

    public S3PutObjectInlineResponse concatentateMultipartUploads(HttpServletResponse httpResp, S3PutObjectInlineRequest request, S3MultipartPart[] parts, OutputStream outputStream) throws IOException

    {

      // [A] Set up and initial error checking

  S3PutObjectInlineResponse response = new S3PutObjectInlineResponse();

  String bucketName = request.getBucketName();

  String key = request.getKey();

  S3MetaDataEntry[] meta = request.getMetaEntries();

  SBucketVO bucket = bucketDao.getByName(bucketName);

  if (bucket == null) {

      logger.error("completeMultipartUpload( failed since " + bucketName

        + " does not exist");

      response.setResultCode(404);

  }

  // [B] Now we need to create the final re-assembled object

  // -> the allocObjectItem checks for the bucket policy PutObject

  // permissions

  OrderedPair<SObjectVO, SObjectItemVO> object_objectitem_pair = allocObjectItem(

    bucket, key, meta, null, request.getCannedAccess());

  OrderedPair<SHostVO, String> host_storagelocation_pair = getBucketStorageHost(bucket);

  S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(host_storagelocation_pair

    .getFirst());

  String itemFileName = object_objectitem_pair.getSecond()

    .getStoredPath();

  // -> Amazon defines that we must return a 200 response immediately to

  // the client, but

  // -> we don't know the version header until we hit here

  httpResp.setStatus(200);

  httpResp.setContentType("text/xml; charset=UTF-8");

  String version = object_objectitem_pair.getSecond().getVersion();

  if (null != version)

      httpResp.addHeader("x-amz-version-id", version);

  httpResp.flushBuffer();

  Transaction txn = Transaction.open(Transaction.AWSAPI_DB);

  // [C] Re-assemble the object from its uploaded file parts

  try {

      // explicit transaction control to avoid holding transaction during

      // long file concatenation process

      txn.start();

      OrderedPair<String, Long> result = bucketAdapter

              .concatentateObjects(host_storagelocation_pair.getSecond(),

                      bucket.getName(), itemFileName, ServiceProvider

                      .getInstance().getMultipartDir(), parts,

                      outputStream);

     

            response.setETag(result.getFirst());

            response.setLastModified(DateHelper.toCalendar(object_objectitem_pair.getSecond().getLastModifiedTime()));

            SObjectItemVO item = itemDao.findById(object_objectitem_pair

                    .getSecond().getId());

            item.setMd5(result.getFirst());

            item.setStoredSize(result.getSecond().longValue());

            itemDao.update(item.getId(), item);

            response.setResultCode(200);

  } catch (Exception e) {

      logger.error("completeMultipartUpload failed due to " + e.getMessage(),e);

      txn.close();

  }

  return response;

    }

   

    /**

     * Return a S3PutObjectInlineResponse which represents an object being created into a bucket     

     * Called from S3ObjectAction when PUTting or POTing an object.

     */

    @DB

    public S3PutObjectInlineResponse handleRequest(S3PutObjectInlineRequest request)

    {

      S3PutObjectInlineResponse response = new S3PutObjectInlineResponse(); 

    String bucketName = request.getBucketName();

    String key = request.getKey();

    long contentLength = request.getContentLength();

    S3MetaDataEntry[] meta = request.getMetaEntries();

    S3AccessControlList acl = request.getAcl();

   

    SBucketVO bucket = bucketDao.getByName(bucketName);

    if (bucket == null) throw new NoSuchObjectException("Bucket " + bucketName + " does not exist");

   

    // Is the caller allowed to write the object?

    // The allocObjectItem checks for the bucket policy PutObject permissions

    OrderedPair<SObjectVO, SObjectItemVO> object_objectitem_pair = allocObjectItem(bucket, key, meta, acl, request.getCannedAccess());

    OrderedPair<SHostVO, String> host_storagelocation_pair = getBucketStorageHost(bucket);   

   

    S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(host_storagelocation_pair.getFirst());

    String itemFileName = object_objectitem_pair.getSecond().getStoredPath();

    InputStream is = null;

    Transaction txn = null;

    try {

      // explicit transaction control to avoid holding transaction during file-copy process

     

        txn = Transaction.open(Transaction.AWSAPI_DB);

        txn.start();

      is = request.getDataInputStream();

      String md5Checksum = bucketAdapter.saveObject(is, host_storagelocation_pair.getSecond(), bucket.getName(), itemFileName);

      response.setETag(md5Checksum);

      response.setLastModified(DateHelper.toCalendar( object_objectitem_pair.getSecond().getLastModifiedTime()));

          response.setVersion( object_objectitem_pair.getSecond().getVersion());

   

      //SObjectItemDaoImpl itemDao = new SObjectItemDaoImpl();

      SObjectItemVO item = itemDao.findById(object_objectitem_pair.getSecond().getId());

      item.setMd5(md5Checksum);

      item.setStoredSize(contentLength);

      itemDao.update(item.getId(), item);

      txn.commit();

    } catch (IOException e) {

      logger.error("PutObjectInline failed due to " + e.getMessage(), e);

    } catch (OutOfStorageException e) {

      logger.error("PutObjectInline failed due to " + e.getMessage(), e);

    } finally {

      if(is != null) {

        try {

          is.close();

        } catch (IOException e) {

          logger.error("PutObjectInline unable to close stream from data handler.", e);

        }

      }

      txn.close();

    }

     

      return response;

    }

   

    /**

     * Return a S3PutObjectResponse which represents an object being created into a bucket     

     * Called from S3RestServlet when processing a DIME request.

     */

    public S3PutObjectResponse handleRequest(S3PutObjectRequest request) 

    {

      S3PutObjectResponse response = new S3PutObjectResponse(); 

    String bucketName = request.getBucketName();

    String key = request.getKey();

    long contentLength = request.getContentLength();

    S3MetaDataEntry[] meta = request.getMetaEntries();

    S3AccessControlList acl = request.getAcl();

   

    SBucketVO bucket = bucketDao.getByName(bucketName);

    if(bucket == null) throw new NoSuchObjectException("Bucket " + bucketName + " does not exist");

   

    // Is the caller allowed to write the object? 

    // The allocObjectItem checks for the bucket policy PutObject permissions

    OrderedPair<SObjectVO, SObjectItemVO> object_objectitem_pair = allocObjectItem(bucket, key, meta, acl, null);

    OrderedPair<SHostVO, String> host_storagelocation_pair = getBucketStorageHost(bucket);

     

    S3BucketAdapter bucketAdapter =  getStorageHostBucketAdapter(host_storagelocation_pair.getFirst());

    String itemFileName = object_objectitem_pair.getSecond().getStoredPath();

    InputStream is = null;

    Transaction txn = null;

    try {

      // explicit transaction control to avoid holding transaction during file-copy process

       

          txn = Transaction.open(Transaction.AWSAPI_DB);

          txn.start();

     

      is = request.getInputStream();

      String md5Checksum = bucketAdapter.saveObject(is, host_storagelocation_pair.getSecond(), bucket.getName(), itemFileName);

      response.setETag(md5Checksum);

      response.setLastModified(DateHelper.toCalendar( object_objectitem_pair.getSecond().getLastModifiedTime()));

     

      SObjectItemVO item = itemDao.findById(object_objectitem_pair.getSecond().getId());

      item.setMd5(md5Checksum);

      item.setStoredSize(contentLength);

      itemDao.update(item.getId(), item);

      txn.commit();

     

    } catch (OutOfStorageException e) {

      logger.error("PutObject failed due to " + e.getMessage(), e);

    } finally {

      if(is != null) {

        try {

          is.close();

        } catch (IOException e) {

          logger.error("Unable to close stream from data handler.", e);

        }

      }

      txn.close();

    }

     

      return response;

    }

    /**

     * The ACL of an object is set at the object version level. By default, PUT sets the ACL of the latest

     * version of an object. To set the ACL of a different version, using the versionId subresource.

     * Called from S3ObjectAction to PUT an object's ACL.

     */

   

    public S3Response handleRequest(S3SetObjectAccessControlPolicyRequest request)

    {

      S3PolicyContext context = null;

     

      // [A] First find the object in the bucket

      S3Response response  = new S3Response();  

      String bucketName = request.getBucketName();

      SBucketVO sbucket = bucketDao.getByName( bucketName );

      if(sbucket == null) {

        response.setResultCode(404);

        response.setResultDescription("Bucket " + bucketName + "does not exist");

        return response;

      }

     

      String nameKey = request.getKey();

      SObjectVO sobject = objectDao.getByNameKey( sbucket, nameKey );    

      if(sobject == null) {

        response.setResultCode(404);

        response.setResultDescription("Object " + request.getKey() + " in bucket " + bucketName + " does not exist");

        return response;

      }

     

    String deletionMark = sobject.getDeletionMark();

    if (null != deletionMark) {

      response.setResultCode(404);

      response.setResultDescription("Object " + request.getKey() + " has been deleted (1)");

      return response;

    }

   

    // [B] Versioning allow the client to ask for a specific version not just the latest

    SObjectItemVO item = null;

        int versioningStatus = sbucket.getVersioningStatus();

    String wantVersion = request.getVersion();

    if ( SBucket.VERSIONING_ENABLED == versioningStatus && null != wantVersion)

       item = sobject.getVersion( wantVersion );

    else item = sobject.getLatestVersion(( SBucket.VERSIONING_ENABLED != versioningStatus ));   

     

    if (item == null) {

        response.setResultCode(404);

      response.setResultDescription("Object " + request.getKey() + " has been deleted (2)");

      return response;     

      }

    if ( SBucket.VERSIONING_ENABLED == versioningStatus ) {

       context = new S3PolicyContext( PolicyActions.PutObjectAclVersion, bucketName );

       context.setEvalParam( ConditionKeys.VersionId, wantVersion );

       response.setVersion( item.getVersion());

    }

    else context = new S3PolicyContext( PolicyActions.PutObjectAcl, bucketName );   

    context.setKeyName( nameKey );

    verifyAccess( context, "SObjectItem", item.getId(), SAcl.PERMISSION_WRITE_ACL );   

    // -> the acl always goes on the instance of the object

      aclDao.save("SObjectItem", item.getId(), request.getAcl());

     

      response.setResultCode(200);

      response.setResultDescription("OK");

      return response;

    }

   

    /**

     * By default, GET returns ACL information about the latest version of an object. To return ACL

     * information about a different version, use the versionId subresource

     * Called from S3ObjectAction to get an object's ACL.

     */

   

    public S3AccessControlPolicy handleRequest(S3GetObjectAccessControlPolicyRequest request)

    {

      S3PolicyContext context = null;

      // [A] Does the object exist that holds the ACL we are looking for?

      S3AccessControlPolicy policy = new S3AccessControlPolicy(); 

     

      String bucketName = request.getBucketName();

      SBucketVO sbucket = bucketDao.getByName( bucketName );

      if (sbucket == null)

        throw new NoSuchObjectException("Bucket " + bucketName + " does not exist");

     

      //SObjectDaoImpl sobjectDao = new SObjectDaoImpl();

      String nameKey = request.getKey();

      SObjectVO sobject = objectDao.getByNameKey( sbucket, nameKey );

      if (sobject == null)

        throw new NoSuchObjectException("Object " + request.getKey() + " does not exist");

       

    String deletionMark = sobject.getDeletionMark();

    if (null != deletionMark) {

      policy.setResultCode(404);

      policy.setResultDescription("Object " + request.getKey() + " has been deleted (1)");

      return policy;

    }

   

    // [B] Versioning allow the client to ask for a specific version not just the latest

    SObjectItemVO item = null;

        int versioningStatus = sbucket.getVersioningStatus();

    String wantVersion = request.getVersion();

    if ( SBucket.VERSIONING_ENABLED == versioningStatus && null != wantVersion)

       item = sobject.getVersion( wantVersion );

    else item = sobject.getLatestVersion(( SBucket.VERSIONING_ENABLED != versioningStatus ));   

     

    if (item == null) {

        policy.setResultCode(404);

      policy.setResultDescription("Object " + request.getKey() + " has been deleted (2)");

      return policy;     

      }

    if ( SBucket.VERSIONING_ENABLED == versioningStatus ) {

       context = new S3PolicyContext( PolicyActions.GetObjectVersionAcl, bucketName );

       context.setEvalParam( ConditionKeys.VersionId, wantVersion );

       policy.setVersion( item.getVersion());

    }

    else context = new S3PolicyContext( PolicyActions.GetObjectAcl, bucketName );   

    context.setKeyName( nameKey );

    verifyAccess( context, "SObjectItem", item.getId(), SAcl.PERMISSION_READ_ACL );   

     

        // [C] ACLs are ALWAYS on an instance of the object

      S3CanonicalUser owner = new S3CanonicalUser();

      owner.setID(sobject.getOwnerCanonicalId());

      owner.setDisplayName("");

      policy.setOwner(owner);

    policy.setResultCode(200);

    

     

      List<SAclVO> grants = aclDao.listGrants( "SObjectItem", item.getId());

      policy.setGrants(S3Grant.toGrants(grants));   

      return policy;

    }

   

    /**

     * Handle requests for GET object and HEAD "get object extended"

     * Called from S3ObjectAction for GET and HEAD of an object.

     */

   

    public S3GetObjectResponse handleRequest(S3GetObjectRequest request)

    {

      S3GetObjectResponse response = new S3GetObjectResponse();

      S3PolicyContext context = null;

      boolean ifRange = false;

    long bytesStart = request.getByteRangeStart();

    long bytesEnd   = request.getByteRangeEnd();

      int resultCode  = 200;

      // [A] Verify that the bucket and the object exist

   

    String bucketName = request.getBucketName();

    SBucketVO sbucket = bucketDao.getByName(bucketName);

    if (sbucket == null) {

      response.setResultCode(404);

      response.setResultDescription("Bucket " + request.getBucketName() + " does not exist");

      return response;

    }

    String nameKey = request.getKey();

    SObjectVO sobject = objectDao.getByNameKey( sbucket, nameKey );

    if (sobject == null) {

      response.setResultCode(404);

      response.setResultDescription("Object " + request.getKey() + " does not exist in bucket " + request.getBucketName());

      return response;

    }

   

    String deletionMark = sobject.getDeletionMark();

    if (null != deletionMark) {

        response.setDeleteMarker( deletionMark );

      response.setResultCode(404);

      response.setResultDescription("Object " + request.getKey() + " has been deleted (1)");

      return response;

    }

   

    // [B] Versioning allow the client to ask for a specific version not just the latest

    SObjectItemVO item = null;

        int versioningStatus = sbucket.getVersioningStatus();

    String wantVersion = request.getVersion();

    if ( SBucket.VERSIONING_ENABLED == versioningStatus && null != wantVersion)      

       item = sobject.getVersion( wantVersion );

    else item = sobject.getLatestVersion(( SBucket.VERSIONING_ENABLED != versioningStatus ));   

     

    if (item == null) {

        response.setResultCode(404);

      response.setResultDescription("Object " + request.getKey() + " has been deleted (2)");

      return response;     

      }

   

    if ( SBucket.VERSIONING_ENABLED == versioningStatus ) {

       context = new S3PolicyContext( PolicyActions.GetObjectVersion, bucketName );

       context.setEvalParam( ConditionKeys.VersionId, wantVersion );

    }

    else context = new S3PolicyContext( PolicyActions.GetObject, bucketName );   

     context.setKeyName( nameKey );

    verifyAccess( context, "SObjectItem", item.getId(), SAcl.PERMISSION_READ );   

   

     

      // [C] Handle all the IFModifiedSince ... conditions, and access privileges

    // -> http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.27 (HTTP If-Range header)

    if (request.isReturnCompleteObjectOnConditionFailure() && (0 <= bytesStart && 0 <= bytesEnd)) ifRange = true;

    resultCode = conditionPassed( request.getConditions(), item.getLastModifiedTime(), item.getMd5(), ifRange );

      if ( -1 == resultCode ) {

        // -> If-Range implementation, we have to return the entire object

        resultCode = 200;

        bytesStart = -1;

        bytesEnd = -1;

      }

      else if (200 != resultCode) {

      response.setResultCode( resultCode );

        response.setResultDescription( "Precondition Failed" );     

      return response;

    }

    // [D] Return the contents of the object inline 

    // -> extract the meta data that corresponds the specific versioned item

    List<SMetaVO> itemMetaData =   metaDao.getByTarget( "SObjectItem", item.getId());

    if (null != itemMetaData)

    {

      int i = 0;

      S3MetaDataEntry[] metaEntries = new S3MetaDataEntry[ itemMetaData.size() ];