Пример #1
0
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)
	}
}
Пример #2
0
// 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.
}
Пример #3
0
		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 {
			log.Errorf("error creating pubsub iterator: %v", err)
		}
		defer it.Stop()

		msgs := make(chan *pubsub.Message)
		go func() {
			for !shouldQuit(quit) {
				m, err := it.Next()
				if err != nil {
					switch err {
					case pubsub.Done:
						log.Infof("pubsub interator finished")
					default:
						log.Errorf("error reading from iterator: %v", err)
Пример #4
0
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
}

var (
	defaultMaxMessages  = gpubsub.MaxPrefetch(10)
	defaultMaxExtension = gpubsub.MaxExtension(60 * time.Second)
)

// Start will start pulling from pubsub via a pubsub.Iterator.
func (s *subscriber) Start() <-chan pubsub.SubscriberMessage {
	output := make(chan pubsub.SubscriberMessage)
	go func(s *subscriber, output chan pubsub.SubscriberMessage) {
		defer close(output)
		var (
			iter iterator
			msg  message
			err  error
		)

		iter, err = s.sub.Pull(s.ctx, defaultMaxMessages, defaultMaxExtension)
		if err != nil {