def test_serialize(self):
req_matcher10 = RequestMatcher(policy=Policy.PRIORITIZE) \
.add_domain_re(r'^intranet$') \
.add_port(443)
req_matcher11 = RequestMatcher(policy=Policy.PRIORITIZE) \
.add_domain_re(r'^server-test$') \
.add_port(8080)
link1 = Link(interface="wlp5s0") \
.add_request_matcher(req_matcher10) \
.add_request_matcher(req_matcher11)
req_matcher2 = RequestMatcher(policy=Policy.FORBID) \
.add_domain_re(r'.com$')
link2 = Link(interface="enp3s0", weight=2) \
.add_request_matcher(req_matcher2)
balancer_req_matcher = RequestMatcher(policy=Policy.ALLOW) \
.add_port(443) \
.add_port(80) \
.add_port(8080)
balancer = Balancer(strategy=Strategy.LEAST_CONNECTIONS) \
.add_request_matcher(balancer_req_matcher) \
.add_link(link1) \
.add_link(link2)
server = Server() \
.set_balancer(balancer)
serialized = serialize(server)
deserialized = deserialize(serialized, Server)
self.assertEqual(serialized, serialize(deserialized))
save_server("test.json", server)
def run_testcases():
requestId = request.args.get('requestId')
if not requestId:
requestId = uuid.uuid1()
if os.getenv('DOVETAIL_HOME'):
dovetail_home = os.getenv('DOVETAIL_HOME')
else:
return 'No DOVETAIL_HOME found in env.\n', 500
server = Server(dovetail_home, requestId, request.json)
msg, ret = server.set_conf_files()
if not ret:
return msg, 500
msg, ret = server.set_vm_images()
if not ret:
return msg, 500
input_str = server.parse_request()
repo_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
run_script = os.path.join(repo_dir, 'run.py')
cmd = 'python3 {} {}'.format(run_script, input_str)
api_home = os.path.join(dovetail_home, str(requestId))
subprocess.Popen(cmd,
shell=True,
env={
'DOVETAIL_HOME': api_home,
'LC_ALL': 'C.UTF-8',
'LANG': 'C.UTF-8'
})
testcases_file = os.path.join(dovetail_home, str(requestId), 'results',
'testcases.json')
for loop in range(60):
if not os.path.isfile(testcases_file):
time.sleep(1)
else:
break
else:
return 'Can not get file testcases.json.\n', 500
with open(testcases_file, "r") as f:
for jsonfile in f:
data = json.loads(jsonfile)
testcases = data['testcases']
testsuite = data['testsuite']
result = server.get_execution_status(testsuite, testcases, testcases)
return jsonify({'result': result}), 200
def start_server(self):
"""
Starts a Server if there isn't one running
"""
print 'Starting server...'
try:
sc_server = Server()
sc_server.silent = True
sc_server.ui_open = True
server_thread = New_Thread(func=sc_server.loop)
server_thread.start()
except:
print 'failed'
def get_testcases_status(exec_id):
if 'testcase' not in request.json:
return 'Need testcases list as input.\n', 400
testcases = request.json['testcase']
dovetail_home = os.getenv('DOVETAIL_HOME')
server = Server(dovetail_home, exec_id, request.json)
testcases_file = os.path.join(dovetail_home, str(exec_id), 'results',
'testcases.json')
with open(testcases_file, "r") as f:
for jsonfile in f:
data = json.loads(jsonfile)
testsuite = data['testsuite']
result = server.get_execution_status(testsuite, testcases,
data['testcases'])
return jsonify({'result': result}), 200
def main():
logging.info(' ** Starting ShakeCast Server ** ')
try:
sc_server = Server()
# start shakecast
sc_server.start_shakecast()
while sc_server.stop_server is False:
sc_server.stop_loop = False
sc_server.loop()
except Exception as e:
exc_tb = sys.exc_info()[2]
filename, line_num, func_name, text = traceback.extract_tb(
exc_tb)[-1]
logging.info('{}: {} - line: {}\nOriginated: {} {} {} {}'.format(
type(e), e, exc_tb.tb_lineno, filename, line_num, func_name,
text))
return
def add_user_to_new_server(self, user_count):
"""
Cria-se um novo servidor, enquanto ele estiver disponível e existir usuários, um novo usuario é adicionado
Parameters
----------
user_count: Numero de usuarios
Returns
-------
Numero de usuários remanescentes
"""
server = Server()
while server.available_server() is True and user_count > 0:
server.add_user(User())
user_count -= 1
self.servers.append(server)
return user_count
from app.server import Server
if __name__ == "__main__":
Server().start()
def main():
Server().run()
if __name__ == '__main__':
from app.server import Server
server = Server()
try:
server.run()
except KeyboardInterrupt:
server.stop()
# -*- coding: utf-8 -*-
import tornado.options
from app.server import Server
from app.application import Application
if __name__ == "__main__":
tornado.options.parse_command_line()
app = Application()
server = Server(app)
server.run_server()
#!/usr/bin/env python from app.server import Server if __name__ == '__main__': app = Server() app.run()
def main():
cfg = json.load('config.json')
server = Server(cfg)
result = server.fct_test()
print(result['status'])
