def add_lb(self, image, ip):
lb_index = 0
for lb in lbs:
if lb.get_image() == image:
lbs[lb_index] = LoadBalancer(image, ip)
return True
lb_index += 1
load_balancer = LoadBalancer(image, ip)
self.lbs.append((load_balancer))
return True
def test_run_full(self):
with open('input.txt', 'r') as file:
lines = file.read()
data = lines.split('\n')
ttask = int(data[0])
umax = int(data[1])
file.close()
load_balancer = LoadBalancer(umax)
print(50 * '=')
tick = 0
for tick, users in enumerate(data[2:], start=1):
if users == '':
continue
print(f'TICK: {tick}')
if int(users) > 0:
for user in range(int(users)):
new_user = User(ttask)
load_balancer.allocate_new_user(new_user)
load_balancer.set_output(tick=tick, input=users)
load_balancer.execute_tick()
load_balancer.clean_servers()
print(50 * '=')
load_balancer.end_active_tasks(last_tick=tick)
assert load_balancer.price == 'R$ 15,00'
def __add_new_lb(self, cip, cport, sip, sport):
p = multiprocessing.current_process()
lb = LoadBalancer(cip, cport, sip, sport)
print "****[Adding Load Balancer [{}]]".format(p.pid)
# print " CIP:{}, CPort:{}".format(lb.cip, lb.cport)
# print " SIP:{}, SPort:{}".format(lb.sip, lb.sport)
# print "-------------------------------------"
lb.start()
def test_price_increase(self):
load_balancer = LoadBalancer(MAX_USER_SERVER)
users_creation = 3
for user in range(users_creation):
new_user = User(TASKS)
load_balancer.allocate_new_user(new_user)
load_balancer.execute_tick()
assert load_balancer.price != 'R$ 0,00'
vcn = VCN(config)
vcn.create_vcn()
vcn.create_gateway()
vcn.create_route_rules()
subnet_threads = []
for ad in ['ad_1', 'ad_2']:
thread = threading.Thread(target=vcn.create_subnet, args=(ad, ))
subnet_threads.append(thread)
thread.start()
join_threads(subnet_threads)
vcn.create_security_rules()
install_threads = []
for subnet in vcn.subnets:
thread = threading.Thread(target=install_mean_stack,
args=(
subnet,
vcn,
))
install_threads.append(thread)
thread.start()
join_threads(install_threads)
lb = LoadBalancer(config, vcn)
lb.create_load_balancer()
lb.create_backend_set()
lb.create_backends()
lb.create_listener()
print('MEAN Stack URL: http://' + lb.public_ip + ':8080')
def random_invocation():
load_balancer = LoadBalancer()
for i in range(100):
print(load_balancer.get_random())
from load_balancer import LoadBalancer
if __name__ == '__main__':
b = LoadBalancer()
b.load_balance()
ga_fwle = 'ga_fwle.log'
logfile = open(ga_fwle, "w")
for r in forwarding_unit_latency_estiamation:
logfile.write(
'Region: {} forward unit latency estimation: {}'.format(
r, forwarding_unit_latency_estiamation[r]))
logfile.write('\n')
logfile.close()
elif param == 'policies':
"""
Test load balancer policies compare them
"""
rr_cfg = config['production_round_robin']
print(rr_cfg)
load_balancer = LoadBalancer(rr_cfg)
load_balancer.run()
wrr_cfg = config['production_weighted_round_robin']
print(wrr_cfg)
load_balancer = LoadBalancer(wrr_cfg)
load_balancer.run()
lc_cfg = config['production_least_connection']
print(lc_cfg)
load_balancer = LoadBalancer(lc_cfg)
load_balancer.run()
wlc_cfg = config['production_weighted_least_connection']
print(wlc_cfg)
load_balancer = LoadBalancer(wlc_cfg)
policy = 'weighted least connection'
cfg = {
'host': 'http://host.docker.internal',
'main_endpoint': 'work',
'port': 5000,
'policy': policy,
'hosts_configuration': {
'emea': 1,
'us': 2,
'asia': 2
},
'req_num': _req_num
}
load_balancer = LoadBalancer(cfg)
load_balancer.run()
print('Finished requests')
else:
# Create a config object for load balancer
policy = None
if 0 <= req_num < 100:
policy = 'round robin'
elif 100 <= req_num < 500:
policy = 'randomized static'
elif 500 <= req_num < 1250:
policy = 'least connection'
elif 1250 <= req_num < 2500:
def add_new_lb(cip, cport, sip, sport):
p = multiprocessing.current_process()
click.echo("Starting Load Balancer with pid[%s], at [%s:%s]" % (p.pid, cip, cport))
lb = LoadBalancer(cip, cport, sip, sport, )
lb.start()
from load_balancer import LoadBalancer, User
import os
if __name__ == '__main__':
if os.path.exists('input.txt'):
with open('input.txt', 'r') as file:
lines = file.read().splitlines()
ttask = int(lines[0])
umax = int(lines[1])
load_balancer = LoadBalancer(umax)
print(50 * '=')
tick = 0
for tick, users in enumerate(lines[2:], start=1):
if users == '':
continue
print(f'TICK: {tick}')
if int(users) > 0:
for user in range(int(users)):
new_user = User(ttask)
load_balancer.allocate_new_user(new_user)
load_balancer.set_output(tick=tick, input=users)
load_balancer.execute_tick()
load_balancer.clean_servers()
print(50 * '=')
def before_first_request():
global load_balancer
latency = eval(input("Latency (s): "))
migration_time = eval(input("Migration Time (s): "))
load_balancer = LoadBalancer(latency, migration_time)
def setUp(self) -> None:
self.load_balancer = LoadBalancer(u_max=2, t_task=4)
return super().setUp()
def __init__(self):
self.load_balancer = LoadBalancer()
self.current = 0
def test_allocate_new_user(self):
load_balancer = LoadBalancer(MAX_USER_SERVER)
new_user = User(TASKS)
status = load_balancer.allocate_new_user(new_user)
assert status is True
def setUpClass(self):
self.server = Server()
self.loadBalancer = LoadBalancer()
supervisors = []
hpaThreads = []
loadBalancerThreads = []
supervisorThreads = []
count = 0
instructions = open("instructions.txt", "r")
commands = instructions.readlines()
for command in commands:
cmdAttributes = command.split()
print(str(command))
with apiServer.etcdLock:
if cmdAttributes[0] == 'Deploy':
apiServer.CreateDeployment(cmdAttributes[1:])
deployment = apiServer.GetDepByLabel(cmdAttributes[1])
loadbalancer = LoadBalancer(kind, apiServer, deployment)
lbThread = threading.Thread(target=loadbalancer)
lbThread.start()
loadBalancers.append(loadbalancer)
loadBalancerThreads.append(lbThread)
elif cmdAttributes[0] == 'AddNode':
apiServer.CreateWorker(cmdAttributes[1:])
elif cmdAttributes[0] == 'DeleteDeployment':
#We have to makesure that our load balancer will end gracefully here
for loadBalancer in loadBalancers:
if loadBalancer.deployment.deploymentLabel == cmdAttributes[1]:
loadBalancer.running = False
apiServer.RemoveDeployment(cmdAttributes[1:])
elif cmdAttributes[0] == 'ReqIn':
apiServer.PushReq(cmdAttributes[1:])
elif cmdAttributes[0] == 'CreateHPA':
def test_create_new_server(self):
load_balancer = LoadBalancer(MAX_USER_SERVER)
status = load_balancer.create_new_server()
assert status == 'success'
def setUp(self) -> None:
self.load_balancer = LoadBalancer(4, 2)
umax_invalid_mesage = (
"umax input is an invalid option. it should be a number between 1 or 10"
)
tasks = [int(i.rstrip("\n")) for i in filereader]
TTASK = int(tasks[0])
if TTASK < 1 or TTASK > 10:
print(ttask_invalid_mesage)
sys.exit()
UMAX = int(tasks[1])
if UMAX < 1 or UMAX > 10:
print(umax_invalid_mesage)
sys.exit()
load_balancer = LoadBalancer(TTASK, UMAX)
tasks = tasks[2:]
with open("output.txt", "w") as output_file:
for i in tasks:
load_balancer.run_tasks()
load_balancer.assign_task_to_server(i)
load_balancer.calculate_user()
output_file.write(load_balancer.output())
output_file.write("\n")
while len(load_balancer.servers):
load_balancer.run_tasks()
load_balancer.calculate_user()
output_file.write(load_balancer.output())
output_file.write("\n")
ec2_north_virginia = EC2(ubuntu20_nvirginia_img, ec2_nv_key_name, 't2.micro',
'us-east-1', 'secgroup-teste', script_machines,
session)
nv_subnets_ids, nv_vpc_ids = ec2_north_virginia.describe_subnets()
print("creating server instance...")
ec2_id_north_virginia = ec2_north_virginia.create_instances(1)
print("Status - OK")
security_group_id = [
instance.security_groups[0]['GroupId']
for instance in ec2_id_north_virginia
]
## Load balancer - North Virginia __init__
lb = LoadBalancer(load_balancer_name, nv_subnets_ids, 'us-east-1')
print("creating load balancer...")
elb_obj = lb.create_elb(security_group_id)
elb_arn = elb_obj['LoadBalancers'][0]['LoadBalancerArn']
elb_dns = elb_obj['LoadBalancers'][0]['DNSName']
a_file = open("script", "r")
list_of_lines = a_file.readlines()
list_of_lines[6] = f"URL_SERVER = '{elb_dns}'\n"
a_file = open("script", "w")
a_file.writelines(list_of_lines)
a_file.close()
print("Status - OK")
def setUp(self):
self.machine = Machine(2)
self.load_balancer = LoadBalancer()
def round_robin_invocation():
load_balancer = LoadBalancer()
for i in range(100):
print(load_balancer.get_round_robin())
from flask import Flask, render_template, redirect, request
from html import *
from Apps.App_master.forms import SearchForm, DocQuery
from load_balancer import LoadBalancer
app = Flask(__name__)
app.config['SECRET_KEY'] = '5791628bb0b13ce1c676dfde280ba245'
load_balancer = LoadBalancer()
@app.route('/')
def landing():
return redirect('/search', code=302)
@app.route('/search', methods=['GET'])
def search():
forms = [SearchForm(), DocQuery()]
return render_template(
'search.html',
title='Search',
forms=forms,
slaves=load_balancer.slave_names
) # dont forget to add templates folder to 'templates' in project structure
@app.route('/search', methods=['POST'])
def get_results():
result = request.json
print(request.get_data())
query = str(request.get_data().split(b'&')[1])[8:-1]
from socket import *
import socket
import threading
import time
import sys
import logging
from load_balancer import LoadBalancer
reverseProxy = LoadBalancer()
class ProcessTheClient(threading.Thread):
def __init__(self, connection, address):
self.connection = connection
self.address = address
threading.Thread.__init__(self)
def run(self):
rcv=""
while True:
try:
data = self.connection.recv(8192)
self.destination_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if data:
server = reverseProxy.get_server()
print(f"forwarded to server {server}")
self.destination_sock.connect(server)
self.destination_sock.sendall(data)
data_balasan = self.destination_sock.recv(8192)
self.connection.sendall(data_balasan)
logging.warning(data)
logging.warning(data_balasan)
