def subscribe(self, execution_service: ExecutionService): download_feature = self def execution_started(execution_id): config = execution_service.get_config(execution_id) if not download_feature._is_downloadable(config): return output_stream = execution_service.get_anonymized_output_stream( execution_id) def output_closed(): output_stream_data = read_until_closed(output_stream) script_output = ''.join(output_stream_data) parameter_values = execution_service.get_parameter_values( execution_id) owner = execution_service.get_owner(execution_id) downloadable_files = download_feature._prepare_downloadable_files( config, script_output, parameter_values, owner) download_feature._execution_download_files[ execution_id] = downloadable_files output_stream.subscribe_on_close(output_closed) execution_service.add_start_listener(execution_started)
def __init__(self, execution_id, user: User, execution_service: ExecutionService, result_folder, file_storage) -> None: self.execution_id = execution_id self.execution_service = execution_service self.config = self.execution_service.get_config(execution_id, user) self.result_files_paths = self._get_paths(execution_id, self._is_post_finish_path) self.inline_image_paths = self._get_paths(execution_id, self._is_inline_image_path) self.prepared_files = {} self.result_files = [] self.inline_images = {} self.inline_image_listeners = [] if not self.result_files_paths and not self.inline_image_paths: return self.output_stream = self.execution_service.get_anonymized_output_stream(execution_id) execution_owner = execution_service.get_owner(execution_id) self.download_folder = file_storage.prepare_new_folder(execution_owner, result_folder) LOGGER.info('Created download folder for ' + execution_owner + ': ' + self.download_folder) if self.result_files_paths: execution_service.add_finish_listener(self._execution_finished, execution_id) if self.inline_image_paths: self._listen_for_images()
def subscribe(self, execution_service: ExecutionService): def start_listener(execution_id): handler = _ScriptHandler(execution_id, execution_service, self.result_folder, self.user_file_storage) self._execution_handlers[execution_id] = handler execution_service.add_start_listener(start_listener)
def setUp(self): test_utils.setup() executor._process_creator = _MockProcessWrapper authorizer = Authorizer([], [], [], EmptyGroupProvider()) self.logging_service = ExecutionLoggingService(test_utils.temp_folder, LogNameCreator(), authorizer) self.executor_service = ExecutionService(_IdGeneratorMock()) self.controller = ExecutionLoggingController(self.executor_service, self.logging_service) self.controller.start()
def setUp(self) -> None: test_utils.setup() executor._process_creator = _MockProcessWrapper self.executor_service = ExecutionService(_IdGeneratorMock()) self.file_download_feature = file_download_feature.FileDownloadFeature( UserFileStorage(b'123456'), test_utils.temp_folder) self.file_download_feature.subscribe(self.executor_service) self.images = []
def create_execution_service(self): file_download_feature = mock_object() file_download_feature.is_downloadable = lambda x: False execution_service = ExecutionService(self.id_generator) self.exec_services.append(execution_service) return execution_service
def setUp(self): super().setUp() test_utils.setup() executor._process_creator = _MockProcessWrapper self.executor_service = ExecutionService(AnyUserAuthorizer(), _IdGeneratorMock()) self.feature = FileDownloadFeature(UserFileStorage(b'123456'), test_utils.temp_folder) self.feature.subscribe(self.executor_service)
def setUp(self): test_utils.setup() executor._process_creator = _MockProcessWrapper self.logging_service = ExecutionLoggingService(test_utils.temp_folder, LogNameCreator()) self.executor_service = ExecutionService(_IdGeneratorMock()) self.controller = ExecutionLoggingController(self.executor_service, self.logging_service) self.controller.start()
def setUp(self) -> None: super().setUp() def create_process(executor, command, working_directory, env_variables): return _MockProcessWrapper(executor, command, working_directory, env_variables) executor._process_creator = create_process authorizer = Authorizer([ANY_USER], ['admin_user'], ['history_user'], [], EmptyGroupProvider()) self.executor_service = ExecutionService(authorizer, _IdGeneratorMock()) self.execution_id = _start(self.executor_service, self.owner_user.user_id) self.script_cleaned = False
def main(): tool_utils.validate_web_imports_exist(os.getcwd()) logging_conf_file = os.path.join(CONFIG_FOLDER, 'logging.json') with open(logging_conf_file, 'rt') as f: log_config = json.load(f) file_utils.prepare_folder(os.path.join('logs')) logging.config.dictConfig(log_config) file_utils.prepare_folder(CONFIG_FOLDER) file_utils.prepare_folder(TEMP_FOLDER) migrations.migrate.migrate(TEMP_FOLDER, CONFIG_FOLDER) server_config = server_conf.from_json(SERVER_CONF_PATH) secret = get_secret(TEMP_FOLDER) config_service = ConfigService(CONFIG_FOLDER) alerts_service = AlertsService(server_config.get_alerts_config()) alerts_service = alerts_service execution_logs_path = os.path.join('logs', 'processes') log_name_creator = LogNameCreator( server_config.logging_config.filename_pattern, server_config.logging_config.date_format) execution_logging_service = ExecutionLoggingService( execution_logs_path, log_name_creator) existing_ids = [ entry.id for entry in execution_logging_service.get_history_entries() ] id_generator = IdGenerator(existing_ids) execution_service = ExecutionService(id_generator) execution_logging_initiator = ExecutionLoggingInitiator( execution_service, execution_logging_service) execution_logging_initiator.start() user_file_storage = UserFileStorage(secret) file_download_feature = FileDownloadFeature(user_file_storage, TEMP_FOLDER) file_download_feature.subscribe(execution_service) file_upload_feature = FileUploadFeature(user_file_storage, TEMP_FOLDER) alerter_feature = FailAlerterFeature(execution_service, alerts_service) alerter_feature.start() server.init(server_config, execution_service, execution_logging_service, config_service, alerts_service, file_upload_feature, file_download_feature, secret)
def subscribe(self, execution_service: ExecutionService): download_feature = self def execution_finished(execution_id): config = execution_service.get_config(execution_id) if not download_feature._is_downloadable(config): return output_stream = execution_service.get_anonymized_output_stream(execution_id) output_stream_data = read_until_closed(output_stream) script_output = ''.join(output_stream_data) parameter_values = execution_service.get_user_parameter_values(execution_id) owner = execution_service.get_owner(execution_id) downloadable_files = download_feature._prepare_downloadable_files( config, script_output, parameter_values, owner) download_feature._execution_download_files[execution_id] = downloadable_files execution_service.add_finish_listener(execution_finished)
class ExecutionLoggingInitiatorTest(unittest.TestCase): def test_start_logging_on_execution_start(self): execution_id = self.executor_service.start_script( create_config_model('my_script'), {}, 'userX', create_audit_names(ip='localhost')) executor = self.executor_service.get_active_executor(execution_id) executor.process_wrapper.finish(0) entry = self.logging_service.find_history_entry(execution_id, 'userX') self.assertIsNotNone(entry) def test_logging_values(self): param1 = create_script_param_config('p1') param2 = create_script_param_config('p2', param='-x') param3 = create_script_param_config('p3', param='-y', no_value=True) param4 = create_script_param_config('p4', param='-z', type='int') config_model = create_config_model( 'my_script', script_command='echo', parameters=[param1, param2, param3, param4]) execution_id = self.executor_service.start_script( config_model, {'p1': 'abc', 'p3': True, 'p4': 987}, 'userX', create_audit_names(ip='localhost', auth_username='******')) executor = self.executor_service.get_active_executor(execution_id) executor.process_wrapper._write_script_output('some text\n') executor.process_wrapper._write_script_output('another text') executor.process_wrapper.finish(0) wait_observable_close_notification(executor.get_anonymized_output_stream(), 2) entry = self.logging_service.find_history_entry(execution_id, 'userX') self.assertIsNotNone(entry) self.assertEqual('userX', entry.user_id) self.assertEqual('sandy', entry.user_name) self.assertEqual('my_script', entry.script_name) self.assertEqual('echo abc -y -z 987', entry.command) self.assertEqual('my_script', entry.script_name) log = self.logging_service.find_log(execution_id) self.assertEqual('some text\nanother text', log) def test_exit_code(self): config_model = create_config_model( 'my_script', script_command='ls', parameters=[]) execution_id = self.executor_service.start_script( config_model, {}, 'userX', create_audit_names(ip='localhost')) executor = self.executor_service.get_active_executor(execution_id) executor.process_wrapper._write_script_output('some text\n') executor.process_wrapper._write_script_output('another text') executor.process_wrapper.finish(14) wait_observable_close_notification(executor.get_anonymized_output_stream(), 2) entry = self.logging_service.find_history_entry(execution_id, 'userX') self.assertEqual(14, entry.exit_code) def setUp(self): test_utils.setup() executor._process_creator = _MockProcessWrapper authorizer = Authorizer([], [], [], EmptyGroupProvider()) self.logging_service = ExecutionLoggingService(test_utils.temp_folder, LogNameCreator(), authorizer) self.executor_service = ExecutionService(_IdGeneratorMock()) self.controller = ExecutionLoggingController(self.executor_service, self.logging_service) self.controller.start() def tearDown(self): test_utils.cleanup() executions = self.executor_service.get_active_executions('userX') for execution_id in executions: try: self.executor_service.kill_script(execution_id) self.executor_service.cleanup_execution(execution_id) except: traceback.print_exc()
class ExecutionServiceAuthorizationTest(unittest.TestCase): owner_user = User('user_x', {audit_utils.AUTH_USERNAME: '******'}) @parameterized.expand([(owner_user.user_id, None), ('another_user', AccessProhibitedException), ('admin_user', AccessProhibitedException), ('history_user', AccessProhibitedException)]) def test_get_active_executor(self, user_id, expected_exception): self._assert_throws_exception( expected_exception, self.executor_service.get_active_executor, self.execution_id, User(user_id, {})) @parameterized.expand([(owner_user.user_id, None), ('another_user', AccessProhibitedException), ('admin_user', AccessProhibitedException), ('history_user', AccessProhibitedException)]) def test_stop_script(self, user_id, expected_exception): self._assert_throws_exception(expected_exception, self.executor_service.stop_script, self.execution_id, User(user_id, {}), has_results=False) @parameterized.expand([(owner_user.user_id, None), ('another_user', AccessProhibitedException), ('admin_user', AccessProhibitedException), ('history_user', AccessProhibitedException)]) def test_kill_script(self, user_id, expected_exception): self._assert_throws_exception(expected_exception, self.executor_service.kill_script, self.execution_id, User(user_id, {}), has_results=False) @parameterized.expand([(owner_user.user_id, None), ('another_user', AccessProhibitedException), ('admin_user', None), ('history_user', None)]) def test_is_running(self, user_id, expected_exception): self._assert_throws_exception(expected_exception, self.executor_service.is_running, self.execution_id, User(user_id, {})) @parameterized.expand([(owner_user.user_id, None), ('another_user', AccessProhibitedException), ('admin_user', AccessProhibitedException), ('history_user', AccessProhibitedException)]) def test_get_config(self, user_id, expected_exception): self._assert_throws_exception(expected_exception, self.executor_service.get_config, self.execution_id, User(user_id, {})) @parameterized.expand([(owner_user.user_id, None), ('another_user', AccessProhibitedException), ('admin_user', AccessProhibitedException), ('history_user', AccessProhibitedException)]) def test_cleanup(self, user_id, expected_exception): self.executor_service.stop_script(self.execution_id, self.owner_user) self._assert_throws_exception(expected_exception, self.executor_service.cleanup_execution, self.execution_id, User(user_id, {}), has_results=False) self.script_cleaned = True def _assert_throws_exception(self, expected_exception, func, *parameters, has_results=True): try: result = func(*parameters) if expected_exception: self.fail('Should throw ' + str(expected_exception) + ', but did not') if has_results: self.assertIsNotNone(result) except Exception as e: self.assertIsInstance(e, expected_exception) def setUp(self) -> None: super().setUp() def create_process(executor, command, working_directory, env_variables): return _MockProcessWrapper(executor, command, working_directory, env_variables) executor._process_creator = create_process authorizer = Authorizer([ANY_USER], ['admin_user'], ['history_user'], [], EmptyGroupProvider()) self.executor_service = ExecutionService(authorizer, _IdGeneratorMock()) self.execution_id = _start(self.executor_service, self.owner_user.user_id) self.script_cleaned = False def tearDown(self) -> None: super().tearDown() executor._process_creator = create_process_wrapper if not self.script_cleaned: self.executor_service.kill_script(self.execution_id, self.owner_user) self.executor_service.cleanup_execution(self.execution_id, self.owner_user)
class ExecutionLoggingInitiatorTest(unittest.TestCase): def test_start_logging_on_execution_start(self): execution_id = self.executor_service.start_script( create_config_model('my_script'), {}, 'userX', create_audit_names(ip='localhost')) executor = self.executor_service.get_active_executor(execution_id) executor.process_wrapper.finish(0) entry = self.logging_service.find_history_entry(execution_id) self.assertIsNotNone(entry) def test_logging_values(self): param1 = create_script_param_config('p1') param2 = create_script_param_config('p2', param='-x') param3 = create_script_param_config('p3', param='-y', no_value=True) param4 = create_script_param_config('p4', param='-z', type='int') config_model = create_config_model( 'my_script', script_command='echo', parameters=[param1, param2, param3, param4]) execution_id = self.executor_service.start_script( config_model, {'p1': 'abc', 'p3': True, 'p4': 987}, 'userX', create_audit_names(ip='localhost', auth_username='******')) executor = self.executor_service.get_active_executor(execution_id) executor.process_wrapper._write_script_output('some text\n') executor.process_wrapper._write_script_output('another text') executor.process_wrapper.finish(0) wait_observable_close_notification(executor.get_anonymized_output_stream(), 2) entry = self.logging_service.find_history_entry(execution_id) self.assertIsNotNone(entry) self.assertEqual('userX', entry.user_id) self.assertEqual('sandy', entry.user_name) self.assertEqual('my_script', entry.script_name) self.assertEqual('echo abc -y -z 987', entry.command) self.assertEqual('my_script', entry.script_name) log = self.logging_service.find_log(execution_id) self.assertEqual('some text\nanother text', log) def test_exit_code(self): config_model = create_config_model( 'my_script', script_command='ls', parameters=[]) execution_id = self.executor_service.start_script( config_model, {}, 'userX', create_audit_names(ip='localhost')) executor = self.executor_service.get_active_executor(execution_id) executor.process_wrapper._write_script_output('some text\n') executor.process_wrapper._write_script_output('another text') executor.process_wrapper.finish(14) wait_observable_close_notification(executor.get_anonymized_output_stream(), 2) entry = self.logging_service.find_history_entry(execution_id) self.assertEqual(14, entry.exit_code) def setUp(self): test_utils.setup() executor._process_creator = _MockProcessWrapper self.logging_service = ExecutionLoggingService(test_utils.temp_folder, LogNameCreator()) self.executor_service = ExecutionService(_IdGeneratorMock()) self.controller = ExecutionLoggingController(self.executor_service, self.logging_service) self.controller.start() def tearDown(self): test_utils.cleanup() executions = self.executor_service.get_active_executions('userX') for execution_id in executions: try: self.executor_service.kill_script(execution_id) self.executor_service.cleanup_execution(execution_id) except: traceback.print_exc()
class TestInlineImages(unittest.TestCase): def setUp(self) -> None: test_utils.setup() executor._process_creator = _MockProcessWrapper self.executor_service = ExecutionService(_IdGeneratorMock()) self.file_download_feature = file_download_feature.FileDownloadFeature( UserFileStorage(b'123456'), test_utils.temp_folder) self.file_download_feature.subscribe(self.executor_service) self.images = [] def tearDown(self) -> None: test_utils.cleanup() executions = self.executor_service.get_active_executions('userX') for execution in executions: self.executor_service.kill_script(execution) def _add_image(self, original_path, new_path): self.images.append((original_path, new_path)) def test_single_static_image(self): path = test_utils.create_file('test.png') config = create_config_model('my_script', output_files=[inline_image(path)]) execution_id = self.start_execution(config) self.write_output(execution_id, '123\n456') self.wait_output_chunks(execution_id, chunks_count=1) self.assert_images(path) def test_multiple_static_images(self): path1 = test_utils.create_file('test1.png') path2 = test_utils.create_file('test2.png') path3 = test_utils.create_file('test3.png') config = create_config_model('my_script', output_files=[ inline_image(path1), inline_image(path2), inline_image(path3) ]) execution_id = self.start_execution(config) self.write_output(execution_id, '123\n' + '456') self.wait_output_chunks(execution_id, chunks_count=1) self.assert_images(path1, path2, path3) def test_single_static_image_when_multiple_outputs(self): path = test_utils.create_file('test.png') config = create_config_model('my_script', output_files=[inline_image(path)]) execution_id = self.start_execution(config) self.write_output(execution_id, '123\n456') self.wait_output_chunks(execution_id, chunks_count=1) self.write_output(execution_id, '789\n0') self.wait_output_chunks(execution_id, chunks_count=2) self.assert_images(path) def test_single_dynamic_image(self): path = test_utils.create_file('test.png') config = create_config_model( 'my_script', output_files=[inline_image('##any_path.png#')]) execution_id = self.start_execution(config) full_path = file_utils.normalize_path(path) self.write_output(execution_id, '123\n' + full_path + '\n456') self.wait_output_chunks(execution_id, chunks_count=1) self.assert_images(full_path) def test_single_dynamic_image_when_unnormalized(self): test_utils.create_file('sub/test.png') config = create_config_model( 'my_script', output_files=[inline_image('#([\.\w]+/)+\w+.png#')]) execution_id = self.start_execution(config) unnormalized_path = os.path.join(test_utils.temp_folder, '.', 'sub', '..', 'sub', 'test.png') self.write_output(execution_id, '_ ' + unnormalized_path + ' _\n') self.wait_output_chunks(execution_id, chunks_count=1) image_keys = [img[0] for img in self.images] self.assertEqual([unnormalized_path], image_keys) def test_mixed_images_when_multiple_output(self): path1 = test_utils.create_file('test123.png') path2 = test_utils.create_file('images/test.png') path3 = test_utils.create_file('a.b.c.png') path4 = test_utils.create_file('test456.png') path5 = test_utils.create_file('some/long/path/me.jpg') config = create_config_model( 'my_script', output_files=[ inline_image(test_utils.temp_folder + os_utils.path_sep() + '#test\d+.png#'), inline_image(path2), inline_image(path3), inline_image('##any_path/path/\w+#.jpg') ]) execution_id = self.start_execution(config) paths = [ normalize_path(p) for p in (path1, path2, path3, path4, path5) ] for index, path in enumerate(paths): self.write_output(execution_id, '__ ' + path + ' __\n') self.wait_output_chunks(execution_id, chunks_count=index + 1) self.write_output(execution_id, '__ ' + path2 + ' __\n') self.wait_output_chunks(execution_id, chunks_count=len(paths) + 1) self.assert_images(*paths) def test_find_multiple_images_by_same_pattern(self): path1 = test_utils.create_file('test123.png') test_utils.create_file('images/test.png') path3 = test_utils.create_file('a.b.c.png') path4 = test_utils.create_file('some/sub/folder/test456.png') config = create_config_model( 'my_script', output_files=[inline_image('##any_path.png#')]) execution_id = self.start_execution(config) paths = [normalize_path(p) for p in (path1, path3, path4)] for index, path in enumerate(paths): self.write_output(execution_id, '__ ' + path + ' __\n') self.wait_output_chunks(execution_id, chunks_count=index + 1) self.assert_images(*paths) def test_image_path_split_in_chunks(self): path = test_utils.create_file('test123.png') config = create_config_model( 'my_script', output_files=[inline_image('##any_path.png#')]) execution_id = self.start_execution(config) normalized = normalize_path(path) self.write_output(execution_id, normalized[:4]) self.wait_output_chunks(execution_id, chunks_count=1) self.write_output(execution_id, normalized[4:] + '\n') self.wait_output_chunks(execution_id, chunks_count=2) self.assert_images(path) def test_image_path_split_in_chunks_and_no_newlines(self): path = test_utils.create_file('test123.png') config = create_config_model( 'my_script', output_files=[inline_image('##any_path.png#')]) execution_id = self.start_execution(config) normalized = normalize_path(path) self.write_output(execution_id, normalized[:4]) self.wait_output_chunks(execution_id, chunks_count=1) self.write_output(execution_id, normalized[4:]) self.wait_output_chunks(execution_id, chunks_count=2) self.executor_service.get_active_executor( execution_id).process_wrapper.stop() self.wait_close(execution_id) self.assert_images(path) def wait_output_chunks(self, execution_id, *, chunks_count): waiter = OutputWaiter() self.executor_service.get_anonymized_output_stream( execution_id).subscribe(waiter) waiter.wait_chunks(chunks_count, timeout=0.5) def wait_close(self, execution_id): chunk_condition = threading.Condition() closed = False def waiter(): global closed closed = True with chunk_condition: chunk_condition.notify_all() self.executor_service.get_anonymized_output_stream( execution_id).subscribe_on_close(waiter) with chunk_condition: chunk_condition.wait_for(lambda: closed, 0.5) def write_output(self, execution_id, output): process_wrapper = self.executor_service.get_active_executor( execution_id).process_wrapper process_wrapper.write_output(output) def start_execution(self, config): execution_id = self.executor_service.start_script( config, {}, 'userX', {}) self.file_download_feature.subscribe_on_inline_images( execution_id, self._add_image) return execution_id def assert_images(self, *paths): normalized_paths = [file_utils.normalize_path(p) for p in paths] actual_paths = [ file_utils.normalize_path(image[0]) for image in self.images ] self.assertCountEqual(normalized_paths, actual_paths)
def main(): project_path = os.getcwd() try: tool_utils.validate_web_build_exists(project_path) except InvalidWebBuildException as e: print(str(e)) sys.exit(-1) logging_conf_file = os.path.join(CONFIG_FOLDER, 'logging.json') with open(logging_conf_file, 'rt') as f: log_config = json.load(f) file_utils.prepare_folder(LOG_FOLDER) logging.config.dictConfig(log_config) server_version = tool_utils.get_server_version(project_path) logging.info('Starting Script Server' + (', v' + server_version if server_version else ' (custom version)')) file_utils.prepare_folder(CONFIG_FOLDER) file_utils.prepare_folder(TEMP_FOLDER) migrations.migrate.migrate(TEMP_FOLDER, CONFIG_FOLDER, SERVER_CONF_PATH, LOG_FOLDER) server_config = server_conf.from_json(SERVER_CONF_PATH, TEMP_FOLDER) secret = get_secret(server_config.secret_storage_file) tornado_client_config.initialize() group_provider = create_group_provider(server_config.user_groups, server_config.authenticator, server_config.admin_users) authorizer = Authorizer(server_config.allowed_users, server_config.admin_users, server_config.full_history_users, server_config.code_editor_users, group_provider) config_service = ConfigService(authorizer, CONFIG_FOLDER) alerts_service = AlertsService(server_config.alerts_config) alerts_service = alerts_service execution_logs_path = os.path.join(LOG_FOLDER, 'processes') log_name_creator = LogNameCreator( server_config.logging_config.filename_pattern, server_config.logging_config.date_format) execution_logging_service = ExecutionLoggingService( execution_logs_path, log_name_creator, authorizer) existing_ids = [ entry.id for entry in execution_logging_service.get_history_entries( None, system_call=True) ] id_generator = IdGenerator(existing_ids) execution_service = ExecutionService(authorizer, id_generator) execution_logging_controller = ExecutionLoggingController( execution_service, execution_logging_service) execution_logging_controller.start() user_file_storage = UserFileStorage(secret) file_download_feature = FileDownloadFeature(user_file_storage, TEMP_FOLDER) file_download_feature.subscribe(execution_service) file_upload_feature = FileUploadFeature(user_file_storage, TEMP_FOLDER) alerter_feature = FailAlerterFeature(execution_service, alerts_service) alerter_feature.start() executions_callback_feature = ExecutionsCallbackFeature( execution_service, server_config.callbacks_config) executions_callback_feature.start() schedule_service = ScheduleService(config_service, execution_service, CONFIG_FOLDER) server.init(server_config, server_config.authenticator, authorizer, execution_service, schedule_service, execution_logging_service, config_service, alerts_service, file_upload_feature, file_download_feature, secret, server_version, CONFIG_FOLDER)
def main(): tool_utils.validate_web_imports_exist(os.getcwd()) logging_conf_file = os.path.join(CONFIG_FOLDER, 'logging.json') with open(logging_conf_file, "rt") as f: log_config = json.load(f) file_utils.prepare_folder(os.path.join('logs')) logging.config.dictConfig(log_config) file_utils.prepare_folder(CONFIG_FOLDER) file_utils.prepare_folder(SCRIPT_CONFIGS_FOLDER) server_config = server_conf.from_json(SERVER_CONF_PATH) ssl_context = None if server_config.is_ssl(): ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_context.load_cert_chain(server_config.get_ssl_cert_path(), server_config.get_ssl_key_path()) file_utils.prepare_folder(TEMP_FOLDER) settings = { "cookie_secret": get_tornado_secret(), "login_url": "/login.html" } auth = TornadoAuth(server_config.authenticator, server_config.authorizer) user_file_storage = UserFileStorage(get_tornado_secret()) file_download_feature = FileDownloadFeature(user_file_storage, TEMP_FOLDER) result_files_folder = file_download_feature.get_result_files_folder() handlers = [(r"/conf/title", GetServerTitle), (r"/scripts/list", GetScripts), (r"/scripts/info", GetScriptInfo), (r"/scripts/execute", ScriptExecute), (r"/scripts/execute/stop", ScriptStop), (r"/scripts/execute/io/(.*)", ScriptStreamSocket), (r'/admin/execution_log/short', GetShortHistoryEntriesHandler), (r'/admin/execution_log/long/(.*)', GetLongHistoryEntryHandler), (r'/' + os.path.basename(result_files_folder) + '/(.*)', DownloadResultFile, { 'path': result_files_folder }), (r"/", ProxiedRedirectHandler, { "url": "/index.html" })] if auth.is_enabled(): handlers.append((r'/login', LoginHandler)) handlers.append((r'/auth/config', AuthConfigHandler)) handlers.append((r'/logout', LogoutHandler)) handlers.append((r"/username", GetUsernameHandler)) handlers.append((r"/(.*)", AuthorizedStaticFileHandler, {"path": "web"})) application = tornado.web.Application(handlers, **settings) application.auth = auth application.server_title = server_config.title application.authorizer = server_config.authorizer application.file_download_feature = file_download_feature application.file_upload_feature = FileUploadFeature( user_file_storage, TEMP_FOLDER) alerts_service = AlertsService(server_config.get_alerts_config()) application.alerts_service = alerts_service execution_logs_path = os.path.join('logs', 'processes') log_name_creator = LogNameCreator( server_config.logging_config.filename_pattern, server_config.logging_config.date_format) execution_logging_service = ExecutionLoggingService( execution_logs_path, log_name_creator) application.execution_logging_service = execution_logging_service existing_ids = [ entry.id for entry in execution_logging_service.get_history_entries() ] id_generator = IdGenerator(existing_ids) execution_service = ExecutionService(execution_logging_service, alerts_service, id_generator) application.execution_service = execution_service http_server = httpserver.HTTPServer(application, ssl_options=ssl_context) http_server.listen(server_config.port, address=server_config.address) io_loop = tornado.ioloop.IOLoop.current() intercept_stop_when_running_scripts(io_loop, execution_service) http_protocol = 'https' if server_config.ssl else 'http' print('Server is running on: %s://%s:%s' % (http_protocol, server_config.address, server_config.port)) io_loop.start()
def main(): try: tool_utils.validate_web_build_exists(os.getcwd()) except InvalidWebBuildException as e: print(str(e)) sys.exit(-1) logging_conf_file = os.path.join(CONFIG_FOLDER, 'logging.json') with open(logging_conf_file, 'rt') as f: log_config = json.load(f) file_utils.prepare_folder(LOG_FOLDER) logging.config.dictConfig(log_config) file_utils.prepare_folder(CONFIG_FOLDER) file_utils.prepare_folder(TEMP_FOLDER) migrations.migrate.migrate(TEMP_FOLDER, CONFIG_FOLDER, SERVER_CONF_PATH, LOG_FOLDER) server_config = server_conf.from_json(SERVER_CONF_PATH, TEMP_FOLDER) secret = get_secret(TEMP_FOLDER) tornado_client_config.initialize() group_provider = create_group_provider(server_config.user_groups, server_config.authenticator, server_config.admin_users) authorizer = Authorizer(server_config.allowed_users, server_config.admin_users, group_provider) config_service = ConfigService(authorizer, CONFIG_FOLDER) alerts_service = AlertsService(server_config.get_alerts_config()) alerts_service = alerts_service execution_logs_path = os.path.join(LOG_FOLDER, 'processes') log_name_creator = LogNameCreator( server_config.logging_config.filename_pattern, server_config.logging_config.date_format) execution_logging_service = ExecutionLoggingService( execution_logs_path, log_name_creator) existing_ids = [ entry.id for entry in execution_logging_service.get_history_entries() ] id_generator = IdGenerator(existing_ids) execution_service = ExecutionService(id_generator) execution_logging_initiator = ExecutionLoggingInitiator( execution_service, execution_logging_service) execution_logging_initiator.start() user_file_storage = UserFileStorage(secret) file_download_feature = FileDownloadFeature(user_file_storage, TEMP_FOLDER) file_download_feature.subscribe(execution_service) file_upload_feature = FileUploadFeature(user_file_storage, TEMP_FOLDER) alerter_feature = FailAlerterFeature(execution_service, alerts_service) alerter_feature.start() server.init(server_config, server_config.authenticator, authorizer, execution_service, execution_logging_service, config_service, alerts_service, file_upload_feature, file_download_feature, secret)