algorithm.go

package main

import (
	"math"
	"sync/atomic"
)

var rrCounter uint64

func LeastConnections(servers []*Server) *Server {
	if len(servers) == 0 {
    	return nil
	}
	
	var bestServers []*Server
	var bestScore float64 = math.MaxFloat64
	// If a server has the same number of connections, we prefer the one with the less weight
	// If both the connections and the weights are same then we waana RoundRobin
	for _, server := range servers {
		serverCon := atomic.LoadInt64(&server.Connections) // Thread Safe Read as traffic in Go is crazy fast
		serverWeight := atomic.LoadInt64(&server.Weight)
		if serverWeight <= 0 {
			serverWeight = 1 // Guard against an Invalid config
		}

		// Lower score = Less loaded relative to its capacity
		score := float64(serverCon) / float64(serverWeight)

		if score < bestScore {
			bestScore = score
			bestServers = []*Server{server}
		} else if score == bestScore {
			bestServers = append(bestServers, server)
		}
	}

	if len(bestServers) == 0 {
		return nil
	}
	idx := atomic.AddUint64(&rrCounter, 1)

	return bestServers[idx % uint64(len(bestServers))]
}