func deleteSubscription(client *pubsub.Client, argv []string) {
checkArgs(argv, 2)
sub := argv[1]
err := client.Subscription(sub).Delete(context.Background())
if err != nil {
log.Fatalf("Deleting Subscription failed: %v", err)
}
fmt.Printf("Subscription %s was deleted.\n", sub)
}
func createTopic(client *pubsub.Client, argv []string) {
checkArgs(argv, 2)
topic := argv[1]
_, err := client.NewTopic(context.Background(), topic)
if err != nil {
log.Fatalf("Creating topic failed: %v", err)
}
fmt.Printf("Topic %s was created.\n", topic)
}
func deleteTopic(client *pubsub.Client, argv []string) {
checkArgs(argv, 2)
topic := argv[1]
err := client.Topic(topic).Delete(context.Background())
if err != nil {
log.Fatalf("Deleting topic failed: %v", err)
}
fmt.Printf("Topic %s was deleted.\n", topic)
}
func checkTopicExists(client *pubsub.Client, argv []string) {
checkArgs(argv, 1)
topic := argv[1]
exists, err := client.Topic(topic).Exists(context.Background())
if err != nil {
log.Fatalf("Checking topic exists failed: %v", err)
}
fmt.Println(exists)
}
func checkSubscriptionExists(client *pubsub.Client, argv []string) {
checkArgs(argv, 1)
sub := argv[1]
exists, err := client.Subscription(sub).Exists(context.Background())
if err != nil {
log.Fatalf("Checking subscription exists failed: %v", err)
}
fmt.Println(exists)
}
func createSubscription(client *pubsub.Client, argv []string) {
checkArgs(argv, 3)
sub := argv[1]
topic := argv[2]
_, err := client.NewSubscription(context.Background(), sub, client.Topic(topic), 0, nil)
if err != nil {
log.Fatalf("Creating Subscription failed: %v", err)
}
fmt.Printf("Subscription %s was created.\n", sub)
}
func listTopics(client *pubsub.Client, argv []string) {
checkArgs(argv, 1)
topics, err := client.Topics(context.Background())
if err != nil {
log.Fatalf("Listing topics failed: %v", err)
}
for _, t := range topics {
fmt.Println(t.Name())
}
}
func listSubscriptions(client *pubsub.Client, argv []string) {
checkArgs(argv, 1)
subs, err := client.Subscriptions(context.Background())
if err != nil {
log.Fatalf("Listing subscriptions failed: %v", err)
}
for _, s := range subs {
fmt.Println(s.Name())
}
}
func publish(client *pubsub.Client, argv []string) {
checkArgs(argv, 3)
topic := argv[1]
message := argv[2]
msgIDs, err := client.Topic(topic).Publish(context.Background(), &pubsub.Message{
Data: []byte(message),
})
if err != nil {
log.Fatalf("Publish failed, %v", err)
}
fmt.Printf("Message '%s' published to topic %s and the message id is %s\n", message, topic, msgIDs[0])
}
// publish publishes a series of messages to the named topic.
func publishMessageBatches(client *pubsub.Client, topicName string, workerID int, rep *reporter) {
var r uint64
topic := client.Topic(topicName)
for !shouldQuit() {
msgPrefix := fmt.Sprintf("Worker: %d, Round: %d,", workerID, r)
if _, err := topic.Publish(context.Background(), genMessages(msgPrefix)...); err != nil {
log.Printf("Publish failed, %v\n", err)
return
}
r++
rep.Inc(*size)
}
}
func listSubscriptions(client *pubsub.Client, argv []string) {
ctx := context.Background()
checkArgs(argv, 1)
subs := client.Subscriptions(ctx)
for {
switch sub, err := subs.Next(); err {
case nil:
fmt.Println(sub.Name())
case pubsub.Done:
return
default:
log.Fatalf("Listing subscriptions failed: %v", err)
}
}
}
func listTopics(client *pubsub.Client, argv []string) {
ctx := context.Background()
checkArgs(argv, 1)
topics := client.Topics(ctx)
for {
switch topic, err := topics.Next(); err {
case nil:
fmt.Println(topic.Name())
case pubsub.Done:
return
default:
log.Fatalf("Listing topics failed: %v", err)
}
}
}
func showSubscription(client *pubsub.Client, argv []string) {
checkArgs(argv, 2)
sub := argv[1]
conf, err := client.Subscription(sub).Config(context.Background())
if err != nil {
log.Fatalf("Getting Subscription failed: %v", err)
}
fmt.Printf("%+v\n", conf)
exists, err := conf.Topic.Exists(context.Background())
if err != nil {
log.Fatalf("Checking whether topic exists: %v", err)
}
if !exists {
fmt.Println("The topic for this subscription has been deleted.")
}
}
func publishLoop(client *pubsub.Client, topic string, workerid int, result chan<- int) {
var r uint64
for {
msgs := make([]*pubsub.Message, *size)
for i := 0; i < *size; i++ {
msgs[i] = &pubsub.Message{
Data: []byte(fmt.Sprintf("Worker: %d, Round: %d, Message: %d", workerid, r, i)),
}
}
_, err := client.Topic(topic).Publish(context.Background(), msgs...)
if err != nil {
log.Printf("Publish failed, %v\n", err)
return
}
r++
if *reportMPS {
result <- *size
}
}
}
// pullMessages reads messages from a subscription, and farms them out to a
// number of goroutines for processing.
func pullMessages(client *pubsub.Client, argv []string) {
checkArgs(argv, 3)
sub := client.Subscription(argv[1])
workers, err := strconv.Atoi(argv[2])
if err != nil {
log.Fatalf("Atoi failed, %v", err)
}
rep := newReporter("Received")
defer rep.Stop()
msgs := make(chan *pubsub.Message)
for i := 0; i < int(workers); i++ {
go processMessages(msgs, rep, !*reportMPS)
}
it, err := sub.Pull(context.Background(), pubsub.MaxExtension(time.Minute))
if err != nil {
log.Fatalf("failed to construct iterator: %v", err)
}
defer it.Stop()
for !shouldQuit() {
m, err := it.Next()
if err != nil {
log.Fatalf("error reading from iterator: %v", err)
}
msgs <- m
}
// Shut down all processMessages goroutines.
close(msgs)
// The deferred call to it.Stop will block until each m.Done has been
// called on each message.
}
Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
Run: func(cmd *cobra.Command, args []string) {
log.Infof("pub called on topic: %s", Topic)
if Gceproject == "" || Topic == "" {
log.Errorf("GCE project and topic must be defined")
os.Exit(1)
}
ctx := context.Background()
pubsubClient := initClient()
gctx := cloud.NewContext(Gceproject, pubsubClient)
var psClient *pubsub.Client
if KeyPath != "" {
psClient = JWTClientInit(&ctx)
} else {
psClient = GCEClientInit(&ctx, Gceproject)
}
if psClient == nil {
log.Errorf("PubSub client is nil")
os.Exit(1)
}
topic := psClient.Topic(Topic)
bytes := []byte(fmt.Sprintf("helloworld %v", time.Now()))
ids, err := topic.Publish(gctx, &pubsub.Message{Data: bytes})
if err != nil {
log.Errorf("error publishing messages: %v", err)
Long: `Subscribe to messages from a specified topic and subscription.`,
Run: func(cmd *cobra.Command, args []string) {
log.Debugf("sub called on topic: %s", Topic)
logsetup()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
if Gceproject == "" || Topic == "" || subscription == "" {
log.Errorf("GCE project, subscription, and topic must be defined")
os.Exit(1)
}
// Configure connection to pubsub
ctx := context.Background()
var psClient *pubsub.Client
if KeyPath != "" {
psClient = JWTClientInit(&ctx)
} else {
psClient = GCEClientInit(&ctx, Gceproject)
}
if psClient == nil {
log.Errorf("PubSub client is nil")
os.Exit(1)
}
log.Debugf("client: %#v", psClient)
// Create message iterator from client
sub := psClient.Subscription(subscription)
it, err := sub.Pull(ctx, pubsub.MaxExtension(time.Minute*1))
if err != nil {