<pre>
Google Cloud Storage bucket that can be used by this application to store
content.
&#64;OutputOnly
</pre>

<code>string default_bucket = 12;</code>
427244
public com.google.protobuf.ByteString
      getDefaultBucketBytes() {
    java.lang.Object ref = defaultBucket_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      defaultBucket_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
837404
@Override
  public GoogleCloudStorageFileSet finish(Collection<? extends OutputWriter<ByteBuffer>> writers)
      throws IOException {
    List<String> fileNames = new ArrayList<>();
    for (OutputWriter<ByteBuffer> writer : writers) {
      SizeSegmentingGoogleCloudStorageFileWriter segWriter =
          (SizeSegmentingGoogleCloudStorageFileWriter) writer;
      for (GoogleCloudStorageFileOutputWriter delegatedWriter : segWriter.getDelegatedWriters()) {
        fileNames.add(delegatedWriter.getFile().getObjectName());
      }
    }
    return new GoogleCloudStorageFileSet(bucket, fileNames);
  }
1095965
private File getDefaultOutputDirectory()
    {
        //The default output directory is the configuration name
        String childOutputDirectory = getConfiguration();
        
        //However, for platforms others than Win32, the default output directory becomes platform/configuration
        if ( ! getPlatform().equals( "Win32" ) )
        {
            childOutputDirectory = new File( getPlatform(), childOutputDirectory ).getPath();
        }
        
        //Place the default output directory within the appropriate base directory
        return new File( getBaseDirectory(), childOutputDirectory );
    }
905202
@Override
  public List<String> listBucketNames()
      throws IOException {
    logger.atFine().log("listBucketNames()");
    List<Bucket> allBuckets = listBucketsInternal();
    List<String> bucketNames = new ArrayList<>(allBuckets.size());
    for (Bucket bucket : allBuckets) {
      bucketNames.add(bucket.getName());
    }
    return bucketNames;
  }
1106809
public com.google.api.Logging getLogging() {
    return logging_ == null ? com.google.api.Logging.getDefaultInstance() : logging_;
  }
857347
public static Configuration get() {
    Configuration conf = new Configuration();
    File cloudConfigPath;
    if (isWindows()) {
      cloudConfigPath = new File(getEnvironment().get("APPDATA"), "gcloud");
    } else {
      cloudConfigPath = new File(System.getProperty("user.home"), ".config/gcloud");
    }
    File credentialFilePath = new File(cloudConfigPath, "application_default_credentials.json");
    if (!credentialFilePath.exists()) {
      return conf;
    }

    try {
      JsonFactory jsonFactory = Utils.getDefaultJsonFactory();
      InputStream inputStream = new FileInputStream(credentialFilePath);
      JsonObjectParser parser = new JsonObjectParser(jsonFactory);
      GenericJson fileContents = parser.parseAndClose(
          inputStream, Charsets.UTF_8, GenericJson.class);
      String fileType = (String) fileContents.get("type");
      if ("authorized_user".equals(fileType)) {
        String clientId = (String) fileContents.get("client_id");
        String clientSecret = (String) fileContents.get("client_secret");
        if (clientId != null && clientSecret != null) {
          LOG.debug("Using GCP user credential from '{}'", credentialFilePath);
          conf.setIfUnset("fs.gs.impl", GoogleHadoopFileSystem.class.getName());
          conf.setIfUnset("fs.AbstractFileSystem.gs.impl", GoogleHadoopFS.class.getName());
          conf.setIfUnset(GoogleHadoopFileSystemBase.GCS_PROJECT_ID_KEY, defaultProject());
          conf.setIfUnset(GoogleHadoopFileSystemBase.GCS_WORKING_DIRECTORY_KEY, "/hadoop");

          conf.setIfUnset(
              HadoopCredentialConfiguration.BASE_KEY_PREFIX +
              HadoopCredentialConfiguration.ENABLE_SERVICE_ACCOUNTS_SUFFIX,
              "false");
          conf.setIfUnset(
              HadoopCredentialConfiguration.BASE_KEY_PREFIX +
              HadoopCredentialConfiguration.CLIENT_ID_SUFFIX,
              clientId);
          conf.setIfUnset(
              HadoopCredentialConfiguration.BASE_KEY_PREFIX +
              HadoopCredentialConfiguration.CLIENT_SECRET_SUFFIX,
              clientSecret);
        }
      }
    } catch (IOException e) {
      LOG.warn("Failed to load GCP user credential from '{}'", credentialFilePath);
    }
    return conf;
  }
558975
public Bucket enableRequesterPays(String bucketName) throws StorageException {
    // [START enable_requester_pays]
    // Instantiate a Google Cloud Storage client
    Storage storage = StorageOptions.getDefaultInstance().getService();

    // The name of the existing bucket to enable requester-paying for, e.g. "my-bucket"
    // String bucketName = "my-bucket"
    BucketInfo bucketInfo = BucketInfo.newBuilder(bucketName).setRequesterPays(true).build();

    // Update the bucket, throws StorageException on failure
    Bucket bucket = storage.update(bucketInfo);

    System.out.println("Requester pay status for " + bucketName + ": " + bucket.requesterPays());
    // [END enable_requester_pays]
    return bucket;
  }
213152
public ByteArrayOutputStream getPartialObjectData(String bucket, String fname, long start, long endIncl,
                                                    @Nullable ByteArrayOutputStream optionalOldOutputToReuse) throws IOException {
    ByteArrayOutputStream out;
    if (null == optionalOldOutputToReuse) {
      out = new ByteArrayOutputStream((int) (endIncl - start + 1));
    } else {
      out = optionalOldOutputToReuse;
      out.reset();
    }
    Storage.Objects.Get getObject = storage.objects().get(bucket, fname);

    getObject.setRequestHeaders(new HttpHeaders().setRange(
        String.format("bytes=%d-%d", start, endIncl)));

    getObject.getMediaHttpDownloader().setDirectDownloadEnabled(!IS_APP_ENGINE);
    getObject.executeMediaAndDownloadTo(out);

    if (out.size() != (endIncl - start + 1)) {
      String err = "getPartialObjectData failed! Expected " + (endIncl - start + 1) + " bytes, got " + out.size();
      LOGGER.log(Level.WARNING, err);
      throw new IOException(err);
    }

    return out;
  }
460761
public Bucket createBucketWithStorageClassAndLocation(String bucketName) {
    // [START createBucketWithStorageClassAndLocation]
    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                // See here for possible values: http://g.co/cloud/storage/docs/storage-classes
                .setStorageClass(StorageClass.COLDLINE)
                // Possible values: http://g.co/cloud/storage/docs/bucket-locations#location-mr
                .setLocation("asia")
                .build());
    // [END createBucketWithStorageClassAndLocation]
    return bucket;
  }
918943
function GCSFS (args) {
    // initialize instance from default args
    _.merge(this, defaultArgs)
    // set args for instance
    mergeArgs(this, args)
    // require bucket
    assert(defined(this.bucketName), 'bucketName required')
    // args for instantiating google cloud storage client
    var gcsArgs = {
        promise: Promise,
    }
    // use key file if set
    if (defined(this.keyFile)) {
        gcsArgs.keyFilename = this.keyFile
    }
    // otherwise use credentials if set
    else if (defined(this.credentials)) {
        gcsArgs.credentials = this.credentials
    }
    else {
        throw new Error('keyFile or credentials required')
    }
    // create new gcs instance
    this.gcs = GCS(gcsArgs)
    // create bucket instance
    this.bucket = this.gcs.bucket(this.bucketName)
}
1274550
public java.lang.String getDefaultHostname() {
    java.lang.Object ref = defaultHostname_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      defaultHostname_ = s;
      return s;
    }
  }
26383
public boolean deleteDefaultBucketAcl(String bucketName) {
    // [START deleteDefaultBucketAcl]
    boolean deleted = storage.deleteDefaultAcl(bucketName, User.ofAllAuthenticatedUsers());
    if (deleted) {
      // the acl entry was deleted
    } else {
      // the acl entry was not found
    }
    // [END deleteDefaultBucketAcl]
    return deleted;
  }
162088
public org.tensorflow.framework.TensorInfo getOutputsOrDefault(
      java.lang.String key,
      org.tensorflow.framework.TensorInfo defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, org.tensorflow.framework.TensorInfo> map =
        internalGetOutputs().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }
754690
@Override
  public CloudStoragePath getPath(String first, String... more) {
    checkArgument(
        !first.startsWith(URI_SCHEME + ":"),
        "Google Cloud Storage FileSystem.getPath() must not have schema and bucket name: %s",
        first);
    return CloudStoragePath.getPath(this, first, more);
  }
150022
public static String DEFAULT_FLOW_DIR() {
    String flow_dir = null;

    try {
      if (ARGS.ga_hadoop_ver != null) {
        PersistManager pm = getPM();
        if (pm != null) {
          String s = pm.getHdfsHomeDirectory();
          if (pm.exists(s)) {
            flow_dir = s;
          }
        }
        if (flow_dir != null) {
          flow_dir = flow_dir + "/h2oflows";
        }
      } else {
        flow_dir = System.getProperty("user.home") + File.separator + "h2oflows";
      }
    }
    catch (Exception ignore) {
      // Never want this to fail, as it will kill program startup.
      // Returning null is fine if it fails for whatever reason.
    }

    return flow_dir;
  }
699516
private void writeObject (ObjectOutputStream out)
        throws IOException
    {
        out.defaultWriteObject();
        for (int idx = 0, pos = 0; pos < _size; idx++) {
            int value = _buckets[idx];
            if (value != _sentinel) {
                out.writeInt(value);
                pos++;
            }
        }
    }
691658
private String initMultipartUpload(String bucketName, String objectName, Map<String, String> headerMap)
    throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
           InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
           InternalException {
    // set content type if not set already
    if (headerMap.get("Content-Type") == null) {
      headerMap.put("Content-Type", "application/octet-stream");
    }

    Map<String,String> queryParamMap = new HashMap<>();
    queryParamMap.put("uploads", "");

    HttpResponse response = executePost(bucketName, objectName, headerMap, queryParamMap, "");

    InitiateMultipartUploadResult result = new InitiateMultipartUploadResult();
    result.parseXml(response.body().charStream());
    response.body().close();
    return result.uploadId();
  }