func delete(client *pubsub.Client, topic string) error {
ctx := context.Background()
// [START delete_topic]
t := client.Topic(topic)
if err := t.Delete(ctx); err != nil {
return err
}
fmt.Printf("Deleted topic: %v\n", t)
// [END delete_topic]
return nil
}
func create(client *pubsub.Client, topic string) error {
ctx := context.Background()
// [START create_topic]
t, err := client.CreateTopic(ctx, topic)
if err != nil {
return err
}
fmt.Printf("Topic created: %v\n", t)
// [END create_topic]
return nil
}
func delete(client *pubsub.Client, name string) error {
ctx := context.Background()
// [START delete_subscription]
sub := client.Subscription(name)
if err := sub.Delete(ctx); err != nil {
return err
}
fmt.Println("Subscription deleted.")
// [END delete_subscription]
return nil
}
func create(client *pubsub.Client, name string, topic *pubsub.Topic) error {
ctx := context.Background()
// [START create_subscription]
sub, err := client.CreateSubscription(ctx, name, topic, 20*time.Second, nil)
if err != nil {
return err
}
fmt.Printf("Created subscription: %v\n", sub)
// [END create_subscription]
return nil
}
func getPolicy(c *pubsub.Client, topicName string) *iam.Policy {
ctx := context.Background()
// [START pubsub_get_topic_policy]
policy, err := c.Topic(topicName).IAM().Policy(ctx)
if err != nil {
log.Fatal(err)
}
for _, role := range policy.Roles() {
log.Print(policy.Members(role))
}
// [END pubsub_get_topic_policy]
return policy
}
func getPolicy(c *pubsub.Client, subName string) *iam.Policy {
ctx := context.Background()
// [START pubsub_get_subscription_policy]
policy, err := c.Subscription(subName).IAM().Policy(ctx)
if err != nil {
log.Fatal(err)
}
for _, role := range policy.Roles() {
log.Printf("%q: %q", role, policy.Members(role))
}
// [END pubsub_get_subscription_policy]
return policy
}
func publish(client *pubsub.Client, topic, msg string) error {
ctx := context.Background()
// [START publish]
t := client.Topic(topic)
msgIDs, err := t.Publish(ctx, &pubsub.Message{
Data: []byte(msg),
})
if err != nil {
return err
}
for _, id := range msgIDs {
fmt.Printf("Published a message; msg ID: %v\n", id)
}
// [END publish]
return nil
}
func testPermissions(c *pubsub.Client, topicName string) []string {
ctx := context.Background()
// [START pubsub_test_topic_permissions]
topic := c.Topic(topicName)
perms, err := topic.IAM().TestPermissions(ctx, []string{
"pubsub.topics.publish",
"pubsub.topics.update",
})
if err != nil {
log.Fatal(err)
}
for _, perm := range perms {
log.Printf("Allowed: %v", perm)
}
// [END pubsub_test_topic_permissions]
return perms
}
func list(client *pubsub.Client) ([]*pubsub.Subscription, error) {
ctx := context.Background()
// [START get_all_subscriptions]
var subs []*pubsub.Subscription
it := client.Subscriptions(ctx)
for {
s, err := it.Next()
if err == iterator.Done {
break
}
if err != nil {
return nil, err
}
subs = append(subs, s)
}
// [END get_all_subscriptions]
return subs, nil
}
func testPermissions(c *pubsub.Client, subName string) []string {
ctx := context.Background()
// [START pubsub_test_subscription_permissions]
sub := c.Subscription(subName)
perms, err := sub.IAM().TestPermissions(ctx, []string{
"pubsub.subscriptions.consume",
"pubsub.subscriptions.update",
})
if err != nil {
log.Fatal(err)
}
for _, perm := range perms {
log.Printf("Allowed: %v", perm)
}
// [END pubsub_test_subscription_permissions]
return perms
}
func createTopicIfNotExists(c *pubsub.Client) *pubsub.Topic {
ctx := context.Background()
const topic = "example-topic"
// Create a topic to subscribe to.
t := c.Topic(topic)
ok, err := t.Exists(ctx)
if err != nil {
log.Fatal(err)
}
if ok {
return t
}
t, err = c.CreateTopic(ctx, topic)
if err != nil {
log.Fatalf("Failed to create the topic: %v", err)
}
return t
}
func list(client *pubsub.Client) ([]*pubsub.Topic, error) {
ctx := context.Background()
// [START list_topics]
var topics []*pubsub.Topic
it := client.Topics(ctx)
for {
topic, err := it.Next()
if err == iterator.Done {
break
}
if err != nil {
return nil, err
}
topics = append(topics, topic)
}
return topics, nil
// [END list_topics]
}
func addUsers(c *pubsub.Client, topicName string) {
ctx := context.Background()
// [START pubsub_set_topic_policy]
topic := c.Topic(topicName)
policy, err := topic.IAM().Policy(ctx)
if err != nil {
log.Fatalf("GetPolicy: %v", err)
}
// Other valid prefixes are "serviceAccount:", "user:"******"group:[email protected]", iam.Editor)
if err := topic.IAM().SetPolicy(ctx, policy); err != nil {
log.Fatalf("SetPolicy: %v", err)
}
// NOTE: It may be necessary to retry this operation if IAM policies are
// being modified concurrently. SetPolicy will return an error if the policy
// was modified since it was retrieved.
// [END pubsub_set_topic_policy]
}
func pullMsgs(client *pubsub.Client, name string, topic *pubsub.Topic) error {
ctx := context.Background()
// publish 10 messages on the topic.
for i := 0; i < 10; i++ {
_, err := topic.Publish(ctx, &pubsub.Message{
Data: []byte(fmt.Sprintf("hello world #%d", i)),
})
if err != nil {
return err
}
}
// [START pull_messages]
sub := client.Subscription(name)
it, err := sub.Pull(ctx)
if err != nil {
return err
}
defer it.Stop()
// Consume 10 messages.
for i := 0; i < 10; i++ {
msg, err := it.Next()
if err == iterator.Done {
break
}
if err != nil {
return err
}
fmt.Printf("Got message: %q\n", string(msg.Data))
msg.Done(true)
}
// [END pull_messages]
return nil
}