Remove --commit/--commit=0 flags/settings.

[MatzeB]

Summary

This removes the possibility to not commit a run. It was easy to forget
to pass the commit flag by accident while when you wanted to check the
submission syntax you could just as well use lnt checkformat instead
of submitting without commit.

This also reverts most of the changes in r308256; as there is little use
in making the flag simpler to use when we can just remove it instead.

[MatzeB]

ping

[MatzeB]

Didn't realize I have submitted this twice, D35588 is the newer version.

docs/importing_data.rst

 
 The format is "test-name.metric", so exec and size are valid metrics for the
 test suite you are submitting to.
 
 Example::
 
     echo -n "foo.exec 25\nbar.score 24.2\nbar/baz.size 110.0\n" > results.txt
     lnt importreport --machine=my-machine-name --order=1234 --testsuite=nts results.txt report.json
-    lnt submit http://mylnt.com/default/submitRun --commit report.json
+    lnt submit http://mylnt.com/default/submitRun report.json
 
 .. _json_format:
 
 LNT Report File Format
 ======================
 
 The lnt importreport tool is an easy way to import data into LNTs test format.
 You can also create LNTs report data directly for additional flexibility.

docs/quickstart.rst

You can create a local LNT instance with, e.g.::
     lnt create ~/myperfdb
 
 This will create an LNT instance at ``~/myperfdb`` which includes the
 configuration of the LNT application and a SQLite database for storing the
 results.
 
 Once you have a local instance, you can either submit results directly with::
 
-     lnt import --commit=1 ~/myperfdb SANDBOX/test-<stamp>/report.json
+     lnt import ~/myperfdb SANDBOX/test-<stamp>/report.json
 
 or as part of a run with::
 
      lnt runtest --submit ~/myperfdb nt ... arguments ...
 
 Once you have submitted results into a database, you can run the LNT web UI
 with::
 
      lnt runserver ~/myperfdb
 
 which runs the server on ``http://localhost:8000`` by default.
 
 In the future, LNT will grow a robust set of command line tools to allow
 investigation of performance results without having to use the web UI.

docs/tests.rst

 a limited about of summary information as testing is in progress. The full
 information can be found in .log files within the test build directory (e.g.,
 ``configure.log`` and ``test.log``).
 
 The final test step was to generate a test report inside the test
 directory. This report can now be submitted directly to an LNT server. For
 example, if we have a local server running as described earlier, we can run::
 
-  $ lnt submit --commit http://localhost:8000/submitRun \
+  $ lnt submit http://localhost:8000/submitRun \
       /tmp/BAR/test-2010-04-17_23-46-40/report.json
   STATUS: 0
 
   OUTPUT:
   IMPORT: /tmp/FOO/lnt_tmp/data-2010-04-17_16-54-35ytpQm_.plist
     LOAD TIME: 0.34s
     IMPORT TIME: 5.23s
   ADDED: 1 machines

docs/tools.rst

-----------------
   ``lnt convert <input path> [<output path>]``
     Convert between LNT test report formats. By default, this will convert to
     the property list format. You can use ``-`` for either the input (to read
     from ``stdin) or the output (to write to ``stdout``).
 
   ``lnt importreport <input path> [<output path>]``
     Convert text based key value pairs into a LNT json report file.
 
-  ``lnt submit [--commit] <server url> <file>+``
+  ``lnt submit <server url> <file>+``
     Submits one or more files to the given server. The ``<server url>`` should
     be the url to the actual ``submitRun`` page on the server; the database
     being submitted to is effectively a part of this URL.
 
-    By default, this only submits the report to the server but does not actually
-    commit the data. When testing, you should verify that the server returns an
-    acceptable response before committing runs.
-
   ``lnt showtests``
     List available built-in tests. See the :ref:`tests` documentation for more
     details on this tool.
 
   ``lnt runtest [<run options>] <test name> ... test arguments ...``
     Run a built-in test. See the :ref:`tests` documentation for more
     details on this tool.
 
 Server-Side Tools
 -----------------
 
 The following tools are used to interact with an LNT server:
 
   ``lnt create <path>``
     Creates a new LNT server instance. This command has a number of parameters
     to tweak the generated server, but they can all be modified after the fact
     in the LNT configuration file.
 
     The default server will have a sqlite3 database named *default*. You can
     specify to use PostgreSQL using ``--db-dir postgresql://user@hostname``.
 
   ``lnt createdb <path>``
     Creates a new LNT sqlite3 database at the specified path.
 
-  ``lnt import [--commit] <instance path> <file>+``
+  ``lnt import <instance path> <file>+``
     Import an LNT data file into a database. You can use ``--database`` to
     select the database to write to. Note that by default this will also
     generate report emails if enabled in the configuration, you can use
     ``--no-email`` to disable this.
 
   ``lnt runserver <instance path>``
     Start the LNT server using a development WSGI server. Additional options can
     be used to control the server host and port, as well as useful development

lnt/lnttool/import_data.py

 import click
 import lnt.formats
 
+
 @click.command("import")
 @click.argument("instance_path", type=click.UNPROCESSED)
 @click.argument("files", nargs=-1, type=click.Path(exists=True), required=True)
 @click.option("--database", default="default", show_default=True,
               help="database to modify")
 @click.option("--format", "output_format", show_default=True,
               type=click.Choice(lnt.formats.format_names + ['<auto>']),
               default='<auto>', help="input format")
[e-mail]("--commit", is_flag=True, help="commit changes to the database")
[e-mail]("--commit", type=int, help="deprecated/ignored option",
+              expose_value=False)
 @click.option("--show-sql", is_flag=True, help="show SQL statements")
 @click.option("--show-sample-count", is_flag=True)
 @click.option("--show-raw-result", is_flag=True)
 @click.option("--testsuite", "-s", default='nts')
 @click.option("--verbose", "-v", is_flag=True,
               help="show verbose test results")
 @click.option("--quiet", "-q", is_flag=True, help="don't show test results")
 @click.option("--no-email", is_flag=True, help="don't send e-mail")
 @click.option("--no-report", is_flag=True, help="don't generate report")
-def action_import(instance_path, files, database, output_format, commit,
-                  show_sql, show_sample_count, show_raw_result, testsuite,
-                  verbose, quiet, no_email, no_report):
+def action_import(instance_path, files, database, output_format, show_sql,
+                  show_sample_count, show_raw_result, testsuite, verbose,
+                  quiet, no_email, no_report):
     """import test data into a database"""
     import contextlib
     import lnt.server.instance
     import lnt.util.ImportData
     import pprint
     import sys
 
     # Load the LNT instance.
     instance = lnt.server.instance.Instance.frompath(instance_path)
     config = instance.config
 
     # Get the database.
     with contextlib.closing(config.get_database(database,
                                                 echo=show_sql)) as db:
         # Load the database.
         success = True
         for file_name in files:
             result = lnt.util.ImportData.import_and_report(
-                config, database, db, file_name,
-                output_format, testsuite, commit, show_sample_count,
-                no_email, no_report)
+                config, database, db, file_name, output_format, testsuite,
+                show_sample_count, no_email, no_report)
 
             success &= result.get('success', False)
             if quiet:
                 continue
 
             if show_raw_result:
                 pprint.pprint(result)
             else:
                 lnt.util.ImportData.print_report_result(result, sys.stdout,
                                                         sys.stderr,
                                                         verbose)
 
         if not success:
             raise SystemExit(1)

lnt/lnttool/main.py

 def action_checkformat(input_file, testsuite):
     """check the format of an LNT test report file"""
     import lnt.server.config
     import lnt.server.db.v4db
     import lnt.util.ImportData
     db = lnt.server.db.v4db.V4DB('sqlite:///:memory:',
                                  lnt.server.config.Config.dummy_instance())
     result = lnt.util.ImportData.import_and_report(
-        None, None, db, input_file, 'json', testsuite, commit=True)
+        None, None, db, input_file, 'json', testsuite)
     lnt.util.ImportData.print_report_result(result, sys.stdout, sys.stderr,
                                             verbose=True)
 
 
 def _print_result_url(results, verbose):
     result_url = results.get('result_url')
     if result_url is not None:
         if verbose:
for name in test_names:
         test_module = lnt.tests.get_module(name)
         description = inspect.cleandoc(test_module.__doc__)
         print '  %-*s - %s' % (max_name, name, description)
 
 
 @click.command("submit")
 @click.argument("url")
 @click.argument("files", nargs=-1, type=click.Path(exists=True), required=True)
[e-mail]("--commit", is_flag=True, help="actually commit the data")
[e-mail]("--commit", type=int, help="deprecated/ignored option",
+              expose_value=False)
 @click.option("--verbose", "-v", is_flag=True,
               help="show verbose test results")
-def action_submit(url, files, commit, verbose):
+def action_submit(url, files, verbose):
     """submit a test report to the server"""
     from lnt.util import ServerUtil
     import lnt.util.ImportData
 
-    if commit:
-        commit = True
-    else:
-        commit = False
-        logger.warning("submit called without --commit, " +
-                       "your results will not be saved at the server.")
-
-    files = ServerUtil.submitFiles(url, files, commit, verbose)
+    files = ServerUtil.submitFiles(url, files, verbose)
     for submitted_file in files:
         if verbose:
             lnt.util.ImportData.print_report_result(
                 submitted_file, sys.stdout, sys.stderr, True)
         _print_result_url(submitted_file, verbose)
 
 
 @click.command("update")
def show_version(ctx, param, value):
     if lnt.__version__:
         print "LNT %s" % (lnt.__version__,)
     ctx.exit()
 
 
 @click.group(invoke_without_command=True, no_args_is_help=True)
 @click.option('--version', is_flag=True, callback=show_version,
               expose_value=False, is_eager=True, help=show_version.__doc__)
-def cli():
+def main():
     """LNT command line tool
 
 \b
 Use ``lnt <command> --help`` for more information on a specific command.
     """
-cli.add_command(action_checkformat)
-cli.add_command(action_create)
-cli.add_command(action_convert)
-cli.add_command(action_import)
-cli.add_command(action_importreport)
-cli.add_command(action_profile)
-cli.add_command(action_runserver)
-cli.add_command(action_runtest)
-cli.add_command(action_send_daily_report)
-cli.add_command(action_send_run_comparison)
-cli.add_command(action_showtests)
-cli.add_command(action_submit)
-cli.add_command(action_update)
-cli.add_command(action_updatedb)
-cli.add_command(action_view_comparison)
-
-
-def main():
     _version_check()
-    # Change deprecated `--commit=1` and `--commit 1` options to new ones.
-    for i in range(1, len(sys.argv)):
-        arg = sys.argv[i]
-        if arg == '--commit=1':
-            sys.argv[i] = '--commit'
-        if arg == '--commit' and i+1 < len(sys.argv) and sys.argv[i+1] == '1':
-            del sys.argv[i+1]
-            break
-    cli()
+main.add_command(action_checkformat)
+main.add_command(action_create)
+main.add_command(action_convert)
+main.add_command(action_import)
+main.add_command(action_importreport)
+main.add_command(action_profile)
+main.add_command(action_runserver)
+main.add_command(action_runtest)
+main.add_command(action_send_daily_report)
+main.add_command(action_send_run_comparison)
+main.add_command(action_showtests)
+main.add_command(action_submit)
+main.add_command(action_update)
+main.add_command(action_updatedb)
+main.add_command(action_view_comparison)
 
 
 if __name__ == '__main__':
     main()

lnt/lnttool/updatedb.py

 import click
 
 
 @click.command("updatedb")
 @click.argument("instance_path", type=click.UNPROCESSED)
 @click.option("--database", default="default", show_default=True,
               help="database to modify")
 @click.option("--testsuite", required=True, help="testsuite to modify")
 @click.option("--tmp-dir", default="lnt_tmp", show_default=True,
               help="name of the temp file directory")
[e-mail]("--commit", is_flag=True, help="commit changes to the database")
 @click.option("--show-sql", is_flag=True,
               help="show SQL statements")
 @click.option("--delete-machine", "delete_machines", default=[],
               type=click.UNPROCESSED, show_default=True, multiple=True,
               help="machine names to delete")
 @click.option("--delete-run", "delete_runs", default=[], show_default=True,
               multiple=True, help="run ids to delete", type=int)
 @click.option("--delete-order", default=[], show_default=True,
               help="run ids to delete")
-def action_updatedb(instance_path, database, testsuite, tmp_dir, commit,
-                    show_sql, delete_machines, delete_runs, delete_order):
+def action_updatedb(instance_path, database, testsuite, tmp_dir, show_sql,
+                    delete_machines, delete_runs, delete_order):
     """modify a database"""
     from lnt.util import logger
     import contextlib
     import lnt.server.instance
 
     # Load the instance.
     instance = lnt.server.instance.Instance.frompath(instance_path)
 
with contextlib.closing(instance.get_database(database,
             ts.delete(run)
 
         if delete_machines:
             machines = ts.query(ts.Machine) \
                 .filter(ts.Machine.name.in_(delete_machines)).all()
             for machine in machines:
                 ts.delete(machine)
 
-        if commit:
-            db.commit()
-        else:
-            db.rollback()

lnt/lnttool/viewcomparison.py

try:
         instance = lnt.server.instance.Instance(None, config)
 
         # Create the database.
         lnt.server.db.migrate.update_path(db_path)
 
         # Import the two reports.
         with contextlib.closing(config.get_database('default')) as db:
             r = import_and_report(config, 'default', db, report_a, '<auto>',
-                                  testsuite, commit=True)
+                                  testsuite)
             import_and_report(config, 'default', db, report_b, '<auto>',
-                              testsuite, commit=True)
+                              testsuite)
 
             # Dispatch another thread to start the webbrowser.
             comparison_url = '%s/v4/nts/2?compare_to=1' % (url,)
             logger.info("opening comparison view: %s" % (comparison_url,))
 
             if not dry_run:
                 thread.start_new_thread(_start_browser, (comparison_url, True))
 

lnt/server/db/testsuitedb.py

def _getOrCreateRun(self, run_data, machine):
         try:
             return query.one(), False
         except sqlalchemy.orm.exc.NoResultFound:
             # If not, add the run.
             self.add(run)
 
             return run, True
 
-    def _importSampleValues(self, tests_data, run, commit, config):
+    def _importSampleValues(self, tests_data, run, config):
         # Load a map of all the tests, which we will extend when we find tests
         # that need to be added.
         test_cache = dict((test.name, test)
                           for test in self.query(self.Test))
 
         profiles = dict()
         field_dict = dict([(f.name, f) for f in self.sample_fields])
         for test_data in tests_data:
def _importSampleValues(self, tests_data, run, config):
                     samples.append(sample)
                 for sample, value in zip(samples, values):
                     if key == 'profile':
                         profile = self.Profile(value, config, name)
                         sample.profile = profiles.get(hash(value), profile)
                     else:
                         sample.set_field(field, value)
 
-    def importDataFromDict(self, data, commit, config=None):
+    def importDataFromDict(self, data, config=None):
         """
         importDataFromDict(data) -> bool, Run
 
         Import a new run from the provided test interchange data, and return
         the constructed Run record.
 
         The boolean result indicates whether the returned record was
         constructed or not (i.e., whether the data was a duplicate submission).
         """
 
         # Construct the machine entry.
         machine, inserted = self._getOrCreateMachine(data['machine'])
 
         # Construct the run entry.
         run, inserted = self._getOrCreateRun(data['run'], machine)
 
         # If we didn't construct a new run, this is a duplicate
         # submission. Return the prior Run.
         if not inserted:
             return False, run
 
-        self._importSampleValues(data['tests'], run, commit, config)
+        self._importSampleValues(data['tests'], run, config)
 
         return True, run
 
     # Simple query support (mostly used by templates)
 
     def machines(self, name=None):
         q = self.query(self.Machine)
         if name:

lnt/server/ui/templates/submit_run.html

 {% extends "layout.html" %}
 {% set components = [] %}
 {% block title %}Submit Run{% endblock %}
 {% block body %}
 
 {% if error is defined %}
   <p><font color="#FF0000">{{ error }}</font></p>
 {% endif %}
 
 <form method="post" enctype="multipart/form-data" action="">
 <b>Input File (plist):</b><br/>
 <input type="file" name="file"><br/>
 
 <p><b>Input Data (plist):</b><br/>
 <textarea name="input_data"></textarea>
 
-<p><b>Commit*:</b><br/>
-<select name="commit">
-<option selected="selected" value="0">0</option>
-<option value="1">1</option>
-</select><br/>
-
 <p><input type="submit" name="submit" value="Submit">
 </form>
 
 {% endblock %}

lnt/server/ui/views.py

 # Database Actions
 def _do_submit():
     if request.method == 'GET':
         return render_template("submit_run.html")
 
     assert request.method == 'POST'
     input_file = request.files.get('file')
     input_data = request.form.get('input_data')
-    commit = int(request.form.get('commit', 0)) != 0
 
     if input_file and not input_file.content_length:
         input_file = None
 
     if not input_file and not input_data:
         return render_template(
             "submit_run.html", error="must provide input file or data")
     if input_file and input_data:
if g.testsuite_name is None:
             pass
     if g.testsuite_name is None:
         g.testsuite_name = 'nts'
 
     # Get a DB connection.
     db = request.get_db()
 
     result = lnt.util.ImportData.import_from_string(current_app.old_config,
-        g.db_name, db, g.testsuite_name, data_value, commit=commit)
+        g.db_name, db, g.testsuite_name, data_value)
 
     # It is nice to have a full URL to the run, so fixup the request URL
     # here were we know more about the flask instance.
     if result.get('result_url'):
         result['result_url'] = request.url_root + result['result_url']
 
     response = flask.jsonify(**result)
     if result['error'] is not None:

lnt/tests/builtintest.py

def print_report(report, output):
         if output == '-':
             output_stream = sys.stdout
         else:
             output_stream = open(output, 'w')
         print >> output_stream, report.render()
         if output_stream is not sys.stdout:
             output_stream.close()
 
-    def submit(self, report_path, config, ts_name=None, commit=True):
+    def submit(self, report_path, config, ts_name=None):
         """Submit the results file to the server.  If no server
         was specified, use a local mock server.
 
         report_path is the location of the json report file.  config
-        holds options for submission url, and verbosity.  When commit
-        is true, results will be saved in the server, otherwise you
-        will just get back a report but server state is not altered.
+        holds options for submission url, and verbosity.
 
         Returns the report from the server.
         """
         assert os.path.exists(report_path), "Failed report should have" \
             " never gotten here!"
         assert ts_name is not None
 
         server_report = None
         if config.submit_url is not None:
             self.log("submitting result to %r" % (config.submit_url,))
             server_report = ServerUtil.submitFile(config.submit_url,
                                                   report_path,
-                                                  commit,
                                                   config.verbose)
         else:
             # Simulate a submission to retrieve the results report.
 
             # Construct a temporary database and import the result.
             self.log("submitting result to dummy instance")
 
             db = lnt.server.db.v4db.V4DB("sqlite:///:memory:",
                                          server_config.Config.dummy_instance())
             server_report = ImportData.import_and_report(
-                None, None, db, report_path, 'json', ts_name, commit)
+                None, None, db, report_path, 'json', ts_name)
 
         assert server_report is not None, "Results were not submitted."
 
         ImportData.print_report_result(server_report, sys.stdout, sys.stderr,
                                        config.verbose)
         return server_report
 
     @staticmethod
     def show_results_url(server_results):
         """Print the result URL"""
         if server_results.get('result_url'):
             print "Results available at:", server_results['result_url']
         else:
             print "Results available at: no URL available"

lnt/tests/compile.py

@click.option("--no-machdep-info", "use_machdep_info",
               flag_value=False, default=True)
 @click.option("--machine-name", "machine_name", type=click.UNPROCESSED,
               help="Machine name to use in submission",
               default=platform.uname()[1])
 @click.option("--submit", "submit_url", metavar="URLORPATH",
               help=("autosubmit the test result to the given server "
                     "(or local instance)"),
               type=click.UNPROCESSED, default=None)
[e-mail]("--commit", "commit",
-              help="whether the autosubmit result should be committed",
-              type=int, default=True)
[e-mail]("--commit", "commit", type=int,
+              help="deprecated/ignored option")
 @click.option("--output", "output", metavar="PATH",
               help="write raw report data to PATH (or stdout if '-')")
 @click.option("-v", "--verbose", "verbose",
               help="show verbose test results", is_flag=True)
 def cli_action(*args, **kwargs):
     global opts
 
     compile_test = CompileTest()
     opts = compile_test.opts
 
     for key, value in kwargs.items():
         setattr(compile_test.opts, key, value)
 
     results = compile_test.run_test(compile_test.opts)
     compile_test.show_results_url(results)

lnt/tests/nt.py

def submit_helper(self, config, commit=False):
             "Should have never gotten here!"
 
         result = None
         if config.submit_url:
             from lnt.util import ServerUtil
             for server in config.submit_url:
                 self.log("submitting result to %r" % (server,))
                 try:
-                    result = ServerUtil.submitFile(server, report_path,
-                                                   commit, False)
+                    result = ServerUtil.submitFile(server, report_path, False)
                 except (urllib2.HTTPError, urllib2.URLError) as e:
                     logger.warning("submitting to {} failed with {}"
                                    .format(server, e))
         else:
             # Simulate a submission to retrieve the results report.
             # Construct a temporary database and import the result.
             self.log("submitting result to dummy instance")
 
             import lnt.server.db.v4db
             import lnt.server.config
             db = lnt.server.db.v4db.V4DB("sqlite:///:memory:",
                                          lnt.server.config.Config.dummy_instance())
             result = lnt.util.ImportData.import_and_report(
-                None, None, db, report_path, 'json', 'nts', commit)
+                None, None, db, report_path, 'json', 'nts')
 
         if result is None:
             fatal("Results were not obtained from submission.")
 
         return result
 
 
 def _tools_check():
@click.option("--run-param", "run_parameters",
               metavar="NAME=VAL",
               help="Add 'NAME' = 'VAL' to the run parameters",
               type=click.UNPROCESSED, multiple=True, default=[])
 @click.option("--submit", "submit_url", metavar="URLORPATH",
               help=("autosubmit the test result to the given server"
                     " (or local instance)"),
               type=click.UNPROCESSED, default=[], multiple=True)
 @click.option("--commit", "commit",
-              help="whether the autosubmit result should be committed",
-              type=int, default=True)
+              help="deprecated/ignored option", type=int, default=True)
 @click.option("--output", "output", metavar="PATH",
               help="write raw report data to PATH (or stdout if '-')",
               default=None)
 @click.option("-v", "--verbose", "verbose",
               help="show verbose test results", is_flag=True)
 @click.option("--exclude-stat-from-submission",
               "exclude_stat_from_submission",
               help="Do not submit the stat of this type ",

lnt/tests/test_suite.py

def run_test(self, opts):
             fd.write(str_template)
 
         csv_report_path = os.path.join(self._base_path,
                                        'test-results.csv')
         str_template = _lit_json_to_csv(json_reports)
         with open(csv_report_path, 'w') as fd:
             fd.write(str_template)
 
-        return self.submit(report_path, self.opts, 'nts', commit=True)
+        return self.submit(report_path, self.opts, 'nts')
 
     def _configure_if_needed(self):
         mkdir_p(self._base_path)
         if not self.configured:
             self._configure(self._base_path)
             self._clean(self._base_path)
             self.configured = True
 
@click.option("--no-auto-name", "auto_name",
               help="Don't automatically derive submission name",
               flag_value=False, default=True)
 @click.option("--run-order", "run_order", metavar="STR",
               help="String to use to identify and order this run")
 @click.option("--submit", "submit_url", metavar="URLORPATH",
               help="autosubmit the test result to the given server"
                    " (or local instance)",
               type=click.UNPROCESSED, default=None)
[e-mail]("--commit", "commit",
-              help="whether the autosubmit result should be committed",
-              type=int, default=True)
[e-mail]("--commit", "commit", type=int,
+              help="deprecated/ignored option")
 @click.option("--succinct-compile-output", "succinct",
               help="run Make without VERBOSE=1", is_flag=True)
 @click.option("-v", "--verbose", "verbose", is_flag=True, default=False,
               help="show verbose test results")
 @click.option("--exclude-stat-from-submission",
               "exclude_stat_from_submission",
               help="Do not submit the stat of this type",
               multiple=True, default=[],

lnt/util/ImportData.py

 from lnt.util import NTEmailReport
 from lnt.util import async_ops
 from lnt.util import logger
 import collections
 import datetime
 import lnt.formats
 import lnt.server.reporting.analysis
 import lnt.testing
 import os
 import re
 import tempfile
 import time
 
 def import_and_report(config, db_name, db, file, format, ts_name,
-                      commit=False, show_sample_count=False,
-                      disable_email=False, disable_report=False):
+                      show_sample_count=False, disable_email=False,
+                      disable_report=False):
     """
     import_and_report(config, db_name, db, file, format, ts_name,
-                      [commit], [show_sample_count],
-                      [disable_email]) -> ... object ...
+                      [show_sample_count], [disable_email]) -> ... object ...
 
     Import a test data file into an LNT server and generate a test report. On
-    success, run is the newly imported run. Note that success is uneffected by
-    the value of commit, this merely changes whether the run (on success) is
-    committed to the database.
+    success, run is the newly imported run.
 
     The result object is a dictionary containing information on the imported run
     and its comparison to the previous run.
     """
     result = {
         'success': False,
         'error': None,
         'import_file': file,
def import_and_report(config, db_name, db, file, format, ts_name,
     importStartTime = time.time()
     try:
         data_schema = data.get('schema')
         if data_schema is not None and data_schema != ts_name:
             result['error'] = ("Importing '%s' data into test suite '%s'" %
                                (data_schema, ts_name))
             return result
 
-        success, run = ts.importDataFromDict(data, commit, config=db_config)
+        success, run = ts.importDataFromDict(data, config=db_config)
     except KeyboardInterrupt:
         raise
     except Exception as e:
         import traceback
         result['error'] = "import failure: %s" % e.message
         result['message'] = traceback.format_exc()
         return result
 
if not disable_report:
                                   toAddress, success)
 
     result['added_machines'] = ts.getNumMachines() - numMachines
     result['added_runs'] = ts.getNumRuns() - numRuns
     result['added_tests'] = ts.getNumTests() - numTests
     if show_sample_count:
         result['added_samples'] = ts.getNumSamples() - numSamples
 
-    result['committed'] = commit
+    result['committed'] = True
     result['run_id'] = run.id
-    if commit:
-        ts.commit()
-        if db_config:
-            #  If we are not in a dummy instance, also run background jobs.
-            #  We have to have a commit before we run, so subprocesses can
-            #  see the submitted data.
-            async_ops.async_fieldchange_calc(db_name, ts, run, config)
 
-    else:
-        ts.rollback()
     # Add a handy relative link to the submitted run.
-
     result['result_url'] = "db_{}/v4/{}/{}".format(db_name, ts_name, run.id)
     result['report_time'] = time.time() - importStartTime
     result['total_time'] = time.time() - startTime
     logger.info("Successfully created {}".format(result['result_url']))
     # If this database has a shadow import configured, import the run into that
     # database as well.
     if config and config.databases[db_name].shadow_import:
         # Load the shadow database to import into.
         db_config = config.databases[db_name]
         shadow_name = db_config.shadow_import
         with closing(config.get_database(shadow_name)) as shadow_db:
             if shadow_db is None:
                 raise ValueError, ("invalid configuration, shadow import "
                                    "database %r does not exist") % shadow_name
 
             # Perform the shadow import.
             shadow_result = import_and_report(config, shadow_name,
                                               shadow_db, file, format, ts_name,
-                                              commit, show_sample_count,
-                                              disable_email, disable_report)
+                                              show_sample_count, disable_email,
+                                              disable_report)
 
             # Append the shadow result to the result.
             result['shadow_result'] = shadow_result
 
     result['success'] = True
     return result
 
 def print_report_result(result, out, err, verbose = True):
for i,item in enumerate(test_results):
                 print >>out, result_info
                 print >>out, "*" * 20
 
     if 'original_run' in result:
         print >>out, ("This submission is a duplicate of run %d, "
                       "already in the database.") % result['original_run']
         print >>out
 
-    if not result['committed']:
-        print >>out, "NOTE: This run was not committed!"
-        print >>out
-
     if result['report_to_address']:
         print >>out, "Report emailed to: %r" % result['report_to_address']
         print >>out
 
     # Print the processing times.
     print >>out, "Processing Times"
     print >>out, "----------------"
     print >>out, "Load   : %.2fs" % result['load_time']
if total_added:
             print >>out, "Added Samples : %d" % result['added_samples']
         print >>out
     print >>out, "Results"
     print >>out, "----------------"
     for kind, count in result_kinds.items():
         print >>out, kind, ":", count
 
 
-def import_from_string(config, db_name, db, ts_name, data, commit=True):
+def import_from_string(config, db_name, db, ts_name, data):
     # Stash a copy of the raw submission.
     #
     # To keep the temporary directory organized, we keep files in
     # subdirectories organized by (database, year-month).
     utcnow = datetime.datetime.utcnow()
     tmpdir = os.path.join(config.tempDir, db_name,
                           "%04d-%02d" % (utcnow.year, utcnow.month))
     try:
def import_from_string(config, db_name, db, ts_name, data):
     os.close(fd)
 
     # Import the data.
     #
     # FIXME: Gracefully handle formats failures and DOS attempts. We
     # should at least reject overly large inputs.
 
     result = lnt.util.ImportData.import_and_report(config, db_name, db,
-            path, '<auto>', ts_name, commit)
+                                                   path, '<auto>', ts_name)
     return result

lnt/util/ServerUtil.py

def _show_json_error(reply):
     except ValueError:
         print "error: {}".format(reply)
         return
     sys.stderr.write("lnt server error: {}\n".format(error.get('error')))
     message = error.get('message', '')
     if message:
         sys.stderr.write(message + '\n')
 
-def submitFileToServer(url, file, commit):
+def submitFileToServer(url, file):
     with open(file, 'rb') as f:
-        values = { 'input_data' : f.read(),
-                   'commit' : ("0","1")[not not commit] }
+        values = {
+            'input_data' : f.read(),
+            'commit' : "1", # used by older servers
+        }
     headers = {'Accept': 'application/json'}
     data = urllib.urlencode(values)
     try:
         response = urllib2.urlopen(urllib2.Request(url, data, headers=headers))
     except urllib2.HTTPError as e:
         _show_json_error(e.read())
         return
     result_data = response.read()
except:
         print
         print "Result:"
         print "error:", result_data
         return
 
     return reply
 
 
-def submitFileToInstance(path, file, commit):
+def submitFileToInstance(path, file):
     # Otherwise, assume it is a local url and submit to the default database
     # in the instance.
     instance = lnt.server.instance.Instance.frompath(path)
     config = instance.config
     db_name = 'default'
     with contextlib.closing(config.get_database(db_name)) as db:
         if db is None:
             raise ValueError("no default database in instance: %r" % (path,))
         return lnt.util.ImportData.import_and_report(
-            config, db_name, db, file, format='<auto>', ts_name='nts',
-            commit=commit)
+            config, db_name, db, file, format='<auto>', ts_name='nts')
 
 
-def submitFile(url, file, commit, verbose):
+def submitFile(url, file, verbose):
     # If this is a real url, submit it using urllib.
     if '://' in url:
-        result = submitFileToServer(url, file, commit)
+        result = submitFileToServer(url, file)
         if result is None:
             return
     else:
-        result = submitFileToInstance(url, file, commit)
+        result = submitFileToInstance(url, file)
     return result
 
 
-def submitFiles(url, files, commit, verbose):
+def submitFiles(url, files, verbose):
     results = []
     for file in files:
-        result = submitFile(url, file, commit, verbose)
+        result = submitFile(url, file, verbose)
         if result:
             results.append(result)
     return results

tests/lnttool/PostgresDB.shtest

 # REQUIRES: postgres
 # RUN: rm -rf "%t.install"
 # RUN: %{shared_inputs}/postgres_wrapper.sh "%t.install" /bin/sh %s "%t.install" postgresql://pgtest@localhost:9100 "%{shared_inputs}"
 set -eux
 
 TESTDIR="$1"
 PGURL="$2"
 SHARED_INPUTS="$3"
 dropdb --if-exists --maintenance-db="${PGURL}/postgres" lnt_regr_test_PostgresDB
 createdb --maintenance-db="${PGURL}/postgres" lnt_regr_test_PostgresDB
 
 lnt create "${TESTDIR}/instance" --db-dir ${PGURL} --default-db lnt_regr_test_PostgresDB
 
 # Import a test set.
-lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --commit --show-sample-count
+lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --show-sample-count
 
 # Import a test set.
-lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --commit --show-sample-count
+lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --show-sample-count
 
 # Check that we remove both the sample and the run, and that we don't commit by
 # default.
 #
 lnt updatedb "${TESTDIR}/instance" --testsuite nts --delete-run 1 \
-  --commit --show-sql > "${TESTDIR}/runrm.out"
+  --show-sql > "${TESTDIR}/runrm.out"
 # RUN: FileCheck --check-prefix CHECK-RUNRM %s < "%t.install/runrm.out"
 
 # CHECK-RUNRM: DELETE FROM "NT_Sample" WHERE "NT_Sample"."ID" = %(ID)s
 # CHECK-RUNRM-NEXT: ({'ID': 1}, {'ID': 2})
 # CHECK-RUNRM: DELETE FROM "NT_Run" WHERE "NT_Run"."ID" = %(ID)s
 # CHECK-RUNRM-NEXT: {'ID': 1}
 # CHECK-RUNRM: COMMIT
 
 # Import a test set.
-lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --commit --show-sample-count
+lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --show-sample-count
 
 # Check that we remove runs when we remove a machine.
 #
 lnt updatedb "${TESTDIR}/instance" --testsuite nts \
-  --delete-machine "LNT SAMPLE MACHINE" --commit \
+  --delete-machine "LNT SAMPLE MACHINE" \
   --show-sql > "${TESTDIR}/machinerm.out"
 # RUN: FileCheck --check-prefix CHECK-MACHINERM %s < "%t.install/machinerm.out"
 
 # CHECK-MACHINERM: DELETE FROM "NT_Sample" WHERE "NT_Sample"."ID" = %(ID)s
 # CHECK-MACHINERM-NEXT: ({'ID': 3}, {'ID': 4})
 # CHECK-MACHINERM: DELETE FROM "NT_Run" WHERE "NT_Run"."ID" = %(ID)s
 # CHECK-MACHINERM-NEXT: {'ID': 2}
 # CHECK-MACHINERM: DELETE FROM "NT_Machine" WHERE "NT_Machine"."ID" = %(ID)s
 # CHECK-MACHINERM-NEXT: {'ID': 1}
 # CHECK-MACHINERM: COMMIT

tests/lnttool/UpdateDB.py

 # RUN: rm -rf %t.install
 # RUN: lnt create %t.install
 
 # Import a test set.
 # RUN: lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count
+# RUN:     --show-sample-count
 
 # Check that we remove both the sample and the run, and that we don't commit by
 # default.
 #
 # RUN: lnt updatedb %t.install --testsuite nts \
-# RUN:     --commit --delete-run 1 --show-sql > %t.out
+# RUN:     --delete-run 1 --show-sql > %t.out
 # RUN: FileCheck --check-prefix CHECK-RUNRM %s < %t.out
 
 # CHECK-RUNRM: DELETE FROM "NT_Sample" WHERE "NT_Sample"."ID" = ?
 # CHECK-RUNRM-NEXT: ((1,), (2,))
 # CHECK-RUNRM: DELETE FROM "NT_Run" WHERE "NT_Run"."ID" = ?
 # CHECK-RUNRM-NEXT: (1,)
 # CHECK-RUNRM: COMMIT
 
 # Check that we remove runs when we remove a machine.
 #
 # RUN: rm -rf %t.install
 # RUN: lnt create %t.install
 # RUN: lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count
+# RUN:     --show-sample-count
 # RUN: lnt updatedb %t.install --testsuite nts \
-# RUN:     --delete-machine "LNT SAMPLE MACHINE" --commit --show-sql > %t.out
+# RUN:     --delete-machine "LNT SAMPLE MACHINE" --show-sql > %t.out
 # RUN: FileCheck --check-prefix CHECK-MACHINERM %s < %t.out
 
 # CHECK-MACHINERM: DELETE FROM "NT_Sample" WHERE "NT_Sample"."ID" = ?
 # CHECK-MACHINERM-NEXT: ((1,), (2,))
 # CHECK-MACHINERM: DELETE FROM "NT_Run" WHERE "NT_Run"."ID" = ?
 # CHECK-MACHINERM-NEXT: (1,)
 # CHECK-MACHINERM: DELETE FROM "NT_Machine" WHERE "NT_Machine"."ID" = ?
 # CHECK-MACHINERM-NEXT: (1,)
 # CHECK-MACHINERM: COMMIT

tests/lnttool/submit.shtest

 # RUN: rm -rf %t.instance
 # RUN: python %{shared_inputs}/create_temp_instance.py \
 # RUN:   %s %{shared_inputs}/SmallInstance %t.instance
 # RUN: %{shared_inputs}/server_wrapper.sh %t.instance 9091 \
 # RUN:    /bin/sh %s %T %S/Inputs %{shared_inputs} %{src_root}
 
 OUTPUT_DIR="$1"
 INPUTS="$2"
 SHARED_INPUTS="$3"
 SRC_ROOT="$4"
 
-lnt submit "http://localhost:9091/db_default/submitRun" --commit 1 "${SHARED_INPUTS}/sample-report.json" -v > "${OUTPUT_DIR}/submit_verbose.txt"
+lnt submit "http://localhost:9091/db_default/submitRun" "${SHARED_INPUTS}/sample-report.json" -v > "${OUTPUT_DIR}/submit_verbose.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-VERBOSE < %T/submit_verbose.txt
 #
 # CHECK-VERBOSE: Import succeeded.
 # CHECK-VERBOSE: --- Tested: 10 tests --
 #
 # CHECK-VERBOSE: Imported Data
 # CHECK-VERBOSE: -------------
 # CHECK-VERBOSE: Added Machines: 1
 # CHECK-VERBOSE: Added Runs    : 1
 # CHECK-VERBOSE: Added Tests   : 2
 #
 # CHECK-VERBOSE: Results
 # CHECK-VERBOSE: ----------------
 # CHECK-VERBOSE: PASS : 10
 # CHECK-VERBOSE: Results available at: http://localhost:9091/db_default/v4/nts/3
 
 
-lnt submit "http://localhost:9091/db_default/submitRun" --commit "${SHARED_INPUTS}/sample-report.json" > "${OUTPUT_DIR}/submit0.txt"
+lnt submit "http://localhost:9091/db_default/submitRun" "${SHARED_INPUTS}/sample-report.json" > "${OUTPUT_DIR}/submit0.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-DEFAULT < %T/submit0.txt
 #
 # Make sure the old --commit=1 style argument is still accepted.
 lnt submit "http://localhost:9091/db_default/submitRun" --commit=1 "${SHARED_INPUTS}/sample-report.json" > "${OUTPUT_DIR}/submit1.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-DEFAULT < %T/submit1.txt
 
 lnt submit "http://localhost:9091/db_default/submitRun" --commit 1 "${SHARED_INPUTS}/sample-report.json" > "${OUTPUT_DIR}/submit2.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-DEFAULT < %T/submit2.txt
 
 # CHECK-DEFAULT: http://localhost:9091/db_default/v4/nts/3
 
 
-lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/compile_submission.json" -v > "${OUTPUT_DIR}/submit_compile.txt"
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" "${INPUTS}/compile_submission.json" -v > "${OUTPUT_DIR}/submit_compile.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-COMPILE0 < %T/submit_compile.txt
 #
 # CHECK-COMPILE0: --- Tested: 10 tests --
 #
 # CHECK-COMPILE0: Imported Data
 # CHECK-COMPILE0: -------------
 # CHECK-COMPILE0: Added Machines: 1
 # CHECK-COMPILE0: Added Runs    : 1
 # CHECK-COMPILE0: Added Tests   : 2
 #
 # CHECK-COMPILE0: Results
 # CHECK-COMPILE0: ----------------
 # CHECK-COMPILE0: PASS : 10
 # CHECK-COMPILE0: Results available at: http://localhost:9091/db_default/v4/compile/5
 
-lnt submit "http://localhost:9091/db_default/submitRun" --commit "${SRC_ROOT}/docs/report-example.json" -v > "${OUTPUT_DIR}/submit_newformat.txt"
+lnt submit "http://localhost:9091/db_default/submitRun" "${SRC_ROOT}/docs/report-example.json" -v > "${OUTPUT_DIR}/submit_newformat.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-NEWFORMAT < %T/submit_newformat.txt
 #
 # CHECK-NEWFORMAT: Import succeeded.
 # CHECK-NEWFORMAT: --- Tested: 10 tests --
 #
 # CHECK-NEWFORMAT: Imported Data
 # CHECK-NEWFORMAT: -------------
 # CHECK-NEWFORMAT: Added Machines: 1
 # CHECK-NEWFORMAT: Added Runs    : 1
 # CHECK-NEWFORMAT: Added Tests   : 2
 #
 # CHECK-NEWFORMAT: Results
 # CHECK-NEWFORMAT: ----------------
 # CHECK-NEWFORMAT: PASS : 10
 # CHECK-NEWFORMAT: Results available at: http://localhost:9091/db_default/v4/nts/4
 
 # For the old submitters/formats we have some detection logic to determine the
 # test-suite based on the Info.Run.tag field instead of the URL. The result
 # should be the same as using the "correct" URL.
-lnt submit "http://localhost:9091/db_default/submitRun" --commit "${INPUTS}/compile_submission.json" -v > "${OUTPUT_DIR}/submit_compile1.txt"
+lnt submit "http://localhost:9091/db_default/submitRun" "${INPUTS}/compile_submission.json" -v > "${OUTPUT_DIR}/submit_compile1.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-COMPILE1 < %T/submit_compile1.txt
 #
 # CHECK-COMPILE1: Import succeeded.
 #
 # CHECK-COMPILE1: Results
 # CHECK-COMPILE1: ----------------
 # CHECK-COMPILE1: PASS : 10
 # CHECK-COMPILE1: Results available at: http://localhost:9091/db_default/v4/compile/5
 
 # Check some error handling/reporting
 rm -f "${OUTPUT_DIR}/submit_errors.txt"
-lnt submit "http://localhost:9091/db_default/v4/badsuite/submitRun" --commit "${INPUTS}/compile_submission.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
+lnt submit "http://localhost:9091/db_default/v4/badsuite/submitRun" "${INPUTS}/compile_submission.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
 # RUN: FileCheck %s --check-prefix=CHECK-ERRORS < %T/submit_errors.txt
 # CHECK-ERRORS: lnt server error: Unknown test suite 'badsuite'!
-lnt submit "http://localhost:9091/db_baddb/v4/compile/submitRun" --commit "${INPUTS}/compile_submission.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
+lnt submit "http://localhost:9091/db_baddb/v4/compile/submitRun" "${INPUTS}/compile_submission.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
 # CHECK-ERRORS: lnt server error: The page you are looking for does not exist.
-lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/invalid_submission0.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" "${INPUTS}/invalid_submission0.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
 # CHECK-ERRORS: lnt server error: could not parse input format
 # ...
 # CHECK-ERRORS: SystemExit: unable to guess input format for
-lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/invalid_submission1.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" "${INPUTS}/invalid_submission1.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
 # CHECK-ERRORS: lnt server error: import failure: machine
 # ...
 # CHECK-ERRORS: KeyError: 'machine'

tests/server/db/ImportProfile.py

 # Check that we can import profiles into a test DB
 #
 # We first construct a temporary LNT instance.
 # RUN: rm -rf %t.install
 # RUN: lnt create %t.install
 
 # Import the test set
 # RUN: lnt import %t.install %S/Inputs/profile-report.json \
-# RUN:   --commit --show-sample-count > %t2.log
+# RUN:   --show-sample-count > %t2.log
 # RUN: ls %t.install/data/profiles
 # RUN: python %s %t.install
 
 import os, sys, glob
 from lnt.testing.profile.profilev1impl import ProfileV1
 
 profile = glob.glob('%s/data/profiles/*.lntprof' % sys.argv[1])[0]
 assert ProfileV1.checkFile(profile)

tests/server/db/ImportV4TestSuiteInstance.py

 # Check the import process into a v4 test suite DB.
 #
 # We first construct a temporary LNT instance.
 # RUN: rm -rf %t.install
 # RUN: lnt create %t.install
 
 # Import the first test set.
 # RUN: lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count > %t1.log
+# RUN:     --show-sample-count > %t1.log
 # RUN: FileCheck -check-prefix=IMPORT-A-1 %s < %t1.log
 #
 # IMPORT-A-1: Added Machines: 1
 # IMPORT-A-1: Added Runs : 1
 # IMPORT-A-1: Added Tests : 1
 # IMPORT-A-1: Added Samples : 2
 
 # Import the second test set.
 # RUN: lnt import %t.install %{shared_inputs}/sample-b-small.plist \
-# RUN:     --commit --show-sample-count --show-sql > %t2.log
+# RUN:     --show-sample-count --show-sql > %t2.log
 # RUN: FileCheck -check-prefix=IMPORT-B %s < %t2.log
 #
 # IMPORT-B: Added Runs : 1
 # IMPORT-B: Added Samples : 1
 
 # Check that reimporting the first test set properly reports as a duplicate.
 # RUN: lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count > %t3.log
+# RUN:     --show-sample-count > %t3.log
 # RUN: FileCheck -check-prefix=IMPORT-A-2 %s < %t3.log
 #
 # IMPORT-A-2: This submission is a duplicate of run 1
 
 # Dump a copy of the database, so it will show up in logs.
 # RUN: sqlite3 %t.install/data/lnt.db .dump
 
 # Run consistency checks on the final database, to validate the import.

tests/server/db/search.py

def setUp(self):
                 data = open(os.path.join(base_path, 'Inputs/report.json.in')) \
                     .read() \
                     .replace('@@MACHINE@@', r[0]) \
                     .replace('@@ORDER@@', r[1])
                 open(f.name, 'w').write(data)
     
                 result = lnt.util.ImportData.import_and_report(
                     None, 'default', self.db, f.name,
-                    '<auto>', 'nts', True, False,
-                    True, True)
+                    '<auto>', 'nts', show_sample_count=False,
+                    disable_email=True, disable_report=True)
 
                 success &= result.get('success', False)
 
         assert success
 
     def _mangleResults(self, rs):
         return [(r.machine.name, str(r.order.llvm_project_revision))
                 for r in rs]

tests/server/db/yamlschema.shtest

 # RUN: rm -rf "%t.install"
 # RUN: lnt create "%t.install"
 # RUN: ln -sf %{src_root}/docs/schema-example.yaml "%t.install/schemas/size.yaml"
-# RUN: lnt import "%t.install" -s size %S/Inputs/customschema-report.json --commit | FileCheck %s
+# RUN: lnt import "%t.install" -s size %S/Inputs/customschema-report.json | FileCheck %s
 
 # CHECK: Import succeeded.
 # CHECK: Imported Data
 # CHECK-NEXT: -------------
 # CHECK-NEXT: Added Machines: 1
 # CHECK-NEXT: Added Runs    : 1
 # CHECK-NEXT: Added Tests   : 1
 #
 # CHECK: Results
 # CHECK: ----------------
 # CHECK: PASS : 3
 
 
 # Migration Tests
 # ===============
 #
 # Inserting with an extra field shouldn't work just yet
-# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report2.json" --commit 2>&1 | FileCheck %s --check-prefix=NOTUPGRADED
+# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report2.json" 2>&1 | FileCheck %s --check-prefix=NOTUPGRADED
 # NOTUPGRADED: Metric u'newfield' unknown in suite
 
 # Upgrading to a schema with metrics/fields removed should fail
 # RUN: rm -f "%t.install/schemas/size.yaml"
 # RUN: ln -sf "%S/Inputs/schema-example-nomigration0.yaml" "%t.install/schemas/size.yaml"
-# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report.json" --commit 2>&1 | FileCheck %s --check-prefix=NOMIGRATION0
+# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report.json" 2>&1 | FileCheck %s --check-prefix=NOMIGRATION0
 # NOMIGRATION0: Cannot automatically migrate database: Metrics removed: data_size
 #
 # RUN: rm -f "%t.install/schemas/size.yaml"
 # RUN: ln -sf "%S/Inputs/schema-example-nomigration1.yaml" "%t.install/schemas/size.yaml"
-# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report.json" --commit 2>&1 | FileCheck %s --check-prefix=NOMIGRATION1
+# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report.json" 2>&1 | FileCheck %s --check-prefix=NOMIGRATION1
 # NOMIGRATION1: Cannot automatically migrate database: Machine fields removed: os
 #
 # RUN: rm -f "%t.install/schemas/size.yaml"
 # RUN: ln -sf "%S/Inputs/schema-example-nomigration2.yaml" "%t.install/schemas/size.yaml"
-# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report.json" --commit 2>&1 | FileCheck %s --check-prefix=NOMIGRATION2
+# RUN: not lnt import "%t.install" -s size "%S/Inputs/customschema-report.json" 2>&1 | FileCheck %s --check-prefix=NOMIGRATION2
 # NOMIGRATION2: Cannot automatically migrate database: Type mismatch in metric 'data_size'
 
 
 # This upgrade should finally work
 # RUN: rm -f "%t.install/schemas/size.yaml"
 # RUN: ln -sf "%S/Inputs/schema-example-migratable.yaml" "%t.install/schemas/size.yaml"
-# RUN: lnt import "%t.install" "%S/Inputs/customschema-report2.json" -s size --commit --show-sql 2>&1 | FileCheck %s --check-prefix=MIGRATION
+# RUN: lnt import "%t.install" "%S/Inputs/customschema-report2.json" -s size --show-sql 2>&1 | FileCheck %s --check-prefix=MIGRATION
 #
 # MIGRATION: ALTER TABLE "size_Sample" ADD COLUMN newfield FLOAT
 # MIGRATION: ALTER TABLE "size_Run" ADD COLUMN new_run_field VARCHAR(256)
 # MIGRATION: ALTER TABLE "size_Machine" ADD COLUMN new_machine_field VARCHAR(256)
 #
 # MIGRATION: Import succeeded.
 # MIGRATION: Imported Data
 # MIGRATION-NEXT: -------------
 # MIGRATION-NEXT: Added Runs    : 1
 #
 # MIGRATION: Results
 # MIGRATION: PASS : 4

tests/utils/blast.py

 import random
 import sys
 
 TESTS = ["about", "after", "again", "air", "all", "along", "also", "an", "and", "another", "any", "are", "around", "as", "at", "away", "back", "be", "because", "been", "before", "below", "between", "both", "but", "by", "came", "can", "come", "could", "day", "did", "different", "do", "does", "don't", "down", "each", "end", "even", "every", "few", "find", "first", "for", "found", "from", "get", "give", "go", "good", "great", "had", "has", "have", "he", "help", "her", "here", "him", "his", "home", "house", "how", "I", "if", "in", "into", "is", "it", "its", "just", "know", "large", "last", "left", "like", "line", "little", "long", "look", "made", "make", "man", "many", "may", "me", "men", "might", "more", "most", "Mr.", "must", "my", "name", "never", "new", "next", "no", "not", "now", "number", "of", "off", "old", "on", "one", "only", "or", "other", "our", "out", "over", "own", "part", "people", "place", "put", "read", "right", "said", "same", "saw", "say", "see", "she", "should", "show", "small", "so", "some", "something", "sound", "still", "such", "take", "tell", "than", "that", "the", "them", "then", "there", "these", "they", "thing", "think", "this", "those", "thought", "three", "through", "time", "to", "together", "too", "two", "under", "up", "us", "use", "very", "want", "water", "way", "we", "well", "went", "were", "what", "when", "where", "which", "while", "who", "why", "will", "with", "word", "work", "world", "would", "write", "year", "you", "your", "was"]
 
 def external_submission(url, fname):
     """Use a LNT subprocess to submit our results."""
     assert os.path.exists(fname)
-    cmd = "lnt submit --verbose --commit {url} {file}".format(
+    cmd = "lnt submit --verbose {url} {file}".format(
         url=url, file=fname)
     print "Calling " + cmd
     subprocess.check_call(cmd, shell=True)
     
     
 def rand_sample():
     """Make a random sized list of random samples."""
     r = random.randint(1,20)