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 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 listTopicSubscriptions(client *pubsub.Client, argv []string) {
checkArgs(argv, 2)
topic := argv[1]
subs, err := client.Topic(topic).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 listTopicSubscriptions(client *pubsub.Client, argv []string) {
ctx := context.Background()
checkArgs(argv, 2)
topic := argv[1]
subs := client.Topic(topic).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 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
}
}
}
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)
os.Exit(1)
}
for _, id := range ids {
log.Infof("%#v", id)
}
},
}
func init() {
RootCmd.AddCommand(pubCmd)
}