def main(self, argv):
args = self._parse_args(argv)
if args.tau_dir:
# Link to tau directory
if argv[0] in '--tau-dir':
del argv[0:2]
elif argv[2] in '--tau-dir':
del argv[2:4]
if args.description:
description = args.description
if argv[0] in '--description':
del argv[0:2]
elif argv[2] in '--description':
del argv[2:4]
else:
description = None
launcher_cmd, application_cmds = Trial.parse_launcher_cmd(argv)
self.logger.debug("Launcher command: %s", launcher_cmd)
self.logger.debug("Application commands: %s", application_cmds)
if args.tau_dir:
Project.controller().storage.tau_dir(args.tau_dir)
return Project.selected().experiment().managed_run(
launcher_cmd, application_cmds, description)
return Project.selected().experiment().managed_run(
launcher_cmd, application_cmds, description)
def main(self, argv):
args = self._parse_args(argv)
if not (args.profile or args.trace or args.sample):
self.parser.error('You must specify at least one measurement.')
proj_ctrl = Project.controller()
try:
proj = proj_ctrl.selected()
except ProjectStorageError:
self.logger.debug("No project found, initializing a new project.")
PROJECT_STORAGE.connect_filesystem()
try:
self._create_project(args)
if not args.bare:
self._populate_project(argv, args)
except:
PROJECT_STORAGE.destroy()
raise
return dashboard_cmd.main([])
except ProjectSelectionError as err:
err.value = "The project has been initialized but no project configuration is selected."
raise err
else:
self.logger.warning("Tau is already initialized and the selected project is '%s'. Use commands like"
" `tau application edit` to edit the selected project or delete"
" '%s' to reset to a fresh environment.", proj['name'], proj_ctrl.storage.prefix)
return EXIT_WARNING
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
targ = Target.controller(proj_ctrl.storage).one({'name': args.target})
if targ is None:
self.parser.error("A target with name %s does not exist." %
args.target)
app = Application.controller(proj_ctrl.storage).one(
{'name': args.application})
if app is None:
self.parser.error("An application with name %s does not exist." %
args.application)
meas = Measurement.controller(proj_ctrl.storage).one(
{'name': args.measurement})
if meas is None:
self.parser.error("A measurement with name %s does not exist." %
args.measurement)
data = {
'name': args.name,
'project': proj.eid,
'target': targ.eid,
'application': app.eid,
'measurement': meas.eid
}
return self._create_record(PROJECT_STORAGE, data)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {
attr: getattr(args, attr)
for attr in self.model.attributes if hasattr(args, attr)
}
# Translate names to eids
proj_ctrl = Project.controller()
for model in Target, Application, Measurement:
attr = model.name.lower()
if attr in data:
record = model.controller(proj_ctrl.storage).one(
{'name': data[attr]})
if record is None:
self.parser.error("Invalid %s: %s" % (attr, data[attr]))
data[attr] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
"""Command program entry point.
Args:
argv (list): Command line arguments.
Returns:
int: Process return code: non-zero if a problem occurred, 0 otherwise
"""
args = self._parse_args(argv)
if args.current:
proj = Project.controller().selected()
try:
expr = proj.experiment()
except ExperimentSelectionError:
print(
util.color_text('No selected experiment: ', 'red') +
'Use `%s` to create or select an experiment.' % select_cmd)
else:
print expr['name']
retval = EXIT_SUCCESS
else:
retval = super(ExperimentListCommand, self).main(argv)
return retval
def main(self, argv):
args = self._parse_args(argv)
if not (args.baseline or args.profile or args.trace or args.sample):
self.parser.error('You must specify at least one measurement.')
proj_ctrl = Project.controller()
try:
proj = proj_ctrl.selected()
except ProjectStorageError:
self.logger.debug("No project found, initializing a new project.")
PROJECT_STORAGE.connect_filesystem()
try:
self._create_project(args)
if not args.bare:
self._populate_project(args)
except:
PROJECT_STORAGE.destroy()
raise
return dashboard_cmd.main([])
except ProjectSelectionError as err:
err.value = "The project has been initialized but no project configuration is selected."
raise err
else:
self.logger.warning(
"Tau is already initialized and the selected project is '%s'. Use commands like"
" `tau application edit` to edit the selected project or delete"
" '%s' to reset to a fresh environment.", proj['name'],
proj_ctrl.storage.prefix)
return EXIT_WARNING
def _project_eid(self):
"""Avoid multiple lookup of the selected project since project selection will not change mid-process."""
try:
return self._selected_project.eid
except AttributeError:
# pylint: disable=attribute-defined-outside-init
self._selected_project = Project.controller(self.storage).selected()
return self._selected_project.eid
def _project_eid(self):
"""Avoid multiple lookup of the selected project since project selection will not change mid-process."""
try:
return self._selected_project.eid
except AttributeError:
# pylint: disable=attribute-defined-outside-init
self._selected_project = Project.controller(self.storage).selected()
return self._selected_project.eid
def test_rename(self):
self.reset_project_storage()
argv = ['proj1', '--new-name', 'proj2']
self.assertCommandReturnValue(0, edit.COMMAND, argv)
proj_ctrl = Project.controller()
self.assertIsNone(proj_ctrl.one({'name': 'proj1'}))
self.assertIsNotNone(proj_ctrl.one({'name': 'proj2'}))
self.assertCommandReturnValue(0, edit.COMMAND, ['proj2', '--new-name', 'proj1'])
def test_rename(self):
self.reset_project_storage()
argv = ['proj1', '--new-name', 'proj2']
self.assertCommandReturnValue(0, edit.COMMAND, argv)
proj_ctrl = Project.controller()
self.assertIsNone(proj_ctrl.one({'name': 'proj1'}))
self.assertIsNotNone(proj_ctrl.one({'name': 'proj2'}))
self.assertCommandReturnValue(0, edit.COMMAND, ['proj2', '--new-name', 'proj1'])
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
name = args.name
proj = proj_ctrl.one({"name": name})
if not proj:
self.parser.error("There is no project configuration named '%s.'" % name)
proj_ctrl.select(proj)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
name = args.name
proj = proj_ctrl.one({"name": name})
if not proj:
self.parser.error("There is no project configuration named '%s.'" %
name)
proj_ctrl.select(proj)
return EXIT_SUCCESS
def main(self, argv):
"""Command program entry point.
Args:
argv (list): Command line arguments.
Returns:
int: Process return code: non-zero if a problem occurred, 0 otherwise
"""
args = self._parse_args(argv)
style_args = ['--' + args.style] if hasattr(args, 'style') else []
levels = arguments.parse_storage_flag(args)
keys = getattr(args, 'keys', [])
single = (len(keys) == 1 and len(levels) == 1)
if single:
proj_name = keys[0]
self.title_fmt = "Project Configuration (%(storage_path)s)"
target_list_cmd.title_fmt = "Targets in project '%s'" % proj_name
application_list_cmd.title_fmt = "Applications in project '%s'" % proj_name
measurement_list_cmd.title_fmt = "Measurements in project '%s'" % proj_name
experiment_list_cmd.title_fmt = "Experiments in project '%s'" % proj_name
retval = super(ProjectListCommand, self).main(argv)
if single:
storage = levels[0]
ctrl = Project.controller(storage)
proj = ctrl.one({'name': keys[0]}, context=False)
for cmd, prop in ((target_list_cmd, 'targets'),
(application_list_cmd, 'applications'),
(measurement_list_cmd, 'measurements'),
(experiment_list_cmd, 'experiments')):
primary_key = proj.attributes[prop]['collection'].key_attribute
records = proj.populate(prop, context=False)
if records:
cmd.main([record[primary_key] for record in records] +
['-p'] + [proj['name']] + style_args)
else:
label = util.color_text('%s: No %s' % (proj['name'], prop),
color='red',
attrs=['bold'])
print "%s. Use `%s` to view available %s.\n" % (label,
cmd, prop)
try:
expr = proj.experiment()
if not isinstance(expr, NoneType):
print util.color_text("Selected Experiment: ",
'cyan') + expr['name']
except ExperimentSelectionError:
print(
util.color_text('No selected experiment: ', 'red') +
'Use `%s` to create or select an experiment.' % select_cmd)
return retval
def _update_record(self, store, data, key):
proj_ctrl = Project.controller()
expr = Project.selected().experiment()
ctrl = self.model.controller(store)
key_attr = self.model.key_attribute
if not ctrl.exists({key_attr: key, 'experiment': expr.eid}):
self.parser.error(
"No %s-level %s with %s='%s'." %
(ctrl.storage.name, self.model_name, key_attr, key))
ctrl.update(data, {key_attr: key, 'experiment': expr.eid})
self.logger.info("Updated %s '%s'", self.model_name, key)
return EXIT_SUCCESS
def main(self, argv):
"""Command program entry point.
Args:
argv (list): Command line arguments.
Returns:
int: Process return code: non-zero if a problem occurred, 0 otherwise
"""
args = self._parse_args(argv)
style_args = ['--' + args.style] if hasattr(args, 'style') else []
levels = arguments.parse_storage_flag(args)
keys = getattr(args, 'keys', [])
single = (len(keys) == 1 and len(levels) == 1)
if single:
proj_name = keys[0]
self.title_fmt = "Project Configuration (%(storage_path)s)"
target_list_cmd.title_fmt = "Targets in project '%s'" % proj_name
application_list_cmd.title_fmt = "Applications in project '%s'" % proj_name
measurement_list_cmd.title_fmt = "Measurements in project '%s'" % proj_name
experiment_list_cmd.title_fmt = "Experiments in project '%s'" % proj_name
retval = super(ProjectListCommand, self).main(argv)
if single:
storage = levels[0]
ctrl = Project.controller(storage)
proj = ctrl.one({'name': keys[0]})
for cmd, prop in ((target_list_cmd, 'targets'),
(application_list_cmd, 'applications'),
(measurement_list_cmd, 'measurements'),
(experiment_list_cmd, 'experiments')):
primary_key = proj.attributes[prop]['collection'].key_attribute
records = proj.populate(prop)
if records:
cmd.main([record[primary_key] for record in records] + style_args)
else:
label = util.color_text('%s: No %s' % (proj['name'], prop), color='red', attrs=['bold'])
print "%s. Use `%s` to view available %s.\n" % (label, cmd, prop)
if proj.get('force_tau_options', False):
self.logger.warning("Project '%s' will add '%s' to TAU_OPTIONS without error checking.",
proj['name'], ' '.join(proj['force_tau_options']))
try:
expr = proj.experiment()
except ExperimentSelectionError:
print (util.color_text('No selected experiment: ', 'red') +
'Use `%s` to create or select an experiment.' % select_cmd)
else:
print util.color_text("Selected Experiment: ", 'cyan') + expr['name']
return retval
def get(self):
ds = []
ns = [p['name'] for p in Project.controller().all()]
for n in ns:
p = Project.controller().one({'name': n})
d = {
"name":
n,
"targets": [x['name'] for x in p.populate('targets')],
"applications":
[x['name'] for x in p.populate('applications')],
"measurements":
list(set([x['name'] for x in p.populate('measurements')])),
"num_experiments":
len(p['experiments'])
}
ds.append(d)
self.set_header("Access-Control-Allow-Origin", "*")
self.finish({"projects": ds})
def main(self, argv):
from taucmdr.cli.commands.project.list import COMMAND as project_list
args = self._parse_args(argv)
tar_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
proj_ctrl = Project.controller()
project_name = args.name
project = proj_ctrl.one({'name': project_name})
if not project:
self.parser.error("'%s' is not a project name. Type `%s` to see valid names." %
(project_name, project_list.command))
updates = dict(project.element)
updates['name'] = getattr(args, 'new_name', project_name)
targets = set(project['targets'])
applications = set(project['applications'])
measurements = set(project['measurements'])
added = self._parse_add_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
removed = self._parse_remove_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
updates['targets'] = list(targets)
updates['applications'] = list(applications)
updates['measurements'] = list(measurements)
try:
force_tau_options = args.force_tau_options
except AttributeError:
pass
else:
# Unset force_tau_options if it was already set and --force-tau-options=none
if updates.pop('force_tau_options', False) and [i.lower().strip() for i in force_tau_options] == ['none']:
proj_ctrl.unset(['force_tau_options'], {'name': project_name})
self.logger.info("Removed 'force-tau-options' from project configuration '%s'.", project_name)
else:
updates['force_tau_options'] = force_tau_options
self.logger.info("Added 'force-tau-options' to project configuration '%s'.", project_name)
proj_ctrl.update(updates, {'name': project_name})
for model in added:
self.logger.info("Added %s '%s' to project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
for model in removed:
self.logger.info("Removed %s '%s' from project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
return EXIT_SUCCESS
def test_set_tau_force_options(self):
self.reset_project_storage()
proj_ctrl = Project.controller()
# Check that 'force-tau-options' is unset in the new project configuration
proj1 = proj_ctrl.one({'name': 'proj1'})
self.assertFalse('force-tau-options' in proj1)
# Test --force-tau-options
tau_options = "-optVerbose -optNoCompInst"
argv = ['proj1', '--force-tau-options=%s' % tau_options]
self.assertCommandReturnValue(0, edit.COMMAND, argv)
# Check that 'force-tau-options' is now a list containing the expected options in the project record
proj1 = proj_ctrl.one({'name': 'proj1'})
self.assertIsNotNone(proj1)
print proj1
self.assertListEqual(proj1['force_tau_options'], [tau_options])
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
trial_ctrl = Trial.controller(proj_ctrl.storage)
proj = proj_ctrl.selected()
expr = proj.experiment()
try:
number = int(args.number)
except ValueError:
self.parser.error("Invalid trial number: %s" % args.number)
fields = {'experiment': expr.eid, 'number': number}
if not trial_ctrl.exists(fields):
self.parser.error("No trial number %s in the current experiment. "
"See `trial list` to see all trial numbers." % number)
trial_ctrl.delete(fields)
self.logger.info('Deleted trial %s', number)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
trial_ctrl = Trial.controller(proj_ctrl.storage)
proj = proj_ctrl.selected()
expr = proj.experiment()
try:
number = int(args.number)
except ValueError:
self.parser.error("Invalid trial number: %s" % args.number)
fields = {'experiment': expr.eid, 'number': number}
if not trial_ctrl.exists(fields):
self.parser.error("No trial number %s in the current experiment. "
"See `trial list` to see all trial numbers." %
number)
trial_ctrl.delete(fields)
self.logger.info('Deleted trial %s', number)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
trial_ctrl = Trial.controller(proj_ctrl.storage)
proj = proj_ctrl.selected()
expr = proj.experiment()
try:
numbers = [int(number) for number in args.number]
except ValueError:
self.parser.error("Invalid trial number: %s" % args.number)
fields = [{'experiment': expr.eid, 'number': number} for number in numbers]
if not any([trial_ctrl.exists(field) for field in fields]):
self.parser.error("No trial number %s in the current experiment. "
"See `trial list` to see all trial numbers." % number)
for i, _ in enumerate(fields):
trial_ctrl.delete(fields[i])
self.logger.info('Deleted trial %s', numbers[i])
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
proj_ctrl = Project.controller()
for model in Target, Application, Measurement:
attr = model.name.lower()
if attr in data:
record = model.controller(proj_ctrl.storage).one({'name': data[attr]})
data[attr] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
targ = Target.controller(proj_ctrl.storage).one({'name': args.target})
if targ is None:
self.parser.error("A target with name %s does not exist." %args.target)
app = Application.controller(proj_ctrl.storage).one({'name': args.application})
if app is None:
self.parser.error("An application with name %s does not exist." %args.application)
meas = Measurement.controller(proj_ctrl.storage).one({'name': args.measurement})
if meas is None:
self.parser.error("A measurement with name %s does not exist." %args.measurement)
data = {'name': args.name,
'project': proj.eid,
'target': targ.eid,
'application': app.eid,
'measurement': meas.eid}
return self._create_record(PROJECT_STORAGE, data)
def main(self, argv):
args = self._parse_args(argv)
keys = getattr(args, 'keys', None)
style = getattr(args, 'style', None) or self.default_style
storage_levels = arguments.parse_storage_flag(args)
context = True
if args.project:
matching = Project.controller().one({'name': args.project})
if matching:
LOGGER.debug("Using project %s", matching.eid)
context = [('project', matching.eid),
('projects', matching.eid)]
else:
LOGGER.debug("Project %s not found", args.project)
return self._list_records([l.name for l in storage_levels],
keys,
style,
context=context)
def main(self, argv):
from taucmdr.cli.commands.project.list import COMMAND as project_list
args = self._parse_args(argv)
tar_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
proj_ctrl = Project.controller()
project_name = args.name
project = proj_ctrl.one({'name': project_name})
if not project:
self.parser.error(
"'%s' is not a project name. Type `%s` to see valid names." %
(project_name, project_list.command))
updates = dict(project)
updates['name'] = getattr(args, 'new_name', project_name)
targets = set(project['targets'])
applications = set(project['applications'])
measurements = set(project['measurements'])
added = self._parse_add_args(args, tar_ctrl, app_ctrl, meas_ctrl,
targets, applications, measurements)
removed = self._parse_remove_args(args, tar_ctrl, app_ctrl, meas_ctrl,
targets, applications, measurements)
updates['targets'] = list(targets)
updates['applications'] = list(applications)
updates['measurements'] = list(measurements)
proj_ctrl.update(updates, {'name': project_name})
for model in added:
self.logger.info("Added %s '%s' to project configuration '%s'.",
model.name.lower(), model[model.key_attribute],
project_name)
for model in removed:
self.logger.info(
"Removed %s '%s' from project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
subargs = ['--' + args.style]
proj_ctrl = Project.controller()
print
try:
proj = proj_ctrl.selected()
except ProjectSelectionError as err:
project_count = proj_ctrl.count()
if project_count > 0:
project_list_cmd.main(subargs)
err.value = "No project configuration selected. There are %d configurations available." % project_count
else:
from taucmdr.cli.commands.project.create import COMMAND as project_create_cmd
err.value = "No project configurations exist."
err.hints = ['Use `%s` to create a new project configuration.' % project_create_cmd]
raise err
else:
project_list_cmd.main(subargs + [proj['name']])
print
return EXIT_SUCCESS
def select(cls, name):
"""Changes the selected experiment in the current project.
Raises:
ExperimentSelectionError: No experiment with the given name in the currently selected project.
Args:
name (str): Name of the experiment to select.
"""
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
expr_ctrl = cls.controller()
data = {"name": name, "project": proj.eid}
matching = expr_ctrl.search(data)
if not matching:
raise ExperimentSelectionError("There is no experiment named '%s' in project '%s'." % (name, proj['name']))
elif len(matching) > 1:
raise InternalError("More than one experiment with data %r exists!" % data)
else:
expr = matching[0]
proj_ctrl.select(proj, expr)
def select(cls, name):
"""Changes the selected experiment in the current project.
Raises:
ExperimentSelectionError: No experiment with the given name in the currently selected project.
Args:
name (str): Name of the experiment to select.
"""
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
expr_ctrl = cls.controller()
data = {"name": name, "project": proj.eid}
matching = expr_ctrl.search(data)
if not matching:
raise ExperimentSelectionError("There is no experiment named '%s' in project '%s'." % (name, proj['name']))
elif len(matching) > 1:
raise InternalError("More than one experiment with data %r exists!" % data)
else:
expr = matching[0]
proj_ctrl.select(proj, expr)
def main(self, argv):
args = self._parse_args(argv)
vargs = vars(args)
vargs['init_options'] = ' '.join(argv)
if not (args.baseline or args.profile or args.trace or args.sample):
self.parser.error('You must specify at least one measurement.')
proj_ctrl = Project.controller()
if args.force:
proj_ctrl.storage.force_cwd(True)
try:
proj = proj_ctrl.selected()
except ProjectStorageError:
self.logger.debug("No project found, initializing a new project.")
PROJECT_STORAGE.connect_filesystem()
try:
self._create_project(args)
if not args.bare:
self._populate_project(args)
except:
PROJECT_STORAGE.destroy()
raise
return dashboard_cmd.main([])
except ProjectSelectionError as err:
err.value = ("The project has been initialized in %s but no project configuration is selected."
% proj_ctrl.storage.prefix)
raise err
else:
cwd_prefix = os.path.realpath(os.path.join(os.getcwd(), PROJECT_DIR))
force_str = ""
if cwd_prefix != proj_ctrl.storage.prefix:
force_str = ("Or use the `tau initialize --force` command to initialize "
"a project in the current directory.")
self.logger.warning("Tau is already initialized and the selected project is '%s'. Use commands like"
" `tau application edit` to edit the selected project or delete"
" '%s' to reset to a fresh environment. %s",
proj['name'], proj_ctrl.storage.prefix, force_str)
return EXIT_WARNING
def main(self, argv):
args = self._parse_args(argv)
trial_numbers = []
for num in getattr(args, 'trial_numbers', []):
try:
trial_numbers.append(int(num))
except ValueError:
self.parser.error("Invalid trial number: %s" % num)
new_trial_numbers = []
for num in getattr(args, 'to', []):
try:
new_trial_numbers.append(int(num))
except ValueError:
self.parser.error("Invalid trial trial number: %s" % num)
if len(trial_numbers) != len(new_trial_numbers):
self.parser.error(
"Invalid number of trials."
" Number of old trials ids should be equal to number of new trial ids."
)
self.logger.info("Renumbering " + ', '.join([
'{} => {}'.format(i, j)
for (i, j) in itertools.izip(trial_numbers, new_trial_numbers)
]))
proj_ctrl = Project.controller()
trial_ctrl = Trial.controller(proj_ctrl.storage)
expr = Project.selected().experiment()
# Check that no trials deleted with this renumbering
for trial_pair in range(0, len(trial_numbers)):
if new_trial_numbers[trial_pair] not in trial_numbers \
and trial_ctrl.exists({'number': new_trial_numbers[trial_pair], 'experiment': expr.eid}):
self.parser.error(
"This renumbering would delete trial %s. If you would like to delete"
" this trial use the `trial delete` subcommand." %
new_trial_numbers[trial_pair])
trial_ctrl.renumber(trial_numbers, new_trial_numbers)
return EXIT_SUCCESS
def main(self, argv):
from taucmdr.cli.commands.project.list import COMMAND as project_list
args = self._parse_args(argv)
tar_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
proj_ctrl = Project.controller()
project_name = args.name
project = proj_ctrl.one({'name': project_name})
if not project:
self.parser.error("'%s' is not a project name. Type `%s` to see valid names." %
(project_name, project_list.command))
updates = dict(project)
updates['name'] = getattr(args, 'new_name', project_name)
targets = set(project['targets'])
applications = set(project['applications'])
measurements = set(project['measurements'])
added = self._parse_add_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
removed = self._parse_remove_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
updates['targets'] = list(targets)
updates['applications'] = list(applications)
updates['measurements'] = list(measurements)
proj_ctrl.update(updates, {'name': project_name})
for model in added:
self.logger.info("Added %s '%s' to project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
for model in removed:
self.logger.info("Removed %s '%s' from project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
subargs = ['--' + args.style]
proj_ctrl = Project.controller()
print
try:
proj = proj_ctrl.selected()
except ProjectSelectionError as err:
project_count = proj_ctrl.count()
if project_count > 0:
project_list_cmd.main(subargs)
err.value = "No project configuration selected. There are %d configurations available." % project_count
else:
from taucmdr.cli.commands.project.create import COMMAND as project_create_cmd
err.value = "No project configurations exist."
err.hints = [
'Use `%s` to create a new project configuration.' %
project_create_cmd
]
raise err
else:
project_list_cmd.main(subargs + [proj['name']])
print
return EXIT_SUCCESS
def create_new_trial(self, old, new):
proj_ctrl = Project.controller()
trial_ctrl = Trial.controller(proj_ctrl.storage)
records = dict(trial_ctrl.one({'number': old}))
records['number'] = new
trial_ctrl.create(records)
def get(self):
def yn(v):
return "yes" if v else "no"
ds = {
"targets": [],
"applications": [],
"measurements": [],
"experiments": []
}
pname = self.get_argument("project")
p = Project.controller().one({'name': pname})
# targets
rs = p.populate("targets")
for r in rs:
r = r.populate()
mpicc = MPI_CC.keyword
shmcc = SHMEM_CC.keyword
d = {
"name": r["name"],
"host_os": r["host_os"],
"host_arch": r["host_arch"],
"host_compilers": r[CC.keyword]["family"],
"mpi_compilers": r[mpicc]["family"] if mpicc in r else "None",
"shmem_compilers": r[shmcc]["family"] if shmcc in r else "None"
}
ds["targets"].append(d)
# applications
rs = p.populate("applications")
for r in rs:
r = r.populate()
d = {
"name": r["name"],
"linkage": r["linkage"],
"openmp": yn(r["openmp"]),
"pthreads": yn(r["pthreads"]),
"tbb": yn(r["tbb"]),
"mpi": yn(r["mpi"]),
"cuda": yn(r["cuda"]),
"opencl": yn(r["opencl"]),
"shmem": yn(r["shmem"]),
"mpc": yn(r["mpc"])
}
ds["applications"].append(d)
# measurements
rs = p.populate("measurements")
for r in rs:
r = r.populate()
d = {
"name": r["name"],
"profile": r["profile"],
"trace": r["trace"],
"sample": yn(r["sample"]),
"source_inst": r["source_inst"],
"compiler_inst": r["compiler_inst"],
"openmp": r["openmp"],
"cuda": yn(r["cuda"]),
"io": yn(r["io"]),
"mpi": yn(r["mpi"]),
"shmem": yn(r["shmem"])
}
ds["measurements"].append(d)
# experiments
rs = p.populate("experiments")
for r in rs:
r = r.populate()
d = {
"name":
r["name"],
"num_trials":
str(len(r["trials"])),
"data_size":
util.human_size(
sum(int(t.get('data_size', 0)) for t in r["trials"])),
"target":
r["target"]["name"],
"application":
r["application"]["name"],
"measurement":
r["measurement"]["name"],
"tau_makefile":
r["tau_makefile"]
}
ds["experiments"].append(d)
self.set_header("Access-Control-Allow-Origin", "*")
self.finish(ds)
