Buckets auflisten

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client) {
  int count = 0;
  gcs::ListBucketsExtendedReader bucket_list = client.ListBucketsExtended();
  for (auto&& result : bucket_list) {
    if (!result) throw std::move(result).status();

    for (auto const& bucket_metadata : result->buckets) {
      std::cout << bucket_metadata.name() << "\n";
      ++count;
    }
    for (auto const& unreachable : result->unreachable) {
      std::cout << "Unreachable location: " << unreachable << "\n";
    }
  }

  if (count == 0) {
    std::cout << "No buckets in default project\n";
  }
}

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client) {
  int count = 0;
  gcs::ListBucketsReader bucket_list = client.ListBuckets();
  for (auto&& bucket_metadata : bucket_list) {
    if (!bucket_metadata) throw std::move(bucket_metadata).status();

    std::cout << bucket_metadata->name() << "\n";
    ++count;
  }

  if (count == 0) {
    std::cout << "No buckets in default project\n";
  }
}

using Google.Api.Gax;
using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;
using System.Linq;

public class ListBucketsWithPartialSuccessSample
{
    /// <summary>
    /// Lists buckets, returning both the reachable buckets and the resource names of buckets from unreachable locations when specific regions are unreachable.
    /// </summary>
    /// <param name="projectId">The ID of the project to list the buckets.</param>
    public (IReadOnlyList<Bucket> Reachable, IReadOnlyList<string> Unreachable) ListBucketsWithPartialSuccess
        (string projectId = "your-project-id")
    {
        var storage = StorageClient.Create();
        var pagedResult = storage.ListBuckets(projectId, options: new ListBucketsOptions
        {
            ReturnPartialSuccess = true
        });

        var reachableBuckets = new List<Bucket>();
        var unreachableBuckets = new List<string>();

        foreach (var page in pagedResult.AsRawResponses())
        {
            reachableBuckets.AddRange(page.Items ?? Enumerable.Empty<Bucket>());
            unreachableBuckets.AddRange(page.Unreachable ?? Enumerable.Empty<string>());
        }

        Console.WriteLine("Buckets:");
        foreach (var bucket in reachableBuckets)
        {
            Console.WriteLine(bucket.Name);
        }

        if (unreachableBuckets.Any())
        {
            Console.WriteLine("The Resource Names of Buckets from Unreachable Locations:");
            foreach (var bucket in unreachableBuckets)
            {
                Console.WriteLine(bucket);
            }
        }
        return (reachableBuckets, unreachableBuckets);
    }
}

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class ListBucketsSample
{
    public IEnumerable<Bucket> ListBuckets(string projectId = "your-project-id")
    {
        var storage = StorageClient.Create();
        var buckets = storage.ListBuckets(projectId);
        Console.WriteLine("Buckets:");
        foreach (var bucket in buckets)
        {
            Console.WriteLine(bucket.Name);
        }
        return buckets;
    }
}

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/iterator"
)

// listBucketsPartialSuccess lists buckets in the project. If ReturnPartialSuccess
// is true, the iterator will return reachable buckets and a list of
// unreachable bucket resource names.
func listBucketsPartialSuccess(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	it := client.Buckets(ctx, projectID)
	// Enable returning unreachable buckets.
	it.ReturnPartialSuccess = true

	fmt.Fprintln(w, "Reachable buckets:")
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// Errors here usually indicate a problem with the overall list operation
			// or connection, such as a network issue, rather than individual
			// buckets being unreachable. Unreachable buckets due to issues like
			// regional outages or permission issues are typically reported via the
			// Unreachable() method below.
			return err
		}
		fmt.Fprintf(w, "- %v\n", battrs.Name)
	}

	// Retrieve the list of buckets that were unreachable.
	unreachable := it.Unreachable()
	if len(unreachable) > 0 {
		fmt.Fprintln(w, "\nUnreachable buckets:")
		for _, r := range unreachable {
			fmt.Fprintf(w, "- %v\n", r)
		}
	} else {
		fmt.Fprintln(w, "\nNo unreachable buckets.")
	}

	return nil
}

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/iterator"
)

// listBuckets lists buckets in the project.
func listBuckets(w io.Writer, projectID string) ([]string, error) {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	var buckets []string
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, err
		}
		buckets = append(buckets, battrs.Name)
		fmt.Fprintf(w, "Bucket: %v\n", battrs.Name)
	}
	return buckets, nil
}

import com.google.api.gax.paging.Page;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ListBucketsWithPartialSuccess {
  public static void listBucketsWithPartialSuccess(String projectId) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Page<Bucket> buckets = storage.list(Storage.BucketListOption.returnPartialSuccess(true));

    // Retrieve the list of buckets that are unreachable due to issues like regional outages or
    // permission issues
    System.out.println("Unreachable buckets: \n");
    for (Bucket bucket : buckets.iterateAll()) {
      if (Boolean.TRUE.equals(bucket.isUnreachable())) {
        System.out.println(bucket.getName());
      }
    }
  }
}

import com.google.api.gax.paging.Page;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ListBuckets {
  public static void listBuckets(String projectId) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Page<Bucket> buckets = storage.list();

    for (Bucket bucket : buckets.iterateAll()) {
      System.out.println(bucket.getName());
    }
  }
}

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function listBucketsPartialSuccess() {
  const option = {
    returnPartialSuccess: true,
    maxResults: 5,
  };
  const [buckets, nextQuery, apiResponse] = await storage.getBuckets(option);

  if (nextQuery && nextQuery.pageToken) {
    console.log(`Next Page Token: ${nextQuery.pageToken}`);
  }

  console.log('\nBuckets:');
  buckets.forEach(bucket => {
    if (bucket.unreachable) {
      console.log(`${bucket.name} (unreachable: ${bucket.unreachable})`);
    } else {
      console.log(`${bucket.name}`);
    }
  });

  if (apiResponse.unreachable && apiResponse.unreachable.length > 0) {
    console.log('\nUnreachable Buckets:');
    apiResponse.unreachable.forEach(item => {
      console.log(item);
    });
  }
}

listBucketsPartialSuccess().catch(console.error);

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function listBuckets() {
  const [buckets] = await storage.getBuckets();

  console.log('Buckets:');
  buckets.forEach(bucket => {
    console.log(bucket.name);
  });
}

listBuckets().catch(console.error);

use Google\Cloud\Storage\StorageClient;

/**
 * Retrieves a list of buckets while gracefully handling regional downtime.
 */
function list_buckets_partial_success(): void
{
    $storage = new StorageClient();
    $options = [ 'returnPartialSuccess' => true ];
    $buckets = $storage->buckets($options);

    // Check for unreachable locations first
    // Note: unreachable() returns an array of strings for buckets in unavailable regions
    if ($unreachable = $buckets->unreachable()) {
        foreach ($unreachable as $location) {
            printf('Unreachable Bucket: %s' . PHP_EOL, $location);
        }
    }

    // Iterate through the buckets that were successfully retrieved
    foreach ($buckets as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

use Google\Cloud\Storage\StorageClient;

/**
 * List all Cloud Storage buckets for the current project.
 */
function list_buckets(): void
{
    $storage = new StorageClient();
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

from google.cloud import storage


def list_buckets_with_partial_success():
    """Lists buckets and includes unreachable buckets in the response."""

    storage_client = storage.Client()

    buckets_iterator = storage_client.list_buckets(return_partial_success=True)

    for page in buckets_iterator.pages:
        if page.unreachable:
            print("Unreachable locations in this page:")
            for location in page.unreachable:
                print(location)

        print("Reachable buckets in this page:")
        for bucket in page:
            print(bucket.name)

from google.cloud import storage


def list_buckets():
    """Lists all buckets."""

    storage_client = storage.Client()
    buckets = storage_client.list_buckets()

    for bucket in buckets:
        print(bucket.name)

# Demonstrates listing Google Cloud Storage buckets with support for partial success.
#
# This method initializes a Google Cloud Storage client and requests a list of buckets.
# When `return_partial_success` is true, the API will return available buckets
# and a list of any buckets that were unreachable.
#
# @param return_partial_success_flag [Boolean] Whether to allow partial success from the API.
#   - true: returns the available buckets and populates `unreachable` with bucket names if any.
#   - false: throws an error if any buckets are unreachable.
def list_buckets_with_partial_success return_partial_success_flag:
  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket_list = storage.buckets return_partial_success: return_partial_success_flag

  puts "Reachable buckets:"
  # limiting the bucket count to be printed to 10 for brevity
  bucket_list.take(10).each do |bucket|
    puts bucket.name
  end

  if bucket_list.unreachable
    puts "\nUnreachable buckets:"
    # limiting the bucket count to be printed to 10 for brevity
    bucket_list.unreachable.take(10).each do |unreachable_bucket_name|
      puts unreachable_bucket_name
    end
  end
end

def list_buckets
  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new

  storage.buckets.each do |bucket|
    puts bucket.name
  end
end

use google_cloud_storage::client::StorageControl;

pub async fn sample(client: &StorageControl, project_id: &str) -> anyhow::Result<()> {
    use google_cloud_gax::paginator::ItemPaginator;

    let mut items = client
        .list_buckets()
        .set_parent(format!("projects/{project_id}"))
        .by_item();
    while let Some(bucket) = items.next().await.transpose()? {
        println!("{bucket:?}");
    }
    Ok(())
}