make seivots-summary handle missing data from seivots files

This is important for when adding new measurements to newer releases.

1 files changed, 40 insertions, 31 deletions

diff --git a/seivots-summary b/seivots-summary
index 7eca1ff..f389a4d 100755
--- a/seivots-summary
+++ b/seivots-summary
@@ -101,8 +101,7 @@ class SeivotsSummary(cliapp.Application):
         for group, caption in self.find_groups(seivots):
             title = 'Profile: %s' % caption
             self.output.write('%s\n%s\n\n' % (title, '-' * len(title)))
-            ops = ['backup', 'restore', 'list_files', 'forget', 'fsck', 
-                   'verify']
+            ops = ['backup', 'restore', 'list_files', 'forget', 'verify']
             for op in ops:
                 self.output.write('Operation: %s\n\n' % op)
                 table = self.make_table(group, op)
@@ -185,15 +184,10 @@ class SeivotsSummary(cliapp.Application):
         # - encryption used
 
         def key(s):
-            def get(section, key, default):
-                if s.has_option(section, key):
-                    return s.get(section, key)
-                else:
-                    return default
-            init = s.getint('0', 'backup.new-data')
-            inc = s.getint('1', 'backup.new-data')
-            prof = get('meta', 'profile-name', 'unknown profile')
-            enc = get('meta', 'encrypted', 'no')
+            init = self.getint(s, '0', 'backup.new-data')
+            inc = self.getint(s, '1', 'backup.new-data')
+            prof = self.get(s, 'meta', 'profile-name', default='unknown')
+            enc = self.get(s, 'meta', 'encrypted', default='no')
             
             return init, inc, prof, enc
 
@@ -215,12 +209,24 @@ class SeivotsSummary(cliapp.Application):
 
         return [(group, caption(group[0])) for group in groups]
 
+    def get(self, seivot, group, key, default=None):
+        if seivot.has_option(group, key):
+            return seivot.get(group, key)
+        else:
+            return default
+
+    def getint(self, seivot, group, key):
+        return int(self.get(seivot, group, key, default=0))
+
+    def getfloat(self, seivot, group, key):
+        return float(self.get(seivot, group, key, default=0.0))
+
     def getkey(self, seivot):
-        return (seivot.getint('meta', 'revision'), 
-                 seivot.getint('meta', 'larch-revision'))
+        return (self.get(seivot, 'meta', 'revision'), 
+                 self.getint(seivot, 'meta', 'larch-revision'))
 
     def get_size(self, seivot):
-        return seivot.getint('0', 'backup.new-data')
+        return self.getint(seivot, '0', 'backup.new-data')
 
     def find_initial_sizes(self, seivots):
         return list(set(self.get_size(s) for s in seivots))
@@ -231,7 +237,8 @@ class SeivotsSummary(cliapp.Application):
     def values(self, op, suffix, seivot):
         for section in seivot.sections():
             if section not in ['meta', '0']:
-                yield section, seivot.getfloat(section, '%s.%s' % (op,suffix))
+                yield (section, 
+                       self.getfloat(seivot, section, '%s.%s' % (op,suffix)))
 
     def find_slowest_incremental(self, op, seivot):
         v = list(self.values(op, 'real', seivot))
@@ -240,39 +247,38 @@ class SeivotsSummary(cliapp.Application):
         return min(v, key=lambda pair: pair[1])[0]
 
     def get_obnam_revision(self, seivot, op):
-        return seivot.get('meta', 'revision')
+        return self.get(seivot, 'meta', 'revision', default='unknown')
 
     def get_larch_revision(self, seivot, op):
-        return seivot.get('meta', 'larch-revision')
+        return self.get(seivot, 'meta', 'larch-revision', default='unknown')
         
     def get_branch(self, seivot, op):
-        return seivot.get('meta', 'branch')
+        return self.get(seivot, 'meta', 'branch', default='unknown')
         
     def get_description(self, seivot, op):
-        if seivot.has_option('meta', 'description'):
-            return seivot.get('meta', 'description')
-        return ''
+        return self.get(seivot, 'meta', 'description', default='')
 
     def get_gen0_speed(self, seivot, op):
-        bytes = seivot.getfloat('0', 'backup.new-data')
+        bytes = self.getfloat(seivot, '0', 'backup.new-data')
         secs = self.get_gen0_time(seivot, op)
         return self.xferspeed(bytes, secs)
 
     def get_gen0_time(self, seivot, op):
-        return seivot.getfloat('0', '%s.real' % op)
+        return self.getfloat(seivot, '0', '%s.real' % op)
 
     def get_gen0_ram(self, seivot, op):
-        return self.ramsize(seivot.getfloat('0', '%s.maxrss' % op) * 1024)
+        return self.ramsize(self.getfloat(seivot, '0', '%s.maxrss' % op) * 
+                            1024)
 
     def get_slowest_speed(self, seivot, op):
         gen = self.find_slowest_incremental(op, seivot)
-        bytes = seivot.getfloat(gen, 'backup.new-data')
-        secs = seivot.getfloat(gen, '%s.real' % op)
+        bytes = self.getfloat(seivot, gen, 'backup.new-data')
+        secs = self.getfloat(seivot, gen, '%s.real' % op)
         return self.xferspeed(bytes, secs)
 
     def get_slowest_time(self, seivot, op):
         gen = self.find_slowest_incremental(op, seivot)
-        secs = seivot.getfloat(gen, '%s.real' % op)
+        secs = self.getfloat(seivot, gen, '%s.real' % op)
         return secs
 
     def get_biggest_ram(self, seivot, op):
@@ -282,18 +288,21 @@ class SeivotsSummary(cliapp.Application):
         return self.ramsize(kilobytes * 1024)
 
     def get_repo_size(self, seivot, op):
-        return self.disksize(seivot.getfloat('0', 'backup.new-data'))
+        return self.disksize(self.getfloat(seivot, '0', 'backup.new-data'))
 
     def get_repo_writes(self, seivot, op):
-        bytes = seivot.getfloat('0', '%s.repo-bytes-written' % op)
+        bytes = self.getfloat(seivot, '0', '%s.repo-bytes-written' % op)
         return self.disksize(bytes)
 
     def get_repo_reads(self, seivot, op):
-        bytes = seivot.getfloat('0', '%s.repo-bytes-read' % op)
+        bytes = self.getfloat(seivot, '0', '%s.repo-bytes-read' % op)
         return self.disksize(bytes)
 
     def xferspeed(self, bytes, seconds):
-        return 8.0 * bytes / seconds / (1000**2)
+        if seconds > 0:
+            return 8.0 * bytes / seconds / (1000**2)
+        else:
+            return 0
 
     def ramsize(self, bytes):
         return float(bytes) / (1024**2)