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 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():
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_umax_size(self):
with pytest.raises(Exception):
assert LoadBalancer(umax=11, ttask=4)
def test_invalid_ttask_max(self):
with pytest.raises(Exception):
assert LoadBalancer(umax=1, ttask=40)
def test_coast_calculator(self):
lb = LoadBalancer(umax=2, ttask=4)
lb.process([1, 3, 0, 1, 0, 1])
assert lb.total_coast == 15
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()
