load balancer algoritm script

gistfile1.txt

import random
import hashlib

class LoadBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.index = 0
        self.connections = {server: 0 for server in servers}
        self.weights = {server: 1 for server in servers}  # Default weight is 1
        self.server_response_times = {server: random.uniform(0.1, 1.0) for server in servers}

    def round_robin(self):
        server = self.servers[self.index]
        self.index = (self.index + 1) % len(self.servers)
        return server

    def least_connections(self):
        server = min(self.connections, key=self.connections.get)
        self.connections[server] += 1
        return server
    
    def ip_hash(self, client_ip):
        hash_value = int(hashlib.md5(client_ip.encode()).hexdigest(), 16)
        server_index = hash_value % len(self.servers)
        return self.servers[server_index]
    
    def weighted_round_robin(self):
        server = max(self.weights, key=self.weights.get)
        self.weights[server] -= 1  # Reduce weight after selecting
        if all(weight == 0 for weight in self.weights.values()):
            self.weights = {server: 1 for server in self.servers}  # Reset weights
        return server
    
    def random_selection(self):
        return random.choice(self.servers)
    
    def least_response_time(self):
        server = min(self.server_response_times, key=self.server_response_times.get)
        return server

# Example usage
servers = ["Server1", "Server2", "Server3"]
lb = LoadBalancer(servers)

print("Round Robin:", lb.round_robin())
print("Least Connections:", lb.least_connections())
print("IP Hash:", lb.ip_hash("192.168.1.1"))
print("Weighted Round Robin:", lb.weighted_round_robin())
print("Random Selection:", lb.random_selection())
print("Least Response Time:", lb.least_response_time())