def run(self): if os.path.isfile(self.kwargs['package']): old_level = logger.getEffectiveLevel() logger.setLevel(logging.ERROR) try: d = dapi.Dap(self.kwargs['package']) if not dapi.DapChecker.check(d): raise exceptions.ExecutionException( 'This DAP is not valid, info can\'t be displayed.') finally: logger.setLevel(old_level) logger.infolines( dapicli.format_local_dap(d, full=self.kwargs.get('full', False))) elif self.kwargs.get('installed'): try: logger.infolines( dapicli.format_installed_dap(self.kwargs['package'], full=self.kwargs.get( 'full', False))) except exceptions.DapiError as e: logger.error(utils.exc_as_decoded_string(e)) raise exceptions.ExecutionException( utils.exc_as_decoded_string(e)) else: try: logger.infolines( dapicli.format_dap_from_dapi(self.kwargs['package'], full=self.kwargs.get( 'full', False))) except exceptions.DapiError as e: logger.error(utils.exc_as_decoded_string(e)) raise exceptions.ExecutionException( utils.exc_as_decoded_string(e))
def run(self): pkgs = exs = [] try: pkgs = self.kwargs['package'] except KeyError: pkgs = dapicli.get_installed_daps() if pkgs: logger.info('Updating all DAP packages ...') else: logger.info( 'No installed DAP packages found, nothing to update.') for pkg in pkgs: logger.info('Updating DAP {pkg} ...'.format(pkg=pkg)) try: updated = dapicli.install_dap( pkg, update=True, update_allpaths=self.kwargs['allpaths'], force=self.kwargs['force']) if updated: logger.info( 'DAP {pkg} successfully updated.'.format(pkg=pkg)) else: logger.info( 'DAP {pkg} is already up to date.'.format(pkg=pkg)) except exceptions.DapiError as e: exs.append(utils.exc_as_decoded_string(e)) logger.error(utils.exc_as_decoded_string(e)) if exs: raise exceptions.ExecutionException('; '.join(exs))
def run(self): """Runs all errors, dependencies and run methods of all *Assistant objects in self.path. Raises: devassistant.exceptions.ExecutionException with a cause if something goes wrong """ self._logging() errors = self._run_path_errors() if errors: raise exceptions.ExecutionException(errors) self._run_path_dependencies() self._run_path_run()
def construct_arg(cls, name, params): """Construct an argument from name, and params (dict loaded from assistant/snippet). """ use_snippet = params.pop('use', None) if use_snippet: # if snippet is used, take this parameter from snippet and update # it with current params, if any try: problem = None snippet = yaml_snippet_loader.YamlSnippetLoader.get_snippet_by_name( use_snippet) # this works much like snippet.args.pop(arg_name).update(arg_params), # but unlike it, this actually returns the updated dict params = dict(snippet.args.pop(name), **params) # if there is SnippetNotFoundException, just let it be raised except KeyError: # snippet doesn't have the requested argument problem = 'Couldn\'t find arg {arg} in snippet {snip}.'.\ format(arg=name, snip=snippet.name) raise exceptions.ExecutionException(problem) if 'flags' not in params: msg = 'Couldn\'t find "flags" in arg {arg}'.format(arg=name) raise exceptions.ExecutionException(msg) return cls(name, *params.pop('flags'), **params)
def run(self): newargs = {} newargs['q'] = ' '.join(self.kwargs['query']) newargs['noassistants'] = self.kwargs['noassistants'] newargs['unstable'] = self.kwargs['unstable'] newargs['notactive'] = self.kwargs['deactivated'] newargs['minimal_rank'] = self.kwargs['minrank'] newargs['minimal_rank_count'] = self.kwargs['mincount'] if not self.kwargs['allplatforms']: newargs['platform'] = utils.get_distro_name() try: logger.infolines(dapicli.format_search(**newargs)) except exceptions.DapiError as e: logger.error(utils.exc_as_decoded_string(e)) raise exceptions.ExecutionException(utils.exc_as_decoded_string(e))
def run(self): error = False old_level = logger.getEffectiveLevel() for pkg in self.kwargs['package']: try: if self.kwargs['nowarnings']: logger.setLevel(logging.ERROR) d = dapi.Dap(pkg) if not dapi.DapChecker.check( d, network=self.kwargs['network'], yamls=not self.kwargs['noyamlcheck']): error = True except (exceptions.DapFileError, exceptions.DapMetaError) as e: logger.error(utils.exc_as_decoded_string(e)) error = True logger.setLevel(old_level) if error: raise exceptions.ExecutionException( 'One or more packages are not sane')
def run(self): exs = [] for pkg in self.kwargs['package']: logger.info('Installing DAP {pkg} ...'.format(pkg=pkg)) if os.path.isfile(pkg): method = dapicli.install_dap_from_path else: method = dapicli.install_dap try: pkgs = method(pkg, force=self.kwargs['force'], nodeps=self.kwargs['nodeps'], reinstall=self.kwargs['reinstall'], __ui__=self.kwargs['__ui__']) logger.info('Successfully installed DAPs {pkgs}'.format( pkgs=' '.join(pkgs))) except exceptions.DapiError as e: exs.append(utils.exc_as_decoded_string(e)) logger.error(utils.exc_as_decoded_string(e)) if exs: raise exceptions.ExecutionException('; '.join(exs))
def add_argument_to(self, parser): """Used by cli to add this as an argument to argparse parser. Args: parser: parser to add this argument to """ from devassistant.cli.devassistant_argparse import DefaultIffUsedActionFactory if isinstance(self.kwargs.get('action', ''), list): # see documentation of DefaultIffUsedActionFactory to see why this is necessary if self.kwargs['action'][0] == 'default_iff_used': self.kwargs[ 'action'] = DefaultIffUsedActionFactory.generate_action( self.kwargs['action'][1]) # In cli 'preserved' is not supported. # It needs to be removed because it is unknown for argparse. self.kwargs.pop('preserved', None) try: parser.add_argument(*self.flags, **self.kwargs) except Exception as ex: problem = "Error while adding argument '{name}': {error}".\ format(name=self.name, error=repr(ex)) raise exceptions.ExecutionException(problem)
def run(self): exs = [] uninstalled = [] for pkg in self.kwargs['package']: if pkg in uninstalled: logger.info('DAP {pkg} already uninstalled'.format(pkg=pkg)) continue logger.info('Uninstalling DAP {pkg} ...'.format(pkg=pkg)) try: done = dapicli.uninstall_dap(pkg, confirm=self.kwargs['force'], allpaths=self.kwargs['allpaths'], __ui__=self.kwargs['__ui__']) if done: logger.info('DAPs {pkgs} successfully uninstalled'.format( pkgs=' '.join(done))) uninstalled += done except exceptions.DapiError as e: exs.append(utils.exc_as_decoded_string(e)) logger.error(utils.exc_as_decoded_string(e)) if exs: raise exceptions.ExecutionException('; '.join(exs))
def run(self): dap = self.kwargs['dap'] doc = self.kwargs.get('doc', None) docdir = utils.find_file_in_load_dirs(os.path.join('doc', dap)) all_docs = [] if docdir is not None: all_docs = self._get_doc_files(docdir) if not all_docs: logger.info('DAP {0} has no documentation.'.format(dap)) elif doc is not None: doc_fullpath = os.path.join(docdir, doc) if doc_fullpath in all_docs: self._show_doc(doc_fullpath) else: msg = 'DAP {0} has no document "{1}".'.format(dap, doc) logger.error(msg) raise exceptions.ExecutionException(msg) else: logger.info('DAP {0} has these docs:'.format(dap)) for d in all_docs: logger.info(d[len(docdir):].strip(os.path.sep)) logger.info( 'Use "da doc {0} <DOC>" to see a specific document'.format( dap))