Adding external servers balancing

Author: SamSyntax

README.md

@@ -101,6 +101,30 @@ forwarding to "localhost:8003"
 forwarding to "localhost:8004"
 forwarding to "localhost:8000"
 ```
+You can also use the loadbalancer to redirect traffic to external servers. Create <b>servers.json</b> in the root directory
+of the project and specify servers (add weights if you want to use Weighted Round Robin).
+```json
+[
+  {
+    "addr": "https://facebook.com",
+    "weight": 2
+  },
+  {
+    "addr": "https://twitch.tv",
+    "weight": 1
+  },
+  {
+    "addr": "https://google.com",
+    "weight": 3
+  }
+]
+```
+Then simply pass <b>-env</b> flag. It accepts "local" and "external" where "local" will start local servers
+and "external" will read the JSON file.
+
+```bash
+make build && ./lb -method wrr -env external
+```
 Customization
 Number of Servers: You can modify the number of servers spawned by changing the <b>-amount</b> flag value.
 Ports: The backend servers listen on ports 8000 and higher. You can modify the port range in the Spawner function.

json.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"os"
+	"strconv"
+)
+
+type ExternalServer struct {
+	Addr   string `json:"addr"`
+	Weight int    `json:"weight"`
+}
+
+func ReadJson() []LbServer {
+	file, err := os.Open("servers.json")
+	if err != nil {
+		log.Fatalf("Failed to load servers from JSON file %v", err)
+	}
+	defer file.Close()
+
+	byteVal, err := io.ReadAll(file)
+	if err != nil {
+		log.Fatalf("Failed to read file: %v", err)
+	}
+
+	var servers []ExternalServer
+	err = json.Unmarshal(byteVal, &servers)
+	if err != nil {
+		log.Fatalf("Failed to unmarshal JSON: %v", err)
+	}
+	res := make([]LbServer, 0, len(servers))
+	for k, s := range servers {
+		lbServer := NewLbServer(s.Addr, s.Weight)
+		lbServer.name = strconv.Itoa(k)
+		res = append(res, *lbServer)
+	}
+
+	return res
+}

loadbalancer.go

@@ -41,31 +41,30 @@ func NewLbServer(addr string, weight int) *LbServer {
 		os.Exit(1)
 	}
 	return &LbServer{
-		addr:  addr,
-		proxy: httputil.NewSingleHostReverseProxy(serverUrl),
-    weight: weight,
-    current: 0,
+		addr:   addr,
+		proxy:  httputil.NewSingleHostReverseProxy(serverUrl),
+		weight: weight,
 	}
 }
 
 type LoadBalancer struct {
 	port            string
 	roundRobinCount int
 	servers         []LbServer
-	weidhted        bool
+	weighted        bool
 }
 
 func NewLoadBalancer(port string, servers []LbServer, weighted bool) *LoadBalancer {
 	return &LoadBalancer{
 		port:            port,
 		roundRobinCount: 0,
 		servers:         servers,
-		weidhted:        weighted,
+		weighted:        weighted,
 	}
 }
 
 func (lb *LoadBalancer) GetNextAvailableServer() LbServer {
-	if lb.weidhted {
+	if lb.weighted {
 		return lb.getWeightedServer()
 	}
 	return lb.getRoundRobinServer()

main.go

@@ -10,8 +10,15 @@ import (
 func main() {
 	nFlag := flag.Int("amount", 1234, "Enter amount of local servers to be spawned")
 	method := flag.String("method", "rr", "Load balancing method: 'rr - Round Robin | wrr - Weighted Round Robin")
+	env := flag.String("env", "local", "Specify wether local servers should be started or provide JSON file with addresses of external servers. ")
 	flag.Parse()
-	servers := Spawner(*nFlag)
+  var servers []LbServer
+	switch *env {
+	case "external":
+    servers = ReadJson()
+	case "local":
+		servers = Spawner(*nFlag)
+	}
 	var lb *LoadBalancer
 	switch *method {
 	case "wrr":

servers.json

@@ -0,0 +1,14 @@
+[
+  {
+    "addr": "https://facebook.com",
+    "weight": 2
+  },
+  {
+    "addr": "https://twitch.tv",
+    "weight": 1
+  },
+  {
+    "addr": "https://google.com",
+    "weight": 3
+  }
+]