def take_action(self, parsed_args):
self.db = db.DB(parsed_args.database)
cache = db_linecache.DBLineCache(self.db, parsed_args.run_id)
self.out = output.OutputFormatter(cache.getline)
run_details = self.db.get_run(parsed_args.run_id)
self.out.start_run(
run_details.id,
run_details.cwd,
run_details.description,
run_details.start_time,
)
for t in self.db.get_trace(parsed_args.run_id):
self.out.trace(
t.run_id,
t.event,
t.func_name,
t.line_no,
t.filename,
t.trace_arg,
t.local_vars,
t.timestamp,
)
self.out.end_run(
run_details.id,
run_details.end_time,
run_details.error_message,
None, # run_details.traceback,
)
def setUp(self):
super(TraceTest, self).setUp()
self.useFixture(fixtures.FakeLogger())
self.db = db.DB(':memory:')
self.db.start_run(
'12345',
'/no/such/dir',
'command line would go here',
1370436103.65,
)
self.local_values = {'name': ['value', 'pairs']}
self.trace_arg = [{'complex': 'value'}]
self.db.trace(
run_id='12345',
call_id='abcd',
event='test',
func_name='test_trace',
line_no=99,
filename='test_db.py',
trace_arg=self.trace_arg,
local_vars=self.local_values,
timestamp=1370436104.65,
)
self.db.trace(
run_id='12345',
call_id='abcd',
event='test',
func_name='test_trace',
line_no=100,
filename='test_db.py',
trace_arg=self.trace_arg,
local_vars=self.local_values,
timestamp=1370436104.65,
)
def take_action(self, parsed_args):
self.db = db.DB(parsed_args.database)
runs = ((r.id, r.cwd, ' '.join(r.description),
_format_timestamp(r.start_time),
_format_timestamp(r.end_time), r.error_message)
for r in self.db.get_runs(only_errors=parsed_args.errors))
return (self.DEFAULT_COLUMNS, runs)
def take_action(self, parsed_args):
self.db = db.DB(parsed_args.database)
run_details = self.db.get_run(parsed_args.run_id)
if not run_details.stats:
print 'No profiling data was collected'
else:
run_details.stats.sort_stats(parsed_args.sort_order)
run_details.stats.print_stats()
def take_action(self, parsed_args):
db_ = db.DB(parsed_args.database)
try:
db_.delete_run(parsed_args.run_id)
self.log.info(u"Deleted run {}".format(parsed_args.run_id))
except db.NoSuchRun:
self.log.warn(u"No run found with id '{}' delete failed".format(
parsed_args.run_id))
def _process_data(self, database, q):
the_db = db.DB(database)
while True:
next_data = q.get()
if next_data is None:
q.task_done()
break
self._dispatch_one(the_db, next_data)
q.task_done()
return
def take_action(self, parsed_args):
database = db.DB(parsed_args.database)
output_dir = parsed_args.output_directory or parsed_args.run_id
report = html.HTMLReport(
run_id=parsed_args.run_id,
output_dir=output_dir,
database=database,
title=parsed_args.title or parsed_args.run_id,
per_page=parsed_args.items_per_page,
)
report.run()
def _copy_run(self, input_name, output_name, run_id):
input_db = db.DB(input_name)
run = input_db.get_run(run_id)
output_db = db.DB(output_name)
start_time = time.mktime(run.start_time.timetuple())
output_db.start_run(
run_id,
run.cwd,
run.description,
start_time,
)
self.log.debug('Copying trace data')
for t in input_db.get_trace(run_id):
timestamp = time.mktime(t.timestamp.timetuple())
output_db.trace(
t.run_id,
t.call_id,
t.event,
t.func_name,
t.line_no,
t.filename,
t.trace_arg,
t.local_vars,
timestamp,
)
for f_info in input_db.get_files_for_run(run_id):
self.log.debug('Adding cached file %s', f_info.name)
f_body = input_db.get_cached_file(run_id, f_info.name)
output_db.cache_file_for_run(
run_id,
f_info.name,
f_body,
)
end_time = time.mktime(run.end_time.timetuple())
output_db.end_run(
run_id=run_id,
end_time=end_time,
message=run.error_message,
traceback=run.traceback,
stats=stats.stats_to_blob(run.stats),
)
def _process_data(self, database, q):
the_db = db.DB(database)
while True:
next_data = q.get()
if next_data is None:
q.task_done()
break
try:
self._dispatch_one(the_db, next_data)
except:
LOG.exception('error processing %r', next_data)
q.task_done()
return
def setUp(self):
super(QueryWithStatsTest, self).setUp()
self.useFixture(fixtures.FakeLogger())
self.db = db.DB(':memory:')
self.db.start_run(
'12345',
'/no/such/dir',
['command', 'line', 'would', 'go', 'here'],
1370436103.65,
)
self.local_values = {'name': ['value', 'pairs']}
self.trace_arg = [{'complex': 'value'}]
self.db.trace(
run_id='12345',
thread_id='t1',
call_id='abcd',
event='test',
func_name='test_trace',
line_no=99,
filename='test_db.py',
trace_arg=self.trace_arg,
local_vars=self.local_values,
timestamp=1370436104.65,
)
self.db.trace(
run_id='12345',
thread_id='t1',
call_id='abcd',
event='test',
func_name='test_trace',
line_no=100,
filename='test_db.py',
trace_arg=self.trace_arg,
local_vars=self.local_values,
timestamp=1370436104.65,
)
self.db.start_run(
'6789',
'/no/such/dir',
['command', 'line', 'would', 'go', 'here'],
1370436104.65,
)
stats_data = stats.stats_to_blob(pstats.Stats(profile.Profile()))
self.db.end_run(
'6789',
1370436105.65,
'error message',
None,
stats=stats_data,
)
def setUp(self):
super(FileCacheTest, self).setUp()
self.useFixture(fixtures.FakeLogger())
self.db = db.DB(':memory:')
self.db.start_run(
'12345',
'/no/such/dir',
['command', 'line', 'would', 'go', 'here'],
1370436103.65,
)
self.db.start_run(
'6789',
'/no/such/dir',
['command', 'line', 'would', 'go', 'here'],
1370436103.65,
)
def setUp(self):
super(DBFileCacheTest, self).setUp()
self.useFixture(fixtures.FakeLogger())
self.db = db.DB(':memory:')
self.db.start_run(
'12345',
'/no/such/dir',
['command', 'line', 'would', 'go', 'here'],
1370436103.65,
)
self.db.cache_file_for_run(
'12345',
'test-file.txt',
'this would be the body\nline two\nline three',
)
self.cache = db_linecache.DBLineCache(self.db, '12345')
def setUp(self):
super(DBFileCacheTest, self).setUp()
self.useFixture(fixtures.FakeLogger())
self.db = db.DB(':memory:')
self.db.start_run(
'12345',
'/no/such/dir',
['command', 'line', 'would', 'go', 'here'],
1370436103.65,
)
self.db.cache_file_for_run(
'12345',
'test-file.txt',
'this would be the body\nline two\nline three',
)
self.db.cache_file_for_run(
'12345',
'with-comments.txt',
'\n'.join([
'# start comment',
'line two',
'',
' # middle comment',
'',
'end line',
'# comment',
'last line',
]),
)
self.db.cache_file_for_run(
'12345',
'multi-line-comments.txt',
'\n'.join([
'# start comment',
'# comment line 2',
'non-comment 1',
'',
' # middle comment',
' # middle comment line 2',
'',
'middle line',
'# last comment',
'# last comment line 2',
'last line',
]),
)
self.cache = db_linecache.DBLineCache(self.db, '12345')
def test_commit(self):
with db.transaction(self.db.conn) as c:
c.execute("""
INSERT INTO run (id, cwd, description, start_time)
VALUES ('12345', 'cwd-here', 'useful description',
1370436103.65)
""")
db2 = db.DB(':memory:')
c2 = db2.conn.cursor()
c2.execute('select * from run')
d = c2.fetchall()
self.assertEqual(d, [])
c3 = self.db.conn.cursor()
c3.execute('select * from run')
d = c3.fetchall()
self.assertEqual(len(d), 1)
def test_rollback(self):
try:
with db.transaction(self.db.conn) as c:
c.execute("""
INSERT INTO run (id, cwd, description, start_time)
VALUES ('12345', 'cwd-here', 'useful description',
1370436103.65)
""")
db2 = db.DB(':memory:')
c2 = db2.conn.cursor()
c2.execute('select * from run')
d = c2.fetchall()
self.assertEqual(d, [])
raise RuntimeError('testing')
except RuntimeError as err:
self.assertEqual(str(err), 'testing')
c3 = self.db.conn.cursor()
c3.execute('select * from run')
d = c3.fetchall()
self.assertEqual(len(d), 0)
def take_action(self, parsed_args):
self.db = db.DB(parsed_args.database)
run = self.db.get_run(parsed_args.run_id)
details = {
'id': run.id,
'cwd': run.cwd,
'description': run.description,
'start_time': run.start_time.isoformat(),
'end_time': run.end_time.isoformat(),
'error_message': run.error_message,
'traceback': run.traceback,
}
output.dump_dictionary(details, self.log.info, 0)
threads = list(self.db.get_thread_details(parsed_args.run_id))
if len(threads) > 1:
for thread in threads:
td = {
'id': thread.id,
'start_time': thread.start_time.isoformat(),
'end_time': thread.end_time.isoformat(),
}
output.dump_dictionary(td, self.log.info, 0)
return
def __init__(self, database_name):
super(DBHook, self).__init__()
self._db = db.DB(database_name)
def __init__(self, database):
self.db = db.DB(database)
self._reset_cache()
def take_action(self, parsed_args):
self.db = db.DB(parsed_args.database)
threads = list(self.db.get_thread_details(parsed_args.run_id))
return (('ID', 'Start', 'End', 'Num Events', 'Num Locations'), threads)
def take_action(self, parsed_args):
self.db = db.DB(parsed_args.database)
run_details = self.db.get_run(parsed_args.run_id)
run_details.stats.dump_stats(parsed_args.filename)
def setUp(self):
super(TransactionTest, self).setUp()
self.useFixture(fixtures.FakeLogger())
self.db = db.DB(':memory:')
