LNT Make machine selection/update more flexible

[MatzeB]

Summary

Note: This patch is in response to the discussion in D35598. It allows to choose between different behaviors on mismatching machine information including the previous behavior of creating a new machine with the same name. My original plan was to always enforce unique machine names and append number suffixes in the duplication/splitting case. But it turns out this was extremely hard to implement correctly while support concurrent accesses, so I went with the previous solution instead where we can have multiple machines with the same name but different ids.

r309247 changed LNTs response to mismatching machine information to
either reject the submission or update the existing machine data. Some
users prefer the previous behavior of creating a separate machine with
the same name instead.

This changes LNT interface to accept an select-machine parameter:

• match: Rejects submission with mismatching machine information
• update: Updates the existing machine on mismatching machine information.
• split: Creates a new machine with the same name (but different id number) when none of the existing ones match the machine information.

[jgreenhalgh]

Thanks for this. I don't know LNT well enough to review the code, but the top-level summary makes sense to me.

@leandron might be able to give more feedback on the code itself.

Thanks for the fix, and sorry for my long delay in getting back to you.

[MatzeB]

In D37083#860435, @jgreenhalgh wrote:

Thanks for this. I don't know LNT well enough to review the code, but the top-level summary makes sense to me.

@leandron might be able to give more feedback on the code itself.

Thanks for the fix, and sorry for my long delay in getting back to you.

Thanks. I'm going to push this now as you seem to be fine with the user interface. We can still tweak the implementation later if necessary and I'd like to push this now to avoid further rebasing.

lnt/lnttool/admin.py

 #!/usr/bin/env python
 import click
+from .common import submit_options
 
 
 def _load_dependencies():
     global yaml, sys, requests, json, os, httplib
     import yaml
     import sys
     import requests
     import json
for run in runs:
         response = config.session.delete(url)
         _check_response(response)
 
 
 @click.command("post-run")
 @_pass_config
 @click.argument("datafiles", nargs=-1, type=click.Path(exists=True),
                 required=True)
[e-mail]("--update-machine", is_flag=True, help="Update machine fields")
[e-mail]("--merge", default="replace", show_default=True,
-              type=click.Choice(['reject', 'replace', 'merge']),
-              help="Merge strategy when run already exists")
-def action_post_run(config, datafiles, update_machine, merge):
+@submit_options
+def action_post_run(config, datafiles, commit, select_machine, merge):
     """Submit report files to server."""
     _check_auth_token(config)
 
     for datafile in datafiles:
         with open(datafile, "r") as datafile:
             data = datafile.read()
 
         url = ('{lnt_url}/api/db_{database}/v4/{testsuite}/runs'
                .format(**config.dict))
         url_params = {
-            'update_machine': 1 if update_machine else 0,
+            'select_machine': select_machine,
             'merge': merge,
         }
         response = config.session.post(url, params=url_params, data=data,
                                        allow_redirects=False)
         _check_response(response)
         if response.status_code == 301:
             sys.stdout.write(response.headers.get('Location') + '\n')
         if config.verbose:

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("--update-machine", is_flag=True,
-                        help="Update machine fields")(func)
+    func = click.option("--select-machine", default='match',
+                        type=click.Choice(['match', 'update', 'split']),
+                        help="How to select and create missing machine")(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
 
 
 def init_logger(loglevel, show_sql=False, stream=None):
     handler = logging.StreamHandler(stream)

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, commit, select_machine, merge):
     """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, updateMachine=update_machine,
-                mergeRun=merge)
+                no_email, no_report, select_machine=select_machine,
+                merge_run=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)
+                                                        sys.stderr, verbose)
 
         if not success:
             raise SystemExit(1)

lnt/lnttool/main.py

 
 
 @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, commit, select_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,
-                                   updateMachine=update_machine,
-                                   mergeRun=merge)
+                                   select_machine=select_machine,
+                                   merge_run=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)
 
 
 @click.command("update")

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, commit=True,
+                                  select_machine='match')
             import_and_report(config, 'default', db, report_b, '<auto>',
-                              testsuite, commit=True, updateMachine=True)
+                              testsuite, commit=True,
+                              select_machine='match')
 
             # 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 get_users_baseline(self):
             # Sometimes this is called from outside the app context.
             # In that case, don't get the user's session baseline.
             return None
         if session_baseline:
             return self.query(self.Baseline).get(session_baseline)
 
         return None
 
-    def _getOrCreateMachine(self, machine_data, forceUpdate):
+    def _getIncompatibleFields(self, existing_machine, new_machine):
+        incompatible_fields = set()
+        for field in self.machine_fields:
+            existing_value = existing_machine.get_field(field)
+            new_value = new_machine.get_field(field)
+            if new_value is None or existing_value == new_value:
+                continue
+            if existing_value is not None:
+                incompatible_fields.add(field.name)
+        existing_parameters = existing_machine.parameters
+        for key, new_value in new_machine.parameters.items():
+            existing_value = existing_parameters.get(key, None)
+            if new_value is None or existing_value == new_value:
+                continue
+            if existing_value is not None:
+                incompatible_fields.add(key)
+        return incompatible_fields
+
+    def _updateMachine(self, existing_machine, new_machine):
+        for field in self.machine_fields:
+            new_value = new_machine.get_field(field)
+            if new_value is None:
+                continue
+            existing_machine.set_field(field, new_value)
+        parameters = existing_machine.parameters
+        for key, new_value in new_machine.parameters.items():
+            if new_value is None and parameters.get(key, None) is not None:
+                continue
+            parameters[key] = new_value
+        existing_machine.parameters = parameters
+
+    def _getOrCreateMachine(self, machine_data, select_machine):
         """
-        _getOrCreateMachine(data, forceUpdate) -> Machine
+        _getOrCreateMachine(data, select_machine) -> Machine
 
         Add or create (and insert) a Machine record from the given machine data
         (as recorded by the test interchange format).
+
+        select_machine strategies:
+        'match': Abort if the existing machine doesn't match the new machine
+                 data.
+        'update': Update the existing machine in cases where the new machine
+                  data doesn't match the existing data.
+        'split': On parameter mismatch create a new machine with a `$NN` suffix
+                 added, or choose an existing compatible machine with such a
+                 suffix.
         """
+        assert select_machine == 'match' or select_machine == 'update' \
+            or select_machine == 'split'
 
         # Convert the machine data into a machine record.
         machine_parameters = machine_data.copy()
         name = machine_parameters.pop('name')
         machine = self.Machine(name)
         machine_parameters.pop('id', None)
         for item in self.machine_fields:
             value = machine_parameters.pop(item.name, None)
             machine.set_field(item, value)
         machine.parameters = machine_parameters
 
         # Look for an existing machine.
         existing_machines = self.query(self.Machine) \
             .filter(self.Machine.name == name) \
             .order_by(self.Machine.id.desc()) \
             .all()
+        # No existing machine? Add one.
         if len(existing_machines) == 0:
             self.add(machine)
             return machine
-
-        existing = existing_machines[0]
-
-        # Unfortunately previous LNT versions allowed multiple machines
-        # with the same name to exist, so we should choose the one that
-        # matches best.
-        if len(existing_machines) > 1:
-            for m in existing_machines:
-                if m.parameters == machine.parameters:
-                    existing = m
-                    break
-
-        # Check and potentially update existing machine.
-        # Parameters that were previously unset are added. If a parameter
-        # changed then we update or abort depending on `forceUpdate`.
-        for field in self.machine_fields:
-            existing_value = existing.get_field(field)
-            new_value = machine.get_field(field)
-            if new_value is None or existing_value == new_value:
-                continue
-            if existing_value is None or forceUpdate:
-                existing.set_field(field, new_value)
-            else:
+        # Search for a compatible machine.
+        existing_machine = None
+        incompatible_fields_0 = []
+            incompatible_fields = self._getIncompatibleFields(m, machine)
+            if len(incompatible_fields) == 0:
+                existing_machine = m
+            if len(incompatible_fields_0) == 0:
+                incompatible_fields_0 = incompatible_fields
+        # All existing machines are incompatible?
+        if existing_machine is None:
+            if select_machine == 'split':
+                # Add a new machine.
+                self.add(machine)
+                return machine
+            if select_machine == 'match':
                 raise MachineInfoChanged("'%s' on machine '%s' changed." %
-                                         (field.name, name))
-        existing_parameters = existing.parameters
-        for key, new_value in machine.parameters.items():
-            existing_value = existing_parameters.get(key, None)
-            if new_value is None or existing_value == new_value:
-                continue
-            if existing_value is None or forceUpdate:
-                existing_parameters[key] = value
+                    (', '.join(incompatible_fields_0), name))
             else:
-                raise MachineInfoChanged("'%s' on machine '%s' changed." %
-                                         (key, name))
-        existing.parameters = existing_parameters
-        return existing
+                assert select_machine == 'update'
+                # Just pick the first and update it below.
+                existing_machine = existing_machines[0]
+
+        self._updateMachine(existing_machine, machine)
+        return existing_machine
 
     def _getOrCreateOrder(self, run_parameters):
         """
         _getOrCreateOrder(data) -> Order
 
         Add or create (and insert) an Order record based on the given run
         parameters (as recorded by the test interchange format).
 
def _importSampleValues(self, tests_data, run, commit, 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, updateMachine,
-                           mergeRun):
+    def importDataFromDict(self, data, commit, config, select_machine,
+                           merge_run):
         """
-        importDataFromDict(data, commit, config, updateMachine, mergeRun)
+        importDataFromDict(data, commit, config, select_machine, merge_run)
             -> 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'.
+        merge_run == 'reject'.
         """
-        machine = self._getOrCreateMachine(data['machine'], updateMachine)
-        run = self._getOrCreateRun(data['run'], machine, mergeRun)
+        machine = self._getOrCreateMachine(data['machine'], select_machine)
+        run = self._getOrCreateRun(data['run'], machine, merge_run)
         self._importSampleValues(data['tests'], run, commit, config)
         return run
 
     # Simple query support (mostly used by templates)
 
     def machines(self, name=None):
         q = self.query(self.Machine)
         if name:

lnt/server/ui/api.py

class Runs(Resource):
     method_decorators = [in_db]
 
     @staticmethod
     @requires_auth_token
     def post():
         """Add a new run into the lnt database"""
         db = request.get_db()
         data = request.data
-        updateMachine = request.values.get('update_machine', False)
+        select_machine = request.values.get('select_machine', 'match')
         merge = request.values.get('merge', 'replace')
         result = lnt.util.ImportData.import_from_string(
             current_app.old_config, g.db_name, db, g.testsuite_name, data,
-            updateMachine=updateMachine, mergeRun=merge)
+            select_machine=select_machine, merge_run=merge)
 
         error = result['error']
         if error is not None:
             response = jsonify(result)
             response.status = '400'
             logger.warning("%s: Submission rejected: %s" %
                            (request.url, error))
             return response

lnt/server/ui/templates/submit_run.html

 <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>
+<p><b>Machine Selection / Creation:</b><br/>
+<select name="select_machine">
+<option selected="selected" value="match">match: Abort if machine information doesn't match</option>
+<option value="update">update: Update matchine if information doesn't match</option>
+<option value="split">split: Create additional machine with same name if information doesn't match</option>
+</select><br/>
+
+<p><b>Merge with existing runs:</b><br/>
+<select name="merge">
+<option selected="selected" value="replace">replace: Replace existing run with same order</option>
+<option value="reject">reject: Abort if run with same order exists</option>
+<option value="append">append: Append and possibly keep multiple runs for same order</option>
 </select><br/>
 
 <p><input type="submit" name="submit" value="Submit">
 </form>
 
 {% endblock %}

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')
+    select_machine = request.form.get('select_machine', 'match')
+    merge_run = 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(
             "submit_run.html", error="must provide input file or data")
     if input_file and input_data:
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)
+        commit=commit, select_machine=select_machine, merge_run=merge_run)
 
     # 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/tests/builtintest.py

def submit(self, report_path, config, ts_name=None, commit=True):
             " 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,
-                updateMachine=config.update_machine, mergeRun=config.merge)
+                select_machine=config.select_machine, merge_run=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/util/ImportData.py

 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'):
+                      select_machine='match', merge_run='replace'):
     """
     import_and_report(config, db_name, db, file, format, ts_name,
                       [commit], [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.
 
     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,
     }
 
+    if select_machine not in ('match', 'update', 'split'):
+        result['error'] = "select_machine must be 'match', 'update' or 'split'"
+        return result
+
     ts = db.testsuite.get(ts_name)
     if ts is None:
         result['error'] = "Unknown test suite '%s'!" % ts_name
         return result
     numMachines = ts.getNumMachines()
     numRuns = ts.getNumRuns()
     numTests = ts.getNumTests()
 
def import_and_report(config, db_name, db, file, format, ts_name,
     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, commit, config=db_config,
-                                    updateMachine=updateMachine,
-                                    mergeRun=mergeRun)
+                                    select_machine=select_machine,
+                                    merge_run=merge_run)
     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 ' \
-                                 'the existing machine information.\n'
+            result['message'] += \
+                '\n\nNote: Use --select-machine=update to update ' \
         return result
 
     # If the import succeeded, save the import path.
     run.imported_from = file
 
     result['import_time'] = time.time() - importStartTime
 
     reportStartTime = time.time()
if config and config.databases[db_name].shadow_import:
                 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)
+                                              select_machine=select_machine,
+                                              merge_run=merge_run)
 
             # Append the shadow result to the result.
             result['shadow_result'] = shadow_result
 
     result['success'] = True
     return result
 
 
if total_added:
         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'):
+                       select_machine='match', merge_run='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, commit=True,
 
     # 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,
-        updateMachine=updateMachine, mergeRun=mergeRun)
+        select_machine=select_machine, merge_run=merge_run)
     return result

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, commit, select_machine, merge_run):
     with open(file, 'rb') as f:
         values = {
             'input_data': f.read(),
             'commit': "1" if commit else "0",
-            'update_machine': "1" if updateMachine else "0",
-            'merge': mergeRun,
+            'select_machine': select_machine,
+            'merge': merge_run,
         }
     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
except:
         print
         print "Result:"
         print "error:", result_data
         return
 
     return reply
 
 
-def submitFileToInstance(path, file, commit, updateMachine=False,
-                         mergeRun='replace'):
+def submitFileToInstance(path, file, commit, select_machine='match',
+                         merge_run='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)
+            commit=commit, select_machine=select_machine, merge_run=merge_run)
 
 
-def submitFile(url, file, commit, verbose, updateMachine=False,
-               mergeRun='replace'):
+def submitFile(url, file, commit, verbose, select_machine='match',
+               merge_run='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, commit, select_machine,
+                                    merge_run)
     else:
-        result = submitFileToInstance(url, file, commit, updateMachine,
-                                      mergeRun)
+        result = submitFileToInstance(url, file, commit, select_machine,
+                                      merge_run)
     return result
 
 
-def submitFiles(url, files, commit, verbose, updateMachine=False,
-                mergeRun='replace'):
+def submitFiles(url, files, commit, verbose, select_machine='match',
+                merge_run='replace'):
     results = []
     for file in files:
-        result = submitFile(url, file, commit, verbose, updateMachine,
-                            mergeRun)
+        result = submitFile(url, file, commit, verbose,
+                            select_machine=select_machine, merge_run=merge_run)
         if result:
             results.append(result)
     return results

tests/lnttool/Inputs/compile_submission_machine_diff_split.json

+{
+  "Machine": {
+    "Info": {
+      "hw.activecpu": "2",
+      "machdep.cpu.vendor": "AMD"
+    },
+    "Name": "some-compile-suite-machine"
+  },
+  "Run": {
+    "End Time": "2017-07-06 15:37:08",
+    "Start Time": "2017-07-06 15:05:23",
+    "Info": {
+      "__report_version__": "1",
+      "run_order": "663405",
+      "tag": "compile"
+    }
+  },
+  "Tests": [
+        {
+            "Data": [
+                13.601326,
+                13.411566,
+                13.490528
+            ],
+            "Info": {},
+            "Name": "compile.build/Adium-1.5.7(config='Debug',j=1).user"
+        }
+  ]
+}

tests/lnttool/submit.shtest

 lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${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
 # 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.
+# CHECK-ERRORS: Note: Use --select-machine=update 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"
 # 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" --commit "${INPUTS}/compile_submission_machine_diff_reject.json" --select-machine=update -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
+
+# Test creationg of new machines on information mismatch in split mode.
+lnt submit "http://localhost:9091/db_default/v4/compile/submitRun" --commit "${INPUTS}/compile_submission_machine_diff_split.json" --select-machine=split -v > "${OUTPUT_DIR}/submit_compile_machine_split.txt"
+# RUN: FileCheck %s --check-prefix=CHECK-SPLITMACHINE < %t.tmp/submit_compile_machine_split.txt
+#
+# We should have added a new machine:
+# CHECK-SPLITMACHINE: Imported Data
+# CHECK-SPLITMACHINE: -------------
+# CHECK-SPLITMACHINE: Added Machines: 1
+# CHECK-SPLITMACHINE: Added Runs    : 1
+#
+# CHECK-SPLITMACHINE: Results
+# CHECK-SPLITMACHINE: ----------------
+# CHECK-SPLITMACHINE: PASS : 5
+# CHECK-SPLITMACHINE: Results available at: http://localhost:9091/db_default/v4/compile/9

tests/server/db/search.py

def setUp(self):
                     .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')
+                    disable_report=True, select_machine='match',
+                    merge_run='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):