← Back to branch summary

~david-goetz/swift/wal_again

« back to all changes in this revision

Viewing changes to swift/obj/auditor.py

  • Committer: Chuck Thier
  • Date: 2011-05-05 21:02:08 UTC
  • mto: This revision was merged to the branch mainline in revision 287.
  • Revision ID: cthier@gmail.com-20110505210208-b4dbw0w62qo0e1rz
removed test that was incorrectly testing for a bad path

Show diffs side-by-side

added added

removed removed

Lines of Context:
swift/obj/auditor.py
63
63
        begin = reported = time.time()
64
64
        self.total_bytes_processed = 0
65
65
        self.total_files_processed = 0
66
 
        total_quarantines = 0
67
 
        total_errors = 0
68
66
        files_running_time = 0
69
 
        time_auditing = 0
70
67
        all_locs = audit_location_generator(self.devices,
71
68
                                            object_server.DATADIR,
72
69
                                            mount_check=self.mount_check,
73
70
                                            logger=self.logger)
74
71
        for path, device, partition in all_locs:
75
 
            loop_time = time.time()
76
72
            self.object_audit(path, device, partition)
77
73
            self.files_running_time = ratelimit_sleep(
78
74
                self.files_running_time, self.max_files_per_second)
79
75
            self.total_files_processed += 1
80
 
            now = time.time()
81
 
            if now - reported >= self.log_time:
 
76
            if time.time() - reported >= self.log_time:
82
77
                self.logger.info(_(
83
78
                    'Object audit (%(type)s). '
84
79
                    'Since %(start_time)s: Locally: %(passes)d passed, '
85
80
                    '%(quars)d quarantined, %(errors)d errors '
86
 
                    'files/sec: %(frate).2f , bytes/sec: %(brate).2f, '
87
 
                    'Total time: %(total).2f, Auditing time: %(audit).2f, '
88
 
                    'Rate: %(audit_rate).2f') % {
 
81
                    'files/sec: %(frate).2f , bytes/sec: %(brate).2f') % {
89
82
                            'type': self.auditor_type,
90
83
                            'start_time': time.ctime(reported),
91
 
                            'passes': self.passes, 'quars': self.quarantines,
 
84
                            'passes': self.passes,
 
85
                            'quars': self.quarantines,
92
86
                            'errors': self.errors,
93
 
                            'frate': self.passes / (now - reported),
94
 
                            'brate': self.bytes_processed / (now - reported),
95
 
                            'total': (now - begin), 'audit': time_auditing,
96
 
                            'audit_rate': time_auditing / (now - begin)})
97
 
                reported = now
98
 
                total_quarantines += self.quarantines
99
 
                total_errors += self.errors
 
87
                            'frate': self.passes / (time.time() - reported),
 
88
                            'brate': self.bytes_processed /
 
89
                                     (time.time() - reported)})
 
90
                reported = time.time()
100
91
                self.passes = 0
101
92
                self.quarantines = 0
102
93
                self.errors = 0
103
94
                self.bytes_processed = 0
104
 
            time_auditing += (now - loop_time)
105
95
        elapsed = time.time() - begin
106
96
        self.logger.info(_(
107
 
            'Object audit (%(type)s) "%(mode)s" mode '
108
 
            'completed: %(elapsed).02fs. Total quarantined: %(quars)d, '
109
 
            'Total errors: %(errors)d, Total files/sec: %(frate).2f , '
110
 
            'Total bytes/sec: %(brate).2f, Auditing time: %(audit).2f, '
111
 
            'Rate: %(audit_rate).2f') % {
112
 
                'type': self.auditor_type, 'mode': mode, 'elapsed': elapsed,
113
 
                'quars': total_quarantines, 'errors': total_errors,
114
 
                'frate': self.total_files_processed / elapsed,
115
 
                'brate': self.total_bytes_processed / elapsed,
116
 
                'audit': time_auditing, 'audit_rate': time_auditing / elapsed})
 
97
                'Object audit (%(type)s) "%(mode)s" mode '
 
98
                'completed: %(elapsed).02fs. '
 
99
                'Total files/sec: %(frate).2f , '
 
100
                'Total bytes/sec: %(brate).2f ') % {
 
101
                    'type': self.auditor_type,
 
102
                    'mode': mode,
 
103
                    'elapsed': elapsed,
 
104
                    'frate': self.total_files_processed / elapsed,
 
105
                    'brate': self.total_bytes_processed / elapsed})
117
106
 
118
107
    def object_audit(self, path, device, partition):
119
108
        """
144
133
            except DiskFileNotExist:
145
134
                return
146
135
            if self.zero_byte_only_at_fps and obj_size:
147
 
                self.passes += 1
148
136
                return
149
137
            for chunk in df:
150
138
                self.bytes_running_time = ratelimit_sleep(