Migrated the FCM impl to the new HTTPClient API (#275)

Author: hiranya911

.gitignore

@@ -1,2 +1,4 @@
 testdata/integration_*
 .vscode/*
+*~
+

internal/http_client.go

@@ -56,10 +56,6 @@ type CreateErrFn func(r *Response) error
 // NewHTTPClient creates a new HTTPClient using the provided client options and the default
 // RetryConfig.
 //
-// The default RetryConfig retries requests on all low-level network errors as well as on HTTP
-// InternalServerError (500) and ServiceUnavailable (503) errors. Repeatedly failing requests are
-// retried up to 4 times with exponential backoff. Retry delay is never longer than 2 minutes.
-//
 // NewHTTPClient returns the created HTTPClient along with the target endpoint URL. The endpoint
 // is obtained from the client options passed into the function.
 func NewHTTPClient(ctx context.Context, opts ...option.ClientOption) (*HTTPClient, string, error) {
@@ -68,8 +64,18 @@ func NewHTTPClient(ctx context.Context, opts ...option.ClientOption) (*HTTPClien
 		return nil, "", err
 	}
 
+	return WithDefaultRetryConfig(hc), endpoint, nil
+}
+
+// WithDefaultRetryConfig creates a new HTTPClient using the provided client and the default
+// RetryConfig.
+//
+// The default RetryConfig retries requests on all low-level network errors as well as on HTTP
+// InternalServerError (500) and ServiceUnavailable (503) errors. Repeatedly failing requests are
+// retried up to 4 times with exponential backoff. Retry delay is never longer than 2 minutes.
+func WithDefaultRetryConfig(hc *http.Client) *HTTPClient {
 	twoMinutes := time.Duration(2) * time.Minute
-	client := &HTTPClient{
+	return &HTTPClient{
 		Client: hc,
 		RetryConfig: &RetryConfig{
 			MaxRetries: 4,
@@ -81,7 +87,6 @@ func NewHTTPClient(ctx context.Context, opts ...option.ClientOption) (*HTTPClien
 			MaxDelay:         &twoMinutes,
 		},
 	}
-	return client, endpoint, nil
 }
 
 // Request contains all the parameters required to construct an outgoing HTTP request.

messaging/messaging.go

@@ -28,14 +28,12 @@ import (
 	"time"
 
 	"firebase.google.com/go/internal"
+	"google.golang.org/api/transport"
 )
 
 const (
 	messagingEndpoint = "https://fcm.googleapis.com/v1"
 	batchEndpoint     = "https://fcm.googleapis.com/batch"
-	iidEndpoint       = "https://iid.googleapis.com"
-	iidSubscribe      = "iid/v1:batchAdd"
-	iidUnsubscribe    = "iid/v1:batchRemove"
 
 	firebaseClientHeader   = "X-Firebase-Client"
 	apiFormatVersionHeader = "X-GOOG-API-FORMAT-VERSION"
@@ -104,37 +102,8 @@ var (
 			"app instance has been unregistered; code: " + registrationTokenNotRegistered,
 		},
 	}
-
-	iidErrorCodes = map[string]struct{ Code, Msg string }{
-		"INVALID_ARGUMENT": {
-			invalidArgument,
-			"request contains an invalid argument; code: " + invalidArgument,
-		},
-		"NOT_FOUND": {
-			registrationTokenNotRegistered,
-			"request contains an invalid argument; code: " + registrationTokenNotRegistered,
-		},
-		"INTERNAL": {
-			internalError,
-			"server encountered an internal error; code: " + internalError,
-		},
-		"TOO_MANY_TOPICS": {
-			tooManyTopics,
-			"client exceeded the number of allowed topics; code: " + tooManyTopics,
-		},
-	}
 )
 
-// Client is the interface for the Firebase Cloud Messaging (FCM) service.
-type Client struct {
-	fcmEndpoint   string // to enable testing against arbitrary endpoints
-	batchEndpoint string // to enable testing against arbitrary endpoints
-	iidEndpoint   string // to enable testing against arbitrary endpoints
-	client        *internal.HTTPClient
-	project       string
-	version       string
-}
-
 // Message to be sent via Firebase Cloud Messaging.
 //
 // Message contains payload data, recipient information and platform-specific configuration
@@ -635,39 +604,10 @@ type ErrorInfo struct {
 	Reason string
 }
 
-// TopicManagementResponse is the result produced by topic management operations.
-//
-// TopicManagementResponse provides an overview of how many input tokens were successfully handled,
-// and how many failed. In case of failures, the Errors list provides specific details concerning
-// each error.
-type TopicManagementResponse struct {
-	SuccessCount int
-	FailureCount int
-	Errors       []*ErrorInfo
-}
-
-func newTopicManagementResponse(resp *iidResponse) *TopicManagementResponse {
-	tmr := &TopicManagementResponse{}
-	for idx, res := range resp.Results {
-		if len(res) == 0 {
-			tmr.SuccessCount++
-		} else {
-			tmr.FailureCount++
-			code := res["error"].(string)
-			info, ok := iidErrorCodes[code]
-			var reason string
-			if ok {
-				reason = info.Msg
-			} else {
-				reason = unknownError
-			}
-			tmr.Errors = append(tmr.Errors, &ErrorInfo{
-				Index:  idx,
-				Reason: reason,
-			})
-		}
-	}
-	return tmr
+// Client is the interface for the Firebase Cloud Messaging (FCM) service.
+type Client struct {
+	*fcmClient
+	*iidClient
 }
 
 // NewClient creates a new instance of the Firebase Cloud Messaging Client.
@@ -679,27 +619,51 @@ func NewClient(ctx context.Context, c *internal.MessagingConfig) (*Client, error
 		return nil, errors.New("project ID is required to access Firebase Cloud Messaging client")
 	}
 
-	hc, _, err := internal.NewHTTPClient(ctx, c.Opts...)
+	hc, _, err := transport.NewHTTPClient(ctx, c.Opts...)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Client{
+		fcmClient: newFCMClient(hc, c),
+		iidClient: newIIDClient(hc),
+	}, nil
+}
+
+type fcmClient struct {
+	fcmEndpoint   string
+	batchEndpoint string
+	project       string
+	version       string
+	httpClient    *internal.HTTPClient
+}
+
+func newFCMClient(hc *http.Client, conf *internal.MessagingConfig) *fcmClient {
+	client := internal.WithDefaultRetryConfig(hc)
+	client.CreateErrFn = handleFCMError
+	client.SuccessFn = internal.HasSuccessStatus
+
+	version := fmt.Sprintf("fire-admin-go/%s", conf.Version)
+	client.Opts = []internal.HTTPOption{
+		internal.WithHeader(apiFormatVersionHeader, apiFormatVersion),
+		internal.WithHeader(firebaseClientHeader, version),
+	}
+
+	return &fcmClient{
 		fcmEndpoint:   messagingEndpoint,
 		batchEndpoint: batchEndpoint,
-		iidEndpoint:   iidEndpoint,
-		client:        hc,
-		project:       c.ProjectID,
-		version:       "fire-admin-go/" + c.Version,
-	}, nil
+		project:       conf.ProjectID,
+		version:       version,
+		httpClient:    client,
+	}
 }
 
 // Send sends a Message to Firebase Cloud Messaging.
 //
 // The Message must specify exactly one of Token, Topic and Condition fields. FCM will
 // customize the message for each target platform based on the arguments specified in the
 // Message.
-func (c *Client) Send(ctx context.Context, message *Message) (string, error) {
+func (c *fcmClient) Send(ctx context.Context, message *Message) (string, error) {
 	payload := &fcmRequest{
 		Message: message,
 	}
@@ -710,36 +674,28 @@ func (c *Client) Send(ctx context.Context, message *Message) (string, error) {
 //
 // This function does not actually deliver the message to target devices. Instead, it performs all
 // the SDK-level and backend validations on the message, and emulates the send operation.
-func (c *Client) SendDryRun(ctx context.Context, message *Message) (string, error) {
+func (c *fcmClient) SendDryRun(ctx context.Context, message *Message) (string, error) {
 	payload := &fcmRequest{
 		ValidateOnly: true,
 		Message:      message,
 	}
 	return c.makeSendRequest(ctx, payload)
 }
 
-// SubscribeToTopic subscribes a list of registration tokens to a topic.
-//
-// The tokens list must not be empty, and have at most 1000 tokens.
-func (c *Client) SubscribeToTopic(ctx context.Context, tokens []string, topic string) (*TopicManagementResponse, error) {
-	req := &iidRequest{
-		Topic:  topic,
-		Tokens: tokens,
-		op:     iidSubscribe,
+func (c *fcmClient) makeSendRequest(ctx context.Context, req *fcmRequest) (string, error) {
+	if err := validateMessage(req.Message); err != nil {
+		return "", err
 	}
-	return c.makeTopicManagementRequest(ctx, req)
-}
 
-// UnsubscribeFromTopic unsubscribes a list of registration tokens from a topic.
-//
-// The tokens list must not be empty, and have at most 1000 tokens.
-func (c *Client) UnsubscribeFromTopic(ctx context.Context, tokens []string, topic string) (*TopicManagementResponse, error) {
-	req := &iidRequest{
-		Topic:  topic,
-		Tokens: tokens,
-		op:     iidUnsubscribe,
+	request := &internal.Request{
+		Method: http.MethodPost,
+		URL:    fmt.Sprintf("%s/projects/%s/messages:send", c.fcmEndpoint, c.project),
+		Body:   internal.NewJSONEntity(req),
 	}
-	return c.makeTopicManagementRequest(ctx, req)
+
+	var result fcmResponse
+	_, err := c.httpClient.DoAndUnmarshal(ctx, request, &result)
+	return result.Name, err
 }
 
 // IsInternal checks if the given error was due to an internal server error.
@@ -812,49 +768,6 @@ type fcmError struct {
 	} `json:"error"`
 }
 
-type iidRequest struct {
-	Topic  string   `json:"to"`
-	Tokens []string `json:"registration_tokens"`
-	op     string
-}
-
-type iidResponse struct {
-	Results []map[string]interface{} `json:"results"`
-}
-
-type iidError struct {
-	Error string `json:"error"`
-}
-
-func (c *Client) makeSendRequest(ctx context.Context, req *fcmRequest) (string, error) {
-	if err := validateMessage(req.Message); err != nil {
-		return "", err
-	}
-
-	request := &internal.Request{
-		Method: http.MethodPost,
-		URL:    fmt.Sprintf("%s/projects/%s/messages:send", c.fcmEndpoint, c.project),
-		Body:   internal.NewJSONEntity(req),
-		Opts: []internal.HTTPOption{
-			internal.WithHeader(apiFormatVersionHeader, apiFormatVersion),
-			internal.WithHeader(firebaseClientHeader, c.version),
-		},
-	}
-
-	resp, err := c.client.Do(ctx, request)
-	if err != nil {
-		return "", err
-	}
-
-	if resp.Status == http.StatusOK {
-		var result fcmResponse
-		err := json.Unmarshal(resp.Body, &result)
-		return result.Name, err
-	}
-
-	return "", handleFCMError(resp)
-}
-
 func handleFCMError(resp *internal.Response) error {
 	var fe fcmError
 	json.Unmarshal(resp.Body, &fe) // ignore any json parse errors at this level
@@ -882,59 +795,3 @@ func handleFCMError(resp *internal.Response) error {
 	}
 	return internal.Errorf(clientCode, "http error status: %d; reason: %s", resp.Status, msg)
 }
-
-func (c *Client) makeTopicManagementRequest(ctx context.Context, req *iidRequest) (*TopicManagementResponse, error) {
-	if len(req.Tokens) == 0 {
-		return nil, fmt.Errorf("no tokens specified")
-	}
-	if len(req.Tokens) > 1000 {
-		return nil, fmt.Errorf("tokens list must not contain more than 1000 items")
-	}
-	for _, token := range req.Tokens {
-		if token == "" {
-			return nil, fmt.Errorf("tokens list must not contain empty strings")
-		}
-	}
-
-	if req.Topic == "" {
-		return nil, fmt.Errorf("topic name not specified")
-	}
-	if !topicNamePattern.MatchString(req.Topic) {
-		return nil, fmt.Errorf("invalid topic name: %q", req.Topic)
-	}
-
-	if !strings.HasPrefix(req.Topic, "/topics/") {
-		req.Topic = "/topics/" + req.Topic
-	}
-
-	request := &internal.Request{
-		Method: http.MethodPost,
-		URL:    fmt.Sprintf("%s/%s", c.iidEndpoint, req.op),
-		Body:   internal.NewJSONEntity(req),
-		Opts:   []internal.HTTPOption{internal.WithHeader("access_token_auth", "true")},
-	}
-	resp, err := c.client.Do(ctx, request)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.Status == http.StatusOK {
-		var result iidResponse
-		if err := json.Unmarshal(resp.Body, &result); err != nil {
-			return nil, err
-		}
-		return newTopicManagementResponse(&result), nil
-	}
-
-	var ie iidError
-	json.Unmarshal(resp.Body, &ie) // ignore any json parse errors at this level
-	var clientCode, msg string
-	info, ok := iidErrorCodes[ie.Error]
-	if ok {
-		clientCode, msg = info.Code, info.Msg
-	} else {
-		clientCode = unknownError
-		msg = fmt.Sprintf("client encountered an unknown error; response: %s", string(resp.Body))
-	}
-	return nil, internal.Errorf(clientCode, "http error status: %d; reason: %s", resp.Status, msg)
-}