// 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 }