import static java.nio.charset.StandardCharsets.UTF_8;

import com.google.gcloud.storage.BlobReadChannel;

import java.io.IOException;

import java.nio.ByteBuffer;

public void run(StorageService storage, Blob blob) throws IOException {

if (blob.size() < 1024) {

System.out.println(new String(storage.load(blob), UTF_8));

try (BlobReadChannel reader = storage.reader(blob)) {

ByteBuffer bytes = ByteBuffer.allocate(64 * 1024);

while (reader.read(bytes) > 0) {

bytes.flip();

System.out.print(UTF_8.decode(bytes));

bytes.clear();

}

}

System.out.printf("Usage: %s [<project_id>] operation <args>*%s%n",

/* * Copyright 2015 Google Inc. All Rights Reserved. * * Licensed 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 com.google.gcloud.spi;import com.google.api.services.storage.model.Bucket;import com.google.api.services.storage.model.StorageObject;import com.google.common.collect.ImmutableList;import com.google.common.collect.ImmutableMap;import com.google.gcloud.storage.BlobWriteChannel;import com.google.gcloud.storage.StorageServiceException;import java.util.List;import java.util.Map;public interface StorageRpc { enum Option { PREDEFINED_ACL("predefinedAcl"), PREDEFINED_DEFAULT_OBJECT_ACL("predefinedDefaultObjectAcl"), IF_METAGENERATION_MATCH("ifMetagenerationMatch"), IF_METAGENERATION_NOT_MATCH("ifMetagenerationNotMatch"), IF_GENERATION_NOT_MATCH("ifGenerationMatch"), IF_GENERATION_MATCH("ifGenerationNotMatch"), IF_SOURCE_METAGENERATION_MATCH("ifSourceMetagenerationMatch"), IF_SOURCE_METAGENERATION_NOT_MATCH("ifSourceMetagenerationNotMatch"), IF_SOURCE_GENERATION_MATCH("ifSourceGenerationMatch"), IF_SOURCE_GENERATION_NOT_MATCH("ifSourceGenerationNotMatch"), PREFIX("prefix"), MAX_RESULTS("maxResults"), PAGE_TOKEN("pageToken"), DELIMITER("delimiter"), VERSIONS("versions"); private final String value; Option(String value) { this.value = value; } public String value() { return value; } @SuppressWarnings("unchecked") <T> T get(Map<Option, ?> options) { return (T) options.get(this); } String getString(Map<Option, ?> options) { return get(options); } Long getLong(Map<Option, ?> options) { return get(options); } Boolean getBoolean(Map<Option, ?> options) { return get(options); } } class Tuple<X, Y> { private final X x; private final Y y; private Tuple(X x, Y y) { this.x = x; this.y = y; } public static <X, Y> Tuple<X, Y> of(X x, Y y) { return new Tuple<>(x, y); } public X x() { return x; } public Y y() { return y; } } class BatchRequest { public final List<Tuple<StorageObject, Map<Option, ?>>> toDelete; public final List<Tuple<StorageObject, Map<Option, ?>>> toUpdate; public final List<Tuple<StorageObject, Map<Option, ?>>> toGet; public BatchRequest(Iterable<Tuple<StorageObject, Map<Option, ?>>> toDelete, Iterable<Tuple<StorageObject, Map<Option, ?>>> toUpdate, Iterable<Tuple<StorageObject, Map<Option, ?>>> toGet) { this.toDelete = ImmutableList.copyOf(toDelete); this.toUpdate = ImmutableList.copyOf(toUpdate); this.toGet = ImmutableList.copyOf(toGet); } } class BatchResponse { public final Map<StorageObject, Tuple<Boolean, StorageServiceException>> deletes; public final Map<StorageObject, Tuple<StorageObject, StorageServiceException>> updates; public final Map<StorageObject, Tuple<StorageObject, StorageServiceException>> gets; public BatchResponse(Map<StorageObject, Tuple<Boolean, StorageServiceException>> deletes, Map<StorageObject, Tuple<StorageObject, StorageServiceException>> updates, Map<StorageObject, Tuple<StorageObject, StorageServiceException>> gets) { this.deletes = ImmutableMap.copyOf(deletes); this.updates = ImmutableMap.copyOf(updates); this.gets = ImmutableMap.copyOf(gets); } } Bucket create(Bucket bucket, Map<Option, ?> options) throws StorageServiceException; StorageObject create(StorageObject object, byte[] content, Map<Option, ?> options) throws StorageServiceException; Tuple<String, Iterable<Bucket>> list(Map<Option, ?> options) throws StorageServiceException; Tuple<String, Iterable<StorageObject>> list(String bucket, Map<Option, ?> options) throws StorageServiceException; Bucket get(Bucket bucket, Map<Option, ?> options) throws StorageServiceException; StorageObject get(StorageObject object, Map<Option, ?> options) throws StorageServiceException; Bucket patch(Bucket bucket, Map<Option, ?> options) throws StorageServiceException; StorageObject patch(StorageObject storageObject, Map<Option, ?> options) throws StorageServiceException; boolean delete(Bucket bucket, Map<Option, ?> options) throws StorageServiceException; boolean delete(StorageObject object, Map<Option, ?> options) throws StorageServiceException; BatchResponse batch(BatchRequest request) throws StorageServiceException; StorageObject compose(Iterable<StorageObject> sources, StorageObject target, Map<Option, ?> targetOptions) throws StorageServiceException; StorageObject copy(StorageObject source, Map<Option, ?> sourceOptions, StorageObject target, Map<Option, ?> targetOptions) throws StorageServiceException; byte[] load(StorageObject storageObject, Map<Option, ?> options) throws StorageServiceException; byte[] read(StorageObject from, Map<Option, ?> options, int position, int bytes) throws StorageServiceException; BlobWriteChannel writer(StorageObject to, Map<Option, ?> options) throws StorageServiceException;}

import java.io.IOException;

void seek(int position) throws IOException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.nio.ByteBuffer;

private static class BlobReadChannelImpl implements BlobReadChannel {

private final StorageServiceOptions serviceOptions;

private final Blob blob;

private final Map<StorageRpc.Option, ?> requestOptions;

private int position;

private boolean isOpen;

private boolean endOfStream;

private transient StorageRpc storageRpc;

private transient RetryParams retryParams;

private transient StorageObject storageObject;

private transient int bufferPos;

private transient byte[] buffer;

BlobReadChannelImpl(StorageServiceOptions serviceOptions, Blob blob,

Map<StorageRpc.Option, ?> requestOptions) {

this.serviceOptions = serviceOptions;

this.blob = blob;

this.requestOptions = requestOptions;

isOpen = true;

initTransients();

}

private void writeObject(ObjectOutputStream out) throws IOException {

if (buffer != null) {

position += bufferPos;

buffer = null;

bufferPos = 0;

endOfStream = false;

}

out.defaultWriteObject();

}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

in.defaultReadObject();

initTransients();

}

private void initTransients() {

storageRpc = serviceOptions.storageRpc();

retryParams = MoreObjects.firstNonNull(serviceOptions.retryParams(), RetryParams.noRetries());

storageObject = blob.toPb();

}

@Override

public boolean isOpen() {

return isOpen;

}

@Override

public void close() {

if (isOpen) {

buffer = null;

isOpen = false;

}

}

private void validateOpen() throws IOException {

if (!isOpen) {

throw new IOException("stream is closed");

}

}

@Override

public void seek(int position) throws IOException {

validateOpen();

throw new UnsupportedOperationException("not supported yet");

// todo: implement

}

@Override

public int read(ByteBuffer byteBuffer) throws IOException {

validateOpen();

if (buffer == null) {

if (endOfStream) {

return -1;

}

final int toRead = Math.max(byteBuffer.remaining(), 256 * 1024);

buffer = runWithRetries(new Callable<byte[]>() {

@Override

public byte[] call() {

return storageRpc.read(storageObject, requestOptions, position, toRead);

}

}, retryParams, EXCEPTION_HANDLER);

if (toRead > buffer.length) {

endOfStream = true;

}

}

int toWrite = Math.min(buffer.length - bufferPos, byteBuffer.remaining());

byteBuffer.put(buffer, bufferPos, toWrite);

bufferPos += toWrite;

if (bufferPos >= buffer.length) {

position += buffer.length;

buffer = null;

bufferPos = 0;

}

return toWrite;

}

}

Map<StorageRpc.Option, ?> optionsMap = optionMap(blob, options);

return new BlobReadChannelImpl(options(), blob, optionsMap);

// todo: consider providing read-timeout