Poc: Send Geo requests as streamed multipart requeststmp-geo-push-poc

1 files changed, 60 insertions, 32 deletions

diff --git a/client/gitlabnet.go b/client/gitlabnet.go
index 38adf2a..43502ca 100644
--- a/client/gitlabnet.go
+++ b/client/gitlabnet.go
@@ -150,21 +150,10 @@ func (c *GitlabNetClient) Post(ctx context.Context, path string, data interface{
 	return c.DoRequest(ctx, http.MethodPost, normalizePath(path), data)
 }
 
-func (c *GitlabNetClient) DoRequest(ctx context.Context, method, path string, data interface{}) (*http.Response, error) {
-	request, err := newRequest(ctx, method, c.httpClient.Host, path, data)
-	if err != nil {
-		return nil, err
-	}
-
-	retryableRequest, err := newRetryableRequest(ctx, method, c.httpClient.Host, path, data)
-	if err != nil {
-		return nil, err
-	}
-
+func (c *GitlabNetClient) prepareRequest(request *http.Request) error {
 	user, password := c.user, c.password
 	if user != "" && password != "" {
 		request.SetBasicAuth(user, password)
-		retryableRequest.SetBasicAuth(user, password)
 	}
 
 	claims := jwt.RegisteredClaims{
@@ -175,44 +164,33 @@ func (c *GitlabNetClient) DoRequest(ctx context.Context, method, path string, da
 	secretBytes := []byte(strings.TrimSpace(c.secret))
 	tokenString, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secretBytes)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	request.Header.Set(apiSecretHeaderName, tokenString)
-	retryableRequest.Header.Set(apiSecretHeaderName, tokenString)
 
-	originalRemoteIP, ok := ctx.Value(OriginalRemoteIPContextKey{}).(string)
+	originalRemoteIP, ok := request.Context().Value(OriginalRemoteIPContextKey{}).(string)
 	if ok {
 		request.Header.Add("X-Forwarded-For", originalRemoteIP)
-		retryableRequest.Header.Add("X-Forwarded-For", originalRemoteIP)
 	}
 
 	request.Header.Add("Content-Type", "application/json")
-	retryableRequest.Header.Add("Content-Type", "application/json")
 	request.Header.Add("User-Agent", c.userAgent)
-	retryableRequest.Header.Add("User-Agent", c.userAgent)
 	request.Close = true
-	retryableRequest.Close = true
 
-	start := time.Now()
+	return nil
+}
 
-	var response *http.Response
-	var respErr error
-	if c.httpClient.HTTPClient != nil {
-		response, respErr = c.httpClient.HTTPClient.Do(request)
-	}
-	if os.Getenv("FF_GITLAB_SHELL_RETRYABLE_HTTP") == "1" && c.httpClient.RetryableHTTP != nil {
-		response, respErr = c.httpClient.RetryableHTTP.Do(retryableRequest)
-	}
+func processResult(request *http.Request, response *http.Response, start time.Time, respErr error) error {
 	fields := log.Fields{
-		"method":      method,
+		"method":      request.Method,
 		"url":         request.URL.String(),
 		"duration_ms": time.Since(start) / time.Millisecond,
 	}
-	logger := log.WithContextFields(ctx, fields)
+	logger := log.WithContextFields(request.Context(), fields)
 
 	if respErr != nil {
 		logger.WithError(respErr).Error("Internal API unreachable")
-		return nil, &ApiError{"Internal API unreachable"}
+		return &ApiError{"Internal API unreachable"}
 	}
 
 	if response != nil {
@@ -220,7 +198,7 @@ func (c *GitlabNetClient) DoRequest(ctx context.Context, method, path string, da
 	}
 	if err := parseError(response); err != nil {
 		logger.WithError(err).Error("Internal API error")
-		return nil, err
+		return err
 	}
 
 	if response.ContentLength >= 0 {
@@ -229,5 +207,55 @@ func (c *GitlabNetClient) DoRequest(ctx context.Context, method, path string, da
 
 	logger.Info("Finished HTTP request")
 
+	return nil
+}
+
+func (c *GitlabNetClient) AppendPath(path string) string {
+	return appendPath(c.httpClient.Host, path)
+}
+
+func (c *GitlabNetClient) DoRawRequest(request *http.Request) (*http.Response, error) {
+	c.prepareRequest(request)
+
+	start := time.Now()
+
+	response, respErr := c.httpClient.HTTPClient.Do(request)
+
+	if err := processResult(request, response, start, respErr); err != nil {
+		return nil, err
+	}
+
 	return response, nil
 }
+
+func (c *GitlabNetClient) DoRequest(ctx context.Context, method, path string, data interface{}) (*http.Response, error) {
+	request, err := newRequest(ctx, method, c.httpClient.Host, path, data)
+	if err != nil {
+		return nil, err
+	}
+
+	retryableRequest, err := newRetryableRequest(ctx, method, c.httpClient.Host, path, data)
+	if err != nil {
+		return nil, err
+	}
+
+	c.prepareRequest(request)
+	c.prepareRequest(retryableRequest.Request)
+
+	start := time.Now()
+
+	var response *http.Response
+	var respErr error
+	if c.httpClient.HTTPClient != nil {
+		response, respErr = c.httpClient.HTTPClient.Do(request)
+	}
+	if os.Getenv("FF_GITLAB_SHELL_RETRYABLE_HTTP") == "1" && c.httpClient.RetryableHTTP != nil {
+		response, respErr = c.httpClient.RetryableHTTP.Do(retryableRequest)
+	}
+
+	if err := processResult(request, response, start, respErr); err != nil {
+		return nil, err
+	}
+
+	return response, err
+}