Generate Logical Parts for object downloads when no .meta file is available (#413)

* Refactor S3 Bucket Name Retrieval Method

* Object Retrieval: Support for Multipart Uploads

* Used getContentLength() from the ObjectMetaData to Calculate the part

* Update Part.java

Reverting changes related to Part.java

* Handle case where external=false and length < 0

---------

Co-authored-by: AzherAliMohammed <68929005+AzherAliMohammed@users.noreply.github.com>
Co-authored-by: Jon Eubank <joneubank@gmail.com>

Author: 3 people

score-server/src/main/java/bio/overture/score/server/repository/s3/S3DownloadService.java

@@ -97,65 +97,82 @@ public ObjectSpecification download(
       if (!excludeUrls) {
         checkPublishedAnalysisState(metadataService.getEntity(objectId));
       }
-
       checkArgument(offset > -1L);
 
-      var objectSpec = getSpecification(objectId);
-
-      // Construct ObjectSpecification for actual object in /data logical folder
       val objectKey = ObjectKeys.getObjectKey(dataDir, objectId);
 
-      List<Part> parts;
-      if (forExternalUse) {
-        // Return as a single part - no matter how large
-        parts = partCalculator.specify(0L, -1L);
-      } else {
-        parts = partCalculator.divide(offset, length);
-      }
+      var objectSpec = getSpecification(objectId);
+
       if (objectSpec == null) {
         ObjectMetadata metadata =
             s3Client.getObjectMetadata(
                 bucketNamingService.getObjectBucketName(objectId), objectKey.getKey());
+
+        List<Part> parts;
+        if (forExternalUse) {
+          // Return as a single part - no matter how large
+          parts = partCalculator.specify(0L, -1L);
+        } else if (length < 0L) {
+          parts = partCalculator.divide(offset, metadata.getContentLength() - offset);
+        } else {
+          parts = partCalculator.divide(offset, length);
+        }
         fillPartUrls(objectKey, parts, false, forExternalUse);
         objectSpec =
             new ObjectSpecification(
-                objectKey.getKey(), objectId, objectId, parts, metadata.getContentLength(), metadata.getETag(), false);
+                objectKey.getKey(),
+                objectId,
+                objectId,
+                parts,
+                metadata.getContentLength(),
+                metadata.getETag(),
+                false);
       }
 
       // Short-circuit in default case
-        if (!forExternalUse && (offset == 0L && length < 0L)) {
-          return excludeUrls ? removeUrls(objectSpec) : objectSpec;
-        }
+      if (!forExternalUse && (offset == 0L && length < 0L)) {
+        return excludeUrls ? removeUrls(objectSpec) : objectSpec;
+      }
 
-        // Calculate range values
-        // To retrieve to the end of the file
-        if (!forExternalUse && (length < 0L)) {
-          length = objectSpec.getObjectSize() - offset;
-        }
+      // Construct ObjectSpecification for actual object in /data logical folder
+      // Calculate range values
+      // To retrieve to the end of the file
+      if (!forExternalUse && (length < 0L)) {
+        length = objectSpec.getObjectSize() - offset;
+      }
 
-        // Validate offset and length parameters:
-        // Check if the offset + length > length - that would be too big
-        if ((offset + length) > objectSpec.getObjectSize()) {
-          throw new InternalUnrecoverableError(
-              "Specified parameters exceed object size (object id: "
-                  + objectId
-                  + ", offset: "
-                  + offset
-                  + ", length: "
-                  + length
-                  + ")");
-        }
-        fillPartUrls(objectKey, parts, objectSpec.isRelocated(), forExternalUse);
+      // Validate offset and length parameters:
+      // Check if the offset + length > length - that would be too big
+      if ((offset + length) > objectSpec.getObjectSize()) {
+        throw new InternalUnrecoverableError(
+            "Specified parameters exceed object size (object id: "
+                + objectId
+                + ", offset: "
+                + offset
+                + ", length: "
+                + length
+                + ")");
+      }
 
-        val spec =
-            new ObjectSpecification(
-                objectKey.getKey(),
-                objectId,
-                objectId,
-                parts,
-                length,
-                objectSpec.getObjectMd5(),
-                objectSpec.isRelocated());
+      List<Part> parts;
+      if (forExternalUse) {
+        // Return as a single part - no matter how large
+        parts = partCalculator.specify(0L, -1L);
+      } else {
+        parts = partCalculator.divide(offset, length);
+      }
+
+      fillPartUrls(objectKey, parts, objectSpec.isRelocated(), forExternalUse);
+
+      val spec =
+          new ObjectSpecification(
+              objectKey.getKey(),
+              objectId,
+              objectId,
+              parts,
+              length,
+              objectSpec.getObjectMd5(),
+              objectSpec.isRelocated());
 
       return excludeUrls ? removeUrls(spec) : spec;
     } catch (Exception e) {
@@ -193,6 +210,7 @@ void checkPublishedAnalysisState(MetadataEntity entity) {
       }
     }
   }
+
   public ObjectSpecification getSpecification(String objectId) {
     val objectKey = ObjectKeys.getObjectKey(dataDir, objectId);
     val objectMetaKey = ObjectKeys.getObjectMetaKey(dataDir, objectId);