You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
88 lines
2.5 KiB
88 lines
2.5 KiB
package pubsub
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/internal/libs/queue"
|
|
)
|
|
|
|
var (
|
|
// ErrUnsubscribed is returned by Next when the client has unsubscribed.
|
|
ErrUnsubscribed = errors.New("subscription removed by client")
|
|
|
|
// ErrTerminated is returned by Next when the subscription was terminated by
|
|
// the publisher.
|
|
ErrTerminated = errors.New("subscription terminated by publisher")
|
|
)
|
|
|
|
// A Subscription represents a client subscription for a particular query.
|
|
type Subscription struct {
|
|
id string
|
|
queue *queue.Queue // open until the subscription ends
|
|
stopErr error // after queue is closed, the reason why
|
|
}
|
|
|
|
// newSubscription returns a new subscription with the given queue capacity.
|
|
func newSubscription(quota, limit int) (*Subscription, error) {
|
|
queue, err := queue.New(queue.Options{
|
|
SoftQuota: quota,
|
|
HardLimit: limit,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Subscription{
|
|
id: uuid.NewString(),
|
|
queue: queue,
|
|
}, nil
|
|
}
|
|
|
|
// Next blocks until a message is available, ctx ends, or the subscription
|
|
// ends. Next returns ErrUnsubscribed if s was unsubscribed, ErrTerminated if
|
|
// s was terminated by the publisher, or a context error if ctx ended without a
|
|
// message being available.
|
|
func (s *Subscription) Next(ctx context.Context) (Message, error) {
|
|
next, err := s.queue.Wait(ctx)
|
|
if errors.Is(err, queue.ErrQueueClosed) {
|
|
return Message{}, s.stopErr
|
|
} else if err != nil {
|
|
return Message{}, err
|
|
}
|
|
return next.(Message), nil
|
|
}
|
|
|
|
// ID returns the unique subscription identifier for s.
|
|
func (s *Subscription) ID() string { return s.id }
|
|
|
|
// publish transmits msg to the subscriber. It reports a queue error if the
|
|
// queue cannot accept any further messages.
|
|
func (s *Subscription) publish(msg Message) error { return s.queue.Add(msg) }
|
|
|
|
// stop terminates the subscription with the given error reason.
|
|
func (s *Subscription) stop(err error) {
|
|
if err == nil {
|
|
panic("nil stop error")
|
|
}
|
|
s.stopErr = err
|
|
s.queue.Close()
|
|
}
|
|
|
|
// Message glues data and events together.
|
|
type Message struct {
|
|
subID string
|
|
data interface{}
|
|
events []types.Event
|
|
}
|
|
|
|
// SubscriptionID returns the unique identifier for the subscription
|
|
// that produced this message.
|
|
func (msg Message) SubscriptionID() string { return msg.subID }
|
|
|
|
// Data returns an original data published.
|
|
func (msg Message) Data() interface{} { return msg.data }
|
|
|
|
// Events returns events, which matched the client's query.
|
|
func (msg Message) Events() []types.Event { return msg.events }
|