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)