Package com.cloud.bridge.model

Examples of com.cloud.bridge.model.SObjectItem


         SObject oneObject = (SObject)it.next();
        Set<SObjectItem> itemsInObject = oneObject.getItems();
        Iterator is = itemsInObject.iterator();
        while( is.hasNext())
        {
          SObjectItem oneItem = (SObjectItem)is.next();
            deleteMetaData( oneItem.getId());
            deleteObjectAcls( "SObjectItem", oneItem.getId());
        }       
       }
        
       // -> delete all the policy state associated with the bucket
       try {
View Full Code Here


      Tuple<String, Long> result = bucketAdapter.concatentateObjects( tupleBucketHost.getSecond(), bucket.getName(), itemFileName, ServiceProvider.getInstance().getMultipartDir(), parts, os );
      response.setETag(result.getFirst());
      response.setLastModified(DateHelper.toCalendar( tupleObjectItem.getSecond().getLastModifiedTime()));
   
      SObjectItemDao itemDao = new SObjectItemDao();
      SObjectItem item = itemDao.get( tupleObjectItem.getSecond().getId());
      item.setMd5(result.getFirst());
      item.setStoredSize(result.getSecond().longValue());
      response.setResultCode(200);

      PersistContext.getSession().save(item);     
    }
    catch (Exception e) {
View Full Code Here

      response.setETag(md5Checksum);
      response.setLastModified(DateHelper.toCalendar( tupleObjectItem.getSecond().getLastModifiedTime()));
          response.setVersion( tupleObjectItem.getSecond().getVersion());
   
      SObjectItemDao itemDao = new SObjectItemDao();
      SObjectItem item = itemDao.get( tupleObjectItem.getSecond().getId());
      item.setMd5(md5Checksum);
      item.setStoredSize(contentLength);
      PersistContext.getSession().save(item);
     
    } catch (IOException e) {
      logger.error("PutObjectInline failed due to " + e.getMessage(), e);
    } catch (OutOfStorageException e) {
View Full Code Here

      String md5Checksum = bucketAdapter.saveObject(is, tupleBucketHost.getSecond(), bucket.getName(), itemFileName);
      response.setETag(md5Checksum);
      response.setLastModified(DateHelper.toCalendar( tupleObjectItem.getSecond().getLastModifiedTime()));
     
      SObjectItemDao itemDao = new SObjectItemDao();
      SObjectItem item = itemDao.get( tupleObjectItem.getSecond().getId());
      item.setMd5(md5Checksum);
      item.setStoredSize(contentLength);
      PersistContext.getSession().save(item);
     
    } catch (OutOfStorageException e) {
      logger.error("PutObject failed due to " + e.getMessage(), e);
    } finally {
View Full Code Here

      return response;
    }
   

    // [B] Versioning allow the client to ask for a specific version not just the latest
    SObjectItem 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
      SAclDao aclDao = new SAclDao();
      aclDao.save("SObjectItem", item.getId(), request.getAcl());
     
      response.setResultCode(200);
      response.setResultDescription("OK");
      return response;
    }
View Full Code Here

      return policy;
    }
   

    // [B] Versioning allow the client to ask for a specific version not just the latest
    SObjectItem 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);
    
      SAclDao aclDao = new SAclDao();
      List<SAcl> grants = aclDao.listGrants( "SObjectItem", item.getId());
      policy.setGrants(S3Grant.toGrants(grants));   
      return policy;
    }
View Full Code Here

      return response;
    }
   

    // [B] Versioning allow the client to ask for a specific version not just the latest
    SObjectItem 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
    SMetaDao metaDao = new SMetaDao();
    List<SMeta> itemMetaData = metaDao.getByTarget( "SObjectItem", item.getId());
    if (null != itemMetaData)
    {
      int i = 0;
      S3MetaDataEntry[] metaEntries = new S3MetaDataEntry[ itemMetaData.size() ];
        ListIterator it = itemMetaData.listIterator();
        while( it.hasNext()) {
          SMeta oneTag = (SMeta)it.next();
          S3MetaDataEntry oneEntry = new S3MetaDataEntry();
          oneEntry.setName( oneTag.getName());
          oneEntry.setValue( oneTag.getValue());
          metaEntries[i++] = oneEntry;
        }
        response.setMetaEntries( metaEntries );
    }
       
    //  -> support a single byte range
    if ( 0 <= bytesStart && 0 <= bytesEnd ) {
         response.setContentLength( bytesEnd - bytesStart )
         resultCode = 206;
    }
    else response.setContentLength( item.getStoredSize());
      if(request.isReturnData())
      {
        response.setETag(item.getMd5());
        response.setLastModified(DateHelper.toCalendar( item.getLastModifiedTime()));
        response.setVersion( item.getVersion());
        if (request.isInlineData())
        {
          Tuple<SHost, String> tupleSHostInfo = getBucketStorageHost(sbucket);
        S3BucketAdapter bucketAdapter = getStorageHostBucketAdapter(tupleSHostInfo.getFirst());
       
        if ( 0 <= bytesStart && 0 <= bytesEnd )
           response.setData(bucketAdapter.loadObjectRange(tupleSHostInfo.getSecond(),
               request.getBucketName(), item.getStoredPath(), bytesStart, bytesEnd ));
        else response.setData(bucketAdapter.loadObject(tupleSHostInfo.getSecond(), request.getBucketName(), item.getStoredPath()));
        }
      }
     
      response.setResultCode( resultCode );
      response.setResultDescription("OK");
View Full Code Here

    }
   
       
    // -> versioning controls what delete means
    String storedPath = null;
    SObjectItem item = null;
        int versioningStatus = sbucket.getVersioningStatus();
    if ( SBucket.VERSIONING_ENABLED == versioningStatus )
      {
       String wantVersion = request.getVersion();
       S3PolicyContext context = new S3PolicyContext( PolicyActions.DeleteObjectVersion, bucketName );
       context.setKeyName( nameKey );
       context.setEvalParam( ConditionKeys.VersionId, wantVersion );
       verifyAccess( context, "SBucket", sbucket.getId(), SAcl.PERMISSION_WRITE );

       if (null == wantVersion) {
         // -> if versioning is on and no versionId is given then we just write a deletion marker
         sobject.setDeletionMark( UUID.randomUUID().toString());
         objectDao.update( sobject );
       }
       else
          // -> are we removing the delete marker?
          String deletionMarker = sobject.getDeletionMark();
          if (null != deletionMarker && wantVersion.equalsIgnoreCase( deletionMarker )) {
            sobject.setDeletionMark( null )
              objectDao.update( sobject )
              response.setResultCode(204);
            return response;
                }
         
          // -> if versioning is on and the versionId is given then we delete the object matching that version
            if ( null == (item = sobject.getVersion( wantVersion ))) {
               response.setResultCode(404);
               return response;
            }
            else {
               // -> just delete the one item that matches the versionId from the database
               storedPath = item.getStoredPath();
               sobject.deleteItem( item.getId());
               objectDao.update( sobject );          
            }
       }
      }
    else
    {   // -> if versioning is off then we do delete the null object
       S3PolicyContext context = new S3PolicyContext( PolicyActions.DeleteObject, bucketName );
       context.setKeyName( nameKey );
       verifyAccess( context, "SBucket", sbucket.getId(), SAcl.PERMISSION_WRITE );

       if ( null == (item = sobject.getLatestVersion( true ))) {
            response.setResultCode(404);
            return response;
         }
         else {
            // -> if no item with a null version then we are done
            if (null == item.getVersion()) {
                // -> remove the entire object
                // -> cascade-deleting can delete related SObject/SObjectItem objects, but not SAcl and SMeta objects.
                storedPath = item.getStoredPath();
              deleteMetaData( item.getId());
              deleteObjectAcls( "SObjectItem", item.getId());
                objectDao.delete( sobject );
            }
         }
    }
   
View Full Code Here

   * TODO - how does the versionIdMarker work when there is a deletion marker in the object?
   */
  private S3ListBucketObjectEntry[] composeListBucketContentEntries(List<SObject> l, String prefix, String delimiter, int maxKeys, boolean enableVersion, String versionIdMarker)
  {
    List<S3ListBucketObjectEntry> entries = new ArrayList<S3ListBucketObjectEntry>();
    SObjectItem latest  = null;
    boolean hitIdMarker = false;
    int count = 0;
   
    for( SObject sobject : l )
    {
      if (delimiter != null && !delimiter.isEmpty())
      {
        if (StringHelper.substringInBetween(sobject.getNameKey(), prefix, delimiter) != null)
          continue;
      }
     
      if (enableVersion)
      {
        hitIdMarker = (null == versionIdMarker ? true : false);

        // -> this supports the REST call GET /?versions
        String deletionMarker = sobject.getDeletionMark();
                if ( null != deletionMarker )
                {
                   // -> TODO we don't save the timestamp when something is deleted
                   S3ListBucketObjectEntry entry = new S3ListBucketObjectEntry();
                 entry.setKey(sobject.getNameKey());
                 entry.setVersion( deletionMarker );
                 entry.setIsLatest( true );
                 entry.setIsDeletionMarker( true );
                 entry.setLastModified( Calendar.getInstance( TimeZone.getTimeZone("GMT") ));
                 entry.setOwnerCanonicalId(sobject.getOwnerCanonicalId());
                 entry.setOwnerDisplayName("");
                 entries.add( entry );
                 latest = null;
                }
                else latest = sobject.getLatestVersion( false );
       
        Iterator<SObjectItem> it = sobject.getItems().iterator();
        while( it.hasNext())
        {
          SObjectItem item = (SObjectItem)it.next();
         
          if ( !hitIdMarker )
          {
             if (item.getVersion().equalsIgnoreCase( versionIdMarker )) {
               hitIdMarker = true;
               entries.add( toListEntry( sobject, item, latest ));
             }
          }
          else entries.add( toListEntry( sobject, item, latest ));
        }
      }
      else
      {   // -> if there are multiple versions of an object then just return its last version
        Iterator<SObjectItem> it = sobject.getItems().iterator();
        SObjectItem lastestItem = null;
        int maxVersion = 0;
        int version = 0;
        while(it.hasNext())
        {
          SObjectItem item = (SObjectItem)it.next();
          String versionStr = item.getVersion();
         
          if ( null != versionStr )
             version = Integer.parseInt(item.getVersion());
          else lastestItem = item;
         
          // -> if the bucket has versions turned on
          if (version > maxVersion) {
            maxVersion = version;
View Full Code Here

  {
    SObjectDao     objectDao     = new SObjectDao();
    SObjectItemDao objectItemDao = new SObjectItemDao();
    SMetaDao       metaDao       = new SMetaDao();
    SAclDao        aclDao        = new SAclDao();
    SObjectItem    item          = null;
    int            versionSeq    = 1;
    int      versioningStatus    = bucket.getVersioningStatus();
   
    Session session = PersistContext.getSession();
     
    // [A] To write into a bucket the user must have write permission to that bucket
    S3PolicyContext context = new S3PolicyContext( PolicyActions.PutObject, bucket.getName());
    context.setKeyName( nameKey );
    context.setEvalParam( ConditionKeys.Acl, cannedAccessPolicy);
    verifyAccess( context, "SBucket", bucket.getId(), SAcl.PERMISSION_WRITE );

    // [A] If versioning is off them we over write a null object item
    SObject object = objectDao.getByNameKey(bucket, nameKey);
    if ( object != null )
    {
       // -> if versioning is on create new object items
       if ( SBucket.VERSIONING_ENABLED == versioningStatus )
       {
            session.lock(object, LockMode.UPGRADE);
            versionSeq = object.getNextSequence();
            object.setNextSequence(versionSeq + 1);
             session.save(object);
           
            item = new SObjectItem();
            item.setTheObject(object);
            object.getItems().add(item);
            item.setVersion(String.valueOf(versionSeq));
            Date ts = DateHelper.currentGMTTime();
            item.setCreateTime(ts);
            item.setLastAccessTime(ts);
            item.setLastModifiedTime(ts);
            session.save(item);
       }
       else
       {    // -> find an object item with a null version, can be null
          //    if bucket started out with versioning enabled and was then suspended
          item = objectItemDao.getByObjectIdNullVersion( object.getId());
          if (item == null)
          {
              item = new SObjectItem();
              item.setTheObject(object);
              object.getItems().add(item);
              Date ts = DateHelper.currentGMTTime();
              item.setCreateTime(ts);
              item.setLastAccessTime(ts);
              item.setLastModifiedTime(ts);
              session.save(item);     
          }
       }
    }
    else
    {    // -> there is no object nor an object item
       object = new SObject();
       object.setBucket(bucket);
       object.setNameKey(nameKey);
       object.setNextSequence(2);
       object.setCreateTime(DateHelper.currentGMTTime());
       object.setOwnerCanonicalId(UserContext.current().getCanonicalUserId());
       session.save(object);
   
         item = new SObjectItem();
         item.setTheObject(object);
         object.getItems().add(item);
         if (SBucket.VERSIONING_ENABLED  == versioningStatus) item.setVersion(String.valueOf(versionSeq));
         Date ts = DateHelper.currentGMTTime();
         item.setCreateTime(ts);
         item.setLastAccessTime(ts);
         item.setLastModifiedTime(ts);
         session.save(item);
    }
     
   
    // [C] We will use the item DB id as the file name, MD5/contentLength will be stored later
    String suffix = null;
    int dotPos = nameKey.lastIndexOf('.');
    if (dotPos >= 0) suffix = nameKey.substring(dotPos);
    if ( suffix != null )
       item.setStoredPath(String.valueOf(item.getId()) + suffix);
    else item.setStoredPath(String.valueOf(item.getId()));
   
    metaDao.save("SObjectItem", item.getId(), meta);
   
   
    // [D] Are we setting an ACL along with the object
    //  -> the ACL is ALWAYS set on a particular instance of the object (i.e., a version)
    if ( null != cannedAccessPolicy )
    {
       setCannedAccessControls( cannedAccessPolicy, "SObjectItem", item.getId(), bucket );
    }
    else if (null == acl || 0 == acl.size())
    {
       // -> this is termed the "private" or default ACL, "Owner gets FULL_CONTROL"
       setSingleAcl( "SObjectItem", item.getId(), SAcl.PERMISSION_FULL );
    }
    else if (null != acl) {
       aclDao.save( "SObjectItem", item.getId(), acl );
    }
   
    session.update(item);   
    return new Tuple<SObject, SObjectItem>(object, item);
  }
View Full Code Here

TOP

Related Classes of com.cloud.bridge.model.SObjectItem

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.