def add_lctr_ref_md5(self, opts=None, sa=None, *refs):
"Add locator and ref_md5 attr for URLs"
if refs:
if isinstance( refs[0], basestring ):
opts.ref_md5 = True
lctrs = [ ret['lctr'] for ret in self.add_lctrs(sa, opts, *refs) ]
return
else:
assert isinstance( refs[0], Locator), refs
lctrs = refs
for lctr in lctrs:
ref = lctr.ref or lctr.global_id
ref_md5 = hashlib.md5( ref ).hexdigest()
md5 = MD5Digest.fetch(( MD5Digest.digest == ref_md5, ),
exists=False)
if not md5:
md5 = MD5Digest( digest=ref_md5,
date_added=datetime.now() )
sa.add( md5 )
log.info("New %s", md5)
lctr.ref_md5 = md5
sa.add( lctr )
if opts.rsr_auto_commit:
sa.commit()
log.note("Updated ref_md5 for %s to %s", lctr, md5)
def rsr_update_metafiles(prog=None, volume=None, volumedb=None, opts=None):
log.debug("{bblack}rsr{bwhite}:update-volume{default}")
i = 0
for path in res.Metafile.walk(prog.pwd):
print(path)
i += 1
new, updated = False, False
metafile = res.Metafile(path)
#if options:
#metafile.basedir = 'media/application/metalink/'
#if metafile.key in volumedb:
# metafile = volumedb[metafile.key]
# #log.info("Found %s in volumedb", metafile.key)
#else:
# new = True
if metafile.needs_update():
log.note("Updating metafile for %s", metafile.path)
metafile.update()
updated = True
#if updated or metafile.key not in volumedb:
# log.note("Writing %s to volumedb", metafile.key)
# volumedb[metafile.key] = metafile
# new = True
if new or updated:
#if options.persist_meta:
#if metafile.non_zero:
# log.note("Overwriting previous metafile at %s", metafile.path)
metafile.write()
for k in metafile.data:
print('\t'+k+':', metafile.data[k])
print('\tSize: ', lib.human_readable_bytesize(
metafile.data['Content-Length'], suffix_as_separator=True))
else:
print('\tOK')
volume.store.sync()
def name_and_categorize(self, opts=None, sa=None,
name=None, mtype=None, mformat=None, genres=None, *paths):
if len(paths) > 1:
assert opts.interactive
for path in paths:
for subpath in res.fs.Dir.walk(paths, opts):#dict(recurse=True)):
print subpath
elif not opts.interactive:
path = paths[0]
mm = Mediameta(name=name)
if mtype:
mt = [ ret['mt'] for ret in self.add_mtype( mtype, None, opts=opts, sa=sa )
if 'mt' in ret ].pop()
mm.mediatype = mt
if mformat:
mf = [ ret['mf'] for ret in self.add_mformats( opts, sa, mformat )
if 'mf' in ret ].pop()
mm.mediaformat = mf
if genres:
mm.genres = [ ret['genre']
for ret in self.add_genre( genre, None, opts=opts, sa=sa )
if 'genre' in ret ]
sa.add(mm)
sa.commit()
log.note("Created media %s", mm)
def signalGetType(xml_node):
ret = xml_node.attrib.get('type', '')
if not ret:
if xml_node.tag.endswith('_vec'):
signal_type = io_vector_default_type
else:
signal_type = io_signal_default_type
log.note("getType: no type defined, defaulting to: " + signal_type)
ret = signal_type
return ret
def __sendHiz(self):
log.note("Sending hiz {0:d}->{1:d}".format(self.impl.hiz[self.cur_hiz][0], self.impl.hiz[self.cur_hiz][1]))
bytelist = []
bytelist.append(int(HwSimCommand.HIZ))
bytelist.append(self.impl.hiz[self.cur_hiz][0])
bytelist.append(self.impl.hiz[self.cur_hiz][1])
bytelist.append(self.__checkSum(bytelist, len(bytelist)))
log.debug("HIZ frame = " + str(bytelist))
self.comm.write(bytearray(bytelist))
def get_session(dbref, initialize=False, metadata=SqlBase.metadata):
if dbref.startswith('sqlite'):
register_sqlite_connection_event()
engine = create_engine(dbref)#, encoding='utf8')
#engine.raw_connection().connection.text_factory = unicode
metadata.bind = engine
if initialize:
log.info("Applying SQL DDL to DB %s..", dbref)
metadata.create_all() # issue DDL create
log.note('Updated schema for %s to %s', dbref, 'X')
session = sessionmaker(bind=engine)()
return session
def rsr_info(self, prog, context, opts, sa, nodes):
"Log some session statistics and info"
log.note("SQLAlchemy session: %s", sa)
models = taxus.core.ID, Node, Name, Tag, taxus.GroupNode, taxus.INode, taxus.Locator
cnt = {}
for m in models:
cnt[m] = sa.query(m).count()
log.note("Number of %s: %s", m.__name__, cnt[m])
if 'node' in self.globaldict and self.globaldict.node:
log.info("Auto commit: %s", opts.rsr_auto_commit)
log.info("%s", self.globaldict.node)
sys.stderr.write('rsr-info: see notice log (-vvv)\n')
def __buildTestSequence(self, xml_node):
sequence = CLS.TestSequence()
cmds = xml_node.findall('vec')
for cmd in cmds:
value = cmd.text
if value[0:4] == '####':
interval = UT.TimeUtils.timeToInterval(
self.meta.component.interval)
value = value.replace('####', interval)
log.note(
"buildTestSequence: no interval defined, defaulting to: \'"
+ interval + "\'")
sequence.list.append(value)
log.info("buildTestSequence: built sequence step with values: \'" +
value + "\'")
return sequence
def __sendVector(self):
log.note("Sending vector {0:d}/{1:d}".format(self.cur_vec + 1, self.impl.md.vectors))
bytelist = []
bytelist.append(int(HwSimCommand.CFG_VECTOR))
bytelist.append(self.impl.vs[self.cur_vec].vector_num & 0xFF)
bytelist.append((self.impl.vs[self.cur_vec].vector_num >> 8) & 0xFF)
bytelist.append(self.impl.vs[self.cur_vec].testcase)
for e in self.impl.vs[self.cur_vec].interval.to_bytes(4, byteorder="little"):
bytelist.append(e)
for s in self.impl.sm:
bytelist.append(ord(self.impl.vs[self.cur_vec].content[s[2]]))
bytelist.append(self.__checkSum(bytelist, len(bytelist)))
log.debug("Vector frame = " + str(bytelist))
self.comm.write(bytearray(bytelist))
def _assert_node(self, Klass, name, sa, opts):
"""
Helper for node creation.
"""
assert name
node = Klass.find(( Klass.name==name, ), sa=sa)
if node:
if name != node.name:
node.name = name
else:
node = Klass(name=name, date_added=datetime.now())
sa.add(node)
log.info("Added new node to session: %s", node)
if opts.rsr_auto_commit:
sa.commit()
yield dict( node = node )
log.note('Asserted %s', node)
def cmd_read_issues(settings, opts, tasks_file, grep_file):
"""
Read new issues from grep-list and write to tasks-doc.
"""
issues = Issue.parse_doc(tasks_file, settings.project_slug)
for comment in Comment.parse_tag_grep(grep_file, settings):
if not comment.issue_id:
log.warn("No %r ID for %s:%s: %s", settings.project_slug,
comment.srcfile, comment.line_nr or '', comment.text )
continue
# TODO: scan for project slug, and match with taskdoc.
if comment.issue_id not in issues:
log.note("New issue from comment: %s" % comment)
issues[comment.issue_id] = Issue.from_comment(comment, settings)
else:
log.info("Existing issue for comment: %s" % comment)
pass # TODO: check, update from changed comment
def setpass():
"""Routing rule to set the password"""
if flask.request.method == "POST":
form = flask.request.form
if not password.check(form['password']):
log.warn("Failed password check")
return ("Incorrect current password. If you can't remember it, "
"try running this: <code>python3 password.py</code> in "
"the application directory.")
else:
if form['npass1'] != form['npass2']:
return "Passwords don't match"
else:
log.note("Changing password")
password.set(form['npass1'])
return "ok"
else:
return setpass_text
def stats(self, prog=None, opts=None, sa=None):
assert sa, (opts, sa)
urls = sa.query(Locator).count()
log.note("Number of URLs: %s", urls)
bms = sa.query(Bookmark).count()
log.note("Number of bookmarks: %s", bms)
for lctr in sa.query(Locator).filter(Locator.global_id==None).all():
lctr.delete()
log.note("Deleted Locator without global_id %s", lctr)
for bm in sa.query(Bookmark).filter(Bookmark.ref_id==None).all():
bm.delete()
log.note("Deleted bookmark without ref %s", bm)
def mm_stats(self, sa=None):
mfs = sa.query(Mediaformat).count()
log.note("Number of mediaformat's: %s", mfs)
mts = sa.query(Mediatype).count()
log.note("Number of mediatype's: %s", mts)
mms = sa.query(Mediameta).count()
log.note("Number of mediameta's: %s", mms)
def txs_session(prog=None, sa=None, opts=None, settings=None):
# default SA session
dbref = opts.dbref
if opts.init:
log.debug("Initializing SQLAlchemy session for %s", dbref)
sa = SessionMixin.get_session('default', opts.dbref, opts.init)
# Host
hostnamestr = current_hostname(opts.init, opts.interactive)
if opts.init:
hostname = hostname_find([hostnamestr], sa)
assert not hostname or not isinstance(hostname, (tuple, list)), hostname
if not hostname:
log.note("New Name: %s", hostnamestr)
hostname = Name(
name=hostnamestr,
date_added=datetime.now())
hostname.commit()
else:
log.warn("Name exists: %s", hostname)
assert hostname
host = host_find([hostname], sa)
if not host:
log.note("New Host: %s", hostnamestr)
host = Host(
hostname=hostname,
date_added=datetime.now())
host.commit()
else:
log.warn("Host exists: %s", host)
assert host
else:
host, name = sa.query(Host, Name)\
.join('hostname')\
.filter(Name.name == hostnamestr).one()
if not host:
log.crit("Could not get host")
urlresolver = LocalPathResolver(host, sa)
log.info("On %s", host)
yield Keywords(sa=sa, ur=urlresolver)
def txs_run(sa=None, ur=None, opts=None, settings=None):
log.debug("{bblack}txs{bwhite}:run{default}")
# XXX: Interactive part, see lind.
"""
"""
results = []
if settings.taxus.walk.yield_directly:
results = None
classes = {}
tags = {}
if '' not in tags:
tags[''] = 'Root'
FS_Path_split = re.compile('[\/\.\+,]+').split
log.info("{bblack}Tagging paths in {green}%s{default}",
os.path.realpath('.') + sep)
cwd = os.getcwd()
assert isinstance(cwd, basestring), cwd
try:
for pathstr in res.Dir.walk_tree_interactive(cwd, opts):
path = ur.get(pathstr, opts)
if isinstance(results, list):
# XXX: path is not initialized yet
results.append(pathstr)
else:
yield path
continue
parts = FS_Path_split(pathstr)
for tagstr in parts:
try:
tag = sa.query(Tag).filter(Tag.name == tagstr).one()
log.note(tag)
except NoResultFound, e:
log.note(e)
# Ask about each new tag, TODO: or rename, fuzzy match.
if tagstr not in tags:
type = raw_input('%s%s%s:?' % (
log.palette['yellow'], tagstr,
log.palette['default']) )
if not type: type = 'Tag'
tags[tagstr] = type
log.info(pathstr)
#log.info(''.join( [ "{bwhite} %s:{green}%s{default}" % (tag, name)
# for tag in parts if tag in tags] ))
except KeyboardInterrupt, e:
log.note(e)
pass
def rsr_session(self, prog, volume, workspace, homedir, opts):
"""
Determine context, and from there get the session/dbref to initialize an
SQLAlchemy session.
The context depends on the current working directory, and defaults to
the nearest workspace; perhaps a volume or the homedir.
"""
session = Session.init(prog.pwd, opts.session)
log.note('Session: %s', session)
if session.context and confparse.haspath(session.context, 'data.repository.root_dir'):
prog.session = session
yield dict(context=session.context)
log.note('Context: %s', session.context)
repo_root = session.context.settings.data.repository.root_dir
else:
repo_root = 'sa_migrate'
# SA session
repo_path = os.path.join(repo_root, opts.repo)
if os.path.exists(repo_path):
log.info("Reading SA migrate config for repo %r" % repo_path)
# hard coded module name, root dir for local repos
from sa_migrate import custom
config = custom.read(repo_path)
log.info("Reading SA migrate config from %r" % config)
repo_opts = custom.migrate_opts(repo_path, config)
dbref = repo_opts['url']
else:
dbref = opts.dbref
log.note('DBRef: %s', dbref)
if opts.init_db:
log.debug("Initializing SQLAlchemy session for %s", dbref)
sa = SessionMixin.get_session(opts.session, dbref, opts.init_db,
SqlBase=SqlBase)
yield dict(sa=sa)
def static_init(self):
"""
Initializes the `prog` variable, determines its name and working
directory and from there looks up all configuration files.
Using the name it then sets up all command-line options.
"""
# Set up a static name context
inheritor = self.__class__
static = StaticContext( inheritor )# XXX IStaticContext()
yield dict( prog=dict( name = static ) )
log.note('prog.name: %s', static)
# Prepare a specification of the paths and types of configuration files
configspec = ConfigSpec( static )# XXX ISimpleConfigSpec(config_file)
yield dict( prog=dict( configspec = configspec ) )
log.note('prog.configspec: %s', configspec)
# Lastly also aggragate all options defined on the inheritance chain
optspec = SimpleCommand.get_optspec( inheritor )
yield dict( prog=dict( optspec = optspec ) )
log.note('prog.optspec: %s', optspec)
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()
def rsr_commit(self, sa):
"Commit changes to SQL"
log.note("Committing SQL changes");
sa.commit()
log.debug("Commit finished");
opts = util.get_opts(__usage__, version=get_version())
# Override dbref setting from schema
if opts.flags.v or opts.flags.verbosity:
log.category = 6
# FIXME: log.category log.test()
#if opts.flags.v
# print opts.flags.v
#if opts.flags.verbosity:
# print opts.flags.verbosity
# schema corresponds to module name
if opts.args.schema:
log.note("Using schema %r", opts.args.schema)
schema = __import__(os.path.splitext(opts.args.schema)[0])
else:
log.note("Using local schema %s", __name__)
schema = sys.modules[__name__]
metadata = schema.SqlBase.metadata
if opts.flags.dbref == __db__:
if hasattr(schema, '__db__'):
opts.flags.dbref = schema.__db__
if ':/' not in opts.flags.dbref: # FIXME: scan for uri properly (regex)
opts.flags.dbref = taxus.ScriptMixin.assert_dbref(opts.flags.dbref)
print opts.flags.dbref
def __sendCmdReset(self):
log.note("Resetting simulator")
self.comm.write(b'rr')
def __sendReport(self):
log.note("Requesting current report")
self.comm.write(b'ss')
def run(self, execution_graph, context, reporter, args=[], kwds={}):
"""
execution_graph:ExecGraph
ties command targets together as nodes in a
network, expressing dependencies and other relations as typed edges.
context:ContextStack is an stack for multiple properties, where each
property is stacked by attribute assignment and popped using 'del'.
Used only for generator right now.
args and kwds are argument vectors shared with all commands, updated and
overriden from each command if needed
"""
log.debug('Target resolver starting with %s', execution_graph.execlist)
target = execution_graph.nextTarget()
while target:
log.note('Run: %s', target.name)
assert isinstance(kwds, dict)
# Execute Target Command routine (returns generator)
context.generator = target.handler.func(
**self.select_kwds(target.handler.func, kwds, args))
if not context.generator:
log.warn("target %s did not return generator", target)
# isgeneratorfunction(context.generator):
else:
# Handle results from Command
for r in context.generator:
if isinstance(r, str):
pass # resolve something from string notation?
# post-exec subcommands..
if res.iface.ITarget.providedBy(r):
if r.required:
execution_graph.require(target, r)
self.run(execution_graph, context, reporter, args=args, kwds=kwds)
else:
execution_graph.append(target, r)
# push post-commands
elif isinstance(r, Targets):
for t in r:
execution_graph.require(target, t)
# replace argument vector
elif isinstance(r, Arguments):
#if r:
# log.warn("Ignored %s", r)
args = r#args.extend(r)
# update keywords
elif isinstance(r, Keywords):
kwds.update(r)
# stop & set process return status bit
elif isinstance(r, int):
if r == 0:
assert not execution_graph, '???'
reporter.flush()
sys.exit(r)
# aggregate var. result data for reporting (to screen, log, ...)
elif res.iface.IReport.providedBy(r):
reporter.append(r)
elif res.iface.IReportable.providedBy(r):
reporter.append(r)
else:
log.warn("Ignored yield from %s: %r", target.name, r)
del context.generator
target = execution_graph.nextTarget()
def __sendExecute(self):
log.note("Requesting execute vector {0:d}/{1:d}".format(self.cur_vec_execute, len(self.impl.vs)))
self.comm.write(b'ee')
def __sendDeviceInfo(self):
log.note("Requesting device information")
self.comm.write(b'dd')
def run(self):
log.note("Loading signal map")
self.sm, self.hiz = self.__loadSignalMap(self.map_file_path)
log.debug("SignalMap = " + str(self.sm))
log.note("Loading metadata")
self.md = Metadata(self.metadata_file_path)
log.note("Loading default vector")
self.dv = self.__loadDefaultVector(self.def_vector_path)
log.debug("DefVector = " + str(self.dv))
log.note("Building vector file list")
if self.tc:
vec_list = []
for i in self.tc:
vec_list.append(self.target_sim_path + "/" + self.comp + "_{0:02d}.vec".format(int(i)))
else:
vec_list = glob.glob(self.target_sim_path + "/" + self.comp + "*.vec")
for vec in vec_list:
if not vec.find("df.vec") == -1:
vec_list.remove(vec)
vec_list.sort()
self.md.testcases = len(vec_list)
log.debug("VectorFiles = " + str(vec_list))
log.note("Building vectors list")
self.vs, self.flags = self.__loadVectors(vec_list)
log.debug("Vectors:")
for v in self.vs:
log.debug(str(v))
self.md.vectors = len(self.vs)
log.note("Metadata = " + str(self.md))
if not self.communication.discoverHwsim():
log.error("HW simulator discovery failed")
log.info("HW simulator discovery " + log.TermColor.LGREEN + "OK" + log.TermColor.NC)
if len(self.vs) > self.device_info.vectors_cnt_max:
log.error("Vector count not supported by hwsim ({0:d}/{1:d})".format(len(self.vs), self.device_info.vectors_cnt_max))
if not self.communication.initSim():
log.error("HW simulator initialization failed")
log.info("HW simulator initialization " + log.TermColor.LGREEN + "OK" + log.TermColor.NC)
if not self.communication.sendHiz():
log.error("Couldn't send HIZ information")
log.info("HW simulator sending HIZ " + log.TermColor.LGREEN + "OK" + log.TermColor.NC)
if not self.communication.sendVectors():
log.error("Couldn't send vectors")
log.info("HW simulator sending vectors " + log.TermColor.LGREEN + "OK" + log.TermColor.NC)
if not self.communication.sendFlags():
log.error("Couldn't send flags")
log.info("HW simulator sending flags " + log.TermColor.LGREEN + "OK" + log.TermColor.NC)
self.communication.executeTests()
if self.failed_testcases > 0:
log.warning((log.TermColor.RED + "FINISHED (failed {0:d} of {1:d} testcases)" + log.TermColor.NC).format(self.failed_testcases, self.md.testcases))
else:
log.info((log.TermColor.LGREEN + "FINISHED (failed {0:d} of {1:d} testcases)" + log.TermColor.NC).format(self.failed_testcases, self.md.testcases))
if not self.communication.sendReset():
log.error("HW simulator RESET failed")
else:
log.note("HW simulator RESET " + log.TermColor.LGREEN + "OK" + log.TermColor.NC)
return
def __sanityCheckValues(self, meta):
for testcase in meta.testcases.list:
for test_entry in testcase.content:
if type(test_entry) is CLS.TestStep:
# set is handled in schema, take care of expect only
expect_list = test_entry.expect_list
for expect_entry in expect_list:
if meta.signals.getSignal(expect_entry).role == "out":
if expect_list[expect_entry] not in ("h", "l",
"-"):
log.error(
"sanityCheckValues: TestStep out={0:s} expect is not ('h', 'l', '-'), got={1:s}"
.format(expect_entry,
expect_list[expect_entry]))
elif meta.signals.getSignal(
expect_entry).role == "out_vec":
for value_pos in range(
0, len(expect_list[expect_entry])):
if expect_list[expect_entry][
value_pos] not in ("h", "l", "-"):
log.error(
"sanityCheckVallues: TestStep out_vec[{0:d}]={1:s} expect is not ('h', 'l', '-'), got={2:s}"
.format(
value_pos, expect_entry,
expect_list[expect_entry]
[value_pos]))
elif meta.signals.getSignal(
expect_entry).role == "inout":
if expect_list[expect_entry] not in ("Z", "H", "L",
"-", "h", "l",
"X"):
log.error(
"sanityCheckValues: TestStep inout={0:s} expect is not ('Z', 'H', 'L', '-', 'h', 'l', 'X'), got={1:s}"
.format(expect_entry,
expect_list[expect_entry]))
elif meta.signals.getSignal(
expect_entry).role == "inout_vec":
for value_pos in range(
0, len(expect_list[expect_entry])):
if expect_list[expect_entry][
value_pos] not in ("Z", "H", "L", "-",
"h", "l", "X"):
log.error(
"sanityCheckVallues: TestStep inout_vec[{0:d}]={1:s} expect is not ('Z', H', 'L', '-', 'h', 'l', 'X'), got={2:s}"
.format(
value_pos, expect_entry,
expect_list[expect_entry]
[value_pos]))
elif type(test_entry) is CLS.TestSequence:
vector_list = test_entry.list
for value in vector_list:
vector = value[len("#### "):].replace(" ", "")
for pos in range(0, len(vector)):
signal = meta.signals.getSignalAtPosition(pos)
if signal.role.startswith("inout"):
# no way to distinguish between set and exp
if vector[pos] not in ("H", "L", "-", "0", "1",
"Z", "l", "h", "X"):
log.error(
"sanityCheckValues: TestSequence {0:s}={1:s} expect is not ('H', 'L', '-', '0', '1', 'Z', 'l', 'h', 'X'), got={2:s}"
.format(signal.role, signal.name,
vector[pos]))
elif type(test_entry) is CLS.TestScript:
log.note(
"sanityCheckValues: no validation for script test available"
)
else:
# should be handeld by schema, but...
log.error("sanityCheckValues: invalid test type")
return True
@app.route("/import", methods=["GET", "POST"])
def import_shapefile():
"""Routing rule for this "Import Shapefile" page."""
db = app.config["DATABASE"]
if flask.request.method == 'POST':
if not password.check(flask.request.form['secret']):
return "Incorrect passcode"
myfile = flask.request.files['file']
if myfile:
with db.insert_lock:
if 'cleardata' in flask.request.form:
db.clear()
try:
import_tool.import_shape_file(myfile, db)
db.commit()
return "ok"
except import_tool.error as e:
db.rollback()
return e.args[0]
else:
return "No file submitted"
else:
return iform_text
if __name__ == '__main__':
log.note("Starting server")
app.run(debug=app.config["DEBUG"],
host=app.config["HOST"],
port=app.config["PORT"]
)
def rdc_run_embedded_issue_scan(self, sa, issue_format=None, opts=None, *paths):
"""
Main function: scan multiple sources and print/log embedded issues
found.
"""
if not paths: paths=['.']
# TODO: make ascii peek optional, charset configurable
# TODO: implement contexts, ref per source
context = ''
source_iter = self.walk_paths(paths)
# pre-compile patterns XXX: per context
matchbox = compile_rdc_matchbox(rc)
taskdocs = {}
for source in source_iter:
data = open(source).read()
lines = get_lines(data)
srcdoc = SrcDoc( source, len(lines) )
taskdocs[source] = srcdoc
parser = Parser(sa, matchbox, source, context, data, lines)
for tag in parser.find_tags():
try:
cmt = parser.for_tag(srcdoc, tag)
except (Exception) as e:
if not opts.quiet:
log.err("Unable to find comment span for tag '%s' at %s:%s " % (
parser.data[tag.start:tag.end], srcdoc.source_name, tag.char_span))
continue
if not cmt:
continue
# XXX
srcdoc.scei.append(cmt)
if opts.quiet:
issue_format = 'id'
print EmbeddedIssue.formats[issue_format](cmt, data)
return
# TODO: old clean/rewrite functions
# iterate paths
for embedded in find_files_with_tag(sa, matchbox, paths):
if embedded.tag_id:
#if embedded.tag_id == NEED_ID:
yield dict(issues=[ embedded ])
try:
if issue_format:
print EmbeddedIssueOld.formats[issue_format](embedded)
log.note('Embedded Issue %r', (embedded.file_name, \
embedded.tag_name, embedded.tag_id, \
embedded.comment_span, embedded.comment_lines, \
embedded.description, embedded.comment_flavour))
except Exception, e:
log.err(e)
#new_id = service.new_issue(embedded.tag_name, embedded.description)
#embedded.set_new_id(new_id)
#service.update_issue(embedded.tag_name, embedded.tag_id,
# embedded.description)
else:
assert False
pass
import log
log.trace(file=False, line=False, caller=True)
def test():
log.error("ERROR")
log.warning("WARNING")
log.success("SUCCESS")
test()
log.info("INFO")
log.debug("DEBUG")
log.suppress("ERROR")
log.error("ERROR")
log.note("NOTE")
