// Clusters returns a list of cluster resources from the specified zone.
// If no zone is specified, it returns all clusters under the user project.
func Clusters(ctx context.Context, zone string) ([]*Resource, error) {
s := rawService(ctx)
if zone == "" {
resp, err := s.Projects.Zones.Clusters.List(internal.ProjID(ctx), "-").Do()
if err != nil {
return nil, err
}
return resourcesFromRaw(resp.Clusters), nil
}
resp, err := s.Projects.Zones.Clusters.List(internal.ProjID(ctx), zone).Do()
if err != nil {
return nil, err
}
return resourcesFromRaw(resp.Clusters), nil
}
// Operations returns a list of operations from the specified zone.
// If no zone is specified, it looks up for all of the operations
// that are running under the user's project.
func Operations(ctx context.Context, zone string) ([]*Op, error) {
s := rawService(ctx)
if zone == "" {
resp, err := s.Projects.Zones.Operations.List(internal.ProjID(ctx), "-").Do()
if err != nil {
return nil, err
}
return opsFromRaw(resp.Operations), nil
}
resp, err := s.Projects.Zones.Operations.List(internal.ProjID(ctx), zone).Do()
if err != nil {
return nil, err
}
return opsFromRaw(resp.Operations), nil
}
// CreateSub creates a Pub/Sub subscription on the backend.
//
// A subscription should subscribe to an existing topic.
//
// The messages that haven't acknowledged will be pushed back to the
// subscription again when the default acknowledgement deadline is
// reached. You can override the default deadline by providing a
// non-zero deadline. Deadline must not be specified to
// precision greater than one second.
//
// As new messages are being queued on the subscription, you
// may recieve push notifications regarding to the new arrivals.
// To receive notifications of new messages in the queue,
// specify an endpoint callback URL.
// If endpoint is an empty string the backend will not notify the
// client of new messages.
//
// If the subscription already exists an error will be returned.
func CreateSub(ctx context.Context, name string, topic string, deadline time.Duration, endpoint string) error {
sub := &raw.Subscription{
Topic: fullTopicName(internal.ProjID(ctx), topic),
}
if int64(deadline) > 0 {
if !isSec(deadline) {
return errors.New("pubsub: deadline must not be specified to precision greater than one second")
}
sub.AckDeadlineSeconds = int64(deadline / time.Second)
}
if endpoint != "" {
sub.PushConfig = &raw.PushConfig{PushEndpoint: endpoint}
}
_, err := rawService(ctx).Projects.Subscriptions.Create(fullSubName(internal.ProjID(ctx), name), sub).Do()
return err
}
// ModifyPushEndpoint modifies the URL endpoint to modify the resource
// to handle push notifications coming from the Pub/Sub backend
// for the specified subscription.
func ModifyPushEndpoint(ctx context.Context, sub, endpoint string) error {
_, err := rawService(ctx).Projects.Subscriptions.ModifyPushConfig(fullSubName(internal.ProjID(ctx), sub), &raw.ModifyPushConfigRequest{
PushConfig: &raw.PushConfig{
PushEndpoint: endpoint,
},
}).Do()
return err
}
// Cluster returns metadata about the specified cluster.
func Cluster(ctx context.Context, zone, name string) (*Resource, error) {
s := rawService(ctx)
resp, err := s.Projects.Zones.Clusters.Get(internal.ProjID(ctx), zone, name).Do()
if err != nil {
return nil, err
}
return resourceFromRaw(resp), nil
}
// ModifyAckDeadline modifies the acknowledgement deadline
// for the messages retrieved from the specified subscription.
// Deadline must not be specified to precision greater than one second.
func ModifyAckDeadline(ctx context.Context, sub string, id string, deadline time.Duration) error {
if !isSec(deadline) {
return errors.New("pubsub: deadline must not be specified to precision greater than one second")
}
_, err := rawService(ctx).Projects.Subscriptions.ModifyAckDeadline(fullSubName(internal.ProjID(ctx), sub), &raw.ModifyAckDeadlineRequest{
AckDeadlineSeconds: int64(deadline / time.Second),
AckIds: []string{id},
}).Do()
return err
}
// SubExists returns true if subscription exists.
//
// Deprecated: Use SubscriptionHandle.Exists instead.
func SubExists(ctx context.Context, name string) (bool, error) {
_, err := rawService(ctx).Projects.Subscriptions.Get(fullSubName(internal.ProjID(ctx), name)).Do()
if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
}
// Ack acknowledges one or more Pub/Sub messages on the
// specified subscription.
func Ack(ctx context.Context, sub string, id ...string) error {
for idx, ackID := range id {
if ackID == "" {
return fmt.Errorf("pubsub: empty ackID detected at index %d", idx)
}
}
_, err := rawService(ctx).Projects.Subscriptions.Acknowledge(fullSubName(internal.ProjID(ctx), sub), &raw.AcknowledgeRequest{
AckIds: id,
}).Do()
return err
}
// Operation returns an operation.
func Operation(ctx context.Context, zone, name string) (*Op, error) {
s := rawService(ctx)
resp, err := s.Projects.Zones.Operations.Get(internal.ProjID(ctx), zone, name).Do()
if err != nil {
return nil, err
}
if resp.StatusMessage != "" {
return nil, errors.New(resp.StatusMessage)
}
return opFromRaw(resp), nil
}
func pull(ctx context.Context, sub string, n int, retImmediately bool) ([]*Message, error) {
if n < 1 || n > batchLimit {
return nil, fmt.Errorf("pubsub: cannot pull less than one, more than %d messages, but %d was given", batchLimit, n)
}
resp, err := rawService(ctx).Projects.Subscriptions.Pull(fullSubName(internal.ProjID(ctx), sub), &raw.PullRequest{
ReturnImmediately: retImmediately,
MaxMessages: int64(n),
}).Do()
if err != nil {
return nil, err
}
msgs := make([]*Message, len(resp.ReceivedMessages))
for i := 0; i < len(resp.ReceivedMessages); i++ {
msg, err := toMessage(resp.ReceivedMessages[i])
if err != nil {
return nil, fmt.Errorf("pubsub: cannot decode the retrieved message at index: %d, PullResponse: %+v", i, resp.ReceivedMessages[i])
}
msgs[i] = msg
}
return msgs, nil
}
// Publish publish messages to the topic's subscribers. It returns
// message IDs upon success.
func Publish(ctx context.Context, topic string, msgs ...*Message) ([]string, error) {
var rawMsgs []*raw.PubsubMessage
if len(msgs) == 0 {
return nil, errors.New("pubsub: no messages to publish")
}
if len(msgs) > batchLimit {
return nil, fmt.Errorf("pubsub: %d messages given, but maximum batch size is %d", len(msgs), batchLimit)
}
rawMsgs = make([]*raw.PubsubMessage, len(msgs))
for i, msg := range msgs {
rawMsgs[i] = &raw.PubsubMessage{
Data: base64.StdEncoding.EncodeToString(msg.Data),
Attributes: msg.Attributes,
}
}
resp, err := rawService(ctx).Projects.Topics.Publish(fullTopicName(internal.ProjID(ctx), topic), &raw.PublishRequest{
Messages: rawMsgs,
}).Do()
if err != nil {
return nil, err
}
return resp.MessageIds, nil
}
// DeleteCluster deletes a cluster.
func DeleteCluster(ctx context.Context, zone, name string) error {
s := rawService(ctx)
_, err := s.Projects.Zones.Clusters.Delete(internal.ProjID(ctx), zone, name).Do()
return err
}
// DeleteSub deletes the subscription.
//
// Deprecated: Use SubscriptionHandle.Delete instead.
func DeleteSub(ctx context.Context, name string) error {
_, err := rawService(ctx).Projects.Subscriptions.Delete(fullSubName(internal.ProjID(ctx), name)).Do()
return err
}
// DeleteTopic deletes the specified topic.
//
// Deprecated: Use TopicHandle.Delete instead.
func DeleteTopic(ctx context.Context, name string) error {
_, err := rawService(ctx).Projects.Topics.Delete(fullTopicName(internal.ProjID(ctx), name)).Do()
return err
}