feat : lc handler

backend/backend.go

@@ -25,3 +25,43 @@ func (backend *Backend) GetIsDead() bool {
 func (backend *Backend) GetConnections() int {
 	return backend.connections
 }
+
+func NewBackend(url string) Backend {
+	return Backend{
+		URL:    url,
+		IsDead: false,
+	}
+}
+
+func NewDefaultBackend() []Backend {
+	return []Backend{
+		{
+			URL:    "http://localhost:8081/",
+			IsDead: false,
+		},
+		{
+			URL:    "http://localhost:8082/",
+			IsDead: false,
+		},
+		{
+			URL:    "http://localhost:8083/",
+			IsDead: false,
+		},
+		{
+			URL:    "http://localhost:8086/",
+			IsDead: false,
+		},
+		{
+			URL:    "http://localhost:8087/",
+			IsDead: false,
+		},
+		{
+			URL:    "http://localhost:8088/",
+			IsDead: false,
+		},
+		{
+			URL:    "http://localhost:8089/",
+			IsDead: false,
+		},
+	}
+}

lc/handler.go

@@ -0,0 +1,38 @@
+package lc
+
+import (
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+
+	"github.com/seipan/mylb/backend"
+)
+
+// lbHandler is a handler for loadbalancing
+func LcHandler(w http.ResponseWriter, r *http.Request) {
+	idx := 0
+	bcds := backend.NewDefaultBackend()
+	lc := NewlcserverPool(bcds)
+	maxLen := len(bcds)
+	// Round Robin
+	lc.mu.Lock()
+	currentBackend := lc.Backends[idx%maxLen]
+	if currentBackend.GetIsDead() {
+		idx++
+	}
+	targetURL, err := url.Parse(lc.Backends[idx%maxLen].URL)
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	idx++
+	lc.mu.Unlock()
+	reverseProxy := httputil.NewSingleHostReverseProxy(targetURL)
+	reverseProxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, e error) {
+		// NOTE: It is better to implement retry.
+		log.Printf("%v is dead.", targetURL)
+		currentBackend.SetDead(true)
+		LcHandler(w, r)
+	}
+	reverseProxy.ServeHTTP(w, r)
+}

lc/serverpool.go

@@ -1,13 +1,14 @@
 package lc
 
 import (
+	"sync"
+
 	"github.com/seipan/mylb/backend"
-	"github.com/seipan/mylb/proxy"
 )
 
 type lcserverPool struct {
-	Proxy    proxy.Proxy       `json:"proxy"`
 	Backends []backend.Backend `json:"backends"`
+	mu       sync.RWMutex
 }
 
 func (s *lcserverPool) GetNextValidPeer() backend.Backend {
@@ -29,3 +30,9 @@ func (s *lcserverPool) GetNextValidPeer() backend.Backend {
 	}
 	return leastConnectedPeer
 }
+
+func NewlcserverPool(backends []backend.Backend) lcserverPool {
+	return lcserverPool{
+		Backends: backends,
+	}
+}

main.go

@@ -2,67 +2,21 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"log"
 	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-	"sync"
 
-	"github.com/seipan/mylb/backend"
-	"github.com/seipan/mylb/proxy"
+	"github.com/seipan/mylb/lc"
 )
 
-type Config struct {
-	Proxy    proxy.Proxy       `json:"proxy"`
-	Backends []backend.Backend `json:"backends"`
-}
-
-var cfg Config
-var mu sync.Mutex
-var idx int = 0
-
-// lbHandler is a handler for loadbalancing
-func lbHandler(w http.ResponseWriter, r *http.Request) {
-	maxLen := len(cfg.Backends)
-	// Round Robin
-	mu.Lock()
-	currentBackend := cfg.Backends[idx%maxLen]
-	if currentBackend.GetIsDead() {
-		idx++
-	}
-	targetURL, err := url.Parse(cfg.Backends[idx%maxLen].URL)
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	idx++
-	mu.Unlock()
-	reverseProxy := httputil.NewSingleHostReverseProxy(targetURL)
-	reverseProxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, e error) {
-		// NOTE: It is better to implement retry.
-		log.Printf("%v is dead.", targetURL)
-		currentBackend.SetDead(true)
-		lbHandler(w, r)
-	}
-	reverseProxy.ServeHTTP(w, r)
-}
-
 // Serve serves a loadbalancer.
 func main() {
-	data, err := os.ReadFile("./config.json")
-	if err != nil {
-		log.Fatal(err.Error())
-	}
-	json.Unmarshal(data, &cfg)
-
 	go healthCheck(context.Background(), nil)
 
 	s := http.Server{
-		Addr:    ":" + cfg.Proxy.Port,
-		Handler: http.HandlerFunc(lbHandler),
+		Addr:    ":" + "8080",
+		Handler: http.HandlerFunc(lc.LcHandler),
 	}
-	if err = s.ListenAndServe(); err != nil {
+	if err := s.ListenAndServe(); err != nil {
 		log.Fatal(err.Error())
 	}
 }