Merge remote branch 'cros/upstream' into master

client/common_lib/base_job.py

 import os, copy, logging, errno, fcntl, time, re, weakref, traceback
+import tarfile
 import cPickle as pickle
-
 from autotest_lib.client.common_lib import autotemp, error, log
 
 
 class job_directory(object):
     """Represents a job.*dir directory."""
 
 
     class JobDirectoryException(error.AutotestError):
         """Generic job_directory exception superclass."""
 
@@ skipping 401 matching lines @@
         return property(getter, setter)
 
 
 class status_log_entry(object):
     """Represents a single status log entry."""
 
     RENDERED_NONE_VALUE = '----'
     TIMESTAMP_FIELD = 'timestamp'
     LOCALTIME_FIELD = 'localtime'
 
+    # non-space whitespace is forbidden in any fields
+    BAD_CHAR_REGEX = re.compile(r'[\t\n\r\v\f]')
+
     def __init__(self, status_code, subdir, operation, message, fields,
                  timestamp=None):
         """Construct a status.log entry.
 
         @param status_code: A message status code. Must match the codes
             accepted by autotest_lib.common_lib.log.is_valid_status.
         @param subdir: A valid job subdirectory, or None.
         @param operation: Description of the operation, or None.
         @param message: A printable string describing event to be recorded.
         @param fields: A dictionary of arbitrary alphanumeric key=value pairs
             to be included in the log, or None.
         @param timestamp: An optional integer timestamp, in the same format
             as a time.time() timestamp. If unspecified, the current time is
             used.
 
         @raise ValueError: if any of the parameters are invalid
         """
-        # non-space whitespace is forbidden in any fields
-        bad_char_regex = r'[\t\n\r\v\f]'
 
         if not log.is_valid_status(status_code):
             raise ValueError('status code %r is not valid' % status_code)
         self.status_code = status_code
 
-        if subdir and re.search(bad_char_regex, subdir):
+        if subdir and self.BAD_CHAR_REGEX.search(subdir):
             raise ValueError('Invalid character in subdir string')
         self.subdir = subdir
 
-        if operation and re.search(bad_char_regex, operation):
+        if operation and self.BAD_CHAR_REGEX.search(operation):
             raise ValueError('Invalid character in operation string')
         self.operation = operation
 
         # break the message line into a single-line message that goes into the
         # database, and a block of additional lines that goes into the status
         # log but will never be parsed
         message_lines = message.split('\n')
         self.message = message_lines[0].replace('\t', ' ' * 8)
         self.extra_message_lines = message_lines[1:]
-        if re.search(bad_char_regex, self.message):
+        if self.BAD_CHAR_REGEX.search(self.message):
             raise ValueError('Invalid character in message %r' % self.message)
 
         if not fields:
             self.fields = {}
         else:
             self.fields = fields.copy()
         for key, value in self.fields.iteritems():
-            if re.search(bad_char_regex, key + value):
+            if self.BAD_CHAR_REGEX.search(key + value):
                 raise ValueError('Invalid character in %r=%r field'
                                  % (key, value))
 
         # build up the timestamp
         if timestamp is None:
             timestamp = int(time.time())
         self.fields[self.TIMESTAMP_FIELD] = str(timestamp)
         self.fields[self.LOCALTIME_FIELD] = time.strftime(
             '%b %d %H:%M:%S', time.localtime(timestamp))
 
@@ skipping 85 matching lines @@
 
 
 class status_logger(object):
     """Represents a status log file. Responsible for translating messages
     into on-disk status log lines.
 
     @property global_filename: The filename to write top-level logs to.
     @property subdir_filename: The filename to write subdir-level logs to.
     """
     def __init__(self, job, indenter, global_filename='status',
-                 subdir_filename='status', record_hook=None):
+                 subdir_filename='status', record_hook=None,
+                 tap_writer=None):
         """Construct a logger instance.
 
         @param job: A reference to the job object this is logging for. Only a
             weak reference to the job is held, to avoid a
             status_logger <-> job circular reference.
         @param indenter: A status_indenter instance, for tracking the
             indentation level.
         @param global_filename: An optional filename to initialize the
             self.global_filename attribute.
         @param subdir_filename: An optional filename to initialize the
             self.subdir_filename attribute.
         @param record_hook: An optional function to be called before an entry
             is logged. The function should expect a single parameter, a
             copy of the status_log_entry object.
+        @param tap_writer: An instance of the class TAPReport for addionally
+            writing TAP files
         """
         self._jobref = weakref.ref(job)
         self._indenter = indenter
         self.global_filename = global_filename
         self.subdir_filename = subdir_filename
         self._record_hook = record_hook
+        if tap_writer is None:
+            self._tap_writer = TAPReport(None)
+        else:
+            self._tap_writer = tap_writer
 
 
     def render_entry(self, log_entry):
         """Render a status_log_entry as it would be written to a log file.
 
         @param log_entry: A status_log_entry instance to be rendered.
 
         @return: The status log entry, rendered as it would be written to the
             logs (including indentation).
         """
@@ skipping 32 matching lines @@
 
         # write out to entry to the log files
         log_text = self.render_entry(log_entry)
         for log_file in log_files:
             fileobj = open(log_file, 'a')
             try:
                 print >> fileobj, log_text
             finally:
                 fileobj.close()
 
+        # write to TAPRecord instance
+        if log_entry.is_end() and self._tap_writer.do_tap_report:
+            self._tap_writer.record(log_entry, self._indenter.indent, log_files)
+
         # adjust the indentation if this was a START or END entry
         if log_entry.is_start():
             self._indenter.increment()
         elif log_entry.is_end():
             self._indenter.decrement()
 
 
+class TAPReport(object):
+    """
+    Deal with TAP reporting for the Autotest client.
+    """
+
+    job_statuses = {
+        "TEST_NA": False,
+        "ABORT": False,
+        "ERROR": False,
+        "FAIL": False,
+        "WARN": False,
+        "GOOD": True,
+        "START": True,
+        "END GOOD": True,
+        "ALERT": False,
+        "RUNNING": False,
+        "NOSTATUS": False
+    }
+
+
+    def __init__(self, enable, resultdir=None, global_filename='status'):
+        """
+        @param enable: Set self.do_tap_report to trigger TAP reporting.
+        @param resultdir: Path where the TAP report files will be written.
+        @param global_filename: File name of the status files .tap extensions
+                will be appended.
+        """
+        self.do_tap_report = enable
+        if resultdir is not None:
+            self.resultdir = os.path.abspath(resultdir)
+        self._reports_container = {}
+        self._keyval_container = {} # {'path1': [entries],}
+        self.global_filename = global_filename
+
+
+    @classmethod
+    def tap_ok(self, success, counter, message):
+        """
+        return a TAP message string.
+
+        @param success: True for positive message string.
+        @param counter: number of TAP line in plan.
+        @param message: additional message to report in TAP line.
+        """
+        if success:
+            message = "ok %s - %s" % (counter, message)
+        else:
+            message = "not ok %s - %s" % (counter, message)
+        return message
+
+
+    def record(self, log_entry, indent, log_files):
+        """
+        Append a job-level status event to self._reports_container. All
+        events will be written to TAP log files at the end of the test run.
+        Otherwise, it's impossilble to determine the TAP plan.
+
+        @param log_entry: A string status code describing the type of status
+                entry being recorded. It must pass log.is_valid_status to be
+                considered valid.
+        @param indent: Level of the log_entry to determine the operation if
+                log_entry.operation is not given.
+        @param log_files: List of full path of files the TAP report will be
+                written to at the end of the test.
+        """
+        for log_file in log_files:
+            log_file_path = os.path.dirname(log_file)
+            key = log_file_path.split(self.resultdir, 1)[1].strip(os.sep)
+            if not key:
+                key = 'root'
+
+            if not self._reports_container.has_key(key):
+                self._reports_container[key] = []
+
+            if log_entry.operation:
+                operation = log_entry.operation
+            elif indent == 1:
+                operation = "job"
+            else:
+                operation = "unknown"
+            entry = self.tap_ok(
+                self.job_statuses.get(log_entry.status_code, False),
+                len(self._reports_container[key]) + 1, operation + "\n"
+            )
+            self._reports_container[key].append(entry)
+
+
+    def record_keyval(self, path, dictionary, type_tag=None):
+        """
+        Append a key-value pairs of dictionary to self._keyval_container in
+        TAP format. Once finished write out the keyval.tap file to the file
+        system.
+
+        If type_tag is None, then the key must be composed of alphanumeric
+        characters (or dashes + underscores). However, if type-tag is not
+        null then the keys must also have "{type_tag}" as a suffix. At
+        the moment the only valid values of type_tag are "attr" and "perf".
+
+        @param path: The full path of the keyval.tap file to be created
+        @param dictionary: The keys and values.
+        @param type_tag: The type of the values
+        """
+        self._keyval_container.setdefault(path, [0, []])
+        self._keyval_container[path][0] += 1
+
+        if type_tag is None:
+            key_regex = re.compile(r'^[-\.\w]+$')
+        else:
+            if type_tag not in ('attr', 'perf'):
+                raise ValueError('Invalid type tag: %s' % type_tag)
+            escaped_tag = re.escape(type_tag)
+            key_regex = re.compile(r'^[-\.\w]+\{%s\}$' % escaped_tag)
+        self._keyval_container[path][1].extend([
+            self.tap_ok(True, self._keyval_container[path][0], "results"),
+            "\n  ---\n",
+        ])
+        try:
+            for key in sorted(dictionary.keys()):
+                if not key_regex.search(key):
+                    raise ValueError('Invalid key: %s' % key)
+                self._keyval_container[path][1].append(
+                    '  %s: %s\n' % (key.replace('{', '_').rstrip('}'),
+                                    dictionary[key])
+                )
+        finally:
+            self._keyval_container[path][1].append("  ...\n")
+        self._write_keyval()
+
+
+    def _write_reports(self):
+        """
+        Write TAP reports to file.
+        """
+        for key in self._reports_container.keys():
+            if key == 'root':
+                sub_dir = ''
+            else:
+                sub_dir = key
+            tap_fh = open(os.sep.join(
+                [self.resultdir, sub_dir, self.global_filename]
+            ) + ".tap", 'w')
+            tap_fh.write('1..' + str(len(self._reports_container[key])) + '\n')
+            tap_fh.writelines(self._reports_container[key])
+            tap_fh.close()
+
+
+    def _write_keyval(self):
+        """
+        Write the self._keyval_container key values to a file.
+        """
+        for path in self._keyval_container.keys():
+            tap_fh = open(path + ".tap", 'w')
+            tap_fh.write('1..' + str(self._keyval_container[path][0]) + '\n')
+            tap_fh.writelines(self._keyval_container[path][1])
+            tap_fh.close()
+
+
+    def write(self):
+        """
+        Write the TAP reports to files.
+        """
+        self._write_reports()
+
+
+    def _write_tap_archive(self):
+        """
+        Write a tar archive containing all the TAP files and
+        a meta.yml containing the file names.
+        """
+        os.chdir(self.resultdir)
+        tap_files = []
+        for rel_path, d, files in os.walk('.'):
+            tap_files.extend(["/".join(
+                [rel_path, f]) for f in files if f.endswith('.tap')])
+        meta_yaml = open('meta.yml', 'w')
+        meta_yaml.write('file_order:\n')
+        tap_tar = tarfile.open(self.resultdir + '/tap.tar.gz', 'w:gz')
+        for f in tap_files:
+            meta_yaml.write("  - " + f.lstrip('./') + "\n")
+            tap_tar.add(f)
+        meta_yaml.close()
+        tap_tar.add('meta.yml')
+        tap_tar.close()
+
+
 class base_job(object):
     """An abstract base class for the various autotest job classes.
 
     @property autodir: The top level autotest directory.
     @property clientdir: The autotest client directory.
     @property serverdir: The autotest server directory. [OPTIONAL]
     @property resultdir: The directory where results should be written out.
         [WRITABLE]
 
     @property pkgdir: The job packages directory. [WRITABLE]
@@ skipping 125 matching lines @@
 
         # initialize all the other directories relative to the base ones
         self._initialize_dir_properties()
         self._resultdir = self._job_directory(
             self._find_resultdir(*args, **dargs), True)
         self._execution_contexts = []
 
         # initialize all the job state
         self._state = self._job_state()
 
+        # initialize tap reporting
+        if dargs.has_key('options'):
+            self._tap = self._tap_init(dargs['options'].tap_report)
+        else:
+            self._tap = self._tap_init(False)
 
     @classmethod
     def _find_base_directories(cls):
         raise NotImplementedError()
 
 
     def _initialize_dir_properties(self):
         """
         Initializes all the secondary self.*dir properties. Requires autodir,
         clientdir and serverdir to already be initialized.
@@ skipping 140 matching lines @@
 
         # create the outputdir and raise a TestError if it isn't valid
         try:
             outputdir = self._job_directory(path, True)
             return outputdir
         except self._job_directory.JobDirectoryException, e:
             logging.exception('%s directory creation failed with %s',
                               subdir, e)
             raise error.TestError('%s directory creation failed' % subdir)
 
+    def _tap_init(self, enable):
+        """Initialize TAP reporting
+        """
+        return TAPReport(enable, resultdir=self.resultdir)
+
 
     def record(self, status_code, subdir, operation, status='',
                optional_fields=None):
         """Record a job-level status event.
 
         Logs an event noteworthy to the Autotest job as a whole. Messages will
         be written into a global status log file, as well as a subdir-local
         status log file (if subdir is specified).
 
         @param status_code: A string status code describing the type of status
@@ skipping 18 matching lines @@
         """Record a job-level status event, using a status_log_entry.
 
         This is the same as self.record but using an existing status log
         entry object rather than constructing one for you.
 
         @param entry: A status_log_entry object
         @param log_in_subdir: A boolean that indicates (when true) that subdir
                 logs should be written into the subdirectory status log file.
         """
         self._get_status_logger().record_entry(entry, log_in_subdir)