def test_remove_two_servers_while_request_in_progress():
sim = SimulatorKernel(outputDirectory = None)
server1 = MockServer(sim, latency = 10)
server2 = MockServer(sim, latency = 10)
server3 = MockServer(sim, latency = 10)
lb = LoadBalancer(sim)
lb.algorithm = 'SQF'
lb.addBackend(server1)
lb.addBackend(server2)
lb.addBackend(server3)
onShutdownCompleted = Mock()
r1 = Request()
r1.onCompleted = Mock()
r2 = Request()
r2.onCompleted = Mock()
r3 = Request()
r3.onCompleted = Mock()
sim.add(0, lambda: lb.request(r1))
sim.add(0, lambda: lb.request(r2))
sim.add(0, lambda: lb.request(r3))
sim.add(1, lambda: lb.removeBackend(server1, onShutdownCompleted))
sim.add(2, lambda: lb.removeBackend(server2, onShutdownCompleted))
sim.run()
r1.onCompleted.assert_called_once_with()
r2.onCompleted.assert_called_once_with()
r3.onCompleted.assert_called_once_with()
assert onShutdownCompleted.call_count == 2
assert server1.numSeenRequests == 1
assert server2.numSeenRequests == 1
assert server3.numSeenRequests == 1
def test_remove_while_request_not_in_progress():
sim = SimulatorKernel(outputDirectory = None)
server1 = MockServer(sim, latency = 0.1)
server2 = MockServer(sim, latency = 0.1)
lb = LoadBalancer(sim)
lb.addBackend(server1)
lb.addBackend(server2)
onShutdownCompleted = Mock()
def remove_active_server():
if server1.numSeenRequests:
lb.removeBackend(server1, onShutdownCompleted)
else:
lb.removeBackend(server2, onShutdownCompleted)
r1 = Request()
r1.onCompleted = Mock()
sim.add(0, lambda: lb.request(r1))
sim.add(1, lambda: remove_active_server())
sim.add(1, lambda: lb.request(Request()))
sim.add(2, lambda: lb.request(Request()))
sim.add(2, lambda: lb.request(Request()))
sim.run()
r1.onCompleted.assert_called_once_with()
onShutdownCompleted.assert_called_once_with()
assert server1.numSeenRequests == 1 or server2.numSeenRequests == 1
assert server1.numSeenRequests == 3 or server2.numSeenRequests == 3
def __init__(self,params):
number_of_servers=int(params["number_of_servers"])
self.number_of_requests = int(params["number_of_requests"])
self.number_of_types = len(params["types_of_requests"])
self.number_of_requests_per_sec = int(params["number_of_requests_per_sec"])
self.generator = RequestGenerator(params["types_of_requests"],int(params["number_of_requests_per_sec"]))
request_type_capacity=[x["output_capacity"] for x in params["types_of_requests"].values()]
server_capacity = self.distribute_output_capacity(number_of_servers,request_type_capacity)
#print "server capacity:", server_capacity
servers = [Server(server_capacity[z]) for z in range(number_of_servers)]
self.loadbalancer = LoadBalancer(servers=servers,method=params["method"])
def test():
sim = SimulatorKernel(outputDirectory = None)
server1 = Mock()
server2 = Mock()
lb = LoadBalancer(sim)
lb.addBackend(server1)
lb.addBackend(server2)
lb.removeBackend(server2)
assert str(lb)
def test_balance(self):
lb = LoadBalancer(umax=2, ttask=4)
lb.process([1, 3, 0, 1, 0, 1])
assert lb.snapshots == ['1', '2,2', '2,2', '2,2,1', '1,2,1', '2', '2', '1', '1', '0']
def test_invalid_ttask_max(self):
with pytest.raises(Exception):
assert LoadBalancer(umax=1, ttask=40)
def test_invalid_umax_size(self):
with pytest.raises(Exception):
assert LoadBalancer(umax=11, ttask=4)
def test_coast_calculator(self):
lb = LoadBalancer(umax=2, ttask=4)
lb.process([1, 3, 0, 1, 0, 1])
assert lb.total_coast == 15
class Simulator:
def __init__(self,params):
number_of_servers=int(params["number_of_servers"])
self.number_of_requests = int(params["number_of_requests"])
self.number_of_types = len(params["types_of_requests"])
self.number_of_requests_per_sec = int(params["number_of_requests_per_sec"])
self.generator = RequestGenerator(params["types_of_requests"],int(params["number_of_requests_per_sec"]))
request_type_capacity=[x["output_capacity"] for x in params["types_of_requests"].values()]
server_capacity = self.distribute_output_capacity(number_of_servers,request_type_capacity)
#print "server capacity:", server_capacity
servers = [Server(server_capacity[z]) for z in range(number_of_servers)]
self.loadbalancer = LoadBalancer(servers=servers,method=params["method"])
def distribute_output_capacity(self,number_of_servers,type_capacity):
server_capacity = [[0 for z in range(self.number_of_types)]
for server in range(number_of_servers)]
for z in range(self.number_of_types):
while (type_capacity[z]>0):
for server in range(number_of_servers):
if type_capacity[z] <= 0:
break
server_capacity[server][z]+=1
type_capacity[z]-=1
return server_capacity
def number_of_servers(self):
return self.loadbalancer.number_of_servers()
def total_service_time(self):
return self.loadbalancer.total_service_time()
def total_wait_time(self):
return self.loadbalancer.total_wait_time()
def total_wait_requests(self):
return self.loadbalancer.total_wait_requests()
def number_of_requests_per_type(self):
return self.loadbalancer.number_of_requests_per_type()
def number_of_failed_requests_per_type(self):
return self.loadbalancer.number_of_failed_requests_per_type()
def simulate(self):
arrival_time = 0
reqno = 0
while True:
for req in self.generator.generate(number_of_requests=100):
reqno += 1
request_type,delay,service_time=req
arrival_time += delay
#print "--- %s arrive at %f" % (request_type,arrival_time)
self.loadbalancer.process(request_type,arrival_time,service_time)
if reqno >=self.number_of_requests:
break
host_logger = 'logstash'
port_logger = 5000
# Get you a test logger
test_logger = logging.getLogger('python-logstash-logger')
# Set it to whatever level you want - default will be info
test_logger.setLevel(logging.DEBUG)
# Create a handler for it
async_handler = AsynchronousLogstashHandler(host_logger,
port_logger,
database_path=None)
# Add the handler to the logger
test_logger.addHandler(async_handler)
# Initialize load balancer
load_balancer = LoadBalancer()
gateway = Gateway() #TODO: make singleton if needed????
# TODO: make it work with True!!!
SAVE_CACHE_RESPONSE = True
# SAVE_CACHE_RESPONSE = False
response_caching = ResponseCaching()
coordinator = TwoPhaseCommit()
###### Define possible cache statuses#####
SUCCESS = 1
CUSTOM_CACHE_FAILED = 2
REDIS_CACHE_FAILED = 3
else:
raise Exception('Input file entered does not exist')
if len(sys.argv) > 2:
output_file = sys.argv[2]
if not os.path.isfile(input_file):
raise Exception('Default input file does not exists')
data = []
print('Loading file in: {}'.format(input_file))
with open(input_file, 'r') as file:
for i, val in enumerate(file.read().split('\n')):
if val.isdigit():
data.append(int(val))
else:
raise Exception('Input values need to be Integers: {} in line {}'.format(val, i))
lb = LoadBalancer(ttask=data[0], umax=data[1])
lb.process(tasks=data[2:])
with open(output_file, 'w+') as file:
file.write('\n'.join(lb.report))
print('Done! Written file in {}'.format(output_file))
def main():
template = Template()
template.add_description("Example Server")
for key, value in Mappings().mappings.iteritems():
template.add_mapping(key, value)
parameters = Parameters()
for param in parameters.values():
template.add_parameter(param)
template.add_metadata({
"AWS::CloudFormation::Interface": {
"ParameterGroups": [
{
"Label": {
"default": "Required parameters."
},
"Parameters": [
"DBPassword",
"KeyPair",
]
},
{
"Label": {
"default": "Advanced: Database and instance"
},
"Parameters": [
"DBInstanceType", "DBStorageSize", "DBBackupRetention",
"EC2InstanceType"
]
},
],
"ParameterLabels": {
"DBPassword": {
"default": "Choose a database password"
},
"DBStorageSize": {
"default": "Database storage (advanced)"
},
"DBBackupRetention": {
"default": "How long to keep backups (advanced)"
},
"DBInstanceType": {
"default": "Database instance class (advanced)"
},
"KeyPair": {
"default": "Choose a key pair"
},
"EC2InstanceType": {
"default": "Instance class (advanced)"
},
}
}
})
vpc = VPC()
for res in vpc.values():
template.add_resource(res)
elb = LoadBalancer(vpc=vpc)
for res in elb.values():
template.add_resource(res)
db = Database(parameters=parameters, vpc=vpc, loadbalancer=elb)
for res in db.values():
template.add_resource(res)
ec2 = EC2(parameters=parameters, vpc=vpc, loadbalancer=elb)
for res in ec2.values():
template.add_resource(res)
template.add_output(
Output("LoadBalancerDNSName",
Value=GetAtt(elb.load_balancer, "DNSName")))
print(template.to_json())
def __init__(self):
self.load_balancer = LoadBalancer()
class Gateway:
MAX_RETRIES = 5
map_service_type_paths = {
"init-student": "type1",
"init_student": "type1",
"nota": "type1",
"nota-atestare": "type1",
"nota_atestare": "type1",
"nota-examen": "type2",
"nota_examen": "type2",
"pune-nota_atestare": "type2",
"pune_nota_atestare": "type2",
"nota-finala": "type2",
"nota_finala": "type2",
"get-all-exam-marks": "type2",
"get-all-midterm-marks": "type2",
"s2-nota-atestare": "type2",
"s2-validate-student-marks": "type2",
"s2-status": "type2",
"s1-status": "type1",
"status": "",
"test-route": "type1",
"test-route-t2": "type2"
}
def __init__(self):
self.load_balancer = LoadBalancer()
def is_path_allowed(self, path):
allowed_paths = self.map_service_type_paths.keys()
return path in allowed_paths
def get_service_type(self, path):
service_type = self.map_service_type_paths[path]
if path == "s1-status":
path = "status"
service_type = "type1"
elif path == "s2-status":
path = "status"
service_type = "type2"
return service_type
async def make_next_request(self,
path,
service_type,
data,
method,
counter=0):
if not self.load_balancer.any_available(service_type):
test_logger.error("ERROR: No service of type " + service_type +
" available")
return {"status": "error", "message": "No services available"}
test_logger.debug("Request data: " + str(data))
parameters = {"path": path, "parameters": data}
test_logger.debug("Parameters " + str(parameters))
circuit_breaker = self.load_balancer.next(service_type)
if circuit_breaker is None:
return {
"status":
"error",
"message":
"Server error in load_balancer.next(...) method. No services found in cache."
}
service_response = await circuit_breaker.request(parameters, method)
if "status" in service_response and service_response[
"status"] == "success":
return {
"status": "success",
"response": service_response["response"]
}
if "status" in service_response and service_response[
"status"] == "error":
if counter < self.MAX_RETRIES:
counter += 1
return await self.make_next_request(path, service_type, data,
method, counter)
if "message" in service_response:
return {
"status": "error",
"message": service_response["message"]
}
return {"status": "error"}
return {"status": "error", "message": "Error in request to service"}
