pubsub

Documentation

Index

• func SetAckResult(r *AckResult, res AcknowledgeStatus, err error)
• func SetPublishResult(r *PublishResult, sid string, err error)
• type AckHandler
  • func MessageAckHandler(m *Message) AckHandler
• type AckResult
  • func NewAckResult() *AckResult
  • func (r *AckResult) Get(ctx context.Context) (res AcknowledgeStatus, err error)
  • func (r *AckResult) Ready() <-chan struct{}
• type AcknowledgeStatus
• type Message
  • func NewMessage(ackh AckHandler) *Message
  • func (m *Message) Ack()
  • func (m *Message) AckWithResult() *AckResult
  • func (m *Message) Nack()
  • func (m *Message) NackWithResult() *AckResult
• type PublishResult
  • func NewPublishResult() *PublishResult
  • func (r *PublishResult) Get(ctx context.Context) (serverID string, err error)
  • func (r *PublishResult) Ready() <-chan struct{}

Functions

func SetAckResult

func SetAckResult(r *AckResult, res AcknowledgeStatus, err error)

SetAckResult sets the ack response and error for a ack result and closes the Ready channel. Any call after the first for the same AckResult is a no-op.

func SetPublishResult

func SetPublishResult(r *PublishResult, sid string, err error)

SetPublishResult sets the server ID and error for a publish result and closes the Ready channel.

Types

type AckHandler

type AckHandler interface {
	// OnAck processes a message ack.
	OnAck()

	// OnNack processes a message nack.
	OnNack()

	// OnAckWithResult processes a message ack and returns
	// a result that shows if it succeeded.
	OnAckWithResult() *AckResult

	// OnNackWithResult processes a message nack and returns
	// a result that shows if it succeeded.
	OnNackWithResult() *AckResult
}

AckHandler implements ack/nack handling.

func MessageAckHandler

func MessageAckHandler(m *Message) AckHandler

MessageAckHandler provides access to the internal field Message.ackh.

type AckResult

type AckResult struct {
	// contains filtered or unexported fields
}

AckResult holds the result from a call to Ack or Nack.

func NewAckResult

func NewAckResult() *AckResult

NewAckResult creates a AckResult.

func (*AckResult) Get

func (r *AckResult) Get(ctx context.Context) (res AcknowledgeStatus, err error)

Get returns the status and/or error result of a Ack, Nack, or Modack call. Get blocks until the Ack/Nack completes or the context is done.

func (*AckResult) Ready

func (r *AckResult) Ready() <-chan struct{}

Ready returns a channel that is closed when the result is ready. When the Ready channel is closed, Get is guaranteed not to block.

type AcknowledgeStatus

type AcknowledgeStatus int

AcknowledgeStatus represents the status of an Ack or Nack request.

const (
	// AcknowledgeStatusSuccess indicates the request was a success.
	AcknowledgeStatusSuccess AcknowledgeStatus = iota
	// AcknowledgeStatusPermissionDenied indicates the caller does not have sufficient permissions.
	AcknowledgeStatusPermissionDenied
	// AcknowledgeStatusFailedPrecondition indicates the request encountered a FailedPrecondition error.
	AcknowledgeStatusFailedPrecondition
	// AcknowledgeStatusInvalidAckID indicates one or more of the ack IDs sent were invalid.
	AcknowledgeStatusInvalidAckID
	// AcknowledgeStatusOther indicates another unknown error was returned.
	AcknowledgeStatusOther
)

type Message

type Message struct {
	// ID identifies this message. This ID is assigned by the server and is
	// populated for Messages obtained from a subscription.
	//
	// This field is read-only.
	ID string

	// Data is the actual data in the message.
	Data []byte

	// Attributes represents the key-value pairs the current message is
	// labelled with.
	Attributes map[string]string

	// PublishTime is the time at which the message was published. This is
	// populated by the server for Messages obtained from a subscription.
	//
	// This field is read-only.
	PublishTime time.Time

	// DeliveryAttempt is the number of times a message has been delivered.
	// This is part of the dead lettering feature that forwards messages that
	// fail to be processed (from nack/ack deadline timeout) to a dead letter topic.
	// If dead lettering is enabled, this will be set on all attempts, starting
	// with value 1. Otherwise, the value will be nil.
	// This field is read-only.
	DeliveryAttempt *int

	// OrderingKey identifies related messages for which publish order should
	// be respected. If empty string is used, message will be sent unordered.
	OrderingKey string
	// contains filtered or unexported fields
}

Message represents a Pub/Sub message.

func NewMessage

func NewMessage(ackh AckHandler) *Message

NewMessage creates a message with an AckHandler implementation, which should not be nil.

func (*Message) Ack

func (m *Message) Ack()

Ack indicates successful processing of a Message passed to the Subscriber.Receive callback. It should not be called on any other Message value. If message acknowledgement fails, the Message will be redelivered. Client code must call Ack or Nack when finished for each received Message. Calls to Ack or Nack have no effect after the first call.

func (*Message) AckWithResult

func (m *Message) AckWithResult() *AckResult

AckWithResult acknowledges a message in Pub/Sub and it will not be delivered to this subscription again.

You should avoid acknowledging messages until you have *finished* processing them, so that in the event of a failure, you receive the message again.

If exactly-once delivery is enabled on the subscription, the AckResult returned by this method tracks the state of acknowledgement operation. If the operation completes successfully, the message is guaranteed NOT to be re-delivered. Otherwise, the result will contain an error with more details about the failure and the message may be re-delivered.

If exactly-once delivery is NOT enabled on the subscription, or if using Pub/Sub Lite, AckResult readies immediately with a AcknowledgeStatus.Success. Since acks in Cloud Pub/Sub are best effort when exactly-once delivery is disabled, the message may be re-delivered. Because re-deliveries are possible, you should ensure that your processing code is idempotent, as you may receive any given message more than once.

func (*Message) Nack

func (m *Message) Nack()

Nack indicates that the client will not or cannot process a Message passed to the Subscriber.Receive callback. It should not be called on any other Message value. Nack will result in the Message being redelivered more quickly than if it were allowed to expire. Client code must call Ack or Nack when finished for each received Message. Calls to Ack or Nack have no effect after the first call.

func (*Message) NackWithResult

func (m *Message) NackWithResult() *AckResult

NackWithResult declines to acknowledge the message which indicates that the client will not or cannot process a Message. This will cause the message to be re-delivered to subscribers. Re-deliveries may take place immediately or after a delay.

If exactly-once delivery is enabled on the subscription, the AckResult returned by this method tracks the state of nack operation. If the operation completes successfully, the result will contain AckResponse.Success. Otherwise, the result will contain an error with more details about the failure.

If exactly-once delivery is NOT enabled on the subscription, or if using Pub/Sub Lite, AckResult readies immediately with a AcknowledgeStatus.Success.

type PublishResult

type PublishResult struct {
	// contains filtered or unexported fields
}

A PublishResult holds the result from a call to Publish.

func NewPublishResult

func NewPublishResult() *PublishResult

NewPublishResult creates a PublishResult.

func (*PublishResult) Get

func (r *PublishResult) Get(ctx context.Context) (serverID string, err error)

Get returns the server-generated message ID and/or error result of a Publish call. Get blocks until the Publish call completes or the context is done.

func (*PublishResult) Ready

func (r *PublishResult) Ready() <-chan struct{}

Ready returns a channel that is closed when the result is ready. When the Ready channel is closed, Get is guaranteed not to block.