Add throttle to context

main.go

@@ -13,22 +13,26 @@ const burstLimit = 2
 
 func main() {
 	ctx := context.Background()
-	throttles := make(map[string]<-chan time.Time)
+	throttles := make(map[string]context.Context)
 	calledLastHour := make([]string, 0)
 
 	http.HandleFunc("/", serveIndexFile)
 	http.HandleFunc("/input.txt", serveInputFile)
 	http.HandleFunc("/result", func(w http.ResponseWriter, r *http.Request) {
 
-		ctx, cancel := context.WithCancel(ctx)
+		cctxV, ok := throttles[r.RemoteAddr]
-		throttle := throttling.CreateThrottle(ctx, burstLimit)
+		if !ok {
+			cctx, cancel := context.WithCancel(ctx)
+			throttle := throttling.CreateThrottle(cctx, burstLimit)
 			a := throttleWithCancel{
 				throttle: throttle,
 				cancel:   cancel,
 			}
-		con := context.WithValue(ctx, "throttle", a)
+			cctxV = context.WithValue(ctx, "throttle", a)
+			throttles[r.RemoteAddr] = cctxV
+		}
 
-		tryResult(ctx, w, r, throttles, calledLastHour)
+		tryResult(cctxV, w, r, calledLastHour)
 	})
 
 	err := http.ListenAndServe(":3333", nil)
@@ -51,19 +55,14 @@ func serveInputFile(w http.ResponseWriter, r *http.Request) {
 	http.ServeFile(w, r, "static/input.txt")
 }
 
-func tryResult(ctx context.Context, w http.ResponseWriter, r *http.Request, throttles map[string]<-chan time.Time, calledLastHour []string) {
+func tryResult(ctx context.Context, w http.ResponseWriter, r *http.Request, calledLastHour []string) {
 	clientIP := r.RemoteAddr
 	clientResult := r.URL.Query().Get("result")
 	fmt.Println(clientIP, clientResult)
 	if !slices.Contains(calledLastHour, clientIP) {
 		calledLastHour = append(calledLastHour, clientIP)
 	}
-	throttle, ok := throttles[clientIP]
+	throttle := ctx.Value("throttle").(throttleWithCancel).throttle
-	if !ok {
-		fmt.Println("Creating new throttle")
-		throttle = throttling.CreateThrottle(ctx, burstLimit)
-		throttles[clientIP] = throttle
-	}
 	payload := throttling.Payload{
 		R:            r,
 		W:            w,

throttling/rateLimit.go

@@ -24,9 +24,6 @@ type Payload struct {
 // CallFunction allows burst rate limiting client calls with the
 // payloads.
 func CallFunction(ctx context.Context, client Client, payload *Payload, throttle <-chan time.Time) {
-	//ctx, cancel := context.WithCancel(ctx)
-	// defer cancel()
-
 	<-throttle // rate limit our client calls
 	client.Call(payload)
 }