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

[MatzeB]

Summary

This removes the possibility to submit but not commit a run.

• Most users want to commit, and it was easy to forget the flag.
• If the intention is to check a submission for errors, lnt checkformat can be used.

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.

[grosser]

Interesting. I wonder if one use case for this option was to submit (but not commit) a run and then just obtain a set of performance comparisons against the last submitted run. I think I have seen this pattern once, but I am not using it.

I personally won't be affected by the removal of this option, so I am fine with dropping it immediately. Now, a slightly less agressive approach would be to just switch it's default value, deprecate it and wait for a release or two to actually remove it.

[MatzeB]

Rebase to ToT

[kristof.beyls]

In D35588#819693, @grosser wrote:

Interesting. I wonder if one use case for this option was to submit (but not commit) a run and then just obtain a set of performance comparisons against the last submitted run. I think I have seen this pattern once, but I am not using it.

I personally won't be affected by the removal of this option, so I am fine with dropping it immediately. Now, a slightly less agressive approach would be to just switch it's default value, deprecate it and wait for a release or two to actually remove it.

I also don't know of any team using the submit-without-commit functionality. So, from my point-of-view, dropping this functionality is also fine.

lnt/trunk/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.

lnt/trunk/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.

lnt/trunk/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

lnt/trunk/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.
 
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 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/trunk/lnt/lnttool/common.py

 from lnt.util import logger
 import click
 import logging
 
 
 def submit_options(func):
-    func = click.option("--commit", is_flag=True,
-                        help="actually commit the data")(func)
+    func = click.option("--commit", type=int, help="deprecated/ignored option",
+                        expose_value=False)(func)
     func = click.option("--update-machine", is_flag=True,
                         help="Update machine fields")(func)
     func = click.option("--merge", default="replace", show_default=True,
                         type=click.Choice(['reject', 'replace', 'append']),
                         help="Merge strategy when run already exists")(func)
     return func
 
 

lnt/trunk/lnt/lnttool/import_data.py

 @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")
 @submit_options
 def action_import(instance_path, files, database, output_format, show_sql,
                   show_sample_count, show_raw_result, testsuite, verbose,
-                  quiet, no_email, no_report, commit, update_machine, merge):
+                  quiet, no_email, no_report, update_machine, merge):
     """import test data into a database"""
     import contextlib
     import lnt.server.instance
     import lnt.util.ImportData
     import pprint
     import sys
     import logging
     from .common import init_logger
 
     init_logger(logging.INFO if show_sql else logging.WARNING,
                 show_sql=show_sql)
 
     # 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)) 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, updateMachine=update_machine,
-                mergeRun=merge)
+                output_format, testsuite, show_sample_count, no_email,
+                no_report, updateMachine=update_machine, mergeRun=merge)
 
             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/trunk/lnt/lnttool/main.py

def action_checkformat(files, testsuite):
     """check the format of LNT test report files"""
     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())
     for file in files:
         result = lnt.util.ImportData.import_and_report(
-            None, None, db, file, '<auto>', testsuite, commit=True)
+            None, None, db, file, '<auto>', testsuite)
         lnt.util.ImportData.print_report_result(result, sys.stdout,
                                                 sys.stderr, verbose=True)
 
 
 @click.command("check-no-errors")
 @click.argument("files", nargs=-1, type=click.Path(exists=True))
 def action_check_no_errors(files):
     '''Check that report contains "no_error": true.'''

 
 
 @click.command("submit")
 @click.argument("url")
 @click.argument("files", nargs=-1, type=click.Path(exists=True), required=True)
 @submit_options
 @click.option("--verbose", "-v", is_flag=True,
               help="show verbose test results")
-def action_submit(url, files, commit, update_machine, merge, verbose):
+def action_submit(url, files, update_machine, merge, 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,
                                    updateMachine=update_machine,
                                    mergeRun=merge)
     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)
 
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_check_no_errors)
-cli.add_command(action_checkformat)
-cli.add_command(action_convert)
-cli.add_command(action_create)
-cli.add_command(action_import)
-cli.add_command(action_importreport)
-cli.add_command(action_profile)
-cli.add_command(action_runserver)
-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)
-cli.add_command(group_admin)
-cli.add_command(group_runtest)
-
-
-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_check_no_errors)
+main.add_command(action_checkformat)
+main.add_command(action_convert)
+main.add_command(action_create)
+main.add_command(action_import)
+main.add_command(action_importreport)
+main.add_command(action_profile)
+main.add_command(action_runserver)
+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)
+main.add_command(group_admin)
+main.add_command(group_runtest)
 
 
 if __name__ == '__main__':
     main()

lnt/trunk/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 .common import init_logger
     from lnt.util import logger
     import contextlib
     import lnt.server.instance
     import logging
 
     init_logger(logging.INFO if show_sql else logging.WARNING,
with contextlib.closing(instance.get_database(database)) as db:
             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/trunk/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, updateMachine=True)
+                                  testsuite, updateMachine=True)
             import_and_report(config, 'default', db, report_b, '<auto>',
-                              testsuite, commit=True, updateMachine=True)
+                              testsuite, updateMachine=True)
 
             # 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/trunk/lnt/server/db/testsuitedb.py

def _importSampleValues(self, tests_data, run, config):
                     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, config, updateMachine, mergeRun):
         """
-        importDataFromDict(data, commit, config, updateMachine, mergeRun)
+        importDataFromDict(data, config, updateMachine, mergeRun)
             -> Run  (or throws ValueError exception)
 
         Import a new run from the provided test interchange data, and return
         the constructed Run record. May throw ValueError exceptions in cases
         like mismatching machine data or duplicate run submission with
         mergeRun == 'reject'.
         """
         machine = self._getOrCreateMachine(data['machine'], updateMachine)

lnt/trunk/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><b>Update Machine:</b><br/>
 <select name="update_machine">
 <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/trunk/lnt/server/ui/views.py

 
 
 ###
 # Database Actions
 def _do_submit():
     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
     updateMachine = int(request.form.get('update_machine', 0)) != 0
     merge = request.form.get('merge', 'replace')
 
     if input_file and not input_file.content_length:
         input_file = None
 
     if not input_file and not input_data:
         return render_template(
def _do_submit():
     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, updateMachine=updateMachine, mergeRun=merge)
+        updateMachine=updateMachine, mergeRun=merge)
 
     # 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)
     error = result['error']

lnt/trunk/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,
+                config.submit_url, report_path, config.verbose,
                 updateMachine=config.update_machine, mergeRun=config.merge)
         else:
             server_report = lnt.util.ImportData.no_submit()
         if server_report:
             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"""
         result_url = server_results.get('result_url', None)
         if result_url is not None:
             print "Results available at:", server_results['result_url']

lnt/trunk/lnt/tests/nt.py

def run_test(self, opts):
             lnt_report_file = open(lnt_report_path, 'w')
             print >>lnt_report_file, report.render()
             lnt_report_file.close()
 
         else:
             test_results = run_test(opts.label, None, config)
             if opts.rerun:
                 self.log("Performing any needed reruns.")
-                server_report = self.submit_helper(config, commit=False)
-                new_samples = _process_reruns(config, server_report, test_results)
+                server_report = self.submit_helper(config)
+                new_samples = _process_reruns(config, server_report,
+                                              test_results)
                 test_results.update_report(new_samples)
 
                 # persist report with new samples.
                 lnt_report_path = config.report_path(None)
 
                 lnt_report_file = open(lnt_report_path, 'w')
                 print >>lnt_report_file, test_results.render()
                 lnt_report_file.close()
 
             if config.output is not None:
                 self.print_report(test_results, config.output)
 
-        commit = True
-        server_report = self.submit_helper(config, commit)
+        server_report = self.submit_helper(config)
 
         ImportData.print_report_result(server_report,
                                        sys.stdout,
                                        sys.stderr,
                                        config.verbose)
         return server_report
 
-    def submit_helper(self, config, commit=False):
+    def submit_helper(self, config):
         """Submit the report to the server.  If no server
         was specified, use a local mock server.
         """
         report_path = config.report_path(None)
         assert os.path.exists(report_path), "Passed an invalid report file. " \
             "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():

lnt/trunk/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
 

lnt/trunk/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,
-                      updateMachine=False, mergeRun='replace'):
+                      show_sample_count=False, disable_email=False,
+                      disable_report=False, updateMachine=False,
+                      mergeRun='replace'):
     """
     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
 
-        run = ts.importDataFromDict(data, config=db_config, updateMachine=updateMachine, mergeRun=mergeRun)
+        run = ts.importDataFromDict(data, config=db_config,
+                                    updateMachine=updateMachine,
+                                    mergeRun=mergeRun)
     except KeyboardInterrupt:
         raise
     except Exception as e:
         import traceback
         result['error'] = "import failure: %s" % e.message
         result['message'] = traceback.format_exc()
         if isinstance(e, lnt.server.db.testsuitedb.MachineInfoChanged):
             result['message'] += '\n\nNote: Use --update-machine to update ' \
if not disable_report:
                                   toAddress, True)
 
     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,
-                                              updateMachine)
+                                              show_sample_count, disable_email,
+                                              disable_report, updateMachine)
 
             # Append the shadow result to the result.
             result['shadow_result'] = shadow_result
 
     result['success'] = True
     return result
 
 
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,
-                       updateMachine=False, mergeRun='replace'):
+def import_from_string(config, db_name, db, ts_name, data, updateMachine=False,
+                       mergeRun='replace'):
     # 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, updateMachine=False,
     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,
+        config, db_name, db, path, '<auto>', ts_name,
         updateMachine=updateMachine, mergeRun=mergeRun)
     return result

lnt/trunk/lnt/util/ServerUtil.py

except ValueError:
         print "error: {}".format(reply)
         return
     sys.stderr.write("error: lnt server: {}\n".format(error.get('error')))
     message = error.get('message', '')
     if message:
         sys.stderr.write(message + '\n')
 
 
-def submitFileToServer(url, file, commit, updateMachine, mergeRun):
+def submitFileToServer(url, file, updateMachine, mergeRun):
     with open(file, 'rb') as f:
         values = {
             'input_data': f.read(),
-            'commit': "1" if commit else "0",
+            'commit': "1",  # compatibility with old servers.
             'update_machine': "1" if updateMachine else "0",
             'merge': mergeRun,
         }
     headers = {'Accept': 'application/json'}
     data = urllib.urlencode(values)
     try:
         response = urllib2.urlopen(urllib2.Request(url, data, headers=headers))
     except urllib2.HTTPError as e:
except:
         print
         print "Result:"
         print "error:", result_data
         return
 
     return reply
 
 
-def submitFileToInstance(path, file, commit, updateMachine=False,
-                         mergeRun='replace'):
+def submitFileToInstance(path, file, updateMachine=False, mergeRun='replace'):
     # 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, updateMachine=updateMachine, mergeRun=mergeRun)
+            updateMachine=updateMachine, mergeRun=mergeRun)
 
 
-def submitFile(url, file, commit, verbose, updateMachine=False,
-               mergeRun='replace'):
+def submitFile(url, file, verbose, updateMachine=False, mergeRun='replace'):
     # If this is a real url, submit it using urllib.
     if '://' in url:
-        result = submitFileToServer(url, file, commit, updateMachine, mergeRun)
+        result = submitFileToServer(url, file, updateMachine, mergeRun)
     else:
-        result = submitFileToInstance(url, file, commit, updateMachine,
-                                      mergeRun)
+        result = submitFileToInstance(url, file, updateMachine, mergeRun)
     return result
 
 
-def submitFiles(url, files, commit, verbose, updateMachine=False,
-                mergeRun='replace'):
+def submitFiles(url, files, verbose, updateMachine=False, mergeRun='replace'):
     results = []
     for file in files:
-        result = submitFile(url, file, commit, verbose, updateMachine,
-                            mergeRun)
+        result = submitFile(url, file, verbose, updateMachine, mergeRun)
         if result:
             results.append(result)
     return results

lnt/trunk/tests/lnttool/MySQLDB.shtest

 # REQUIRES: mysql
 # RUN: rm -rf "%t.install"
 # RUN: %{shared_inputs}/mysql_wrapper.sh "%t.install" 9109 /bin/sh %s "%t.install" "%{shared_inputs}"
 set -eux
 
 TESTDIR="$1"
 SHARED_INPUTS="$2"
 
 lnt create "${TESTDIR}/instance" --db-dir mysql://root@localhost:9109 --default-db testdb --show-sql
 
 # 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-b-small.plist" --commit --show-sample-count
+lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-a-small.plist" --show-sample-count
+lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-b-small.plist" --show-sample-count

lnt/trunk/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-b-small.plist" --commit --show-sample-count
+lnt import "${TESTDIR}/instance" "${SHARED_INPUTS}/sample-b-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}, {'ID': 5})
 # 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

lnt/trunk/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.
+# Check that we remove both the sample and the run.
 #
 # 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

lnt/trunk/tests/lnttool/submit.shtest

 # RUN: rm -rf %t.instance
 # RUN: rm -rf %t.tmp && mkdir -p %t.tmp
 # 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.tmp %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.tmp/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"
-# RUN: FileCheck %s --check-prefix=CHECK-SUBMIT0 < %t.tmp/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-SUBMIT1 < %t.tmp/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-SUBMIT2 < %t.tmp/submit2.txt
-
+lnt submit "http://localhost:9091/db_default/submitRun" --commit=1 "${SHARED_INPUTS}/sample-report.json" > "${OUTPUT_DIR}/submit0.txt"
+# RUN: FileCheck %s --check-prefix=CHECK-SUBMIT0 < %t.tmp/submit0.txt
 # CHECK-SUBMIT0: http://localhost:9091/db_default/v4/nts/4
+
+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-SUBMIT1 < %t.tmp/submit1.txt
 # CHECK-SUBMIT1: http://localhost:9091/db_default/v4/nts/5
-# CHECK-SUBMIT2: http://localhost:9091/db_default/v4/nts/6
 
 
-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.tmp/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.tmp/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/7
+# CHECK-NEWFORMAT: Results available at: http://localhost:9091/db_default/v4/nts/6
 
 # 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.tmp/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/6
 
 # 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.tmp/submit_errors.txt
 # CHECK-ERRORS: error: lnt server: 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: error: lnt server: 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: error: lnt server: 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: error: lnt server: import failure: machine
 # ...
 # CHECK-ERRORS: KeyError: 'machine'
-lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/compile_submission_machine_diff_reject.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" "${INPUTS}/compile_submission_machine_diff_reject.json" >> "${OUTPUT_DIR}/submit_errors.txt" 2>&1
 # CHECK-ERRORS: error: lnt server: import failure: 'hw.activecpu' on machine 'some-compile-suite-machine' changed.
 # ...
 # CHECK-ERRORS: MachineInfoChanged: 'hw.activecpu' on machine 'some-compile-suite-machine' changed.
 # CHECK-ERRORS: Note: Use --update-machine to update the existing machine information.
 
 
 
 # Adding extra fields to the machine in a submission is fine.
-lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/compile_submission_machine_diff_fine.json" -v > "${OUTPUT_DIR}/submit_compile_machine_diff_fine.txt"
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" "${INPUTS}/compile_submission_machine_diff_fine.json" -v > "${OUTPUT_DIR}/submit_compile_machine_diff_fine.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-MACHINEDIFF < %t.tmp/submit_compile_machine_diff_fine.txt
 #
 # CHECK-MACHINEDIFF: Imported Data
 # CHECK-MACHINEDIFF: -------------
 # CHECK-MACHINEDIFF-NOT: Added Machines
 # CHECK-MACHINEDIFF: Added Runs    : 1
 # CHECK-MACHINEDIFF-NOT: Added Machines
 #
 # CHECK-MACHINEDIFF: Results
 # CHECK-MACHINEDIFF: ----------------
 # CHECK-MACHINEDIFF: PASS : 9
 # CHECK-MACHINEDIFF: Results available at: http://localhost:9091/db_default/v4/compile/7
 
 # Test updating existing machine
-lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/compile_submission_machine_diff_reject.json" --update-machine -v > "${OUTPUT_DIR}/submit_compile_machine_update.txt"
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" "${INPUTS}/compile_submission_machine_diff_reject.json" --update-machine -v > "${OUTPUT_DIR}/submit_compile_machine_update.txt"
 # RUN: FileCheck %s --check-prefix=CHECK-UPDATEMACHINE < %t.tmp/submit_compile_machine_update.txt
 #
 # CHECK-UPDATEMACHINE: Imported Data
 # CHECK-UPDATEMACHINE: -------------
 # CHECK-UPDATEMACHINE-NOT: Added Machines
 # CHECK-UPDATEMACHINE: Added Runs    : 1
 # CHECK-UPDATEMACHINE-NOT: Added Machines
 #
 # CHECK-UPDATEMACHINE: Results
 # CHECK-UPDATEMACHINE: ----------------
 # CHECK-UPDATEMACHINE: PASS : 9
 # CHECK-UPDATEMACHINE: Results available at: http://localhost:9091/db_default/v4/compile/8

lnt/trunk/tests/runtest/nt.py

 # RUN:   --sandbox %t.SANDBOX \
 # RUN:   --test-suite %S/Inputs/rerun-test-suite1 \
 # RUN:   --cc %{shared_inputs}/FakeCompilers/clang-r154331 \
 # RUN:   --no-timestamp --rerun --run-order 1 > %t.log 2> %t.err
 # RUN: FileCheck --check-prefix CHECK-SUBMIT-STDOUT < %t.log %s
 # RUN: FileCheck --check-prefix CHECK-SUBMIT-STDERR < %t.err %s
 
 # CHECK-SUBMIT-STDOUT: Import succeeded.
-# CHECK-SUBMIT-STDOUT: Added Runs    : 1
+# CHECK-SUBMIT-STDOUT: PASS : 345
 
 # CHECK-SUBMIT-STDERR: inferred C++ compiler under test
 # CHECK-SUBMIT-STDERR: checking source versions
 # CHECK-SUBMIT-STDERR: using nickname
 # CHECK-SUBMIT-STDERR: starting test
 # CHECK-SUBMIT-STDERR: configuring
 # CHECK-SUBMIT-STDERR: building test-suite tools
 # CHECK-SUBMIT-STDERR: executing "nightly tests" with -j1

lnt/trunk/tests/runtest/rerun.py

 # RUN:   --sandbox %t.SANDBOX \
 # RUN:   --test-suite %S/Inputs/rerun-test-suite1 \
 # RUN:   --cc %{shared_inputs}/FakeCompilers/clang-r154331 \
 # RUN:   --no-timestamp --rerun --run-order 1 > %t.log 2> %t.err
 # RUN: FileCheck --check-prefix CHECK-STDOUT < %t.log %s
 # RUN: FileCheck --check-prefix CHECK-STDERR < %t.err %s
 
 # CHECK-STDOUT: Import succeeded.
-# CHECK-STDOUT: Added Runs    : 1
+# CHECK-STDOUT: PASS : 345
 
 # CHECK-STDERR: inferred C++ compiler under test
 # CHECK-STDERR: checking source versions
 # CHECK-STDERR: using nickname
 # CHECK-STDERR: starting test
 # CHECK-STDERR: configuring
 # CHECK-STDERR: building test-suite tools
 # CHECK-STDERR: executing "nightly tests" with -j1

 # RUN:   --cc %{shared_inputs}/FakeCompilers/clang-r154331 \
 # RUN:   --no-timestamp --rerun --run-order 4 --verbose \
 # RUN:   > %t.2.log 2> %t.2.err || cat %t.2.err
 # RUN: echo "Run 2"
 # RUN: FileCheck --check-prefix CHECK-STDOUT2 < %t.2.log %s
 # RUN: FileCheck --check-prefix CHECK-STDERR2 < %t.2.err %s
 
 # CHECK-STDOUT2: Import succeeded.
-# CHECK-STDOUT2: Added Runs    : 1
+# CHECK-STDOUT2: FAIL : 3
+# CHECK-STDOUT2: PASS : 342
 
 # CHECK-STDERR2: inferred C++ compiler under test
 # CHECK-STDERR2: checking source versions
 # CHECK-STDERR2: using nickname
 # CHECK-STDERR2: starting test
 # CHECK-STDERR2: configuring
 # CHECK-STDERR2: building test-suite tools
 # CHECK-STDERR2: executing "nightly tests" with -j1

lnt/trunk/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)

lnt/trunk/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-A-1: PASS : 5
 
 # 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 appending to an existing order
 # RUN: lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count --merge=append >& %t_append.log
+# RUN:     --show-sample-count --merge=append >& %t_append.log
 # RUN: FileCheck -check-prefix=IMPORT-A-APPEND %s < %t_append.log
 #
 # IMPORT-A-APPEND-NOT: Added Machines
 # IMPORT-A-APPEND: Added Runs : 1
 # IMPORT-A-APPEND-NOT: Added Tests
 # IMPORT-A-APPEND: Added Samples : 2
 #
 # IMPORT-A-APPEND: PASS : 5
 
 # Check that reimporting replaces the existing run.
 # RUN: lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count --merge=replace >& %t_replace.log
+# RUN:     --show-sample-count --merge=replace >& %t_replace.log
 # RUN: FileCheck -check-prefix=IMPORT-A-REPLACE %s < %t_replace.log
 #
 # IMPORT-A-REPLACE-NOT: Added Machines
 # IMPORT-A-REPLACE: Added Runs : -1
 # IMPORT-A-REPLACE-NOT: Added Tests
 # IMPORT-A-REPLACE: Added Samples : -2
 #
 # IMPORT-A-REPLACE: PASS : 5
 
 # Check that reimporting the first test set properly reports as a duplicate.
 # RUN: not lnt import %t.install %{shared_inputs}/sample-a-small.plist \
-# RUN:     --commit --show-sample-count --merge=reject >& %t_reject.log
+# RUN:     --show-sample-count --merge=reject >& %t_reject.log
 # RUN: FileCheck -check-prefix=IMPORT-A-REJECT %s < %t_reject.log
 #
 # IMPORT-A-REJECT: Duplicate submission for '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.

lnt/trunk/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,
-                    format='<auto>', ts_name='nts', commit=True,
-                    show_sample_count=False, disable_email=True,
-                    disable_report=True, updateMachine=False,
-                    mergeRun='reject')
+                    format='<auto>', ts_name='nts', show_sample_count=False,
+                    disable_email=True, disable_report=True,
+                    updateMachine=False, mergeRun='reject')
 
                 assert result.get('success', False)
 
     def _mangleResults(self, rs):
         return [(r.machine.name, str(r.order.llvm_project_revision))
                 for r in rs]
         
     def test_specific(self):

lnt/trunk/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

lnt/trunk/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)