func SetAckResult(r *AckResult, resAcknowledgeStatus, errerror)

func SetPublishResult(r *PublishResult, sidstring, errerror)

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}

funcMessageAckHandler¶

func MessageAckHandler(m *Message)AckHandler

MessageAckHandler provides access to the internal field Message.ackh.

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

funcNewAckResult¶added inv0.104.0

func NewAckResult() *AckResult

NewAckResult creates a AckResult.

func (*AckResult)Get¶added inv0.104.0

func (r *AckResult) Get(ctxcontext.Context) (resAcknowledgeStatus, errerror)

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¶added inv0.104.0

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 AcknowledgeStatusint

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.IDstring// 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.PublishTimetime.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.OrderingKeystring// contains filtered or unexported fields}

funcNewMessage¶

func NewMessage(ackhAckHandler) *Message

NewMessage creates a message with an AckHandler implementation, which shouldnot 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¶added inv0.104.0

func (m *Message) AckWithResult() *AckResult

AckWithResult acknowledges a message in Pub/Sub and it will not bedelivered 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, theAckResult returned by this method tracks the state of acknowledgementoperation. If the operation completes successfully, the message isguaranteed NOT to be re-delivered. Otherwise, the result willcontain an error with more details about the failure and themessage may be re-delivered.

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

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¶added inv0.104.0

func (m *Message) NackWithResult() *AckResult

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

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

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

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

funcNewPublishResult¶

func NewPublishResult() *PublishResult

NewPublishResult creates a PublishResult.

func (*PublishResult)Get¶

func (r *PublishResult) Get(ctxcontext.Context) (serverIDstring, errerror)

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.