autotest: Test new meta files in crash directory

client/site_tests/logging_CrashSender/logging_CrashSender.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import logging, os
+import logging, os, re
 from autotest_lib.client.bin import site_crash_test, site_utils, test
 from autotest_lib.client.common_lib import error, utils
 
+_25_HOURS_AGO = -25 * 60 * 60
 _CRASH_SENDER_CRON_PATH = '/etc/cron.hourly/crash_sender.hourly'
 _DAILY_RATE_LIMIT = 32
 _MIN_UNIQUE_TIMES = 4
+_HWCLASS_PATH = '/sys/devices/platform/chromeos_acpi/HWID'
 _SECONDS_SEND_SPREAD = 3600
 
-
 class logging_CrashSender(site_crash_test.CrashTest):
     version = 1
 
 
-    def _test_sender_simple_minidump(self):
-        """Test sending a single minidump crash report."""
+    def _check_hardware_info(self, result):
+        # Get board name
+        lsb_release = utils.read_file('/etc/lsb-release')
+        board_match = re.search(r'CHROMEOS_RELEASE_BOARD=(.*)', lsb_release)
+        if not ('Board: %s' % board_match.group(1)) in result['output']:
+            raise error.TestFail('Missing board name %s in output' %
+                                 board_match.group(1))
+        # Get hwid
+        hwclass = 'unknown'
+        if os.path.exists(_HWCLASS_PATH):
+            hwclass = utils.read_file(_HWCLASS_PATH)
+        if not ('HWClass: %s' % hwclass) in result['output']:
+            raise error.TestFail('Missing hwclass %s in output' % hwclass)
+
+
+    def _check_simple_minidump_send(self, report):
         self._set_sending(True)
-        result = self._call_sender_one_crash()
+        result = self._call_sender_one_crash(report=report)
         if (result['report_exists'] or
             result['rate_count'] != 1 or
             not result['send_attempt'] or
             not result['send_success'] or
             result['sleep_time'] < 0 or
             result['sleep_time'] >= _SECONDS_SEND_SPREAD or
             result['report_kind'] != 'minidump' or
-            result['exec_name'] != 'fake'):
+            result['report_payload'] != '/var/spool/crash/fake.dmp' or
+            result['exec_name'] != 'fake' or
+            not 'Version: my_ver' in result['output']):
             raise error.TestFail('Simple minidump send failed')
+        self._check_hardware_info(result)
+
+
+    def _test_sender_simple_minidump(self):
+        """Test sending a single minidump crash report."""
+        self._check_simple_minidump_send(None)
+
+
+    def _shift_file_mtime(self, path, delta):
+        statinfo = os.stat(path)
+        os.utime(path, (statinfo.st_atime,
+                        statinfo.st_mtime + delta))
+
+
+    def _test_sender_simple_old_minidump(self):
+        """Test that old minidumps and metadata are sent."""
+        self._set_sending(True)
+        dmp_path = self.write_crash_dir_entry('fake.dmp', '')
+        meta_path = self.write_fake_meta('fake.meta', 'fake')
+        self._shift_file_mtime(dmp_path, _25_HOURS_AGO)
+        self._shift_file_mtime(meta_path, _25_HOURS_AGO)
+        self._check_simple_minidump_send(meta_path)
 
 
     def _test_sender_simple_kernel_crash(self):
         """Test sending a single kcrash report."""
         self._set_sending(True)
-        kcrash_fake_report = self.create_fake_crash_dir_entry(
-            'kernel.today.kcrash')
+        kcrash_fake_report = self.write_crash_dir_entry(
+            'kernel.today.kcrash', '')
+        self.write_fake_meta('kernel.today.meta', 'kernel')
         result = self._call_sender_one_crash(report=kcrash_fake_report)
         if (result['report_exists'] or
             result['rate_count'] != 1 or
             not result['send_attempt'] or
             not result['send_success'] or
             result['sleep_time'] < 0 or
             result['sleep_time'] >= _SECONDS_SEND_SPREAD or
             result['report_kind'] != 'kcrash' or
+            (result['report_payload'] !=
+             '/var/spool/crash/kernel.today.kcrash') or
             result['exec_name'] != 'kernel'):
             raise error.TestFail('Simple kcrash send failed')
+        self._check_hardware_info(result)
 
 
     def _test_sender_pausing(self):
         """Test the sender returns immediately when the pause file is present.
 
         This is testing the sender's test functionality - if this regresses,
         other tests can become flaky because the cron-started sender may run
         asynchronously to these tests."""
         self._set_sending(False)
         result = self._call_sender_one_crash()
@@ skipping 34 matching lines @@
         # Now the _DAILY_RATE_LIMIT ^ th send request should fail.
         result = self._call_sender_one_crash()
         if (not result['report_exists'] or
             not 'Cannot send more crashes' in result['output'] or
             result['rate_count'] != _DAILY_RATE_LIMIT):
             raise error.TestFail('Crash rate limiting did not take effect')
 
         # Set one rate file a day earlier and verify can send
         rate_files = os.listdir(self._CRASH_SENDER_RATE_DIR)
         rate_path = os.path.join(self._CRASH_SENDER_RATE_DIR, rate_files[0])
-        statinfo = os.stat(rate_path)
-        os.utime(rate_path, (statinfo.st_atime,
-                             statinfo.st_mtime - (60 * 60 * 25)))
+        self._shift_file_mtime(rate_path, _25_HOURS_AGO)
         utils.system('ls -l ' + self._CRASH_SENDER_RATE_DIR)
         result = self._call_sender_one_crash()
         if (not result['send_attempt'] or
             not result['send_success'] or
             result['rate_count'] != _DAILY_RATE_LIMIT):
             raise error.TestFail('Crash not sent even after 25hrs pass')
 
 
     def _test_sender_single_instance(self):
         """Test the sender fails to start when another instance is running.
@@ skipping 17 matching lines @@
         if not result['send_attempt'] or result['send_success']:
             raise error.TestError('Did not properly cause a send failure')
         if result['rate_count'] != 1:
             raise error.TestFail('Did not count a failed send against rate '
                                  'limiting')
         if not result['report_exists']:
             raise error.TestFail('Expected minidump to be saved for later '
                                  'sending')
 
 
-    def _test_sender_leaves_core_files(self):
-        """Test that a core file is left in the send directory.
-
-        Core files will only persist for developer/testing images.  We
-        should never remove such a file."""
+    def _test_sender_orphaned_files(self):
+        """Test that payload and unknown files that are old are removed."""
+        core_file = self.write_crash_dir_entry('random1.core', '')
+        unknown_file = self.write_crash_dir_entry('.unknown', '')
+        # As new files, we expect crash_sender to leave these alone.
         self._set_sending(True)
-        # Call prepare function to make sure the directory exists.
-        core_name = 'something.ending.with.core'
-        core_path = self.create_fake_crash_dir_entry(core_name)
-        result = self._call_sender_one_crash()
-        if not 'Ignoring core file.' in result['output']:
-            raise error.TestFail('Expected ignoring core file message')
-        if not os.path.exists(core_path):
-            raise error.TestFail('Core file was removed')
+        results = self._call_sender_one_crash()
+        if ('Removing old orphaned file' in results['output'] or
+            not os.path.exists(core_file) or
+            not os.path.exists(unknown_file)):
+            raise error.TestFail('New orphaned files were removed')
+        self._shift_file_mtime(core_file, _25_HOURS_AGO)
+        self._shift_file_mtime(unknown_file, _25_HOURS_AGO)
+        results = self._call_sender_one_crash()
+        if (not 'Removing old orphaned file' in results['output'] or
+            os.path.exists(core_file) or os.path.exists(unknown_file)):
+            raise error.TestFail(
+                'Old orphaned files were not removed')
 
 
-    def _test_sender_unknown_report_kind(self):
+    def _test_sender_incomplete_metadata(self):
+        """Test that incomplete metadata file is removed once old."""
+        meta_file = self.write_crash_dir_entry('incomplete.meta', 'half=1')
+        dmp_file = self.write_crash_dir_entry('incomplete.dmp', '')
+        # As new files, we expect crash_sender to leave these alone.
         self._set_sending(True)
-        bad_report = self.create_fake_crash_dir_entry('fake.bad')
-        result = self._call_sender_one_crash(report=bad_report)
-        if (result['report_exists'] or
-            result['rate_count'] != 0 or
-            result['send_attempt'] or
-            result['send_success'] or
-            not 'Unknown report' in result['output']):
-            raise error.TestFail('Error handling of unknown report kind failed')
+        results = self._call_sender_one_crash()
+        if ('Removing recent incomplete report' in results['output'] or
+            not os.path.exists(meta_file) or
+            not os.path.exists(dmp_file)):
+            raise error.TestFail('New unknown files were removed')
+        self._shift_file_mtime(meta_file, _25_HOURS_AGO)
+        results = self._call_sender_one_crash()
+        if (not 'Removing old incomplete metadata' in results['output'] or
+            os.path.exists(meta_file) or os.path.exists(dmp_file)):
+            raise error.TestFail(
+                'Old unknown/incomplete files were not removed')
 
 
     def _test_cron_runs(self):
         """Test sender runs successfully as part of the hourly cron job.
 
         Assuming we've run test_sender_simple which shows that a minidump
         gets removed as part of sending, we run the cron job (which is
         asynchronous) and wait for that file to be removed to just verify
         the job eventually runs the sender."""
         self._set_sending(True)
@@ skipping 11 matching lines @@
         crash_sender_log = self._log_reader.get_logs()
         logging.debug('Contents of crash sender log: ' + crash_sender_log)
         result = self._parse_sender_output(crash_sender_log)
         if not result['send_attempt'] or not result['send_success']:
             raise error.TestFail('Cron simple run test failed')
 
 
     def run_once(self):
         self.run_crash_tests([
             'sender_simple_minidump',
+            'sender_simple_old_minidump',
             'sender_simple_kernel_crash',
             'sender_pausing',
             'sender_reports_disabled',
             'sender_rate_limiting',
             'sender_single_instance',
             'sender_send_fails',
-            'sender_leaves_core_files',
-            'sender_unknown_report_kind',
+            'sender_orphaned_files',
+            'sender_incomplete_metadata',
             'cron_runs'])