Added cookie jar and simplified HTTP acks

cmd/discord/rest/client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"mime/multipart"
 	"net/http"
+	"net/http/cookiejar"
 	"net/textproto"
 	"strconv"
 	"sync"
@@ -53,18 +54,26 @@ func NewClient(token string, opts ...ClientOption) (*Client, error) {
 		apply(&options)
 	}
 
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create a new cookie jar: %w", err)
+	}
+
 	client := &Client{
 		token:            token,
 		rateLimitMx:      sync.Mutex{},
 		rateLimitBuckets: make(map[string]time.Time),
-		http:             http.Client{Timeout: time.Millisecond * 5000}, // discord is very slow sometimes
-		observer:         options.observer,
+		http: http.Client{
+			Timeout: time.Millisecond * 5000, // discord is very slow sometimes
+			Jar:     jar,
+		},
+		observer: options.observer,
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
 
-	_, err := client.lookupApplicationID(ctx)
+	_, err = client.lookupApplicationID(ctx)
 	if err != nil {
 		return nil, err
 	}

cmd/discord/router/handler.go

@@ -16,7 +16,6 @@ import (
 	"github.com/bwmarrin/discordgo"
 	"github.com/cufee/aftermath/cmd/discord/commands/builder"
 	"github.com/cufee/aftermath/cmd/discord/common"
-	"github.com/cufee/aftermath/cmd/discord/rest"
 	"github.com/cufee/aftermath/internal/localization"
 	"github.com/cufee/aftermath/internal/log"
 	"github.com/cufee/aftermath/internal/retry"
@@ -50,9 +49,6 @@ func (router *router) HTTPHandler() (http.HandlerFunc, error) {
 			return
 		}
 
-		// we validated the request and are working on it
-		w.WriteHeader(http.StatusProcessing)
-
 		cmd, err := router.routeInteraction(data)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -69,26 +65,14 @@ func (router *router) HTTPHandler() (http.HandlerFunc, error) {
 			return
 		}
 
-		res := retry.Retry(
-			func() (struct{}, error) {
-				ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*500)
-				defer cancel()
-
-				err := router.restClient.AckInteractionResponse(ctx, data.ID, data.Token, cmd.Ephemeral)
-				if errors.Is(err, rest.ErrInteractionAlreadyAcked) {
-					err = nil
-				}
-				return struct{}{}, err
-			},
-			5,
-			time.Millisecond*250)
-		if res.Err != nil {
-			log.Warn().Err(res.Err).Str("id", data.ID).Msg("failed to ack an interaction")
-			// cross our fingers and hope discord registered one of those requests, or will propagate the ack from the response body
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		if cmd.Ephemeral {
+			w.Write([]byte(`{"type":5,"data":{"flags":64}}`))
+		} else {
+			w.Write([]byte(`{"type":5}`))
 		}
 
-		w.WriteHeader(http.StatusAccepted)
-
 		// run the interaction handler
 		go func() {
 			// while the limit for a deferred reply is on a scale of minutes, we probably do not want a user to wait that long

internal/external/blitzkit/client.go

@@ -1,24 +1,16 @@
 package blitzkit
 
 import (
-	"context"
 	"net/http"
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/pkg/errors"
 )
 
 //go:generate go tool github.com/bufbuild/buf/cmd/buf generate --template buf.gen.yaml --path averages.proto
 
 var ErrServiceUnavailable = errors.New("blitzkit averages unavailable")
 
-type Client interface {
-	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
-}
-
-var _ Client = &client{} // just a marker to see if it is implemented correctly
-
 type client struct {
 	http           http.Client
 	requestTimeout time.Duration

internal/external/blitzstars/client.go

@@ -1,20 +1,14 @@
 package blitzstars
 
 import (
-	"context"
 	"net/http"
 	"time"
 
-	"github.com/cufee/aftermath/internal/stats/frame"
 	"github.com/pkg/errors"
 )
 
 var ErrServiceUnavailable = errors.New("blitz stars unavailable")
 
-type Client interface {
-	CurrentTankAverages(ctx context.Context) (map[string]frame.StatsFrame, error)
-}
-
 type client struct {
 	http           http.Client
 	apiURL         string

internal/stats/fetch/v1/multisource.go

@@ -32,10 +32,10 @@ type multiSourceClient struct {
 
 	database  database.Client
 	wargaming wargaming.Client
-	averages  *averages.Client
+	averages  averages.Source
 }
 
-func NewMultiSourceClient(wargaming wargaming.Client, averages *averages.Client, database database.Client) (*multiSourceClient, error) {
+func NewMultiSourceClient(wargaming wargaming.Client, averages averages.Source, database database.Client) (*multiSourceClient, error) {
 	return &multiSourceClient{
 		database:  database,
 		wargaming: wargaming,

render_test.go

@@ -51,12 +51,12 @@ func TestRenderReplay(t *testing.T) {
 
 	env.LoadTestEnv(t)
 	db := tests.StaticTestingDatabase()
-	wg, _ := wargamingClientsFromEnv(nil)
+	wg, _ := wargamingClientsFromEnv(tests.NewNoopObserver())
 
 	printer, err := localization.NewPrinter("stats", language.English)
 	is.NoErr(err)
 
-	fetch, err := fetch.NewMultiSourceClient(wg, nil, db)
+	fetch, err := fetch.NewMultiSourceClient(wg, tests.StaticTestingFetch(), db)
 	is.NoErr(err)
 
 	replayFiles := []string{"replay_defeat.wotbreplay", "replay_victory.wotbreplay", "replay_draw.wotbreplay", "replay_rating.wotbreplay"}

tests/noop_metrics.go

@@ -0,0 +1,9 @@
+package tests
+
+type NoopObserver struct{}
+
+func (o *NoopObserver) Record(source, operation string, failed bool) {}
+
+func NewNoopObserver() *NoopObserver {
+	return &NoopObserver{}
+}