Merge branch 'main' of https://git.tornberg.me/mats/go-cart-actor

2025-11-10 19:47:23 +01:00
parent 44d7c1faad caab742461
commit 8bf29020dd
14 changed files with 588 additions and 106 deletions
--- a/cmd/cart/checkout_server.go
+++ b/cmd/cart/checkout_server.go
@@ -29,7 +29,7 @@ func (a *App) HandleCheckoutRequests(amqpUrl string, mux *http.ServeMux) {
 	orderHandler := NewAmqpOrderHandler(conn)
 	orderHandler.DefineTopics()

-	mux.HandleFunc("/push", func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc("POST /push", func(w http.ResponseWriter, r *http.Request) {

 		if r.Method != http.MethodPost {
 			w.WriteHeader(http.StatusMethodNotAllowed)
@@ -59,7 +59,7 @@ func (a *App) HandleCheckoutRequests(amqpUrl string, mux *http.ServeMux) {
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
-		err = a.klarnaClient.AcknowledgeOrder(orderId)
+		err = a.klarnaClient.AcknowledgeOrder(r.Context(), orderId)
 		if err != nil {
 			log.Printf("Error acknowledging order: %v\n", err)
 		}
@@ -67,7 +67,7 @@ func (a *App) HandleCheckoutRequests(amqpUrl string, mux *http.ServeMux) {
 		w.WriteHeader(http.StatusOK)
 	})

-	mux.HandleFunc("/checkout", a.server.CheckoutHandler(func(order *CheckoutOrder, w http.ResponseWriter) error {
+	mux.HandleFunc("GET /checkout", a.server.CheckoutHandler(func(order *CheckoutOrder, w http.ResponseWriter) error {
 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
 		w.Header().Set("Permissions-Policy", "payment=(self \"https://js.stripe.com\" \"https://m.stripe.network\" \"https://js.playground.kustom.co\")")
 		w.WriteHeader(http.StatusOK)
@@ -75,7 +75,7 @@ func (a *App) HandleCheckoutRequests(amqpUrl string, mux *http.ServeMux) {
 		return err
 	}))

-	mux.HandleFunc("/confirmation/{order_id}", func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc("GET /confirmation/{order_id}", func(w http.ResponseWriter, r *http.Request) {

 		orderId := r.PathValue("order_id")
 		order, err := a.klarnaClient.GetOrder(orderId)
@@ -102,7 +102,7 @@ func (a *App) HandleCheckoutRequests(amqpUrl string, mux *http.ServeMux) {
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprintf(w, tpl, order.HTMLSnippet)
 	})
-	mux.HandleFunc("/validate", func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc("POST /validate", func(w http.ResponseWriter, r *http.Request) {
 		log.Printf("Klarna order validation, method: %s", r.Method)
 		if r.Method != "POST" {
 			w.WriteHeader(http.StatusMethodNotAllowed)
--- a/cmd/cart/klarna-client.go
+++ b/cmd/cart/klarna-client.go
@@ -1,6 +1,7 @@
 package main

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -64,13 +65,13 @@ func (k *KlarnaClient) getOrderResponse(res *http.Response) (*CheckoutOrder, err
 	return nil, fmt.Errorf("%s", res.Status)
 }

-func (k *KlarnaClient) CreateOrder(reader io.Reader) (*CheckoutOrder, error) {
+func (k *KlarnaClient) CreateOrder(ctx context.Context, reader io.Reader) (*CheckoutOrder, error) {
 	//bytes.NewReader(reply.Payload)
 	req, err := http.NewRequest("POST", k.Url+"/checkout/v3/orders", reader)
 	if err != nil {
 		return nil, err
 	}
-
+	req.WithContext(ctx)
 	req.Header.Add("Content-Type", "application/json")
 	req.SetBasicAuth(k.UserName, k.Password)

@@ -82,13 +83,14 @@ func (k *KlarnaClient) CreateOrder(reader io.Reader) (*CheckoutOrder, error) {
 	return k.getOrderResponse(res)
 }

-func (k *KlarnaClient) UpdateOrder(orderId string, reader io.Reader) (*CheckoutOrder, error) {
+func (k *KlarnaClient) UpdateOrder(ctx context.Context, orderId string, reader io.Reader) (*CheckoutOrder, error) {
 	//bytes.NewReader(reply.Payload)
 	req, err := http.NewRequest("POST", fmt.Sprintf("%s/checkout/v3/orders/%s", k.Url, orderId), reader)
 	if err != nil {
 		return nil, err
 	}

+	req.WithContext(ctx)
 	req.Header.Add("Content-Type", "application/json")
 	req.SetBasicAuth(k.UserName, k.Password)

@@ -100,12 +102,12 @@ func (k *KlarnaClient) UpdateOrder(orderId string, reader io.Reader) (*CheckoutO
 	return k.getOrderResponse(res)
 }

-func (k *KlarnaClient) AbortOrder(orderId string) error {
+func (k *KlarnaClient) AbortOrder(ctx context.Context, orderId string) error {
 	req, err := http.NewRequest("POST", fmt.Sprintf("%s/checkout/v3/orders/%s/abort", k.Url, orderId), nil)
 	if err != nil {
 		return err
 	}
-
+	req.WithContext(ctx)
 	req.SetBasicAuth(k.UserName, k.Password)

 	_, err = http.DefaultClient.Do(req)
@@ -113,11 +115,12 @@ func (k *KlarnaClient) AbortOrder(orderId string) error {
 }

 // ordermanagement/v1/orders/{order_id}/acknowledge
-func (k *KlarnaClient) AcknowledgeOrder(orderId string) error {
+func (k *KlarnaClient) AcknowledgeOrder(ctx context.Context, orderId string) error {
 	req, err := http.NewRequest("POST", fmt.Sprintf("%s/ordermanagement/v1/orders/%s/acknowledge", k.Url, orderId), nil)
 	if err != nil {
 		return err
 	}
+	req.WithContext(ctx)
 	id := uuid.New()

 	req.SetBasicAuth(k.UserName, k.Password)
--- a/cmd/cart/main.go
+++ b/cmd/cart/main.go
@@ -1,15 +1,16 @@
 package main

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
+	"net"
 	"net/http"
 	"net/http/pprof"
 	"os"
 	"os/signal"
 	"strings"
-	"syscall"
 	"time"

 	"git.tornberg.me/go-cart-actor/pkg/actor"
@@ -21,6 +22,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 )

 var (
@@ -158,7 +160,15 @@ func main() {
 	// go diskStorage.SaveLoop(10 * time.Second)
 	UseDiscovery(pool)

-	mux.Handle("/cart/", http.StripPrefix("/cart", syncedServer.Serve()))
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
+	otelShutdown, err := setupOTelSDK(ctx)
+	if err != nil {
+		log.Fatalf("Unable to start otel %v", err)
+	}
+
+	syncedServer.Serve(mux)
 	// only for local
 	mux.HandleFunc("GET /add/remote/{host}", func(w http.ResponseWriter, r *http.Request) {
 		pool.AddRemote(r.PathValue("host"))
@@ -202,23 +212,41 @@ func main() {

 	mux.HandleFunc("/openapi.json", ServeEmbeddedOpenAPI)

-	sigs := make(chan os.Signal, 1)
-	done := make(chan bool, 1)
-	signal.Notify(sigs, syscall.SIGTERM)
+	srv := &http.Server{
+		Addr:         ":8080",
+		BaseContext:  func(net.Listener) context.Context { return ctx },
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 20 * time.Second,
+		Handler:      otelhttp.NewHandler(mux, "/"),
+	}

-	go func() {
-		sig := <-sigs
-		fmt.Println("Shutting down due to signal:", sig)
+	defer func() {
+
+		fmt.Println("Shutting down due to signal")
+		otelShutdown(context.Background())
 		diskStorage.Close()
 		pool.Close()

-		done <- true
+	}()
+
+	srvErr := make(chan error, 1)
+	go func() {
+		srvErr <- srv.ListenAndServe()
 	}()

 	log.Print("Server started at port 8080")
-	go http.ListenAndServe(":8080", mux)
+
 	go http.ListenAndServe(":8081", debugMux)
-	<-done
+
+	select {
+	case err = <-srvErr:
+		// Error when starting HTTP server.
+		log.Fatalf("Unable to start server: %v", err)
+	case <-ctx.Done():
+		// Wait for first CTRL+C.
+		// Stop receiving signal notifications as soon as possible.
+		stop()
+	}

 }

--- a/cmd/cart/otel.go
+++ b/cmd/cart/otel.go
@@ -0,0 +1,117 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/log/global"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/log"
+	"go.opentelemetry.io/otel/sdk/metric"
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+// setupOTelSDK bootstraps the OpenTelemetry pipeline.
+// If it does not return an error, make sure to call shutdown for proper cleanup.
+func setupOTelSDK(ctx context.Context) (func(context.Context) error, error) {
+	var shutdownFuncs []func(context.Context) error
+	var err error
+
+	// shutdown calls cleanup functions registered via shutdownFuncs.
+	// The errors from the calls are joined.
+	// Each registered cleanup will be invoked once.
+	shutdown := func(ctx context.Context) error {
+		var err error
+		for _, fn := range shutdownFuncs {
+			err = errors.Join(err, fn(ctx))
+		}
+		shutdownFuncs = nil
+		return err
+	}
+
+	// handleErr calls shutdown for cleanup and makes sure that all errors are returned.
+	handleErr := func(inErr error) {
+		err = errors.Join(inErr, shutdown(ctx))
+	}
+
+	// Set up propagator.
+	prop := newPropagator()
+	otel.SetTextMapPropagator(prop)
+
+	// Set up trace provider.
+	tracerProvider, err := newTracerProvider()
+	if err != nil {
+		handleErr(err)
+		return shutdown, err
+	}
+	shutdownFuncs = append(shutdownFuncs, tracerProvider.Shutdown)
+	otel.SetTracerProvider(tracerProvider)
+
+	// Set up meter provider.
+	meterProvider, err := newMeterProvider()
+	if err != nil {
+		handleErr(err)
+		return shutdown, err
+	}
+	shutdownFuncs = append(shutdownFuncs, meterProvider.Shutdown)
+	otel.SetMeterProvider(meterProvider)
+
+	// Set up logger provider.
+	loggerProvider, err := newLoggerProvider()
+	if err != nil {
+		handleErr(err)
+		return shutdown, err
+	}
+	shutdownFuncs = append(shutdownFuncs, loggerProvider.Shutdown)
+	global.SetLoggerProvider(loggerProvider)
+
+	return shutdown, err
+}
+
+func newPropagator() propagation.TextMapPropagator {
+	return propagation.NewCompositeTextMapPropagator(
+		propagation.TraceContext{},
+		propagation.Baggage{},
+	)
+}
+
+func newTracerProvider() (*trace.TracerProvider, error) {
+	traceExporter, err := otlptracegrpc.New(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	tracerProvider := trace.NewTracerProvider(
+		trace.WithBatcher(traceExporter,
+			// Default is 5s. Set to 1s for demonstrative purposes.
+			trace.WithBatchTimeout(time.Second)),
+	)
+	return tracerProvider, nil
+}
+
+func newMeterProvider() (*metric.MeterProvider, error) {
+	exporter, err := otlpmetricgrpc.New(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	provider := metric.NewMeterProvider(metric.WithReader(metric.NewPeriodicReader(exporter)))
+	return provider, nil
+}
+
+func newLoggerProvider() (*log.LoggerProvider, error) {
+	logExporter, err := otlploggrpc.New(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	loggerProvider := log.NewLoggerProvider(
+		log.WithProcessor(log.NewBatchProcessor(logExporter)),
+	)
+	return loggerProvider, nil
+}
--- a/cmd/cart/pool-server.go
+++ b/cmd/cart/pool-server.go
@@ -2,6 +2,7 @@ package main

 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -17,6 +18,13 @@ import (
 	"github.com/gogo/protobuf/proto"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	"go.opentelemetry.io/contrib/bridges/otelslog"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/trace"
 )

 var (
@@ -59,7 +67,7 @@ func (s *PoolServer) GetCartHandler(w http.ResponseWriter, r *http.Request, id c

 func (s *PoolServer) AddSkuToCartHandler(w http.ResponseWriter, r *http.Request, id cart.CartId) error {
 	sku := r.PathValue("sku")
-	msg, err := GetItemAddMessage(sku, 1, getCountryFromHost(r.Host), nil)
+	msg, err := GetItemAddMessage(r.Context(), sku, 1, getCountryFromHost(r.Host), nil)
 	if err != nil {
 		return err
 	}
@@ -191,14 +199,14 @@ type SetCartItems struct {
 	Items   []Item `json:"items"`
 }

-func getMultipleAddMessages(items []Item, country string) []proto.Message {
+func getMultipleAddMessages(ctx context.Context, items []Item, country string) []proto.Message {
 	wg := sync.WaitGroup{}
 	mu := sync.Mutex{}
 	msgs := make([]proto.Message, 0, len(items))
 	for _, itm := range items {
 		wg.Go(
 			func() {
-				msg, err := GetItemAddMessage(itm.Sku, itm.Quantity, country, itm.StoreId)
+				msg, err := GetItemAddMessage(ctx, itm.Sku, itm.Quantity, country, itm.StoreId)
 				if err != nil {
 					log.Printf("error adding item %s: %v", itm.Sku, err)
 					return
@@ -221,7 +229,7 @@ func (s *PoolServer) SetCartItemsHandler(w http.ResponseWriter, r *http.Request,

 	msgs := make([]proto.Message, 0, len(setCartItems.Items)+1)
 	msgs = append(msgs, &messages.ClearCartRequest{})
-	msgs = append(msgs, getMultipleAddMessages(setCartItems.Items, setCartItems.Country)...)
+	msgs = append(msgs, getMultipleAddMessages(r.Context(), setCartItems.Items, setCartItems.Country)...)

 	reply, err := s.ApplyLocal(id, msgs...)
 	if err != nil {
@@ -237,7 +245,7 @@ func (s *PoolServer) AddMultipleItemHandler(w http.ResponseWriter, r *http.Reque
 		return err
 	}

-	reply, err := s.ApplyLocal(id, getMultipleAddMessages(setCartItems.Items, setCartItems.Country)...)
+	reply, err := s.ApplyLocal(id, getMultipleAddMessages(r.Context(), setCartItems.Items, setCartItems.Country)...)
 	if err != nil {
 		return err
 	}
@@ -257,7 +265,7 @@ func (s *PoolServer) AddSkuRequestHandler(w http.ResponseWriter, r *http.Request
 	if err != nil {
 		return err
 	}
-	msg, err := GetItemAddMessage(addRequest.Sku, int(addRequest.Quantity), addRequest.Country, addRequest.StoreId)
+	msg, err := GetItemAddMessage(r.Context(), addRequest.Sku, int(addRequest.Quantity), addRequest.Country, addRequest.StoreId)
 	if err != nil {
 		return err
 	}
@@ -302,7 +310,7 @@ func getLocale(country string) string {
 	return "sv-se"
 }

-func (s *PoolServer) CreateOrUpdateCheckout(host string, id cart.CartId) (*CheckoutOrder, error) {
+func (s *PoolServer) CreateOrUpdateCheckout(ctx context.Context, host string, id cart.CartId) (*CheckoutOrder, error) {
 	country := getCountryFromHost(host)
 	meta := &CheckoutMeta{
 		Terms:        fmt.Sprintf("https://%s/terms", host),
@@ -328,9 +336,9 @@ func (s *PoolServer) CreateOrUpdateCheckout(host string, id cart.CartId) (*Check
 	}

 	if grain.OrderReference != "" {
-		return s.klarnaClient.UpdateOrder(grain.OrderReference, bytes.NewReader(payload))
+		return s.klarnaClient.UpdateOrder(ctx, grain.OrderReference, bytes.NewReader(payload))
 	} else {
-		return s.klarnaClient.CreateOrder(bytes.NewReader(payload))
+		return s.klarnaClient.CreateOrder(ctx, bytes.NewReader(payload))
 	}
 }

@@ -449,18 +457,49 @@ func CartIdHandler(fn func(cartId cart.CartId, w http.ResponseWriter, r *http.Re
 func (s *PoolServer) ProxyHandler(fn func(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error) func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error {
 	return func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error {
 		if ownerHost, ok := s.OwnerHost(uint64(cartId)); ok {
+			ctx, span := tracer.Start(r.Context(), "proxy")
+			defer span.End()
+			span.SetAttributes(attribute.String("cartid", cartId.String()))
+			hostAttr := attribute.String("other host", ownerHost.Name())
+			span.SetAttributes(hostAttr)
+			logger.InfoContext(ctx, "cart proxyed", "result", ownerHost.Name())
+			proxyCalls.Add(ctx, 1, metric.WithAttributes(hostAttr))
 			handled, err := ownerHost.Proxy(uint64(cartId), w, r)
+
 			grainLookups.Inc()
 			if err == nil && handled {
 				return nil
 			}
 		}
-
+		_, span := tracer.Start(r.Context(), "own")
+		span.SetAttributes(attribute.String("cartid", cartId.String()))
+		defer span.End()
 		return fn(w, r, cartId)

 	}
 }

+var (
+	tracer = otel.Tracer(name)
+
+	meter      = otel.Meter(name)
+	logger     = otelslog.NewLogger(name)
+	proxyCalls metric.Int64Counter
+
+// rollCnt metric.Int64Counter
+)
+
+func init() {
+	var err error
+	proxyCalls, err = meter.Int64Counter("proxy.calls",
+		metric.WithDescription("Number of proxy calls"),
+		metric.WithUnit("{calls}"))
+	if err != nil {
+		panic(err)
+	}
+
+}
+
 type AddVoucherRequest struct {
 	VoucherCode string `json:"code"`
 }
@@ -511,7 +550,7 @@ func (s *PoolServer) CheckoutHandler(fn func(order *CheckoutOrder, w http.Respon
 	return CookieCartIdHandler(s.ProxyHandler(func(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
 		orderId := r.URL.Query().Get("order_id")
 		if orderId == "" {
-			order, err := s.CreateOrUpdateCheckout(r.Host, cartId)
+			order, err := s.CreateOrUpdateCheckout(r.Context(), r.Host, cartId)
 			if err != nil {
 				return err
 			}
@@ -545,46 +584,57 @@ func (s *PoolServer) RemoveVoucherHandler(w http.ResponseWriter, r *http.Request
 	return nil
 }

-func (s *PoolServer) Serve() *http.ServeMux {
+func (s *PoolServer) Serve(mux *http.ServeMux) {

-	mux := http.NewServeMux()
-	mux.HandleFunc("OPTIONS /", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-		w.Header().Set("Access-Control-Allow-Methods", "GET, PUT, POST, DELETE")
-		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
-		w.WriteHeader(http.StatusOK)
-	})
+	// mux.HandleFunc("OPTIONS /cart", func(w http.ResponseWriter, r *http.Request) {
+	// 	w.Header().Set("Access-Control-Allow-Origin", "*")
+	// 	w.Header().Set("Access-Control-Allow-Methods", "GET, PUT, POST, DELETE")
+	// 	w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+	// 	w.WriteHeader(http.StatusOK)
+	// })

-	mux.HandleFunc("GET /", CookieCartIdHandler(s.ProxyHandler(s.GetCartHandler)))
-	mux.HandleFunc("GET /add/{sku}", CookieCartIdHandler(s.ProxyHandler(s.AddSkuToCartHandler)))
-	mux.HandleFunc("POST /add", CookieCartIdHandler(s.ProxyHandler(s.AddMultipleItemHandler)))
-	mux.HandleFunc("POST /", CookieCartIdHandler(s.ProxyHandler(s.AddSkuRequestHandler)))
-	mux.HandleFunc("POST /set", CookieCartIdHandler(s.ProxyHandler(s.SetCartItemsHandler)))
-	mux.HandleFunc("DELETE /{itemId}", CookieCartIdHandler(s.ProxyHandler(s.DeleteItemHandler)))
-	mux.HandleFunc("PUT /", CookieCartIdHandler(s.ProxyHandler(s.QuantityChangeHandler)))
-	mux.HandleFunc("DELETE /", CookieCartIdHandler(s.ProxyHandler(s.RemoveCartCookie)))
-	mux.HandleFunc("POST /delivery", CookieCartIdHandler(s.ProxyHandler(s.SetDeliveryHandler)))
-	mux.HandleFunc("DELETE /delivery/{deliveryId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveDeliveryHandler)))
-	mux.HandleFunc("PUT /delivery/{deliveryId}/pickupPoint", CookieCartIdHandler(s.ProxyHandler(s.SetPickupPointHandler)))
-	mux.HandleFunc("PUT /voucher", CookieCartIdHandler(s.ProxyHandler(s.AddVoucherHandler)))
-	mux.HandleFunc("PUT /subscription-details", CookieCartIdHandler(s.ProxyHandler(s.SubscriptionDetailsHandler)))
-	mux.HandleFunc("DELETE /voucher/{voucherId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveVoucherHandler)))
+	handleFunc := func(pattern string, handlerFunc func(http.ResponseWriter, *http.Request)) {
+		attr := attribute.String("http.route", pattern)
+		mux.HandleFunc(pattern, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			span := trace.SpanFromContext(r.Context())
+			span.SetAttributes(attr)

-	//mux.HandleFunc("GET /checkout", CookieCartIdHandler(s.ProxyHandler(s.HandleCheckout)))
-	//mux.HandleFunc("GET /confirmation/{orderId}", CookieCartIdHandler(s.ProxyHandler(s.HandleConfirmation)))
+			labeler, _ := otelhttp.LabelerFromContext(r.Context())
+			labeler.Add(attr)

-	mux.HandleFunc("GET /byid/{id}", CartIdHandler(s.ProxyHandler(s.GetCartHandler)))
-	mux.HandleFunc("GET /byid/{id}/add/{sku}", CartIdHandler(s.ProxyHandler(s.AddSkuToCartHandler)))
-	mux.HandleFunc("POST /byid/{id}", CartIdHandler(s.ProxyHandler(s.AddSkuRequestHandler)))
-	mux.HandleFunc("DELETE /byid/{id}/{itemId}", CartIdHandler(s.ProxyHandler(s.DeleteItemHandler)))
-	mux.HandleFunc("PUT /byid/{id}", CartIdHandler(s.ProxyHandler(s.QuantityChangeHandler)))
-	mux.HandleFunc("POST /byid/{id}/delivery", CartIdHandler(s.ProxyHandler(s.SetDeliveryHandler)))
-	mux.HandleFunc("DELETE /byid/{id}/delivery/{deliveryId}", CartIdHandler(s.ProxyHandler(s.RemoveDeliveryHandler)))
-	mux.HandleFunc("PUT /byid/{id}/delivery/{deliveryId}/pickupPoint", CartIdHandler(s.ProxyHandler(s.SetPickupPointHandler)))
-	mux.HandleFunc("PUT /byid/{id}/voucher", CookieCartIdHandler(s.ProxyHandler(s.AddVoucherHandler)))
-	mux.HandleFunc("DELETE /byid/{id}/voucher/{voucherId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveVoucherHandler)))
-	//mux.HandleFunc("GET /byid/{id}/checkout", CartIdHandler(s.ProxyHandler(s.HandleCheckout)))
-	//mux.HandleFunc("GET /byid/{id}/confirmation", CartIdHandler(s.ProxyHandler(s.HandleConfirmation)))
+			handlerFunc(w, r)
+		}))
+	}
+
+	handleFunc("GET /cart", CookieCartIdHandler(s.ProxyHandler(s.GetCartHandler)))
+	handleFunc("GET /cart/add/{sku}", CookieCartIdHandler(s.ProxyHandler(s.AddSkuToCartHandler)))
+	handleFunc("POST /cart/add", CookieCartIdHandler(s.ProxyHandler(s.AddMultipleItemHandler)))
+	handleFunc("POST /cart", CookieCartIdHandler(s.ProxyHandler(s.AddSkuRequestHandler)))
+	handleFunc("POST /cart/set", CookieCartIdHandler(s.ProxyHandler(s.SetCartItemsHandler)))
+	handleFunc("DELETE /cart/{itemId}", CookieCartIdHandler(s.ProxyHandler(s.DeleteItemHandler)))
+	handleFunc("PUT /cart", CookieCartIdHandler(s.ProxyHandler(s.QuantityChangeHandler)))
+	handleFunc("DELETE /cart", CookieCartIdHandler(s.ProxyHandler(s.RemoveCartCookie)))
+	handleFunc("POST /cart/delivery", CookieCartIdHandler(s.ProxyHandler(s.SetDeliveryHandler)))
+	handleFunc("DELETE /cart/delivery/{deliveryId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveDeliveryHandler)))
+	handleFunc("PUT /cart/delivery/{deliveryId}/pickupPoint", CookieCartIdHandler(s.ProxyHandler(s.SetPickupPointHandler)))
+	handleFunc("PUT /cart/voucher", CookieCartIdHandler(s.ProxyHandler(s.AddVoucherHandler)))
+	handleFunc("PUT /cart/subscription-details", CookieCartIdHandler(s.ProxyHandler(s.SubscriptionDetailsHandler)))
+	handleFunc("DELETE /cart/voucher/{voucherId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveVoucherHandler)))
+
+	//mux.HandleFunc("GET /cart/checkout", CookieCartIdHandler(s.ProxyHandler(s.HandleCheckout)))
+	//mux.HandleFunc("GET /cart/confirmation/{orderId}", CookieCartIdHandler(s.ProxyHandler(s.HandleConfirmation)))
+
+	handleFunc("GET /cart/byid/{id}", CartIdHandler(s.ProxyHandler(s.GetCartHandler)))
+	handleFunc("GET /cart/byid/{id}/add/{sku}", CartIdHandler(s.ProxyHandler(s.AddSkuToCartHandler)))
+	handleFunc("POST /cart/byid/{id}", CartIdHandler(s.ProxyHandler(s.AddSkuRequestHandler)))
+	handleFunc("DELETE /cart/byid/{id}/{itemId}", CartIdHandler(s.ProxyHandler(s.DeleteItemHandler)))
+	handleFunc("PUT /cart/byid/{id}", CartIdHandler(s.ProxyHandler(s.QuantityChangeHandler)))
+	handleFunc("POST /cart/byid/{id}/delivery", CartIdHandler(s.ProxyHandler(s.SetDeliveryHandler)))
+	handleFunc("DELETE /cart/byid/{id}/delivery/{deliveryId}", CartIdHandler(s.ProxyHandler(s.RemoveDeliveryHandler)))
+	handleFunc("PUT /cart/byid/{id}/delivery/{deliveryId}/pickupPoint", CartIdHandler(s.ProxyHandler(s.SetPickupPointHandler)))
+	handleFunc("PUT /cart/byid/{id}/voucher", CookieCartIdHandler(s.ProxyHandler(s.AddVoucherHandler)))
+	handleFunc("DELETE /cart/byid/{id}/voucher/{voucherId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveVoucherHandler)))
+	//mux.HandleFunc("GET /cart/byid/{id}/checkout", CartIdHandler(s.ProxyHandler(s.HandleCheckout)))
+	//mux.HandleFunc("GET /cart/byid/{id}/confirmation", CartIdHandler(s.ProxyHandler(s.HandleConfirmation)))

-	return mux
 }
--- a/cmd/cart/product-fetcher.go
+++ b/cmd/cart/product-fetcher.go
@@ -1,6 +1,7 @@
 package main

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -26,9 +27,14 @@ func getBaseUrl(country string) string {
 	return "http://localhost:8082"
 }

-func FetchItem(sku string, country string) (*index.DataItem, error) {
+func FetchItem(ctx context.Context, sku string, country string) (*index.DataItem, error) {
 	baseUrl := getBaseUrl(country)
-	res, err := http.Get(fmt.Sprintf("%s/api/by-sku/%s", baseUrl, sku))
+	req, err := http.NewRequest("GET", fmt.Sprintf("%s/api/by-sku/%s", baseUrl, sku), nil)
+	req = req.WithContext(ctx)
+	if err != nil {
+		return nil, err
+	}
+	res, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
@@ -38,8 +44,8 @@ func FetchItem(sku string, country string) (*index.DataItem, error) {
 	return &item, err
 }

-func GetItemAddMessage(sku string, qty int, country string, storeId *string) (*messages.AddItem, error) {
-	item, err := FetchItem(sku, country)
+func GetItemAddMessage(ctx context.Context, sku string, qty int, country string, storeId *string) (*messages.AddItem, error) {
+	item, err := FetchItem(ctx, sku, country)
 	if err != nil {
 		return nil, err
 	}
--- a/cmd/inventory/main.go
+++ b/cmd/inventory/main.go
@@ -44,18 +44,25 @@ func main() {
 		s.UpdateInventory(p, "4", "4", 40)
 		return nil
 	})
-	err = s.ReserveInventory(inventory.ReserveRequest{
-		SKU:        "1",
-		LocationID: "1",
-		Quantity:   3,
-	}, inventory.ReserveRequest{
-		SKU:        "2",
-		LocationID: "2",
-		Quantity:   15,
-	})
+	err = s.ReserveInventory(
+		inventory.ReserveRequest{
+			SKU:        "1",
+			LocationID: "1",
+			Quantity:   3,
+		},
+		inventory.ReserveRequest{
+			SKU:        "2",
+			LocationID: "2",
+			Quantity:   15,
+		},
+		inventory.ReserveRequest{
+			SKU:        "3",
+			LocationID: "3",
+			Quantity:   25,
+		},
+	)
 	if err != nil {
 		log.Printf("Unable to reserve inventory: %v", err)
-		return
 	}
 	v, err := s.GetInventory("1", "1")
 	if err != nil {