// This example demonstrates calling the Cloud Pub/Sub API.
//
// Before running this example, be sure to enable Cloud Pub/Sub
// service on your project in Developer Console at:
// https://console.developers.google.com/
//
// Unless you run this sample on Compute Engine instance, please
// create a new service account and download a JSON key file for it at
// the developer console: https://console.developers.google.com/
//
// It has the following subcommands:
//
// create_topic <name>
// delete_topic <name>
// create_subscription <name> <linked_topic>
// delete_subscription <name>
// publish <topic> <message>
// pull_messages <subscription> <numworkers>
// publish_messages <topic> <numworkers>
//
// You can choose any names for topic and subscription as long as they
// follow the naming rule described at:
// https://cloud.google.com/pubsub/overview#names
//
// You can create/delete topics/subscriptions by self-explanatory
// subcommands.
//
// The "publish" subcommand is for publishing a single message to a
// specified Cloud Pub/Sub topic.
//
// The "pull_messages" subcommand is for continuously pulling messages
// from a specified Cloud Pub/Sub subscription with specified number
// of workers.
//
// The "publish_messages" subcommand is for continuously publishing
// messages to a specified Cloud Pub/Sub topic with specified number
// of workers.
func main() {
flag.Parse()
argv := flag.Args()
checkArgs(argv, 1)
if *projID == "" {
usageAndExit("Please specify Project ID.")
}
client, err := pubsub.NewClient(context.Background(), *projID)
if err != nil {
log.Fatalf("creating pubsub client: %v", err)
}
commands := map[string]func(client *pubsub.Client, argv []string){
"create_topic": createTopic,
"delete_topic": deleteTopic,
"list_topics": listTopics,
"list_topic_subscriptions": listTopicSubscriptions,
"topic_exists": checkTopicExists,
"create_subscription": createSubscription,
"show_subscription": showSubscription,
"delete_subscription": deleteSubscription,
"subscription_exists": checkSubscriptionExists,
"list_subscriptions": listSubscriptions,
"publish": publish,
"publish_messages": publishMessages,
"pull_messages": pullMessages,
}
subcommand := argv[0]
if f, ok := commands[subcommand]; ok {
f(client, argv)
} else {
usageAndExit(fmt.Sprintf("Function not found for %s", subcommand))
}
}
// NewSubscriber will instantiate a new Subscriber that wraps
// a pubsub.Iterator.
func NewSubscriber(ctx context.Context, cfg Config) (pubsub.Subscriber, error) {
client, err := gpubsub.NewClient(ctx, cfg.ProjectID)
if err != nil {
return nil, err
}
return &subscriber{
sub: subscriptionImpl{sub: client.Subscription(cfg.Subscription)},
ctx: ctx,
name: cfg.Subscription,
stop: make(chan chan error, 1),
}, nil
}
func main() {
flag.Parse()
if *projID == "" {
log.Fatal("-p is required")
}
if *subName == "" {
log.Fatal("-s is required")
}
quit := make(chan os.Signal, 1)
signal.Notify(quit, os.Interrupt)
ctx := context.Background()
client, err := pubsub.NewClient(ctx, *projID)
if err != nil {
log.Fatalf("creating pubsub client: %v", err)
}
sub := client.Subscription(*subName)
it, err := sub.Pull(ctx, pubsub.MaxExtension(time.Minute))
if err != nil {
fmt.Printf("error constructing iterator: %v", err)
return
}
defer it.Stop()
go func() {
<-quit
it.Stop()
}()
for i := 0; i < *numConsume; i++ {
m, err := it.Next()
if err == pubsub.Done {
break
}
if err != nil {
fmt.Printf("advancing iterator: %v", err)
break
}
fmt.Printf("got message: %v\n", string(m.Data))
m.Done(true)
}
}
// GCEClientInit uses Google's host FS searching functionality to find auth
// tokens if they exist. eg: GCE VMs, Authenticated Developers
func GCEClientInit(ctx *context.Context, project string) *pubsub.Client {
var client *pubsub.Client
clientOnce := new(sync.Once)
clientOnce.Do(func() {
source, err := google.DefaultTokenSource(*ctx, pubsub.ScopePubSub)
if err != nil {
log.Errorf("error creating token source: %v", err)
os.Exit(1)
}
client, err = pubsub.NewClient(*ctx, project, cloud.WithTokenSource(source))
if err != nil {
log.Errorf("error creating pubsub.Client: %v", err)
os.Exit(1)
}
})
return client
}
func main() {
ctx := context.Background()
client, err := pubsub.NewClient(ctx, mustGetenv("GCLOUD_PROJECT"))
if err != nil {
log.Fatal(err)
}
// Create topic if it doesn't exist.
topic, _ = client.NewTopic(ctx, mustGetenv("PUBSUB_TOPIC"))
http.HandleFunc("/", listHandler)
http.HandleFunc("/pubsub/publish", publishHandler)
http.HandleFunc("/pubsub/push", pushHandler)
appengine.Main()
}
// CreateGooglePubSubClient returns client communicate with google Pub/Sub service
func CreateGooglePubSubClient() (*pubsub.Client, error) {
envValue := os.Getenv(NDGooglePubSubURL)
if envValue != "" {
googlePubSubURL = envValue
}
envValue = os.Getenv(NDGoogleProjectID)
if envValue != "" {
googleProjectID = envValue
}
ctx := cloud.NewContext(googleProjectID, http.DefaultClient)
o := []cloud.ClientOption{
cloud.WithBaseHTTP(http.DefaultClient),
cloud.WithEndpoint(googleDatastoreURL),
}
client, _ := pubsub.NewClient(ctx, googleProjectID, o...)
return client, nil
}
// This example demonstrates calling the Cloud Pub/Sub API.
//
// Before running this example, be sure to enable Cloud Pub/Sub
// service on your project in Developer Console at:
// https://console.developers.google.com/
//
// Unless you run this sample on Compute Engine instance, please
// create a new service account and download a JSON key file for it at
// the developer console: https://console.developers.google.com/
//
// It has the following subcommands:
//
// create_topic <name>
// delete_topic <name>
// create_subscription <name> <linked_topic>
// delete_subscription <name>
// publish <topic> <message>
// pull_messages <subscription> <numworkers>
// publish_messages <topic> <numworkers>
//
// You can choose any names for topic and subscription as long as they
// follow the naming rule described at:
// https://cloud.google.com/pubsub/overview#names
//
// You can create/delete topics/subscriptions by self-explanatory
// subcommands.
//
// The "publish" subcommand is for publishing a single message to a
// specified Cloud Pub/Sub topic.
//
// The "pull_messages" subcommand is for continuously pulling messages
// from a specified Cloud Pub/Sub subscription with specified number
// of workers.
//
// The "publish_messages" subcommand is for continuously publishing
// messages to a specified Cloud Pub/Sub topic with specified number
// of workers.
func main() {
flag.Parse()
argv := flag.Args()
checkArgs(argv, 1)
if *projID == "" {
usageAndExit("Please specify Project ID.")
}
oldStyle := map[string]func(ctx context.Context, argv []string){
"publish": publish,
"pull_messages": pullMessages,
"publish_messages": publishMessages,
}
newStyle := map[string]func(client *pubsub.Client, argv []string){
"create_topic": createTopic,
"delete_topic": deleteTopic,
"list_topics": listTopics,
"list_topic_subscriptions": listTopicSubscriptions,
"topic_exists": checkTopicExists,
"create_subscription": createSubscription,
"delete_subscription": deleteSubscription,
"subscription_exists": checkSubscriptionExists,
"list_subscriptions": listSubscriptions,
}
subcommand := argv[0]
if f, ok := oldStyle[subcommand]; ok {
httpClient, err := newClient(*jsonFile)
if err != nil {
log.Fatalf("clientAndId failed, %v", err)
}
ctx := cloud.NewContext(*projID, httpClient)
f(ctx, argv)
} else if f, ok := newStyle[subcommand]; ok {
client, err := pubsub.NewClient(context.Background(), *projID)
if err != nil {
log.Fatalf("creating pubsub client: %v", err)
}
f(client, argv)
} else {
usageAndExit(fmt.Sprintf("Function not found for %s", subcommand))
}
}
// JWTClientInit reads in a service account JSON token and creates an oauth
// token for communicating with GCE.
func JWTClientInit(ctx *context.Context) *pubsub.Client {
jsonKey, err := ioutil.ReadFile(KeyPath)
if err != nil {
log.Errorf("error reading keyfile: %v", err)
os.Exit(1)
}
conf, err := google.JWTConfigFromJSON(jsonKey, pubsub.ScopePubSub)
if err != nil {
log.Errorf("error creating conf file: %v", err)
}
oauthTokenSource := conf.TokenSource(*ctx)
psClient, err := pubsub.NewClient(*ctx, Gceproject, cloud.WithTokenSource(oauthTokenSource))
if err != nil {
log.Errorf("error creating pubsub client: %v", err)
os.Exit(1)
}
return psClient
}
func main() {
flag.Parse()
if *projID == "" {
log.Fatal("-p is required")
}
if *subName == "" {
log.Fatal("-s is required")
}
ctx := context.Background()
client, err := pubsub.NewClient(ctx, *projID)
if err != nil {
log.Fatalf("creating pubsub client: %v", err)
}
sub := client.Subscription(*subName)
it, err := sub.Pull(ctx)
if err != nil {
fmt.Printf("error constructing iterator: %v", err)
return
}
for i := 0; i < *numConsume; i++ {
m, err := it.Next(ctx)
if err != nil {
break
}
fmt.Printf("got message: %v\n", string(m.Data))
m.Done(true)
}
it.Close()
if err != nil {
fmt.Printf("%v", err)
}
}
func configurePubsub(projectID string) (*pubsub.Client, error) {
if _, ok := DB.(*memoryDB); ok {
return nil, errors.New("Pub/Sub worker doesn't work with the in-memory DB " +
"(worker does not share its memory as the main app). Configure another " +
"database in bookshelf/config.go first (e.g. MySQL, Cloud Datastore, etc)")
}
ctx := context.Background()
client, err := pubsub.NewClient(ctx, projectID)
if err != nil {
return nil, err
}
// Create the topic if it doesn't exist.
if exists, err := client.Topic(PubsubTopicID).Exists(ctx); err != nil {
return nil, err
} else if !exists {
if _, err := client.NewTopic(ctx, PubsubTopicID); err != nil {
return nil, err
}
}
return client, nil
}