def __init__(self, prefixes=None, prompt_func=None, popen=None, event_handler=None): if not event_handler: event_handler = Reporter() if not popen: popen = RosePopener(event_handler=event_handler) self.event_handler = event_handler self.popen = popen self.prompt_func = prompt_func self.prefixes = [] self.unreachable_prefixes = [] self.auth_managers = {} conf = ResourceLocator.default().get_conf() conf_rosie_id = conf.get(["rosie-id"], no_ignore=True) if conf_rosie_id is None: raise RosieWSClientConfError() for key, node in conf_rosie_id.value.items(): if node.is_ignored() or not key.startswith("prefix-ws."): continue prefix = key.replace("prefix-ws.", "") self.auth_managers[prefix] = RosieWSClientAuthManager( prefix, popen=self.popen, prompt_func=self.prompt_func) if not prefixes: prefixes_str = conf_rosie_id.get_value(["prefixes-ws-default"]) if prefixes_str: prefixes = shlex.split(prefixes_str) else: prefixes = sorted(self.auth_managers.keys()) self.set_prefixes(prefixes)
def main(): """Launcher for the CLI.""" opt_parser = RoseOptionParser() opt_parser.add_my_options('name') opts, args = opt_parser.parse_args(sys.argv[1:]) event_handler = Reporter(opts.verbosity - opts.quietness) suite_vc_cmp = SuiteVCComparator(event_handler) suite_name = opts.name if not suite_name and args: suite_name = args[0] if not suite_name: suite_name = os.getenv(suite_vc_cmp.suite_engine_proc.SUITE_NAME_ENV) if not suite_name: opt_parser.print_usage(sys.stderr) sys.exit(2) try: lines = suite_vc_cmp.cmp_source_vc_info(suite_name=suite_name) except Exception as exc: event_handler(exc) traceback.print_exc() sys.exit(2) else: if lines is None: event_handler( '%s: rose-suite-run.version: VC info not found' % ( suite_name), kind=Reporter.KIND_ERR, level=Reporter.FAIL) sys.exit(2) lines = list(line for line in lines) for line in lines: event_handler('%s\n' % line, prefix='') if lines: sys.exit(1) else: sys.exit(0)
def checkout(): """CLI function: checkout.""" opt_parser = RoseOptionParser( usage='rosie checkout [OPTIONS] ID ...', description=''' Checkout local copies of suites. For each `ID` in the argument list, checkout a working copy of the suite identified by `ID` to the standard location. ''', ).add_my_options("force_mode") opt_parser.modify_option( 'force_mode', help=('If working copy for suite identified by `ID` already exists,' ' remove it. Continue to the next `ID` if checkout of a suite' ' fails.'), ) opts, args = opt_parser.parse_args() verbosity = opts.verbosity - opts.quietness report = Reporter(verbosity) client = RosieVCClient(event_handler=report, force_mode=opts.force_mode) SuiteId.svn.event_handler = client.event_handler ret_code = 0 for arg in args: try: client.checkout(arg) except (FileExistError, RosePopenError, SuiteIdPrefixError) as exc: ret_code = 1 report(exc) if not opts.force_mode: sys.exit(1) if ret_code: sys.exit(ret_code)
def delete(): """CLI function: delete.""" opt_parser = RoseOptionParser(usage='rosie delete [OPTIONS] [--] [ID ...]', description=''' Delete suites. Check the standard working copy location for a checked out suite matching `ID` and remove it if there is no uncommitted change (or if `--force` is specified). Delete the suite directory structure from the HEAD of the central repository matching the `ID`. If no `ID` is specified and `$PWD` is a working copy of a suite, use the `ID` of the suite in the working copy. ''').add_my_options("force_mode", "non_interactive", "local_only") opt_parser.modify_option( 'force_mode', help=("Remove working copies even if there are uncommitted changes." "\nContinue with the next `ID` if delete of a suite fails."), ) opts, args = opt_parser.parse_args() report = Reporter(opts.verbosity - opts.quietness) client = RosieVCClient(event_handler=report, force_mode=opts.force_mode) SuiteId.svn.event_handler = client.event_handler if not args: args.append(SuiteId(location=os.getcwd())) interactive_mode = not opts.non_interactive prompt = PROMPT_DELETE if opts.local_only: prompt = PROMPT_DELETE_LOCAL ret_code = 0 for arg in args: if interactive_mode: try: response = input(prompt % arg) except EOFError: ret_code = 1 continue if response == YES_TO_ALL: interactive_mode = False elif response != YES: ret_code = 1 continue if opts.debug_mode: client.delete(arg, opts.local_only) else: try: client.delete(arg, opts.local_only) except ( LocalCopyStatusError, RosePopenError, SuiteIdPrefixError, ) as exc: client.event_handler(exc) ret_code = 1 if not opts.force_mode: sys.exit(1) if ret_code: sys.exit(ret_code)
def lookup(argv): """CLI command to run the various search types""" opt_parser = RoseOptionParser().add_my_options( "address_mode", "all_revs", "lookup_mode", "no_headers", "prefixes", "print_format", "query_mode", "reverse", "search_mode", "sort") opts, args = opt_parser.parse_args(argv) if not args: sys.exit(opt_parser.print_usage()) if not opts.lookup_mode: if args[0].startswith("http"): opts.lookup_mode = "address" else: opts.lookup_mode = "search" ws_client = RosieWSClient( prefixes=opts.prefixes, event_handler=Reporter(opts.verbosity - opts.quietness)) try: if opts.lookup_mode == "address": data_and_url_list = ws_client.address_lookup(url=args[0]) elif opts.lookup_mode == "query": q_items = ws_client.query_split(args) for i, q_item in enumerate(q_items): q_items[i] = " ".join(q_item) data_and_url_list = ws_client.query( q_items, all_revs=int(opts.all_revs)) else: # if opts.lookup_mode == "search": data_and_url_list = ws_client.search( args, all_revs=int(opts.all_revs)) except RosieWSClientError as exc: if opts.debug_mode: traceback.print_exc() sys.exit(str(exc)) for data, url in data_and_url_list: _display_maps(opts, ws_client, data, url)
def main(): """Implement "rose suite-shutdown".""" argv = sys.argv[1:] method_name = argv.pop(0) opt_parser = RoseOptionParser() opt_parser.add_my_options("name", "non_interactive") opts, args = opt_parser.parse_args(argv) event_handler = Reporter(opts.verbosity - opts.quietness) suite_control = SuiteControl(event_handler=event_handler) method = getattr(suite_control, method_name) confirm = None suite_names = [] if not opts.non_interactive: confirm = prompt else: if opts.name: suite_names.append(opts.name) else: try: suite_name = get_suite_name(event_handler) suite_names.append(suite_name) except SuiteNotFoundError as exc: event_handler(exc) sys.exit(1) if opts.debug_mode: for sname in suite_names: method(sname, confirm, sys.stderr, sys.stdout, *args) else: for sname in suite_names: try: method(sname, confirm, sys.stderr, sys.stdout, *args) except Exception as exc: event_handler(exc) sys.exit(1)
def main(): """Implement "rose suite-hook" command.""" opt_parser = RoseOptionParser() opt_parser.add_my_options("mail_cc", "mail", "retrieve_job_logs", "shutdown") opts, args = opt_parser.parse_args() for key in ["mail_cc"]: values = [] if getattr(opts, key): for value in getattr(opts, key): values.extend(value.split(",")) setattr(opts, key, values) report = Reporter(opts.verbosity - opts.quietness - 1) # Reduced default popen = RosePopener(event_handler=report) suite_engine_proc = SuiteEngineProcessor.get_processor( event_handler=report, popen=popen) args = suite_engine_proc.process_suite_hook_args(*args, **vars(opts)) hook = RoseSuiteHook(event_handler=report, popen=popen, suite_engine_proc=suite_engine_proc) hook(*args, should_mail=opts.mail, mail_cc_list=opts.mail_cc, should_shutdown=opts.shutdown, should_retrieve_job_logs=opts.retrieve_job_logs)
def main(): """Implement the "rose config-dump" command.""" opt_parser = RoseOptionParser() opt_parser.add_my_options("conf_dir", "files", "no_pretty_mode") opts = opt_parser.parse_args()[0] verbosity = opts.verbosity - opts.quietness report = Reporter(verbosity) fs_util = FileSystemUtil(report) if opts.conf_dir: fs_util.chdir(opts.conf_dir) file_names = [] if opts.files: file_names = opts.files else: for dirpath, _, filenames in os.walk("."): for filename in fnmatch.filter(filenames, "rose-*.conf"): path = os.path.join(dirpath, filename)[2:] # remove leading ./ file_names.append(path) for file_name in file_names: handle = NamedTemporaryFile() node = ConfigLoader()(file_name) if (not opts.no_pretty_mode and os.path.basename(file_name) != META_CONFIG_NAME): pretty_format_config(node, ignore_error=True) ConfigDumper()(node, handle) handle.seek(0) if not filecmp.cmp(handle.name, file_name, shallow=False): report(ConfigDumpEvent(file_name)) ConfigDumper()(node, file_name)
def main(): """rose task-env.""" opt_parser = RoseOptionParser() opt_parser.add_my_options("cycle", "cycle_offsets", "path_globs", "prefix_delim", "suffix_delim") opts, args = opt_parser.parse_args() report = Reporter(opts.verbosity - opts.quietness - 1) suite_engine_proc = SuiteEngineProcessor.get_processor( event_handler=report) kwargs = dict(vars(opts)) try: task_props = suite_engine_proc.get_task_props(*args, **kwargs) for key, value in task_props: report(str(EnvExportEvent(key, value)) + "\n", level=0) path_globs = opts.path_globs if path_globs is None: path_globs = [] prepend_paths_map = get_prepend_paths(report, task_props.suite_dir, path_globs, full_mode=True) for key, prepend_paths in prepend_paths_map.items(): orig_paths = [] orig_v = os.getenv(key, "") if orig_v: orig_paths = orig_v.split(os.pathsep) path = os.pathsep.join(prepend_paths + orig_paths) report(str(EnvExportEvent(key, path)) + "\n", level=0) except Exception as exc: report(exc) if opts.debug_mode: traceback.print_exc() sys.exit(1)
def rose_env_cat(args, opts): if not args: args = ["-"] if not opts.output_file or opts.output_file == "-": out_handle = sys.stdout else: out_handle = open(opts.output_file, "w") for arg in args: if arg == "-": in_handle = sys.stdin else: try: in_handle = open(arg) except FileNotFoundError as exc: Reporter().report(exc) if opts.debug_mode: raise exc return line_num = 0 while True: line_num += 1 line = in_handle.readline() if not line: break try: out_handle.write( env_var_process(line, opts.unbound, opts.match_mode)) except UnboundEnvironmentVariableError as exc: name = arg if arg == "-": name = "<STDIN>" sys.exit("%s:%s: %s" % (name, line_num, str(exc))) in_handle.close() out_handle.close()
def hello(argv): """Set up connection to a Rosie web service.""" opt_parser = RoseOptionParser().add_my_options("prefixes") opts = opt_parser.parse_args(argv)[0] report = Reporter(opts.verbosity - opts.quietness) ws_client = RosieWSClient(prefixes=opts.prefixes, event_handler=report) for response_data, response_url in ws_client.hello(): report("%s: %s" % (response_url, response_data), level=0)
def __init__(self, event_handler=None, popen=None): if event_handler is None: event_handler = Reporter() self.event_handler = event_handler if popen is None: popen = RosePopener(self.event_handler) self.popen = popen self.path = os.path.dirname( os.path.dirname(sys.modules["metomi.rosie"].__file__))
def rose_fileinstall(srcdir=None, opts=None, rundir=None): """Call Rose Fileinstall. Args: srcdir(pathlib.Path): Search for a ``rose-suite.conf`` file in this location. rundir (pathlib.Path) """ if not rose_config_exists(rundir, opts): return False # Load the config tree config_tree = rose_config_tree_loader(rundir, opts) if any(i.startswith('file') for i in config_tree.node.value): try: startpoint = os.getcwd() os.chdir(rundir) except FileNotFoundError as exc: raise exc else: # Carry out imports. import asyncio from metomi.rose.config_processor import ConfigProcessorsManager from metomi.rose.popen import RosePopener from metomi.rose.reporter import Reporter from metomi.rose.fs_util import FileSystemUtil # Update config tree with install location # NOTE-TO-SELF: value=os.environ["CYLC_WORKFLOW_RUN_DIR"] config_tree.node = config_tree.node.set( keys=["file-install-root"], value=str(rundir) ) # Artificially set rose to verbose. event_handler = Reporter(3) fs_util = FileSystemUtil(event_handler) popen = RosePopener(event_handler) # Get an Asyncio loop if one doesn't exist: # Rose may need an event loop to invoke async interfaces, # doing this here incase we want to go async in cylc-rose. # See https://github.com/cylc/cylc-rose/pull/130/files try: asyncio.get_event_loop() except RuntimeError: asyncio.set_event_loop(asyncio.new_event_loop()) # Process fileinstall. config_pm = ConfigProcessorsManager(event_handler, popen, fs_util) config_pm(config_tree, "file") finally: os.chdir(startpoint) return config_tree.node
def __init__(self, event_handler=None, popen=None): if event_handler is None: event_handler = Reporter() self.event_handler = event_handler if popen is None: popen = RosePopener(self.event_handler) self.popen = popen path = os.path.dirname( os.path.dirname(sys.modules["metomi.rosie"].__file__)) self.usertools_manager = SchemeHandlersManager([path], "rosie.usertools", ["get_emails"])
def main(): """Launcher for the CLI.""" opt_parser = metomi.rose.opt_parse.RoseOptionParser() opt_parser.add_my_options() opts, args = opt_parser.parse_args(sys.argv[1:]) reporter = Reporter(opts.verbosity - opts.quietness) is_top_level = False if len(args) > 1: reporter.report('Only one argument accepted\n', level=Reporter.FAIL) sys.exit(1) if len(args) == 0: key = ROSE_INSTALL_ROOT / 'etc' path = ResourceLocator(paths=[ROSE_INSTALL_ROOT]).locate('etc') is_top_level = True else: key = args[0] try: path = ResourceLocator().locate(key) except ResourceError: reporter.report('Resource not found\n', level=Reporter.FAIL) sys.exit(1) if path.is_file(): print(path) elif path.is_dir(): print(f'{key}/') for item in path.iterdir(): if is_top_level: item = item.relative_to(path) else: item = item.relative_to(path.parent) print(f' {item}')
def upgrade_offset(offset: str) -> str: """Convert offset values in the legacy format Args: offset: offset matching [0-9]+[wdhms] Returns: Offset in isodate compatible format. URL: https://github.com/metomi/rose/issues/2577 Examples: >>> upgrade_offset('1w') [WARN] This offset syntax 1w is deprecated: Using P7DT0H0M0S 'P7DT0H0M0S' >>> upgrade_offset('1w1d1h') [WARN] This offset syntax 1w1d1h is deprecated: Using P8DT1H0M0S 'P8DT1H0M0S' >>> upgrade_offset('1h1d') [WARN] This offset syntax 1h1d is deprecated: Using P1DT1H0M0S 'P1DT1H0M0S' """ sign = '-' if offset[0] == '-' else '' offsets = LEGACY_OFFSET.findall(offset) offsets = {unit.upper(): number for number, unit in offsets} # Rose 2019 did not make any distinction between 1s1m and 1m1s, # so we do an implicit sort here: weeks, days, hours, minutes, seconds = [0 for _ in range(5)] for unit, value in offsets.items(): if unit == 'W': weeks = int(value) if unit == 'D': days = int(value) if unit == 'H': hours = int(value) if unit == 'M': minutes = int(value) if unit == 'S': seconds = int(value) days = days + weeks * 7 result = f'{sign}P{days}DT{hours}H{minutes}M{seconds}S' Reporter().report( f'This offset syntax {offset} is deprecated: Using {result}', prefix=Reporter.PREFIX_WARN, level=Reporter.WARN) return result
def main(): """Launcher for the CLI.""" opt_parser = RoseOptionParser( usage='rose task-run [OPTIONS] [--] [APP-COMMAND ...]', description=''' Provide an environment to run a suite task. Provides environment variables documented in `rose task-env`. It is worth noting that if the environment variables are already provided by `rose task-env`, this command will not override them. Normally, the suite task will select a Rose application configuration that has the same name as the task. This can be overridden by the `--app-key=KEY` option or the `ROSE_TASK_APP` environment variable. SHORT OPTIONS All options of `rose app-run` and `rose task-env` are supported. Additional options are: --app-key=KEY Specify a named application configuration. ''', epilog=''' ENVIRONMENT VARIABLES All environment variables of `rose app-run` and `rose task-env` are supported. All environment variables documented in `rose task-env` are passed to the application `rose task-run` runs. The following environment variables are used by `rose task-run`: ROSE_TASK_APP Specify a named application configuration. SEE ALSO * `rose app-run` * `rose task-env` ''', ) option_keys = TaskRunner.OPTIONS opt_parser.add_my_options(*option_keys) opts, args = opt_parser.parse_args() event_handler = Reporter(opts.verbosity - opts.quietness) runner = TaskRunner(event_handler) try: sys.exit(runner(opts, args)) except Exception as exc: runner.handle_event(exc) if opts.debug_mode: traceback.print_exc() if isinstance(exc, RosePopenError): sys.exit(exc.ret_code) else: sys.exit(1)
def main(): """Launcher for the CLI.""" opt_parser = RoseOptionParser( usage='%prog [OPTIONS] [--] [COMMAND ...]', description=''' Run an application according to its configuration. May run a builtin application (if the `mode` setting in the configuration specifies the name of a builtin application) or a command. Determine the command to run in this order: 1. If `COMMAND` is specified, invoke the command. 2. If the `--command-key=KEY` option is defined, invoke the command specified in `[command]KEY`. 3. If the `ROSE_APP_COMMAND_KEY` environment variable is set, the command specified in the `[command]KEY` setting in the application configuration whose `KEY` matches it is used. 4. If the environment variable `ROSE_TASK_NAME` is defined and a setting in the `[command]` section has a key matching the value of the environment variable, then the value of the setting is used as the command. 5. Invoke the command specified in `[command]default`. ''', epilog=''' ENVIRONMENT VARIABLES optional ROSE_APP_COMMAND_KEY Switch to a particular command specified in `[command]KEY`. optional ROSE_APP_MODE Specifies a builtin application to run. optional ROSE_APP_OPT_CONF_KEYS Each `KEY` in this space delimited list switches on an optional configuration. The configurations are applied first-to-last. optional ROSE_FILE_INSTALL_ROOT If specified, change to the specified directory to install files. ''' ) option_keys = AppRunner.OPTIONS opt_parser.add_my_options(*option_keys) opts, args = opt_parser.parse_args() event_handler = Reporter(opts.verbosity - opts.quietness) runner = AppRunner(event_handler) try: sys.exit(runner(opts, args)) except Exception as exc: runner.handle_event(exc) if opts.debug_mode: traceback.print_exc() if isinstance(exc, RosePopenError): sys.exit(exc.ret_code) else: sys.exit(1)
def main(): """Launcher for the CLI.""" opt_parser = metomi.rose.opt_parse.RoseOptionParser( usage='rose resource RESOURCE_PATH', description=''' Display the path of resources in the Rose Python installation. * If the requested resource exists and is a file its path is printed. * If the requested resource exists and is a directory it is listed. Provide no arguments to see a list of top-level resources. EXAMPLES # List top-level resources: $ rose resource # List the contents of the "syntax" directory: $ rose resource syntax # Extract the Rose syntax file for the Vim text editor: $ rose resource syntax/rose-conf.vim ''', epilog=''' ARGUMENTS RESOURCE_PATH Path of the resource to extract. Run `rose resource` to see the list of resources. ''', ) opt_parser.add_my_options() opts, args = opt_parser.parse_args() reporter = Reporter(opts.verbosity - opts.quietness) is_top_level = False if len(args) > 1: reporter.report('Only one argument accepted\n', level=Reporter.FAIL) sys.exit(1) if len(args) == 0: key = ROSE_INSTALL_ROOT / 'etc' path = ResourceLocator(paths=[ROSE_INSTALL_ROOT]).locate('etc') is_top_level = True else: key = args[0] try: path = ResourceLocator().locate(key) except ResourceError: reporter.report('Resource not found\n', level=Reporter.FAIL) sys.exit(1) if path.is_file(): print(path) elif path.is_dir(): print(f'{key}/') for item in path.iterdir(): if is_top_level: item = item.relative_to(path) else: item = item.relative_to(path.parent) print(f' {item}')
def main(): """Implement "rosa svn-post-commit".""" opt_parser = RoseOptionParser() opts, args = opt_parser.parse_args() report = Reporter(opts.verbosity - opts.quietness) hook = RosieSvnPostCommitHook(report) try: repos, revision = args[0:2] hook.run(repos, revision) except Exception as exc: report(exc) if opts.debug_mode: traceback.print_exc() sys.exit(1)
def main(): """rosa db-create.""" db_conf = ResourceLocator.default().get_conf().get(["rosie-db"]) if db_conf is not None: opts = RoseOptionParser().parse_args()[0] reporter = Reporter(opts.verbosity - opts.quietness) init = RosieDatabaseInitiator(event_handler=reporter) conf = ResourceLocator.default().get_conf() for key in db_conf.value: if key.startswith("db."): prefix = key.replace("db.", "", 1) db_url = conf.get_value(["rosie-db", "db." + prefix]) repos_path = conf.get_value(["rosie-db", "repos." + prefix]) init(db_url, repos_path)
def __init__(self, event_handler=None, host_selector=None, suite_engine_proc=None): if event_handler is None: event_handler = Reporter() self.event_handler = event_handler if host_selector is None: host_selector = HostSelector(event_handler=event_handler) self.host_selector = host_selector if suite_engine_proc is None: suite_engine_proc = SuiteEngineProcessor.get_processor( event_handler=event_handler) self.suite_engine_proc = suite_engine_proc
def main(): """Implement "rosa svn-pre-commit".""" add_meta_paths() opt_parser = RoseOptionParser() opts, args = opt_parser.parse_args() repos, txn = args report = Reporter(opts.verbosity - opts.quietness) hook = RosieSvnPreCommitHook(report) try: hook(repos, txn) except Exception as exc: report(exc) if opts.debug_mode: traceback.print_exc() sys.exit(1)
def main(): """Implement "rose date".""" opt_parser = RoseOptionParser() opt_parser.add_my_options( "calendar", "diff", "offsets1", "offsets2", "parse_format", "print_format", "task_cycle_time_mode", "as_total", "utc_mode", ) opts, args = opt_parser.parse_args() report = Reporter(opts.verbosity - opts.quietness) ref_point_str = None if opts.task_cycle_time_mode: ref_point_str = os.getenv(RoseDateTimeOperator.TASK_CYCLE_TIME_ENV) if ref_point_str is None: exc = UnboundEnvironmentVariableError( RoseDateTimeOperator.TASK_CYCLE_TIME_ENV) report(exc) if opts.debug_mode: raise exc sys.exit(1) date_time_oper = RoseDateTimeOperator( parse_format=opts.parse_format, utc_mode=opts.utc_mode, calendar_mode=opts.calendar, ref_point_str=ref_point_str, ) try: if len(args) < 2: if opts.duration_print_format: _convert_duration(date_time_oper, opts, args) else: _print_time_point(date_time_oper, opts, args) else: _print_duration(date_time_oper, opts, args) except OffsetValueError as exc: report(exc) if opts.debug_mode: raise exc sys.exit(1)
def __init__(self, opts, reporter=None, popen=None, fs_util=None): self.opts = opts if reporter is None: self.reporter = Reporter(opts.verbosity - opts.quietness) else: self.reporter = reporter if popen is None: self.popen = RosePopener(event_handler=self.reporter) else: self.popen = popen if fs_util is None: self.fs_util = FileSystemUtil(event_handler=self.reporter) else: self.fs_util = fs_util self.host_selector = HostSelector(event_handler=self.reporter, popen=self.popen)
def main(): """Implement "rose suite-log" CLI.""" opt_parser = RoseOptionParser() opt_parser.add_my_options("archive_mode", "force_mode", "name", "non_interactive", "prune_remote_mode", "update_mode", "user", "view_mode") opts, args = opt_parser.parse_args() report = Reporter(opts.verbosity - opts.quietness) try: suite_log_view(opts, args, report) except Exception as exc: report(exc) if opts.debug_mode: traceback.print_exc() sys.exit(1)
def rose_fileinstall(srcdir=None, opts=None, rundir=None): """Call Rose Fileinstall. Args: srcdir(pathlib.Path): Search for a ``rose-suite.conf`` file in this location. rundir (pathlib.Path) """ if not rose_config_exists(rundir, opts): return False # Load the config tree config_tree = rose_config_tree_loader(rundir, opts) if any(i.startswith('file') for i in config_tree.node.value): try: startpoint = os.getcwd() os.chdir(rundir) except FileNotFoundError as exc: raise exc else: # Carry out imports. from metomi.rose.config_processor import ConfigProcessorsManager from metomi.rose.popen import RosePopener from metomi.rose.reporter import Reporter from metomi.rose.fs_util import FileSystemUtil # Update config tree with install location # NOTE-TO-SELF: value=os.environ["CYLC_WORKFLOW_RUN_DIR"] config_tree.node = config_tree.node.set( keys=["file-install-root"], value=str(rundir) ) # Artificially set rose to verbose. event_handler = Reporter(3) fs_util = FileSystemUtil(event_handler) popen = RosePopener(event_handler) # Process files config_pm = ConfigProcessorsManager(event_handler, popen, fs_util) config_pm(config_tree, "file") finally: os.chdir(startpoint) return config_tree.node
def __init__( self, prefix, popen=None, prompt_func=None, event_handler=None ): self.prefix = prefix root = self._get_conf_value("ws") if root is None: raise UndefinedRosiePrefixWS(self.prefix) if not root.endswith("/"): root += "/" self.root = root urlparse_res = urlparse(self.root) self.scheme = urlparse_res[0] self.host = urlparse_res[1] self.password_orig = None self.username_orig = None self.password = None self.username = None if popen is None: popen = RosePopener() self.popen = popen self.prompt_func = prompt_func if event_handler is None: self.event_handler = Reporter() else: self.event_handler = event_handler res_loc = ResourceLocator.default() password_stores_str = ( res_loc.default() .get_conf() .get_value( keys=["rosie-id", "prefix-password-store." + self.prefix], default=self.PASSWORD_STORES_STR, ) ) for password_store_name in shlex.split(password_stores_str): password_store_cls = self.PASSWORD_STORE_CLASSES.get( password_store_name ) if password_store_cls is not None and password_store_cls.usable(): self.password_store = password_store_cls() break else: self.password_store = None self.requests_kwargs = {} self._init_https_params()
def main(): """Launcher for the CLI.""" opt_parser = RoseOptionParser() option_keys = AppRunner.OPTIONS opt_parser.add_my_options(*option_keys) opts, args = opt_parser.parse_args(sys.argv[1:]) event_handler = Reporter(opts.verbosity - opts.quietness) runner = AppRunner(event_handler) try: sys.exit(runner(opts, args)) except Exception as exc: runner.handle_event(exc) if opts.debug_mode: traceback.print_exc() if isinstance(exc, RosePopenError): sys.exit(exc.ret_code) else: sys.exit(1)
def list_local_suites(argv): """CLI command to list all the locally checked out suites""" opt_parser = RoseOptionParser().add_my_options( "no_headers", "prefixes", "print_format", "reverse", "sort", "user") opts = opt_parser.parse_args(argv)[0] report = Reporter(opts.verbosity - opts.quietness) if opts.user: alternative_roses_dir = SuiteId.get_local_copy_root(opts.user) report(UserSpecificRoses(alternative_roses_dir), prefix=None) ws_client = RosieWSClient(prefixes=opts.prefixes, event_handler=report) if ws_client.unreachable_prefixes: bad_prefix_string = " ".join(ws_client.unreachable_prefixes) report( RosieWSClientError( ERR_PREFIX_UNREACHABLE.format(bad_prefix_string))) _display_maps(opts, ws_client, ws_client.query_local_copies(opts.user))