Merge lp:~javier.collado/utah/bug1084083 into lp:utah

[Javier Collado]

This branch writes a default yaml report file for each runlist when a problem
happens and the real yaml file cannot be retrieved.

An example of the contents of the default file is:
---
arch: amd64
build_number: '20121129'
commands: []
errors: 0
failures: 0
fetch_errors: 0
install_type: desktop
media-info: Ubuntu 13.04 "Raring Ringtail" - Alpha amd64 (20121129)
ran_at: 2012-11-30_12-11-55
release: raring
runlist: /tmp/utah_W9b_VV/default.run
uname: ''

The fields that it contains all the fields suggested by Joe and it validates
according to the schema in parser.py (some of the fields that were missing have
been added to the schema). However, there isn't any calculation about the
number of test cases that have been skipped. Please let me know if this is fine
or there's a real need to provide some more data.

[Gema Gomez (gema)]

Looks good to me!

review: Approve

[Joe Talbott (joetalbott)]

'passes' seems to be missing from that output.

review: Needs Information

[lp:~javier.collado/utah/bug1084083]

774. By Javier Collado on 2012-11-30

Added passes to the default report

[Javier Collado (javier.collado)]

Good catch! I added passes to the default report and reviewed the schema (all
fields should be included now).

By the way, I've noticed that 'media-info' is the only field that uses a dash
in its name, all the other ones use an underscore.

review: Needs Resubmitting

[Joe Talbott (joetalbott)]

Looks good to me. Thanks.

review: Approve

=== modified file 'examples/utah_syslog.sh'
--- examples/utah_syslog.sh	2012-07-31 14:22:31 +0000
+++ examples/utah_syslog.sh	2012-11-30 14:52:20 +0000
@@ -2,5 +2,5 @@
 
 for MACHINE in $@
 do
-  cat /var/log/utah/$(echo "$MACHINE" | grep -o "utah-[0-9]*")-*.syslog.log
+  cat /var/log/utah/$(echo "$MACHINE" | grep -o "utah-[0-9]\+")-*.syslog.log
 done
 
=== modified file 'utah/iso.py'
--- utah/iso.py	2012-11-16 19:27:27 +0000
+++ utah/iso.py	2012-11-30 14:52:20 +0000
@@ -8,6 +8,7 @@
 import subprocess
 import sys
 import urllib
+import re
 
 from hashlib import md5
 
@@ -62,8 +63,10 @@
         # Ubuntu 12.10 "Quantal Quetzal" - Alpha amd64 (20120820)
         # i.e. Ubuntu Version (LTS) "Series Codename" - Alpha/Beta/Release
         # arch (buildnumber)
+        self.media_info = self.dump(self.infofile).communicate()[0]
         self.arch = self.getarch()
         self.series = self.getseries()
+        self.buildnumber = self.getbuildnumber()
 
     def _loggersetup(self):
         """
@@ -118,8 +121,7 @@
         """
         Unpack the image's info file to get the arch.
         """
-        stdout = self.dump(self.infofile).communicate()[0]
-        arch = stdout.split()[-2]
+        arch = self.media_info.split()[-2]
         self.logger.info('Arch is: ' + arch)
         return arch
 
@@ -127,14 +129,19 @@
         """
         Unpack the image's info file to get the series.
         """
-        stdout = self.dump(self.infofile).communicate()[0]
-        for word in stdout.split():
+        for word in self.media_info.split():
             if word.startswith('"'):
                 series = word.strip('"').lower()
                 break
         self.logger.info('Series is ' + series)
         return series
 
+    def getbuildnumber(self):
+        """Unpack the image's info file to get the build number."""
+        match = re.search('.*\(([0-9.]+)\)$', self.media_info)
+        build_number = match.group(1) if match else '?'
+        return build_number
+
     def dldisplay(self, blocks, size, total):
         """
         Display download information.
 
=== modified file 'utah/parser.py'
--- utah/parser.py	2012-11-30 09:33:04 +0000
+++ utah/parser.py	2012-11-30 14:52:20 +0000
@@ -40,6 +40,10 @@
                 'type': 'string',
                 'required': True,
             },
+            'ran_at': {
+                'type': 'string',
+                'required': True,
+            },
             'commands': {
                 'type': 'array',
                 'items': {'type': COMMAND_SCHEMA},
@@ -74,6 +78,18 @@
                 'type': 'string',
                 'required': True,
             },
+            'arch': {
+                'type': 'string',
+                'required': True,
+            },
+            'release': {
+                'type': 'string',
+                'required': True,
+            },
+            'build_number': {
+                'type': 'string',
+                'required': True,
+            },
         },
     }
 
 
=== modified file 'utah/run.py'
--- utah/run.py	2012-11-29 16:37:23 +0000
+++ utah/run.py	2012-11-30 14:52:20 +0000
@@ -5,6 +5,9 @@
 import os
 import time
 import urllib
+import json
+import yaml
+import traceback
 
 from utah import config
 from utah.exceptions import UTAHException
@@ -14,68 +17,120 @@
     """
     Run some tests and retrieve results.
     """
-    # Since we're running from a script, output INFO
-    for logger in [machine.logger] + machine.logger.handlers:
-        if logger.level > logging.INFO:
-            logger.setLevel(logging.INFO)
-
-    # Write the machine name to standard out for log gathering
-    print('Running on machine: ' + machine.name)
-
-    if args.json:
-        extraopts = ' -f json'
-        suffix = 'json'
-    else:
-        extraopts = ''
-        suffix = 'yaml'
-
-    locallogs = []
-
-    machine.installclient()
-
-    extraopts += " --install-type " + machine.installtype
-
     def _run(runlist):
         """Run a single runlist."""
-        locallist = urllib.urlretrieve(runlist)[0]
-        machine.uploadfiles([locallist], os.path.normpath('/tmp'))
+        stdout = None
 
-        options = ' -r /tmp/' + os.path.basename(locallist)
-        utah_command = 'utah' + extraopts + options
         try:
-            # Server will return same code as client
+            locallist = urllib.urlretrieve(runlist)[0]
+            machine.uploadfiles([locallist], os.path.normpath('/tmp'))
+
+            options = ' -r /tmp/' + os.path.basename(locallist)
+            utah_command = 'utah' + extraopts + options
             exitstatus, stdout, _stderr = machine.run(utah_command, root=True)
         except UTAHException as error:
             machine.logger.error('Failed to run test: ' + str(error))
-            return 1
+            exitstatus = 1
+
+        _write(runlist, stdout)
+
+        return exitstatus
+
+    def _write(runlist, report=None):
+        """Write runlist report.
+
+        Report will be written using appropriate filename based on the runlist.
+        If report is None becase there was some problem, then a default empty
+        report will be generated.
+
+        """
+        timestamp = time.strftime('%Y-%m-%d_%H-%m-%S', time.gmtime())
+
+        if report is None:
+            # Generate default report with empty results to fake client output
+            default_report = {
+                'runlist': runlist,
+                'media-info': machine.image.media_info,
+                'build_number': machine.image.buildnumber,
+                'release': machine.image.series,
+                'ran_at': timestamp,
+                'install_type': machine.installtype,
+                'arch': machine.arch,
+                'commands': [],
+                'fetch_errors': 0,
+                'errors': 0,
+                'failures': 0,
+                'passes': 0,
+                'uname': '',
+
+
+            }
+            if report_type == 'json':
+                report = json.dumps(default_report)
+            elif report_type == 'yaml':
+                report = yaml.dump(default_report,
+                                   explicit_start='---',
+                                   default_flow_style=False)
+            else:
+                raise ValueError('Unexpected report type: {}'
+                                 .format(report_type))
 
         listname = os.path.basename(runlist)
-        timestamp = time.strftime('%Y-%m-%d_%H-%m-%S', time.gmtime())
         log_filename = ('{machine}_{runlist}_{timestamp}.{suffix}'
                         .format(machine=machine.name,
                                 runlist=listname,
                                 timestamp=timestamp,
-                                suffix=suffix))
+                                suffix=report_type))
         locallog = os.path.join(config.logpath, log_filename)
         locallog = os.path.normpath(locallog)
         with open(locallog, 'w') as f:
-            f.write(stdout)
+            f.write(report)
         machine.logger.info('Test log copied to ' + locallog)
         locallogs.append(locallog)
         if args.dumplogs:
             with open(locallog, 'r') as f:
                 print(f.read())
 
-        return exitstatus
-
-    exitstatuses = [_run(runlist) for runlist in args.runlists]
-    exitstatus = int(any(exitstatuses))
-
-    if args.files is not None:
-        try:
-            locallogs += getfiles(args, machine)
-        except Exception as err:
-            machine.logger.warning('Failed to download files: ' + str(err))
+    # Since we're running from a script, output INFO
+    for logger in [machine.logger] + machine.logger.handlers:
+        if logger.level > logging.INFO:
+            logger.setLevel(logging.INFO)
+
+    # Write the machine name to standard out for log gathering
+    print('Running on machine: ' + machine.name)
+
+    if args.json:
+        extraopts = ' -f json'
+        report_type = 'json'
+
+    else:
+        extraopts = ''
+        report_type = 'yaml'
+    extraopts += " --install-type " + machine.installtype
+
+    locallogs = []
+    try:
+        machine.installclient()
+    except Exception:
+        traceback.print_exc()
+        machine.logger.error('Failed to install client. '
+                             'Writing empty reports.')
+
+        # Make sure that default logs are written
+        for runlist in args.runlists:
+            _write(runlist)
+        exitstatus = 1
+    else:
+        # Server will return success code only if the execution
+        # of every runlist was successful
+        exitstatuses = [_run(runlist) for runlist in args.runlists]
+        exitstatus = int(any(exitstatuses))
+
+        if args.files is not None:
+            try:
+                locallogs += getfiles(args, machine)
+            except Exception as err:
+                machine.logger.warning('Failed to download files: ' + str(err))
 
     return exitstatus, locallogs