def init(): config = list(confparse.expand_config_path('domain.rc')) "Configuration filename." assert config, "Missing domain.rc" if len(config)> 1: print("XXX multiple rc", config) settings = confparse.load_path(config[0]) "Static, persisted settings."
def find_config_file(self, rc): rcfile = list(confparse.expand_config_path(rc)) config_file = None if rcfile: config_file = rcfile.pop() # FIXME :if not config_file: assert config_file, \ "Missing config-file for %s, perhaps use init_config_file" %( rc, ) assert isinstance(config_file, str), config_file assert os.path.exists(config_file), \ "Missing %s, perhaps use init_config_file"%config_file return config_file
def main(argv, doc=__doc__, usage=__usage__): """ Execute using docopt-mpe options. """ # Process environment db = os.getenv( 'VOLUME_DB', __db__ ) if db is not __db__: usage = usage.replace(__db__, db) opts = util.get_opts(doc + usage, version=get_version(), argv=argv[1:]) opts.flags.dbref = taxus.ScriptMixin.assert_dbref(opts.flags.dbref) # Load configuration config_file = list(confparse.expand_config_path(opts.flags.config)).pop() settings = confparse.load_path(config_file) pprint(settings.todict()) print for v, p in settings.volume.items(): print v, p print for v, s in settings.volumes.items(): print v, s
def test_1(self): self.assert_(exists(self.realname)) rcfile = list(confparse.expand_config_path(self.name)) self.assertEqual(rcfile, [self.realname])
def confparse_test_func1_(self): self._print_test_files() conf = expand_config_path(self.NAME).next() #self.assertEqual(conf, self.name) settings = load(self.NAME)
def confparse_test_func1_find_config(self): rcs = list(expand_config_path('testrc')) self.assertEqual(rcs, [join(getcwd(), self.RC)]) test_runcom = expand_config_path('testrc').next() return test_runcom
"""archive file - rewrite locator so that file is beneath archive-root, adding a date tag. Take a set of paths and assert that each real location is an archived path. Move files and symlink to archive root if needed. Exceptions are when the files are either too old or too large. """ import os, sys, re, fnmatch, datetime, optparse, itertools import confparse from cmdline import log config = confparse.expand_config_path('cllct.rc') "Root configuration file." settings = confparse.load_path(config.next()) "Static, persisted settings." # Settings with hard-coded defaults #volumes = settings.rsr.volumes#.getlist([ '%(home)/htdocs/' ]) #"Physically disjunct storage trees." # archive_root = settings.volume.cabinet.root #archive_root = settings.rsr.volumes.archive #.getstr('%(volumes)') "Root for current archive." #
facio: {} usr: {} """ import datetime import os from pprint import pformat import re import socket import sys import yaml import confparse config = list(confparse.expand_config_path('domain.rc')) "Configuration filename." assert config, "Missing domain.rc" if len(config)> 1: print "XXX multiple rc", config settings = confparse.load_path(config[0]) "Static, persisted settings." def reload(): global settings settings = settings.reload() if 'dynamic' not in settings: settings['dynamic'] = [] # Reparse interfaces settings['interfaces'] = confparse.Values({}, root=settings) for host in settings.node:
def main(argv, doc=__doc__, usage=__usage__): """ Execute using docopt-mpe options. prog [opts] [CTX] ( FILE... | DIR... ) """ # Process environment db = os.getenv( 'FINFO_DB', __db__ ) if db is not __db__: usage = usage.replace(__db__, db) ctx = confparse.Values(dict( opts = util.get_opts(doc + usage, version=get_version(), argv=argv[1:]) )) ctx.opts.flags.dbref = taxus.ScriptMixin.assert_dbref(ctx.opts.flags.dbref) # Load configuration ctx.config_file = list(confparse.expand_config_path(ctx.opts.flags.config)).pop() ctx.settings = settings = confparse.load_path(ctx.config_file) # Load SA session ctx.sa = get_session(ctx.opts.flags.dbref) # DEBUG: pprint(ctx.settings.todict()) # Process arguments dirs = [] # Shift paths from ctx arg if ctx.opts.args.CTX and os.path.exists(ctx.opts.args.CTX): ctx.opts.args.FILE.append(ctx.opts.args.CTX) ctx.opts.args.CTX = None # Sort out dirs from files for arg in ctx.opts.args.FILE: if os.path.isdir(arg): ctx.opts.args.FILE.remove(arg) dirs.append(arg) elif os.path.isfile(arg): pass else: log.note("Unhandled path %r" % arg) ctx.opts.args.DIR = dirs # Set default path context if ctx.opts.flags.name: assert not ctx.opts.args.CTX ctx.opts.args.CTX = ctx.opts.flags.name elif not ctx.opts.args.CTX: ctx.opts.args.CTX = 'current' # XXX: create prefixes object on context ctx.prefixes = confparse.Values(dict( map= settings.finfo['prefix-map'], env={}, map_={} )) if 'homedir' not in ctx.prefixes.map: ctx.prefixes.map['homedir'] = 'HOME=%s' % os.path.expanduser('~') if 'current' not in ctx.prefixes.map: ctx.prefixes.map['current'] = '$PWD:$HOME' if 'pwd' not in ctx.prefixes.map: ctx.prefixes.map['pwd'] = 'PWD=%s' % os.path.abspath('.') for prefix, path in ctx.prefixes.map.items(): if '=' in path: envvar, path = path.split('=') if envvar in ctx.prefixes.env: assert ctx.prefixes.env[envvar] == prefix, ( ctx.prefixes.env[envvar], prefix ) ctx.prefixes.env[envvar] = prefix # Pre-pocess binds from env flags if not isinstance(ctx.opts.flags.env, list): ctx.opts.flags.env = [ ctx.opts.flags.env ] for env_map in ctx.opts.flags.env: envvar, prefix = env_map.split('=') if envvar in ctx.prefixes.env: assert prefix == ctx.prefixes.env[envvar] else: ctx.prefixes.env[envvar] = prefix envvalue = os.getenv(envvar, None) if envvalue: ctx.prefixes.map[prefix] = "%s=%s" % ( envvar, envvalue ) #ctx.prefixes.map_[prefix] = envvalue.split(':') # Post-process prefixes after passed flags, and resolve all values for prefix, spec in ctx.prefixes.map.items(): if '=' in spec: envvar, spec = spec.split('=') if envvar in ctx.prefixes.env: assert ctx.prefixes.env[envvar] == prefix, ( ctx.prefixes.env[envvar], prefix ) ctx.prefixes.env[envvar] = prefix specs = spec.split(':') set_ = [] for idx, path in enumerate(specs): path = os.path.expanduser(path) if varname.match(path): refpref = ctx.prefixes.env[path[1:]] #refpath = ctx.prefixes.map[] path = '#prefixes/'+refpref elif '$' in path: pass #else: # path = '#prefixes/'+prefix+':'+str(idx) set_.append(path) ctx.prefixes.map_[prefix] = set_ ctx.pathrefs = ctx.prefixes.map_[ctx.opts.args.CTX] #DEBUG: #print ctx.opts.todict() #print pformat(ctx.prefixes.todict()) #print pformat(ctx.pathrefs) # Preprocess filters to regex if 'FILTER' not in ctx.opts.args: ctx.opts.args.FILTER = [] if not ctx.opts.args.FILTER: ctx.opts.args.FILTER = default_filters if ctx.opts.flags.documents: ctx.opts.args.FILTER = doc_filters + ctx.opts.args.FILTER for idx, filter in enumerate(ctx.opts.args.FILTER): if isinstance(filter, str): ctx.opts.args.FILTER[idx] = fnmatch.translating(filter) # Resolve FILE/DIR arguments files, dirs = [], [] for arg in ctx.opts.args.FILE + ctx.opts.args.DIR: r = find_local(arg, search_path(ctx.pathrefs, ctx)) if not r: continue prefix, file, dir = r if not dir: raise Exception("No path for %s" % arg) elif file: files.append((prefix, file)) else: dirs.append((prefix, dir)) print("Resolved arguments to %s dirs, %s files" % ( len(dirs), len(files) )) # XXX: if not ctx.opts.flags.directories: if ctx.opts.flags.recurse: # Resolve all dirs to file lists for p, d in dirs: for top, path_dirs, path_files in os.walk(os.path.join(p, d)): for path_dir in list(path_dirs): for filter in ctx.opts.args.FILTER: if not filter.match(os.path.basename(path_dir)): path_dirs.remove(path_dir) break if top.startswith('./'): top = top[2:] for path_file in list(path_files): filter = None for filter in ctx.opts.args.FILTER: if filter.match(os.path.basename(path_file)): break else: continue if not filter.match(os.path.basename(path_file)): path_files.remove(path_file) if path_file not in path_files: continue files.append((p, os.path.join(top, path_file))) print("Continue with %s files" % len(files)) mfadapter = None res.persistence.PersistedMetaObject.stores['metafile'] = mfadapter prefix = None for p, f in files: if ctx.opts.flags.auto_prefix: prefixes = find_prefixes(p, ctx) assert prefixes # FIXME: how come only use first?? prefix = prefixes.next() assert len(ctx.prefixes.map_[prefix]) == 1, prefix name = f[len(ctx.prefixes.map_[prefix][0])+1:] else: prefix = ctx.opts.args.CTX name = f[len(p)+1:] ref = prefix+':'+name if ctx.opts.flags.names_only: print ref else: # TODO: get INode through context? Also add mediatype & parameters # resolver. But needs access to finfo ctx.. record = taxus.INode.get_instance(name=ref, _sa=ctx.sa) # GNU/Linux: -bi = --brief --mime # Darwin/BSD: -bI = --brief --mime #mediatype = lib.cmd('file --brief --mime "%s"', path).strip() # XXX: see basename-reg? #if ctx.opts.flags.update == True: # TODO: repopulate metadata; mf = res.metafile.Metafile(f) assert mf.date_accessed record.date_accessed = mf.date_accessed assert mf.date_modified record.date_modified = mf.date_modified if not record.node_id: ctx.sa.add(record) print record, record.date_updated, record.date_modified #sys.exit() if ctx.opts.flags.update: ctx.sa.commit()