// 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.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
}
// 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.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
}
func call(ctx context.Context, method string, req proto.Message, resp proto.Message) error {
payload, err := proto.Marshal(req)
if err != nil {
return err
}
url := baseUrl(ctx) + internal.ProjID(ctx) + "/" + method
r, err := internal.HTTPClient(ctx).Post(url, "application/x-protobuf", bytes.NewReader(payload))
if err != nil {
return err
}
defer r.Body.Close()
all, err := ioutil.ReadAll(r.Body)
if r.StatusCode != http.StatusOK {
e := &errHTTP{
StatusCode: r.StatusCode,
err: err,
}
if err == nil {
e.Body = string(all)
}
return e
}
if err != nil {
return err
}
if err = proto.Unmarshal(all, resp); err != nil {
return err
}
return 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),
Name: fullSubName(internal.ProjID(ctx), name),
}
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).Subscriptions.Create(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 {
return rawService(ctx).Subscriptions.ModifyPushConfig(&raw.ModifyPushConfigRequest{
Subscription: fullSubName(internal.ProjID(ctx), sub),
PushConfig: &raw.PushConfig{
PushEndpoint: endpoint,
},
}).Do()
}
// 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, deadline time.Duration) error {
if !isSec(deadline) {
return errors.New("pubsub: deadline must not be specified to precision greater than one second")
}
return rawService(ctx).Subscriptions.ModifyAckDeadline(&raw.ModifyAckDeadlineRequest{
Subscription: fullSubName(internal.ProjID(ctx), sub),
AckDeadlineSeconds: int64(deadline),
}).Do()
}
// TopicExists returns true if a topic exists with the specified name.
func TopicExists(ctx context.Context, name string) (bool, error) {
_, err := rawService(ctx).Topics.Get(fullTopicName(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
}
// 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.ErrorMessage != "" {
return nil, errors.New(resp.ErrorMessage)
}
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).Subscriptions.PullBatch(&raw.PullBatchRequest{
Subscription: fullSubName(internal.ProjID(ctx), sub),
ReturnImmediately: retImmediately,
MaxEvents: int64(n),
}).Do()
if err != nil {
return nil, err
}
msgs := make([]*Message, len(resp.PullResponses))
for i := 0; i < len(resp.PullResponses); i++ {
msg, err := toMessage(resp.PullResponses[i])
if err != nil {
return nil, fmt.Errorf("pubsub: cannot decode the retrieved message at index: %d, PullResponse: %+v", i, resp.PullResponses[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 {
var rawLabels []*raw.Label
if len(msg.Labels) > 0 {
rawLabels = make([]*raw.Label, len(msg.Labels))
j := 0
for k, v := range msg.Labels {
rawLabels[j] = &raw.Label{
Key: k,
StrValue: v,
}
j++
}
}
rawMsgs[i] = &raw.PubsubMessage{
Data: base64.URLEncoding.EncodeToString(msg.Data),
Label: rawLabels,
}
}
resp, err := rawService(ctx).Topics.PublishBatch(&raw.PublishBatchRequest{
Topic: fullTopicName(internal.ProjID(ctx), topic),
Messages: rawMsgs,
}).Do()
if err != nil {
return nil, err
}
return resp.MessageIds, nil
}
// DeleteTopic deletes the specified topic.
func DeleteTopic(ctx context.Context, name string) error {
return rawService(ctx).Topics.Delete(fullTopicName(internal.ProjID(ctx), name)).Do()
}
// CreateTopic creates a new topic with the specified name on the backend.
// It will return an error if topic already exists.
func CreateTopic(ctx context.Context, name string) error {
_, err := rawService(ctx).Topics.Create(&raw.Topic{
Name: fullTopicName(internal.ProjID(ctx), name),
}).Do()
return err
}
// Ack acknowledges one or more Pub/Sub messages on the
// specified subscription.
func Ack(ctx context.Context, sub string, id ...string) error {
return rawService(ctx).Subscriptions.Acknowledge(&raw.AcknowledgeRequest{
Subscription: fullSubName(internal.ProjID(ctx), sub),
AckId: id,
}).Do()
}
// DeleteSub deletes the subscription.
func DeleteSub(ctx context.Context, name string) error {
return rawService(ctx).Subscriptions.Delete(fullSubName(internal.ProjID(ctx), name)).Do()
}
// 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
}