def has_upgrade(request): """ Возвращает новую версию зу инсталера, на которую можно обновиться. """ return { 'version': Core.get_instance().has_upgrade() if Core.get_instance() else None }
def sync_core(): """ После каждой установки выполнить sync чтобы current.yaml был в актуальном сосотоянии """ logging.debug('start core updating after install process finished') Core.get_instance().set_expired(True) Core.get_instance().update()
def logs_clear(request): """ Очищает директорию логов. """ Core.get_instance().clear_logs() return { 'size': Core.get_instance().get_logs_size() }
def cache_clear(request): """ Очищает директорию кеша. """ Core.get_instance().clear_cache() return { 'size': Core.get_instance().get_cache_size() }
def __init__(self, links_file, url): """""" self.config = shared.configuration self.links_file = links_file self.stop_flag = False self.buffer = [] self.url = url Core.__init__(self)
def command_upgrade(params): state = params["params"] # check self upgrading if "product" in state["products"][0] and state["products"][0]["product"] == core.version.NAME: Core.get_instance().upgrade(state['products'], state.get('parameters'), True) raise SelfUpgradeException("Helicon Zoo is upgrading yourself", params["parent_pid"]) else: return Core.get_instance().upgrade(state['products'], state.get('parameters'), True)
def launch_iis_express(self, site_name): """ Launch an iisexpress deamon for the site "iisxexpress /site:sitename" """ executable = IIS.APP_CMD_EXPRESS_PATH if not Core.exist_uniq_process("iisexpress_"+site_name): Core.start_uniq_process([executable, "/site:{0}".format(site_name)], "iisexpress_"+site_name) return True
def test_handler_arguments(self): class FooModule(BaseModule): def boot(self): self.subscribe(self.handle) def handle(self, message): pass ai = Core() ai.add_module(FooModule()) self.assertRaises(ModuleError, lambda: ai.boot())
def __init__(self): cmd.Cmd.__init__(self) self.core = Core() self.core.list() self.intro = "\nDecision Support System Logger: For information type help or ? \n" self.prompt = ">> " self.completekey = 'tab' self._hist = [] self._locals = [] self._globals = []
def test_handler_type_matches_subscribe(self): class ModuleWithTypeMismatch(BaseModule): def boot(self) -> None: self.subscribe(self.handle, types=EventTypeA) def handle(self, event: EventTypeB): pass ai = Core() ai.add_module(ModuleWithTypeMismatch()) self.assertRaises(ModuleError, lambda: ai.boot())
def command_upgrade(params): state = params["params"] # check self upgrading if "product" in state["products"][0] and state["products"][0][ "product"] == core.version.NAME: Core.get_instance().upgrade(state['products'], state.get('parameters'), True) raise SelfUpgradeException("Helicon Zoo is upgrading yourself", params["parent_pid"]) else: return Core.get_instance().upgrade(state['products'], state.get('parameters'), True)
def test_subscribing_non_event_class(self): class FakeEvent: pass class BadSubscriber(BaseModule): def boot(self): self.subscribe(lambda: None, types=FakeEvent) ai = Core() module = BadSubscriber() ai.add_module(module) self.assertRaises(ModuleSubscribedToNonEventClassError, lambda: ai.boot())
def __init__(self, app): QMainWindow.__init__(self) self.app = app self.core = Core() self.assets: Assets = Assets() self.last_login: str = 'never' self.login_repeater = Repeater() self.tray_icon = SystemTrayIcon(parent=self, assets=self.assets, profile_list=self.core.config.list_groups()) self.log_dialog = LogDialog(self) self.config_dialog = ConfigDialog(self) self.set_key_dialog = SetKeyDialog(self) self.rotate_key_dialog = RotateKeyDialog(self) self.tray_icon.show()
def create_upgrade_task(products: ProductCollection, parameter_manager: ParametersManager): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_UPGRADE сохранить в базе данных зхапустить воркер :param products: :param parameter_manager: :return: """ settings = json_encode(Core.get_instance().settings.get_state()) job_array = [] task_object = TaskDataModel(command="upgrade", settings=settings) for product in products: title = product.title state = { 'products': [product.to_dict()], 'parameters': parameter_manager.get_state() } state2save = json_encode(state) job = JobDataModel(command=JobDataModel.COMMAND_UPGRADE, title=title, params=state2save, task=task_object, settings=settings) job_array.append(job) task = Task(task_model=task_object, jobs=job_array) return task
def create_upgrade_task(products: ProductCollection, parameter_manager: ParametersManager): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_UPGRADE сохранить в базе данных зхапустить воркер :param products: :param parameter_manager: :return: """ settings = json_encode(Core.get_instance().settings.get_state()) job_array = [] task_object = TaskDataModel(command="upgrade", settings=settings) for product in products: title = product.title state = { 'products': [product.to_dict()], 'parameters': parameter_manager.get_state() } state2save = json_encode(state) job = JobDataModel( command=JobDataModel.COMMAND_UPGRADE, title=title, params=state2save, task=task_object, settings=settings ) job_array.append(job) task = Task(task_model=task_object, jobs=job_array) return task
def __init__(self, product_names, args_parameters=None): if not product_names: raise UninstallCommandError('no products specified') self.core = Core.get_instance() self.product_names = product_names self.args_parameters = args_parameters
def create_uninstall_task(products: ProductCollection): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_UNINSTALL сохранить в базе данных зхапустить воркер :param requested_products: :param products: :param parameter_manager: :return: """ job_array = [] settings = json_encode(Core.get_instance().settings.get_state()) task_object = TaskDataModel(command="uninstall", settings=settings) for product in products: state = { 'products': [product.name], } job = JobDataModel( command=JobDataModel.COMMAND_UNINSTALL, title=product.title, params=json_encode(state), settings=settings) job_array.append(job) task = Task(task_model=task_object, jobs=job_array) return task
def create_install_task(products: ProductCollection, parameter_manager: ParametersManager): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_INSTALL сохранить в базе данных зхапустить воркер :param products: продукты для установки (продукты которые выбрал пользователь + зависимости) :param parameter_manager: :return: номер таска """ settings = json_encode(Core.get_instance().settings.get_state()) job_array = [] task_object = TaskDataModel(command="install", settings=settings) for product in products: title = product.title state = { 'products': [product.to_dict()], 'parameters': parameter_manager.get_state() } state2save = json_encode(state) job = JobDataModel(command=JobDataModel.COMMAND_INSTALL, title=title, params=state2save, task=task_object, settings=settings) job_array.append(job) task = Task(task_model=task_object, jobs=job_array) return task
def __init__(self, *args): self.web_frontend_url = "http://127.0.0.1:7799/api/1/core/sync/" self.process = None self.logger = None self.timer_read_log = None self.timer_check_logdir = None self.check_new_tasks = None self.decoder = OutputDecoder() # TODO remove port from code self.port = 7798 self.logger = logging.getLogger() self.log_reader = None # remove all handlers self.logger.handlers = [] # add only db handler self.core = Core.get_instance() self.configs = { 'max_messages_per': 100, "queue": Queue(), 'buffer': 1, 'sessions': {}, "state": "reading", 'status_done': False, 'task': None } self.application = tornado.web.Application([ (r"/socket/log", WebSocketHandler, {"configs": self.configs}), (r"/test", MainHandler, {"configs": self.configs}) ])
def install_application(request, app_name): """ Этот вызов используется для передать в веб-интерфейс дерево зависимостей для первого шага install application Возвращает продукты необходимые для установки Application для запуска инсталяции используется стандартный вызов install Примеры запросов и ответов: начальный запрос: """ req = json_request(request) # это начальный запрос? dm = DependencyManager() core = Core.get_instance() # продукты, которые запрошены на установку (без зависимостей) requested_products = [app_name] if len(requested_products) > 1: raise RuntimeError("You are able to install only one application") application_item = [ dm.get_dependencies(product_name) for product_name in requested_products ] resp = {'task': None, "state": "requirements", 'items': application_item} return resp
def create_upgrade_task(self, requested_products: list, products: ProductCollection): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_UPGRADE сохранить в базе данных зхапустить воркер :param requested_products: :param products: :param parameter_manager: :return: """ title = 'Upgrading products: {0}'.format(', '.join([product_name for product_name in requested_products])) state = { 'requested_products': requested_products, 'products': products.get_names_list(), 'parameters': {} } settings = Core.get_instance().settings.get_state() logging.debug('state: {0}'.format(state)) task = Task( command=Task.COMMAND_UPGRADE, title=title, params=json.dumps(state, sort_keys=True, indent=1), settings=json.dumps(settings, sort_keys=True, indent=1) ) task.save() # production # For debug worker uncomment this #self.task.execute() return task.id
def product_list(request): """ Получить список продуктов с учетом фильтров filter - тип продукта, product, application, engine installed - установлен или нет q - строка поиска :param request: :return: """ product_filter = request.GET.get('filter', None) installed_filter = request.GET.get('installed', None) if installed_filter is not None: installed_filter = int(installed_filter) q = request.GET.get('q', None) core = Core.get_instance() core.update() if q: q = urllib.parse.unquote_plus(q) products = core.feed.dump_products(core.feed.search_products(q)) else: products = core.feed.dump_products( core.feed.filter_products(product_filter, installed_filter)) return products
def start_new_task(task, user_proc_exit_cb=None, save_buffer=True): worker = TornadoWorker.get_instance() logging.debug("we have new job to start %s" % str(task)) core = Core.get_instance() new_job = Job.create_job(task, core) logging.debug(new_job) if new_job.task_id not in worker.pool["buffer"]: worker.pool["buffer"][new_job.task_id] = [] task.update(status=JobDataModel.STATUS_RUNNING) proc_exit_cb = None if user_proc_exit_cb: proc_exit_cb = lambda job, exit_code: TornadoWorker.process_finished( worker, job, exit_code, user_proc_exit_cb) else: proc_exit_cb = lambda job, exit_code: TornadoWorker.process_finished( worker, job, exit_code) read_logs = None if save_buffer: read_logs = lambda lines, log_level: TornadoWorker.async_read_logs( worker, new_job, lines, log_level) else: read_logs = lambda lines, log_level: TornadoWorker.async_write_logs2stdout( worker, new_job, lines, log_level) job_log_manager = LogManager(core) new_job.start_job_async(job_log_manager, proc_exit_cb, read_logs)
def test_match_product(self): p = Product(core=Core.create_instance()) p.merge(product="Zoo", version="4.0") self.assertTrue(ProductComparer("zoo>3.0.0.1").match('zoo', '4.0')) self.assertFalse(ProductComparer("zoo>4.0").match('zoo', '4.0')) self.assertFalse(ProductComparer("foo>3.0").match('zoo', '4.0'))
def test_match_product(self): p = Product(core=Core.get_instance()) p.merge(product="Zoo", version="4.0") self.assertTrue(ProductComparer("zoo>3.0.0.1").match('zoo', '4.0')) self.assertFalse(ProductComparer("zoo>4.0").match('zoo', '4.0')) self.assertFalse(ProductComparer("foo>3.0").match('zoo', '4.0'))
def create_uninstall_task(self, products: ProductCollection): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_UNINSTALL сохранить в базе данных зхапустить воркер :param requested_products: :param products: :param parameter_manager: :return: """ title = 'Uninstalling products: {0}'.format(', '.join([product.title for product in products])) state = { 'products': products.get_names_list(), } settings = Core.get_instance().settings.get_state() task = Task( command=Task.COMMAND_UNINSTALL, title=title, params=json.dumps(state, sort_keys=True, indent=1), settings=json.dumps(settings, sort_keys=True, indent=1)) task.save() self.task = task self.run_worker(task.id) return task.id
def create_install_task(products: ProductCollection, parameter_manager: ParametersManager): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_INSTALL сохранить в базе данных зхапустить воркер :param products: продукты для установки (продукты которые выбрал пользователь + зависимости) :param parameter_manager: :return: номер таска """ settings = json_encode(Core.get_instance().settings.get_state()) job_array = [] task_object = TaskDataModel(command="install", settings=settings) for product in products: title = product.title state = { 'products': [product.to_dict()], 'parameters': parameter_manager.get_state() } state2save = json_encode(state) job = JobDataModel( command=JobDataModel.COMMAND_INSTALL, title=title, params=state2save, task=task_object, settings=settings ) job_array.append(job) task = Task(task_model=task_object, jobs=job_array) return task
def get_dependencies(self, product_name): """ найти зависомости для продукта :param product_name: :return: :raise Exception: """ if not isinstance(product_name, str): raise Exception("Expected string. got '{0}'".format(product_name)) product = Core.get_instance().feed.get_product(product_name) result = dict() if product is None: result["product"] = "None" return result result["product"] = product.to_dict(True) parameter_manager = ParametersManager([product]) result['parameters'] = [product_parameter.to_dict() for product_parameter in parameter_manager.get_for_product(product)] if product.is_installed(): result['can_upgrade'] = bool(product.upgrade_command) result['last_version'] = product.version == product.get_installed_version() else: result['can_upgrade'] = True result['last_version'] = False dependencies = product.get_dependencies() if dependencies is None or len(dependencies) == 0: return result result["and"] = self._get_dependencies_for_node(dependencies) return result
def create_uninstall_task(products: ProductCollection): """ фабричный метод: создать такс с переданными параметрами, с типом COMMAND_UNINSTALL сохранить в базе данных зхапустить воркер :param requested_products: :param products: :param parameter_manager: :return: """ job_array = [] settings = json_encode(Core.get_instance().settings.get_state()) task_object = TaskDataModel(command="uninstall", settings=settings) for product in products: state = { 'products': [product.name], } job = JobDataModel(command=JobDataModel.COMMAND_UNINSTALL, title=product.title, params=json_encode(state), settings=settings) job_array.append(job) task = Task(task_model=task_object, jobs=job_array) return task
def __init__(self, path, engine, callback_exit): """ подготовить окружение к запуску дочернего процесса нужно - загрузить .zoo - найти на каком энжайне он работает - найти энжайн - взять текущие переменные окружения - взять переменные окружения энжайна - взять переменные окружения .zoo - раскрыть все переменные окружения запустить дочерний процесс :param path: """ self.updated = None self.path = path self.core = Core.get_instance() self.buffer = [] self.env = os.environ.copy() self.physical_path = self.core.api.os.web_server.map_webserver_path(self.path) if self.physical_path: self.site_root = self.core.api.os.web_server.siteroot4path(self.physical_path) self.app_physical_path = self.core.api.os.web_server.find_app_physical_path(self.physical_path, self.site_root) if self.app_physical_path: self.zoo_config = self.core.api.os.web_server.get_zoo_config(self.app_physical_path) # emulate zoo module variables self.env["INSTANCE_ID"] = "0" self.env["APPL_PHYSICAL_PATH"] = self.app_physical_path self.env["APPL_PHYSICAL_SHORT_PATH"] = self.core.api.os.shell.get_short_path_name(self.app_physical_path) self.env["APPL_VIRTUAL_PATH"] = self.app_physical_path self.env["APPL_ID"] = self.env["APPL_VIRTUAL_PATH"].replace("/", "") std_console = self.env.copy() if self.zoo_config: try: zoo_env = self.core.api.os.web_server.create_environment(self.zoo_config, std_console, engine) self.env = zoo_env except Exception as e: logging.debug(" cant create environment from zoo file") logging.debug(e) logging.debug(traceback.format_exc()) notes = str(e) + "\n" # we try to create console porcess in any case of errors else: # IT'S IMPORTANT FRO SECURITY REASONS raise Exception("There is no settings for this path {0}".format(path)) self.pipe_stdin = None self.pipe_stdout = None self.pipe_stderr = None self.proc = None self.connection = None self.callback_exit=callback_exit self.on_callback_exit=None self.__start_process()
def icon(request, product_name): """ Возвращает иконку (бинарное содерживое файла) для продукта """ # находим путь к иконке core = Core.get_instance() product = core.feed.get_product(product_name) icon_path = product.icon if not icon_path: raise Http404() # если путь урл — отсылаеи редирект if icon_path.startswith('http'): return HttpResponseRedirect(icon_path) if not os.path.exists(icon_path): # такого пути нет - 404 raise Http404() # получаем миме-тип иконки mimetype = mimetypes.guess_type(os.path.basename(icon_path))[0] # читаем содержимое файла иконки with open(icon_path, 'rb') as fh: response = HttpResponse(body=fh.read()) # ставим кеширующий хидер response["Content-Type"] = mimetype response['Cache-Control'] = 'public,max-age=3600' return response
def website_create(request): """ хендлер для запроса, создать сайт создает и возвращает сайт, или ошибка :param request: :return: """ if request.method != 'POST': return HttpResponseNotAllowed(['POST']) req = json_request(request) name = req['name'] ip_address = req['ip_address'] port = req['port'] hostname = req['hostname'] # 127.0.0.1:8085:localhost1.helicontech.com binding = 'http/{0}:{1}:{2}'.format(ip_address, port, hostname) core = Core.get_instance() try: path = core.api.os.web_server.create_physical_path_for_virtual_path( name) core.api.os.web_server.site_create(name, path, binding) website_object = core.api.os.web_server.get_site(name) response = {'error': None, 'website': website_object.to_dict()} except Exception as e: response = {'error': str(e), 'website': None} return response
class Message: def __init__(self): self._core = Core() self._response = self._core.response def response(self, _id, _text): try: self._core.buffer(_id, _text) if self._core.isExc(_id, _text): self._response = self._core.response else: return None except: return None return self._response
def uninstall_program(program, log_path, version=None, ignore_exit_code=False, no_wait=False): """ Uninstall MSI by program name :param program: object of type InstalledProductInfo() :param version: program version to uninstall :param log_path: :param ignore_exit_code: :return: """ if program.guid is None: raise Exception("Can't uninstall program. No program.guid.") command = r'msiexec.exe /norestart /q /X{0} /l! "{1}"'.format( program.guid, log_path) exit_code = Core.get_instance().api.os.shell.cmd(command, ignore_exit_code=True, no_wait=no_wait) if exit_code == 3010: # Reboot required code logging.warning( 'WARNING: Installation requested a system reboot.\nYou may need to reboot the system manually to complete this installation.' ) elif exit_code != 0 and not ignore_exit_code: # Other errors rise exception raise RuntimeError('Installation "{0}" failed: ({1}) {2}'.format( program.name, exit_code, win32api.FormatMessageW(exit_code))) return exit_code
def cmd(command, ignore_exit_code=False, envs=None, no_wait=False): """ Run command via subprocess and return exit code """ logging.info('> {0}'.format(command)) # This code is needed to start 64-bit version of cmd.exe on 64-bit os. # Not sure yet which version is correct if platform.machine().find('64') > 0 and not sys.maxsize > 2**32: executable = '{0}\Sysnative\cmd.exe /C "{1}"'.format(os.getenv('SystemRoot'), command) else: executable = '{0}\System32\cmd.exe /C "{1}"'.format(os.getenv('SystemRoot'), command) if not envs: envs = os.environ envs['PATH'] = Core.get_instance().expandvars(envs['PATH']) # exit_code = subprocess.check_call(executable, env=envs, stdout=sys.stdout, stderr=sys.stderr, shell=True) process = subprocess.Popen(executable, env=envs, stdout=sys.stdout, stderr=sys.stderr) # exit if do not need to wait process if no_wait: return 0 process.wait() exit_code = process.returncode if exit_code != 0 and not ignore_exit_code: try: str_error = os.strerror(exit_code) except (OverflowError, ValueError): str_error = "" # raise error if exit code is not 0 raise RuntimeError('Execute of command "{0}" failed: ({1}) {2}'.format(command, exit_code, str_error )) return exit_code
def __init__(self, product_names: list=None, feed=None, feeds=None, ready_json=False, fail_on_product_not_found=True ): """ :type feed: Feed :param product_names: string list of product names :param feed: core.storage.feed for installed products (uninstall process), core.feed for all products """ from core.core import Core self.core = Core.get_instance() self.feeds = [] if feed: self.feeds.append(feed) if feeds: self.feeds.extend(feeds) if len(self.feeds) == 0: self.feeds.append(self.core.feed) self.fail_on_product_not_found = fail_on_product_not_found self.coll = [] if ready_json: for dict_product in product_names: self.add_product_from_json(dict_product) else: if product_names : for name in product_names: self.add_by_name(name)
def load_yaml(self): logging.debug("Loading from '{0}'".format(self.url)) try: headers = { 'User-Agent': 'Zoo Agent {0}; {1}'.format( VERSION, Core.get_instance().settings.get_platform().__repr__()) } req = request.Request(self.url, headers=headers) stream = request.urlopen(req) # stream = request.urlopen(self.url, headers = headers) except Exception as ex: raise RuntimeError('Could not load url {0}'.format( self.url)) from ex # TODO move to yaml_helper items = yaml.load( stream, # TODO: read Last-Modified header yaml_loader.YamlLoader) self.patch_file_path(items) if items is None: items = [] return items
def logs(request): """ Возвращает размер директории логов. """ return { 'size': Core.get_instance().get_logs_size() }
def cache(request): """ Возвращает размер директории кеша. """ return { 'size': Core.get_instance().get_cache_size() }
def install(filename, log_path, optional_parameters: dict = None, ignore_exit_code=False, no_wait=False): """ Install MSI with options :param filename: :param log_path: :param optional_parameters: :param ignore_exit_code: :param no_wait: """ command = r'msiexec.exe /norestart /q /i "{0}" /l! "{1}" ALLUSERS=1'.format( filename, log_path) if optional_parameters: for k, v in optional_parameters.items(): if v and v != "": command += ' {0}="{1}"'.format(k, v) exit_code = Core.get_instance().api.os.shell.cmd(command, ignore_exit_code=True, no_wait=no_wait) if exit_code == 3010: # Reboot required code logging.warning( 'WARNING: Installation requested a system reboot.\nYou may need to reboot the system manually to complete this installation.' ) elif exit_code != 0 and not ignore_exit_code: # Other errors rise exception raise RuntimeError('Installation "{0}" failed: ({1}) {2}'.format( filename, exit_code, win32api.FormatMessageW(exit_code))) return exit_code
def __init__(self, product_names: list = None, feed=None, feeds=None, ready_json=False, fail_on_product_not_found=True): """ :type feed: Feed :param product_names: string list of product names :param feed: core.storage.feed for installed products (uninstall process), core.feed for all products """ from core.core import Core self.core = Core.get_instance() self.feeds = [] if feed: self.feeds.append(feed) if feeds: self.feeds.extend(feeds) if len(self.feeds) == 0: self.feeds.append(self.core.feed) self.fail_on_product_not_found = fail_on_product_not_found self.coll = [] if ready_json: for dict_product in product_names: self.add_product_from_json(dict_product) else: if product_names: for name in product_names: self.add_by_name(name)
def install_application(request, app_name): """ Этот вызов используется для передать в веб-интерфейс дерево зависимостей для первого шага install application Возвращает продукты необходимые для установки Application для запуска инсталяции используется стандартный вызов install Примеры запросов и ответов: начальный запрос: """ req = json_request(request) # это начальный запрос? dm = DependencyManager() core = Core.get_instance() # продукты, которые запрошены на установку (без зависимостей) requested_products = [app_name] if len(requested_products) > 1: raise RuntimeError("You are able to install only one application") application_item = [dm.get_dependencies(product_name) for product_name in requested_products] resp = {'task': None, "state": "requirements", 'items': application_item} return resp
def check_webserver_installed(req): core = Core.get_instance() server = core.platform.web_server if not isinstance(core.api.os.web_server, NoWebServer): if server == "iisexpress" or server == "iis": if os.path.exists(core.api.os.web_server.APP_CMD): return {"status": True, "server": server} return {"status": False, "server": server}
def update(request): """ Запускает апгрейд ядра и редиректит на главную, где показывает процесс создания нового ядра. """ core = Core.get_instance() core_loader = CoreLoader.get_instance() core_loader.restart(core.settings) return HttpResponseRedirect("/")
def setDbServer(self, dbServer): if (dbServer == SqoopModel.PRODUCT_DB): self.dbServer = { 'mysql_host': self.systemConf['mysql_produce_db']['host'], 'mysql_user': self.systemConf['mysql_produce_db']['user'], 'mysql_password': self.systemConf['mysql_produce_db']['password'], 'mysql_port': self.systemConf['mysql_produce_db']['port'], } self.dbServerModel = Core.getModelInterface('ProduceDb') elif (dbServer == SqoopModel.DW_DB): self.dbServer = { 'mysql_host': self.systemConf['mysql_bi_db']['host'], 'mysql_user': self.systemConf['mysql_bi_db']['user'], 'mysql_password': self.systemConf['mysql_bi_db']['password'], 'mysql_port': self.systemConf['mysql_bi_db']['port'], } self.dbServerModel = Core.getModelInterface('BiDb')
def pool_list(request): """ Хендлер. Получить список пулов ииса :param request: :return: """ core = Core.get_instance() pools = core.api.os.web_server.get_app_pool_list() return [pool.to_dict() for pool in pools]
def __init__(self, *kargs, **kargws): self.path = kargws["path"] self.task_id = kargws["task_id"] self.working_path = InstallLogReader.generate_path_name(self.path, self.task_id) self.watching_list = {} self.last_modified = None self.core = Core.get_instance() if not self.core.api.os.shell.ensure_exists(self.working_path): self.core.api.os.shell.make_dir(self.working_path)
def test_module_receives_all_events(self): ai = Core() module = AllEventsModule() ai.add_module(module) ai.boot() ai.publish(EventTypeA(content="a")) ai.publish(EventTypeB(content="b")) self.assertEqual(['a', 'b'], module.received_events)
def __init__(self, path): """ подготовить окружение к запуску дочернего процесса нужно - загрузить .zoo - найти на каком энжайне он работает - найти энжайн - взять текущие переменные окружения - взять переменные окружения энжайна - взять переменные окружения .zoo - раскрыть все переменные окружения запустить дочерний процесс :param path: """ self.path = path self.core = Core.get_instance() self.physical_path = self.core.api.os.web_server.map_webserver_path(self.path) self.zoo_config = self.core.api.os.web_server.get_zoo_config(self.physical_path) self.env = os.environ.copy() # emulate zoo module variables self.env["INSTANCE_ID"] = "0" self.env["APPL_PHYSICAL_PATH"] = self.physical_path self.env["APPL_PHYSICAL_SHORT_PATH"] = self.core.api.os.shell.get_short_path_name(self.physical_path) self.env["APPL_VIRTUAL_PATH"] = self.path self.env["APPL_ID"] = self.env["APPL_VIRTUAL_PATH"].replace("/","") #self.env["IIS_BINDNGS"] = self.core.api.os.web_server.get_site() if self.zoo_config: if self.zoo_config['engine']: engine_config = self.core.engine_storage.get_product(self.zoo_config['engine']).config if engine_config: if 'environment_variables' in engine_config: engine_env = engine_config.get('environment_variables') self.update_env(self.env, engine_env) if 'environment_variables' in self.zoo_config: app_env = self.zoo_config.get('environment_variables') self.update_env(self.env, app_env) self.env = self.expand_variables_in_dict(self.env) self.process = None self.std_out = "" self.std_err = "" self.stdout_reader = None self.stderr_reader = None self.timestamp = 0 self.start()
def main(): banner() parser = argparse.ArgumentParser(description='UserFinder v1.0.1') parser.add_argument('-u', '--url', type=str, help='Crawl specific url', default=None) parser.add_argument('-n', '--name', type=str, help='Crawl specific name', default=None, required=True) parser.add_argument('-v', "--verbose", action='store_true', default=False) args = parser.parse_args() c = Core(name=args.name, url=args.url, verbose=args.verbose) c.run()
def website_launch(request): core = Core.get_instance() sites = core.api.os.web_server.get_list_of_sites() req = json_request(request) name = req['sitename'] url = req['url'] if core.platform.web_server == "iisexpress": core.api.os.web_server.launch_iis_express(name) return {"status": True}
def uninstall(filename, log_path, ignore_exit_code=False): """ Uninstall MSI with options :param filename: :param log_path: :param ignore_exit_code: :return: """ command = 'msiexec.exe /norestart /q /X "{0}" /log "{1}"'.format(filename, log_path) return Core.get_instance().api.os.shell.cmd(command, ignore_exit_code=ignore_exit_code)
def trigger(self, evaluation_type): for nc in self.network_configurations: for spec in self.background_specs: nc.setup_network_graph(mininet_setup_gap=1, synthesis_setup_gap=1) background = self.configure(nc, self.run_time, self.base_dir, spec, evaluation_type) exp = Core(self.run_time, nc, self.script_dir, self.base_dir, self.replay_pcaps_dir, self.base_dir + "/logs/" + str(nc.project_name) + "_" + evaluation_type + "_" + str(nc.link_latency) + "_" + str(spec), background[0], background[1], background[2]) exp.start_project()
def test_output_expression_result(self): class TestHelperBot(BaseModule): events: List[BaseEvent] def boot(self) -> None: self.events = [] self.subscribe(lambda event: self.events.append(event)) helper = TestHelperBot() bot = MathBot() ai = Core() ai.add_module(bot) ai.add_module(helper) ai.boot() ai.publish(TextInput('10+2')) self.assertIn(MathParsed(Addition(Constant(10), Constant(2))), helper.events) self.assertIn(TextOutput('The result is: 12.0'), helper.events)
def main() -> int: """ Define the project's mainline execution. Creates and interacts with the command line argument parser, `argparse`, in addition to setting the debugging standard project-wide, and initiating file processing with the `Core` module. This method exists largely as a pseudo-manager for keeping track of program flow and high-level return codes. """ # Define a program for the argument argparser argparser = argparse.ArgumentParser(description="C file parser for unique \ strings and their associated functions") # Verbosity is a boolean flag rather than the traditional level argparser.add_argument("-v", "--verbose", help="Set verbosity/\ debug level", action="store_true") # A user may specify n files as positional arguments argparser.add_argument("files", type=argparse.FileType("r"), nargs="+") # Grab the arguments from the command line args = argparser.parse_args() # Configures the hierarchical (root-level) logger instance # TODO: Granularity beyond ON/OFF may follow in future releases if args.verbose: logging.basicConfig(level=logging.DEBUG) # Create an instance of `Core`, which is responsible for managing # high level functionality and program flow mngr = Core() # Double check that the files specified on the command line are # in the proper mode and exist at the correct location Verifier.check_parsable(args.files) # Process each file, appending unique func:str pairs as found mngr.process_files(args.files) # Ultimately produce a final dictionary and convert to JSON mngr.generate_bundle() # Drop the JSON bundle to disk under the out/ directory mngr.export() return 0