Java StorageObject.getContentLength方法代码示例

import org.jets3t.service.model.StorageObject; //导入方法依赖的package包/类
@Override
public FileMetadata retrieveMetadata(String key) throws IOException {
  StorageObject object = null;
  try {
    LOG.debug("Getting metadata for key: {} from bucket: {}",
        key, bucket.getName());
    object = s3Service.getObjectDetails(bucket.getName(), key);
    return new FileMetadata(key, object.getContentLength(),
        object.getLastModifiedDate().getTime());

  } catch (ServiceException e) {
    try {
      // process
      handleException(e, key);
      return null;
    } catch (FileNotFoundException fnfe) {
      // and downgrade missing files
      return null;
    }
  } finally {
    if (object != null) {
      object.closeDataInputStream();
    }
  }
}
 

import org.jets3t.service.model.StorageObject; //导入方法依赖的package包/类
/**
 * list objects
 * @param prefix prefix
 * @param delimiter delimiter
 * @param maxListingLength max no. of entries
 * @param priorLastKey last key in any previous search
 * @return a list of matches
 * @throws IOException on any reported failure
 */

private PartialListing list(String prefix, String delimiter,
    int maxListingLength, String priorLastKey) throws IOException {
  try {
    if (!prefix.isEmpty() && !prefix.endsWith(PATH_DELIMITER)) {
      prefix += PATH_DELIMITER;
    }
    StorageObjectsChunk chunk = s3Service.listObjectsChunked(bucket.getName(),
        prefix, delimiter, maxListingLength, priorLastKey);
    
    FileMetadata[] fileMetadata =
      new FileMetadata[chunk.getObjects().length];
    for (int i = 0; i < fileMetadata.length; i++) {
      StorageObject object = chunk.getObjects()[i];
      fileMetadata[i] = new FileMetadata(object.getKey(),
          object.getContentLength(), object.getLastModifiedDate().getTime());
    }
    return new PartialListing(chunk.getPriorLastKey(), fileMetadata,
        chunk.getCommonPrefixes());
  } catch (ServiceException e) {
    handleException(e, prefix);
    return null; // never returned - keep compiler happy
  }
}
 

import org.jets3t.service.model.StorageObject; //导入方法依赖的package包/类
@Override
public FileMetadata retrieveMetadata(String key) throws IOException {
  StorageObject object = null;
  try {
    if(LOG.isDebugEnabled()) {
      LOG.debug("Getting metadata for key: " + key + " from bucket:" + bucket.getName());
    }
    object = s3Service.getObjectDetails(bucket.getName(), key);
    return new FileMetadata(key, object.getContentLength(),
        object.getLastModifiedDate().getTime());

  } catch (ServiceException e) {
    // Following is brittle. Is there a better way?
    if ("NoSuchKey".equals(e.getErrorCode())) {
      return null; //return null if key not found
    }
    handleServiceException(e);
    return null; //never returned - keep compiler happy
  } finally {
    if (object != null) {
      object.closeDataInputStream();
    }
  }
}
 

import org.jets3t.service.model.StorageObject; //导入方法依赖的package包/类
private void downloadThrows(final S3Artifact s3Artifact, final Path downloadTo) throws Exception {
  log.info("Downloading {}", s3Artifact);

  Jets3tProperties jets3tProperties = Jets3tProperties.getInstance(Constants.JETS3T_PROPERTIES_FILENAME);
  jets3tProperties.setProperty("httpclient.socket-timeout-ms", Long.toString(configuration.getS3ChunkDownloadTimeoutMillis()));

  final S3Service s3 = new RestS3Service(getCredentialsForBucket(s3Artifact.getS3Bucket()), null, null, jets3tProperties);

  long length = 0;

  if (s3Artifact.getFilesize().isPresent()) {
    length = s3Artifact.getFilesize().get();
  } else {
    StorageObject details = s3.getObjectDetails(s3Artifact.getS3Bucket(), s3Artifact.getS3ObjectKey());

    Preconditions.checkNotNull(details, "Couldn't find object at %s/%s", s3Artifact.getS3Bucket(), s3Artifact.getS3ObjectKey());

    length = details.getContentLength();
  }

  int numChunks = (int) (length / configuration.getS3ChunkSize());

  if (length % configuration.getS3ChunkSize() > 0) {
    numChunks++;
  }

  final long chunkSize = length / numChunks + (length % numChunks);

  log.info("Downloading {}/{} in {} chunks of {} bytes to {}", s3Artifact.getS3Bucket(), s3Artifact.getS3ObjectKey(), numChunks, chunkSize, downloadTo);

  final ExecutorService chunkExecutorService = Executors.newFixedThreadPool(numChunks, new ThreadFactoryBuilder().setDaemon(true).setNameFormat("S3ArtifactDownloaderChunkThread-%d").build());
  final List<Future<Path>> futures = Lists.newArrayListWithCapacity(numChunks);

  for (int chunk = 0; chunk < numChunks; chunk++) {
    futures.add(chunkExecutorService.submit(new S3ArtifactChunkDownloader(configuration, log, s3, s3Artifact, downloadTo, chunk, chunkSize, length, exceptionNotifier)));
  }

  long remainingMillis = configuration.getS3DownloadTimeoutMillis();
  boolean failed = false;

  for (int chunk = 0; chunk < numChunks; chunk++) {
    final Future<Path> future = futures.get(chunk);

    if (failed) {
      future.cancel(true);
      continue;
    }

    final long start = System.currentTimeMillis();

    if (!handleChunk(s3Artifact, future, downloadTo, chunk, start, remainingMillis)) {
      failed = true;
    }

    remainingMillis -= (System.currentTimeMillis() - start);
  }

  chunkExecutorService.shutdownNow();

  Preconditions.checkState(!failed, "Downloading %s/%s failed", s3Artifact.getS3Bucket(), s3Artifact.getS3ObjectKey());
}