import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
/**
 * Synchronizes the object to the BLOB store. The {@link CloudFileChannelTransport} is used here
 * to construct the payload, and run a pre and post action.
 * @param writeMetaData 	Whether to also write metadata or not
 * @throws IOException
 */
protected void syncToBlobStore(boolean writeMetaData) throws IOException {
	// Should we write?
	if (cloudFileOptions.contains(StandardOpenOption.WRITE) ||
			cloudFileOptions.contains(StandardOpenOption.APPEND) || writeShouldSync) {
		syncCount.incrementAndGet();
		LOG.debug("Executing pre-sync interceptor action {} for local file store '{}' to cloud path '{}'",
				transport.getClass().getName(), localPath, path);
		transport.preSyncToCloud(this, writeMetaData);
		LOG.debug("Executed pre-sync interceptor action {} for local file store '{}' to cloud path '{}' OK",
				transport.getClass().getName(), localPath, path);
		LOG.debug("Synchronizing from local file store '{}' to cloud path '{}'", localPath, path);
		File pathFile = localPath.toFile();
		
		// Sync to blob store
		Payload payload = transport.createPayload(localPath);
		try {
			// Read the file content from the channel so far
			BlobStore blobStore = context.getBlobStore();
			BlobBuilder blobBuilder = buildPayload(pathFile, payload, blobStore);
			transport.storeBlob(context, path.getContainerName(), blobBuilder.build(), getPutOption(), writeMetaData);
		} finally {
			payload.close();
		}

		LOG.info("Synchronized from local file store '{}' to cloud path '{}' OK", localPath, path);
		LOG.debug("Executing post-sync interceptor action {} for local file store '{}' to cloud path '{}'",
				transport.getClass().getName(), localPath, path);
		transport.postSyncToCloud(this, writeMetaData);
		LOG.debug("Executed post-sync interceptor action {} for local file store '{}' to cloud path '{}' OK",
				transport.getClass().getName(), localPath, path);
	}
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Inject
protected OSSBlobUtils(
      BlobBuilder blobBuilder,
      Provider<BlobBuilder> blobBuilders,
      ClearListStrategy clearContainerStrategy,
      GetDirectoryStrategy getDirectoryStrategy,
      MkdirStrategy mkdirStrategy,
      CountListStrategy countBlobsStrategy,
      DeleteDirectoryStrategy rmDirStrategy) {
   super(blobBuilders, clearContainerStrategy, getDirectoryStrategy, mkdirStrategy, countBlobsStrategy, rmDirStrategy);
   this.blobBuilder = blobBuilder;
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
protected void configure() {
   bind(OSSApi.class).to(OSSApiImpl.class);
   bind(BlobStore.class).to(OSSBlobStore.class);
   bind(BlobRequestSigner.class).to(OSSBlobRequestSigner.class);
   bind(ConsistencyModel.class).toInstance(ConsistencyModel.EVENTUAL);
   bind(BlobBuilder.class).to(OSSBlobBuilder.class);
   bind(BlobUtils.class).to(OSSBlobUtils.class);
   bind(LocationsSupplier.class).to(OSSLocationsSupplier.class);
   bind(RegionIdsSupplier.class).to(OSSRegionIdsSupplier.class);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
private static void addContentMetdataFromHttpRequest(
        BlobBuilder.PayloadBlobBuilder builder,
        HttpServletRequest request) {
    ImmutableMap.Builder<String, String> userMetadata =
            ImmutableMap.builder();
    for (String headerName : Collections.list(request.getHeaderNames())) {
        if (startsWithIgnoreCase(headerName, USER_METADATA_PREFIX)) {
            userMetadata.put(
                    headerName.substring(USER_METADATA_PREFIX.length()),
                    Strings.nullToEmpty(request.getHeader(headerName)));
        }
    }
    builder.cacheControl(request.getHeader(
                    HttpHeaders.CACHE_CONTROL))
            .contentDisposition(request.getHeader(
                    HttpHeaders.CONTENT_DISPOSITION))
            .contentEncoding(request.getHeader(
                    HttpHeaders.CONTENT_ENCODING))
            .contentLanguage(request.getHeader(
                    HttpHeaders.CONTENT_LANGUAGE))
            .userMetadata(userMetadata.build());
    String contentType = request.getContentType();
    if (contentType != null) {
        builder.contentType(contentType);
    }
    long expires = request.getDateHeader(HttpHeaders.EXPIRES);
    if (expires != -1) {
        builder.expires(new Date(expires));
    }
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder() {
   return blobBuilder;
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
private void handleInitiateMultipartUpload(HttpServletRequest request,
        HttpServletResponse response, BlobStore blobStore,
        String containerName, String blobName)
        throws IOException, S3Exception {
    ByteSource payload = ByteSource.empty();
    BlobBuilder.PayloadBlobBuilder builder = blobStore
            .blobBuilder(blobName)
            .payload(payload);
    addContentMetdataFromHttpRequest(builder, request);
    builder.contentLength(payload.size());

    BlobAccess access;
    String cannedAcl = request.getHeader("x-amz-acl");
    if (cannedAcl == null || cannedAcl.equalsIgnoreCase("private")) {
        access = BlobAccess.PRIVATE;
    } else if (cannedAcl.equalsIgnoreCase("public-read")) {
        access = BlobAccess.PUBLIC_READ;
    } else if (CANNED_ACLS.contains(cannedAcl)) {
        throw new S3Exception(S3ErrorCode.NOT_IMPLEMENTED);
    } else {
        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return;
    }
    PutOptions options = new PutOptions().setBlobAccess(access);

    MultipartUpload mpu = blobStore.initiateMultipartUpload(containerName,
            builder.build().getMetadata(), options);

    if (Quirks.MULTIPART_REQUIRES_STUB.contains(getBlobStoreType(
            blobStore))) {
        blobStore.putBlob(containerName, builder.name(mpu.id()).build(),
                options);
    }

    try (Writer writer = response.getWriter()) {
        response.setContentType(XML_CONTENT_TYPE);
        XMLStreamWriter xml = xmlOutputFactory.createXMLStreamWriter(
                writer);
        xml.writeStartDocument();
        xml.writeStartElement("InitiateMultipartUploadResult");
        xml.writeDefaultNamespace(AWS_XMLNS);

        writeSimpleElement(xml, "Bucket", containerName);
        writeSimpleElement(xml, "Key", blobName);
        writeSimpleElement(xml, "UploadId", mpu.id());

        xml.writeEndElement();
        xml.flush();
    } catch (XMLStreamException xse) {
        throw new IOException(xse);
    }
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
default BlobBuilder blobBuilder(String name) {
    return delegate().blobBuilder(name);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder(String s) {
    return delegate.blobBuilder(s);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder(String s) {
    return nearStore.blobBuilder(s);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder(String name) {
    return blobUtils.blobBuilder().name(name);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder(String name) {
    return delegate().blobBuilder(name);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder(String name) {
    return app.getBlobStore(0).blobBuilder(name);
}
 

import org.jclouds.blobstore.domain.BlobBuilder; //导入依赖的package包/类
@Override
public BlobBuilder blobBuilder(String name) {
    throw new UnsupportedOperationException("async is not supported");
}