List subscriptions

namespacepubsub_admin=::google::cloud::pubsub_admin;
[](pubsub_admin::SubscriptionAdminClientclient,
std::stringconst&project_id){
intcount=0;
google::pubsub::v1::ListSubscriptionsRequestrequest;
request.set_project(google::cloud::Project(project_id).FullName());
for(auto&subscription:client.ListSubscriptions(request)){
if(!subscription)throwstd::move(subscription).status();
std::cout << "Subscription Name: " << subscription->name() << "\n";
++count;
}
if(count==0){
std::cout << "No subscriptions found in project " << project_id << "\n";
}
}

usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.PubSub.V1 ;
usingSystem.Collections.Generic;
publicclassListSubscriptionsSample
{
publicIEnumerable<Subscription>ListSubscriptions(stringprojectId)
{
SubscriberServiceApiClient subscriber=SubscriberServiceApiClient .Create ();
ProjectName projectName=ProjectName .FromProject (projectId);
varsubscriptions=subscriber.ListSubscriptions (projectName);
returnsubscriptions;
}
}

import(
"context"
"fmt"
"cloud.google.com/go/pubsub/v2"
"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
"google.golang.org/api/iterator"
)
funclist(projectIDstring)([]*pubsubpb.Subscription,error){
// projectID := "my-project-id"
ctx:=context.Background()
client,err:=pubsub.NewClient(ctx,projectID)
iferr!=nil{
returnnil,fmt.Errorf("pubsub.NewClient: %w",err)
}
deferclient.Close()
varsubs[]*pubsubpb.Subscription
req:=&pubsubpb.ListSubscriptionsRequest{
Project:fmt.Sprintf("projects/%s",projectID),
}
it:=client.SubscriptionAdminClient.ListSubscriptions(ctx,req)
for{
s,err:=it.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnnil,fmt.Errorf("Next: %w",err)
}
subs=append(subs,s)
}
returnsubs,nil
}

importcom.google.cloud.pubsub.v1.SubscriptionAdminClient ;
importcom.google.pubsub.v1.ProjectName ;
importcom.google.pubsub.v1.Subscription ;
importjava.io.IOException;
publicclass ListSubscriptionsInProjectExample{
publicstaticvoidmain(String...args)throwsException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
listSubscriptionInProjectExample(projectId);
}
publicstaticvoidlistSubscriptionInProjectExample(StringprojectId)throwsIOException{
try(SubscriptionAdminClient subscriptionAdminClient=SubscriptionAdminClient .create()){
ProjectName projectName=ProjectName .of(projectId);
for(Subscription subscription:
subscriptionAdminClient.listSubscriptions(projectName).iterateAll()){
System.out.println(subscription.getName());
}
System.out.println("Listed all the subscriptions in the project.");
}
}
}

//ImportstheGoogleCloudclientlibrary
const{PubSub}=require('@google-cloud/pubsub');
//Createsaclient;cachethisforfurtheruse
constpubSubClient=newPubSub();
asyncfunctionlistSubscriptions(){
//Listsallsubscriptionsinthecurrentproject
const[subscriptions]=awaitpubSubClient.getSubscriptions();
console.log('Subscriptions:');
subscriptions.forEach(subscription=>console.log(subscription.name));
}

// Imports the Google Cloud client library
import{PubSub, Subscription} from'@google-cloud/pubsub';
// Creates a client; cache this for further use
const pubSubClient = new PubSub();
async function listSubscriptions() {
 // Lists all subscriptions in the current project
 const [subscriptions] = await pubSubClient.getSubscriptions();
 console.log('Subscriptions:');
 subscriptions.forEach((subscription: Subscription) =>
 console.log(subscription.name),
 );
}

use Google\Cloud\PubSub\PubSubClient;
/**
 * Lists all Pub/Sub subscriptions.
 *
 * @param string $projectId The Google project ID.
 */
function list_subscriptions($projectId)
{
 $pubsub = new PubSubClient([
 'projectId' => $projectId,
 ]);
 foreach ($pubsub->subscriptions() as $subscription) {
 printf('Subscription: %s' . PHP_EOL, $subscription->name());
 }
}

fromgoogle.cloudimport pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
subscriber = pubsub_v1.SubscriberClient ()
project_path = f"projects/{project_id}"
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
 for subscription in subscriber.list_subscriptions(
 request={"project": project_path}
 ):
 print(subscription.name)

pubsub=Google::Cloud::PubSub .new
subscription_admin=pubsub.subscription_admin
subscriptions=subscription_admin.list_subscriptions\
project:pubsub.project_path
puts"Subscriptions:"
subscriptions.eachdo|subscription|
putssubscription.name
end

namespacepubsub_admin=::google::cloud::pubsub_admin;
namespacepubsub=::google::cloud::pubsub;
[](pubsub_admin::TopicAdminClientclient,std::stringconst&project_id,
std::stringconst&topic_id){
autoconsttopic=pubsub::Topic(project_id,topic_id);
std::cout << "Subscription list for topic " << topic << ":\n";
for(auto&name:client.ListTopicSubscriptions(topic.FullName())){
if(!name)throwstd::move(name).status();
std::cout << " " << *name << "\n";
}
}

usingGoogle.Cloud.PubSub.V1 ;
usingSystem.Collections.Generic;
publicclassListSubscriptionsInTopicSample
{
publicIEnumerable<string>ListSubscriptionsInTopic(stringprojectId,stringtopicId)
{
PublisherServiceApiClient publisher=PublisherServiceApiClient .Create ();
TopicName topicName=TopicName .FromProjectTopic (projectId,topicId);
IEnumerable<string>subscriptions=publisher.ListTopicSubscriptions (topicName);
returnsubscriptions;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/pubsub/v2"
"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
"google.golang.org/api/iterator"
)
funclistSubscriptions(wio.Writer,projectID,topicIDstring)error{
// projectID := "my-project-id"
// topicName := "projects/sample-248520/topics/ocr-go-test-topic"
ctx:=context.Background()
client,err:=pubsub.NewClient(ctx,projectID)
iferr!=nil{
returnfmt.Errorf("pubsub.NewClient: %w",err)
}
deferclient.Close()
req:=&pubsubpb.ListTopicSubscriptionsRequest{
Topic:fmt.Sprintf("projects/%s/topics/%s",projectID,topicID),
}
it:=client.TopicAdminClient.ListTopicSubscriptions(ctx,req)
for{
sub,err:=it.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnfmt.Errorf("error listing topic subscriptions: %w",err)
}
fmt.Fprintf(w,"got subscription: %s\n",sub)
}
returnnil
}

importcom.google.cloud.pubsub.v1.TopicAdminClient ;
importcom.google.pubsub.v1.TopicName ;
importjava.io.IOException;
publicclass ListSubscriptionsInTopicExample{
publicstaticvoidmain(String...args)throwsException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
StringtopicId="your-topic-id";
listSubscriptionInTopicExample(projectId,topicId);
}
publicstaticvoidlistSubscriptionInTopicExample(StringprojectId,StringtopicId)
throwsIOException{
try(TopicAdminClient topicAdminClient=TopicAdminClient .create()){
TopicName topicName=TopicName .of(projectId,topicId);
for(Stringsubscription:topicAdminClient.listTopicSubscriptions(topicName).iterateAll()){
System.out.println(subscription);
}
System.out.println("Listed all the subscriptions in the topic.");
}
}
}

/**
 * TODO(developer): Uncomment this variable before running the sample.
 */
//consttopicNameOrId='YOUR_TOPIC_NAME_OR_ID';
//ImportstheGoogleCloudclientlibrary
const{PubSub}=require('@google-cloud/pubsub');
//Createsaclient;cachethisforfurtheruse
constpubSubClient=newPubSub();
asyncfunctionlistTopicSubscriptions(topicNameOrId){
//Listsallsubscriptionsforthetopic
const[subscriptions]=awaitpubSubClient
.topic(topicNameOrId)
.getSubscriptions();
console.log(`Subscriptionsfor${topicNameOrId}:`);
subscriptions.forEach(subscription=>console.log(subscription.name));
}

/**
 * TODO(developer): Uncomment this variable before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// Imports the Google Cloud client library
import{PubSub, Subscription} from'@google-cloud/pubsub';
// Creates a client; cache this for further use
const pubSubClient = new PubSub();
async function listTopicSubscriptions(topicNameOrId: string) {
 // Lists all subscriptions for the topic
 const [subscriptions] = await pubSubClient
 .topic(topicNameOrId)
 .getSubscriptions();
 console.log(`Subscriptions for ${topicNameOrId}:`);
 subscriptions.forEach((subscription: Subscription) =>
 console.log(subscription.name),
 );
}

fromgoogle.cloudimport pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
publisher = pubsub_v1.PublisherClient ()
topic_path = publisher.topic_path(project_id, topic_id)
response = publisher.list_topic_subscriptions(request={"topic": topic_path})
for subscription in response:
 print(subscription)

# topic_id = "your-topic-id"
pubsub=Google::Cloud::PubSub .new
topic_admin=pubsub.topic_admin
response=topic_admin.list_topic_subscriptions\
topic:pubsub.topic_path(topic_id)
puts"Subscriptions in topic #{topic_id}:"
response.subscriptions.eachdo|subscription_name|
putssubscription_name
end