| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * 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. |
| */ |
| package org.jclouds.examples.rackspace.cloudfiles; |
| |
| import com.google.common.collect.ImmutableMultimap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Multimap; |
| import com.google.common.io.ByteSource; |
| import com.google.common.io.Closeables; |
| import com.google.common.io.Files; |
| import com.google.common.util.concurrent.FutureCallback; |
| import com.google.common.util.concurrent.Futures; |
| import com.google.common.util.concurrent.ListenableFuture; |
| import com.google.common.util.concurrent.ListeningExecutorService; |
| import com.google.common.util.concurrent.MoreExecutors; |
| import org.jclouds.ContextBuilder; |
| import org.jclouds.blobstore.BlobStore; |
| import org.jclouds.blobstore.domain.Blob; |
| import org.jclouds.domain.Location; |
| import org.jclouds.io.Payloads; |
| import org.jclouds.openstack.swift.v1.blobstore.RegionScopedBlobStoreContext; |
| import org.jclouds.openstack.swift.v1.options.UpdateContainerOptions; |
| import org.jclouds.rackspace.cloudfiles.v1.CloudFilesApi; |
| |
| import java.io.Closeable; |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.URI; |
| import java.util.List; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.ExecutionException; |
| |
| import static com.google.common.base.Preconditions.checkArgument; |
| import static com.google.common.collect.Iterables.getOnlyElement; |
| import static java.util.concurrent.Executors.newFixedThreadPool; |
| import static org.jclouds.examples.rackspace.cloudfiles.Constants.PROVIDER; |
| import static org.jclouds.examples.rackspace.cloudfiles.Constants.REGION; |
| import static org.jclouds.openstack.swift.v1.reference.SwiftHeaders.STATIC_WEB_ERROR; |
| import static org.jclouds.openstack.swift.v1.reference.SwiftHeaders.STATIC_WEB_INDEX; |
| |
| /** |
| * Upload an entire directory and all of its sub-directories to a Cloud Files container. The local directory hierarchy |
| * will be mimicked as pseudo-hierarchical directories (http://j.mp/rax-hier) within the container. This is a great |
| * way to upload content for a static website (http://j.mp/rax-static). |
| */ |
| public class UploadDirectoryToCDN implements Closeable { |
| private static final int THREADS = Integer.getInteger("upload.threadpool.size", 10); |
| |
| private final BlobStore blobStore; |
| private final CloudFilesApi cloudFiles; |
| |
| /** |
| * To get a username and API key see http://jclouds.apache.org/guides/rackspace/ |
| * |
| * The first argument (args[0]) must be your username |
| * The second argument (args[1]) must be your API key |
| * The third argument (args[2]) must be the path to the local directory |
| * The fourth argument (args[3]) must be the remote container name |
| */ |
| public static void main(String[] args) throws IOException { |
| UploadDirectoryToCDN uploadDirToCDN = new UploadDirectoryToCDN(args[0], args[1]); |
| |
| try { |
| uploadDirToCDN.uploadDirectory(args[2], args[3]); |
| uploadDirToCDN.enableCdnContainer(args[3]); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| finally { |
| uploadDirToCDN.close(); |
| } |
| } |
| |
| public UploadDirectoryToCDN(String username, String apiKey) { |
| RegionScopedBlobStoreContext context = ContextBuilder.newBuilder(PROVIDER) |
| .credentials(username, apiKey) |
| .buildView(RegionScopedBlobStoreContext.class); |
| blobStore = context.getBlobStore(REGION); |
| cloudFiles = blobStore.getContext().unwrapApi(CloudFilesApi.class); |
| } |
| |
| /** |
| * Generate a list of all of the local files under the specified dirPath and then upload them to container. |
| */ |
| private void uploadDirectory(String dirPath, String container) throws InterruptedException, ExecutionException { |
| File dir = new File(dirPath); |
| checkArgument(dir.isDirectory(), "%s is not a directory", dirPath); |
| |
| System.out.format("Uploading %s to %s", dirPath, container); |
| |
| // There is only one assignable location because we are using the RegionScopedBlobStoreContext |
| Location location = getOnlyElement(blobStore.listAssignableLocations()); |
| blobStore.createContainerInLocation(location, container); |
| |
| List<BlobDetail> blobDetails = Lists.newArrayList(); |
| generateFileList(dir, "", blobDetails); |
| uploadFiles(container, blobDetails); |
| } |
| |
| /** |
| * Recursively generate the list of files to upload. |
| */ |
| private void generateFileList(File localDir, String remotePath, List<BlobDetail> blobDetails) { |
| for (File localFile: localDir.listFiles()) { |
| String remoteBlobName = remotePath + localFile.getName(); |
| |
| if (localFile.isFile()) { |
| blobDetails.add(new BlobDetail(remoteBlobName, localFile)); |
| } |
| else { |
| generateFileList(localFile, remoteBlobName + "/", blobDetails); |
| } |
| } |
| } |
| |
| /** |
| * Upload the files in parallel. |
| */ |
| private void uploadFiles(String container, List<BlobDetail> blobDetails) |
| throws InterruptedException, ExecutionException { |
| ListeningExecutorService executor = MoreExecutors.listeningDecorator(newFixedThreadPool(THREADS)); |
| List<ListenableFuture<BlobDetail>> blobUploaderFutures = Lists.newArrayList(); |
| BlobUploaderCallback blobUploaderCallback = new BlobUploaderCallback(); |
| |
| try { |
| |
| for (BlobDetail blobDetail: blobDetails) { |
| BlobUploader blobUploader = new BlobUploader(container, blobDetail); |
| ListenableFuture<BlobDetail> blobDetailFuture = executor.submit(blobUploader); |
| blobUploaderFutures.add(blobDetailFuture); |
| |
| Futures.addCallback(blobDetailFuture, blobUploaderCallback); |
| } |
| |
| ListenableFuture<List<BlobDetail>> future = Futures.successfulAsList(blobUploaderFutures); |
| List<BlobDetail> uploadedBlobDetails = future.get(); // begin the upload |
| |
| System.out.format("%n"); |
| |
| for (int i = 0; i < uploadedBlobDetails.size(); i++) { |
| if (uploadedBlobDetails.get(i) != null) { |
| BlobDetail blobDetail = uploadedBlobDetails.get(i); |
| System.out.format(" %s (eTag: %s)%n", blobDetail.getRemoteBlobName(), blobDetail.getETag()); |
| } |
| else { |
| System.out.format(" %s (ERROR)%n", blobDetails.get(i).getLocalFile().getAbsolutePath()); |
| } |
| } |
| } |
| finally { |
| executor.shutdown(); |
| } |
| } |
| |
| /** |
| * This method will put your container on a Content Distribution Network and |
| * make it available as a static website. |
| */ |
| private void enableCdnContainer(String container) { |
| System.out.format("Enable CDN%n"); |
| Multimap<String, String> enableStaticWebHeaders = |
| ImmutableMultimap.of(STATIC_WEB_INDEX, "index.html", |
| STATIC_WEB_ERROR, "error.html"); |
| |
| UpdateContainerOptions opts = new UpdateContainerOptions().headers(enableStaticWebHeaders); |
| cloudFiles.getContainerApi(REGION).update(container, opts); |
| |
| // enable the CDN container |
| URI cdnURI = cloudFiles.getCDNApi(REGION).enable(container); |
| System.out.format(" Go to %s/%n", cdnURI); |
| } |
| |
| /** |
| * Always close your service when you're done with it. |
| */ |
| public void close() throws IOException { |
| Closeables.close(blobStore.getContext(), true); |
| } |
| |
| /** |
| * A Callable responsible for uploading an object to a container. Returns a BlobDetail with the eTag of the |
| * uploaded object. |
| */ |
| private class BlobUploader implements Callable<BlobDetail> { |
| private final String container; |
| private final BlobDetail toBeUploadedBlobDetail; |
| |
| protected BlobUploader(String container, BlobDetail toBeUploadedBlobDetail) { |
| this.container = container; |
| this.toBeUploadedBlobDetail = toBeUploadedBlobDetail; |
| } |
| |
| public BlobDetail call() throws Exception { |
| ByteSource byteSource = Files.asByteSource(toBeUploadedBlobDetail.getLocalFile()); |
| |
| Blob blob = blobStore.blobBuilder(toBeUploadedBlobDetail.getRemoteBlobName()) |
| .payload(Payloads.newByteSourcePayload(byteSource)) |
| .contentType("") // allows Cloud Files to determine the content type |
| .build(); |
| String eTag = blobStore.putBlob(container, blob); |
| BlobDetail uploadedBlobDetail = new BlobDetail( |
| toBeUploadedBlobDetail.getRemoteBlobName(), toBeUploadedBlobDetail.getLocalFile(), eTag); |
| |
| return uploadedBlobDetail; |
| } |
| } |
| |
| /** |
| * Example of a FutureCallback triggered when an upload has finished. Just prints out a character to inform |
| * the user of upload progress. |
| */ |
| private class BlobUploaderCallback implements FutureCallback<BlobDetail> { |
| |
| public void onSuccess(BlobDetail result) { |
| System.out.format("."); |
| } |
| |
| public void onFailure(Throwable t) { |
| System.out.format("X %s", t); |
| } |
| } |
| |
| /** |
| * An immutable class for holding details about an object. When an object has been successfully uploaded the |
| * eTag will be present. |
| */ |
| public static class BlobDetail { |
| private final String remoteBlobName; |
| private final File localFile; |
| private final String eTag; |
| |
| protected BlobDetail(String remoteBlobName, File localFile) { |
| this(remoteBlobName, localFile, null); |
| } |
| |
| protected BlobDetail(String remoteBlobName, File localFile, String eTag) { |
| this.remoteBlobName = remoteBlobName; |
| this.localFile = localFile; |
| this.eTag = eTag; |
| } |
| |
| public String getRemoteBlobName() { |
| return remoteBlobName; |
| } |
| |
| public File getLocalFile() { |
| return localFile; |
| } |
| |
| public String getETag() { |
| return eTag; |
| } |
| |
| public boolean isUploaded() { |
| return eTag != null; |
| } |
| } |
| } |