def make_BareConfig(self): a = BareConfig() # Test components of the BareConfig class: self.test_url = 'https://api.gentoo.org/overlays/repositories.xml' assertEqual(a['overlay'], self.test_url) self.test_keys = [ 'bzr_addopts', 'bzr_command', 'bzr_postsync', 'bzr_syncopts', 'cache', 'config', 'configdir', 'custom_news_func', 'custom_news_pkg', 'cvs_addopts', 'cvs_command', 'cvs_postsync', 'cvs_syncopts', 'darcs_addopts', 'darcs_command', 'darcs_postsync', 'darcs_syncopts', 'g-common_command', 'g-common_generateopts', 'g-common_postsync', 'g-common_syncopts', 'git_addopts', 'git_command', 'git_email', 'git_postsync', 'git_syncopts', 'git_user', 'installed', 'local_list', 'make_conf', 'mercurial_addopts', 'mercurial_command', 'mercurial_postsync', 'mercurial_syncopts', 'news_reporter', 'nocheck', 'nocolor', 'output', 'overlay_defs', 'overlays', 'proxy', 'quiet', 'quietness', 'rsync_command', 'rsync_postsync', 'rsync_syncopts', 'stderr', 'stdin', 'stdout', 'storage', 'svn_addopts', 'svn_command', 'svn_postsync', 'svn_syncopts', 't/f_options', 'tar_command', 'tar_postsync', 'umask', 'verbose', 'width' ] assertEqual(sorted(a), self.test_keys) assertEqual(a.get_option('nocheck'), True)
def init_layman(config=None): '''Returns the initialized ``LaymanAPI``. :param config: the layman's configuration to use (optional) ''' if config is None: config = BareConfig(read_configfile=True, quietness=1) return LaymanAPI(config)
def __init__(self, config=None, report_errors=False, output=None): """ @param configfile: optional config file to use instead of the default. can be a BareConfig or ArgsParser config class. default is BareConfig(output=output) @param report_errors: optional bool to silence some error reporting to stdout default is False @param output: optional Message class instance created with your settings. default is Message(module='layman') other params are defaults. """ self.config = config if config is not None else BareConfig( output=output) self.output = self.config['output'] self.report_errors = report_errors # add our error recording function to output self.output.error_callback = self._error # get installed and available dbs self._installed_db = None self._installed_ids = None self._available_db = None self._available_ids = None self._error_messages = [] self.sync_results = [] self.config.set_option( 'mounts', Mounter(self._get_installed_db, self.get_installed, config=self.config))
def __init__(self, stdout=sys.stdout, stdin=sys.stdin, stderr=sys.stderr, config=None, read_configfile=True, quiet=False, quietness=4, verbose=False, nocolor=False, width=0, root=None): """Input parameters are optional to override the defaults. sets up our LaymanAPI with defaults or passed in values and returns an instance of it""" self.message = Message(out=stdout, err=stderr) self.config = BareConfig(output=self.message, stdout=stdout, stdin=stdin, stderr=stderr, config=config, read_configfile=read_configfile, quiet=quiet, quietness=quietness, verbose=verbose, nocolor=nocolor, width=width, root=root) LaymanAPI.__init__(self, self.config, report_errors=True, output=self.config['output']) return
def _overlays_bug(self, number): config = BareConfig() filename = os.path.join(HERE, 'testfiles', 'overlays_bug_%d.xml'\ % number) o = DbBase(config, [filename]) for verbose in (True, False): for t in o.list(verbose=verbose): print(t[0].decode('utf-8')) print()
def write_db(self): tmpdir = tempfile.mkdtemp(prefix='laymantmp_') test_xml = os.path.join(tmpdir, 'test.xml') test_json = os.path.join(tmpdir, 'test.json') config = BareConfig() a = DbBase(config, [ HERE + '/testfiles/global-overlays.xml', ]) b = DbBase({ 'output': Message(), 'db_type': 'xml' }, [ test_xml, ]) b.overlays['wrobel-stable'] = a.overlays['wrobel-stable'] b.write(test_xml) c = DbBase({ 'output': Message(), 'db_type': 'xml' }, [ test_xml, ]) keys = sorted(c.overlays) self.assertEqual(keys, ['wrobel-stable']) config.set_option('db_type', 'json') a = DbBase(config, [ HERE + '/testfiles/global-overlays.json', ]) b = DbBase({ 'output': Message(), 'db_type': 'json' }, [ test_json, ]) b.overlays['twitch153'] = a.overlays['twitch153'] b.write(test_json) c = DbBase({ 'output': Message(), 'db_type': 'json' }, [ test_json, ]) keys = sorted(c.overlays) self.assertEqual(keys, ['twitch153']) # Clean up: os.unlink(test_xml) os.unlink(test_json) shutil.rmtree(tmpdir)
def test(self): archives = [] try: from layman.overlays.modules.tar.tar import TarOverlay archives.append('tar') from layman.overlays.modules.squashfs.squashfs import SquashfsOverlay archives.append('squashfs') except ImportError: pass for archive in archives: xml_text, repo_name, temp_archive_path = getattr( self, "_create_%(archive)s_overlay" % {'archive': archive})() (fd, temp_collection_path) = tempfile.mkstemp() with os.fdopen(fd, 'w') as f: f.write(xml_text) # Make playground directory temp_dir_path = tempfile.mkdtemp() # Make DB from it config = BareConfig() # Necessary for all mountable overlay types layman_inst = LaymanAPI(config=config) db = DbBase(config, [temp_collection_path]) specific_overlay_path = os.path.join(temp_dir_path, repo_name) o = db.select(repo_name) # Actual testcase o.add(temp_dir_path) self.assertTrue(os.path.exists(specific_overlay_path)) # (1/2) Sync with source available o.sync(temp_dir_path) self.assertTrue(os.path.exists(specific_overlay_path)) os.unlink(temp_archive_path) try: # (2/2) Sync with source _not_ available o.sync(temp_dir_path) except: pass self.assertTrue(os.path.exists(specific_overlay_path)) o.delete(temp_dir_path) self.assertFalse(os.path.exists(specific_overlay_path)) # Cleanup os.unlink(temp_collection_path) os.rmdir(temp_dir_path)
def _run(self, number): #config = {'output': Message()} config = BareConfig() # Discuss renaming files to "branch-%d.xml" filename1 = os.path.join(HERE, 'testfiles', 'subpath-%d.xml' % number) # Read, write, re-read, compare os1 = DbBase(config, [filename1]) filename2 = tempfile.mkstemp()[1] os1.write(filename2) os2 = DbBase(config, [filename2]) os.unlink(filename2) self.assertTrue(os1 == os2) # Pass original overlays return os1
def _get_layman_api(self): ''' Initializes layman api. @rtype layman.api.LaymanAPI instance ''' # Make it so that we aren't initializing the # LaymanAPI instance if it already exists and # if the current storage location hasn't been # changed for the new repository. self.storage = self.repo.location.replace(self.repo.name, '') if self._layman and self.storage in self.current_storage: return self._layman config = BareConfig() configdir = {'configdir': config.get_option('configdir')} self.message = Message(out=sys.stdout, err=sys.stderr) self.current_storage = self.storage options = { 'config': config.get_option('config') % (configdir), 'quiet': self.settings.get('PORTAGE_QUIET'), 'quietness': config.get_option('quietness'), 'overlay_defs': config.get_option('overlay_defs') % (configdir), 'output': self.message, 'nocolor': self.settings.get('NOCOLOR'), 'root': self.settings.get('EROOT'), 'storage': self.current_storage, 'verbose': self.settings.get('PORTAGE_VERBOSE'), 'width': self.settings.get('COLUMNWIDTH'), } self.config = OptionConfig(options=options, root=options['root']) # Reloads config to read custom overlay # xml files. reload_config(self.config) layman_api = LaymanAPI(self.config, report_errors=True, output=self.config['output']) self._layman = layman_api return layman_api
def install_overlay(module, name, list_url=None): '''Installs the overlay repository. If not on the central overlays list, then :list_url of an alternative list must be provided. The list will be fetched and saved under ``%(overlay_defs)/%(name.xml)`` (location of the ``overlay_defs`` is read from the Layman's configuration). :param name: the overlay id :param list_url: the URL of the remote repositories list to look for the overlay definition (optional, default: None) :returns: True if the overlay was installed, or False if already exists (i.e. nothing has changed) :raises ModuleError ''' # read Layman configuration layman_conf = BareConfig(read_configfile=True) layman = init_layman(layman_conf) if layman.is_installed(name): return False if module.check_mode: mymsg = 'Would add layman repo \'' + name + '\'' module.exit_json(changed=True, msg=mymsg) if not layman.is_repo(name): if not list_url: raise ModuleError( "Overlay '%s' is not on the list of known " "overlays and URL of the remote list was not provided." % name) overlay_defs = layman_conf.get_option('overlay_defs') dest = path.join(overlay_defs, name + '.xml') download_url(module, list_url, dest) # reload config layman = init_layman() if not layman.add_repos(name): raise ModuleError(layman.get_errors()) return True
def create_overlay_package(config=None, repo=None, logger=None, xterm_titles=None): ''' Creates a layman overlay object from the given repos.conf repo info. @params config: layman.config class object @params repo: portage.repo class object @rtype tuple: overlay name and layman.overlay object or None ''' if repo: overlay = {'sources': []} desc = 'Defined and created from info in %(repo)s config file...'\ % ({'repo': repo.name}) if not config: config = BareConfig() if not repo.branch: repo.branch = '' overlay['name'] = repo.name overlay['descriptions'] = [desc] overlay['owner_name'] = 'repos.conf' overlay['owner_email'] = '127.0.0.1' overlay['sources'].append( [repo.sync_uri, repo.layman_type, repo.branch]) overlay['priority'] = repo.priority ovl = Overlay.Overlay(config=config, ovl_dict=overlay, ignore=1) return (repo.name, ovl) msg = '!!! laymansync sez... Error: repo not found.' if logger and xterm_titles: logger(xterm_titles, msg) writemsg_level(msg + '\n', level=logging.ERROR, noiselevel=-1) return None