gufi_du updates

Added --inodes
Added --separate-dirs
Reduced number of --verbose prints

Author: calccrypto

scripts/gufi_du

@@ -74,7 +74,6 @@ def get_blocksize(value):
     str_val = gufi_common.get_blocksize(value)
 
     units = 0 # number of chars to remove
-    multiplier = 1024
     if str_val[-2:] == 'iB':
         units -= 2
         multiplier = 1024
@@ -123,6 +122,14 @@ def build_expression_parser():
                         action='store_true',
                         help='produce a grand total')
 
+    parser.add_argument('--inodes',
+                        action='store_true',
+                        help='list inode usage information instead of block usage')
+
+    parser.add_argument('-S', '--separate-dirs',
+                        action='store_true',
+                        help='for directories do not include size of subdirectories')
+
     parser.add_argument('-s', '--summarize',
                         action='store_true',
                         help='display only a total for each argument')
@@ -138,35 +145,80 @@ def build_expression_parser():
     return parser
 
 # process files/links
-def nondir(E_col, name):
+def nondir(args, name):
+    if args.inodes:
+        E_col = '1'
+    elif args.apparent_size:
+        E_col = 'size'
+    else:
+        E_col = 'blocks'
+
     # isroot is set to 1 since the size should be used for --total
     return [
         '-y', '0',
         '-z', '0',
         '-E', 'SELECT level(), 1, {0}, rpath(sname, sroll) || \'/\' || name FROM {1} WHERE name == \'{2}\';'.format(E_col,
-                                                                                                                         gufi_common.VRPENTRIES,
-                                                                                                                         name),
+                                                                                                                    gufi_common.VRPENTRIES,
+                                                                                                                    name),
     ]
 
 # no flags
 # print self and all subdirectories
-def none(T_col):
+def none(args):
+    if args.inodes:
+        T_col = '{0}.totfiles + {0}.totlinks'
+    elif args.apparent_size:
+        T_col = '{0}.totsize'
+    else:
+        T_col = '{0}.totblocks'
+
     return [
         '-a', '2', # run -T on all directories
-        '-T', 'SELECT level(), isroot, {0}, rpath(sname, sroll) FROM {1} LEFT JOIN {2} ON {1}.inode == {2}.inode;'.format(T_col,
+        '-T', 'SELECT level(), isroot, {0}, rpath(sname, sroll) FROM {1} LEFT JOIN {2} ON {1}.inode == {2}.inode;'.format(T_col.format(gufi_common.TREESUMMARY),
                                                                                                                           gufi_common.TREESUMMARY,
                                                                                                                           gufi_common.VRSUMMARY),
     ]
 
+# --separate-dirs
+def separate_dirs(args):
+    if args.inodes:
+        S_col = 'totfiles + totlinks'
+    elif args.apparent_size:
+        S_col = 'totsize'
+    else:
+        S_col = 'totblocks'
+
+    # summarize is turned on -> get only input path
+    if args.summarize:
+        return [
+        '-y', '0',
+        '-z', '0',
+        '-S', 'SELECT level(), isroot, {0}, rpath(sname, sroll) FROM {1} WHERE isroot == 1;'.format(S_col,
+                                                                                                    gufi_common.VRSUMMARY),
+    ]
+
+    # get entire subtree
+    return [
+        '-S', 'SELECT level(), isroot, {0}, rpath(sname, sroll) FROM {1};'.format(S_col,
+                                                                                  gufi_common.VRSUMMARY),
+    ]
+
 # --summarize
 # print single size for each input path
-def summarize(T_col):
+def summarize(args):
+    if args.inodes:
+        T_col = '{0}.totfiles + {0}.totlinks'
+    elif args.apparent_size:
+        T_col = '{0}.totsize'
+    else:
+        T_col = '{0}.totblocks'
+
     return [
         '-y', '0',
         '-z', '0',
-        '-T', 'SELECT level(), isroot, {0}, rpath(sname, sroll) FROM {1} LEFT JOIN {2} ON {1}.inode == {2}.inode WHERE {2}.isroot == 1;'.format(T_col,
-                                                                                                                          gufi_common.TREESUMMARY,
-                                                                                                                          gufi_common.VRSUMMARY),
+        '-T', 'SELECT level(), isroot, {0}, rpath(sname, sroll) FROM {1} LEFT JOIN {2} ON {1}.inode == {2}.inode WHERE {2}.isroot == 1;'.format(T_col.format(gufi_common.TREESUMMARY),
+                                                                                                                                                gufi_common.TREESUMMARY,
+                                                                                                                                                gufi_common.VRSUMMARY),
     ]
 
 # argv[0] should be the command name
@@ -179,6 +231,9 @@ def run(argv, config_path):
     parser = build_expression_parser()
     args = parser.parse_args(argv[1:])
 
+    if args.inodes and (args.apparent_size or args.block_size):
+        sys.stderr.write("warning: options --apparent-size and -b are ineffective with --inodes\n")
+
     # cache the length of the indexroot + '/'
     INDEXROOT_LEN = len(config.indexroot) + 1
 
@@ -232,14 +287,14 @@ def run(argv, config_path):
 
         # append the queries to run
         if basename:
-            query_cmd += nondir('size' if args.apparent_size else 'blocks', basename)
+            query_cmd += nondir(args, basename)
         else:
-            T_ACTUAL   = '{0}.totblocks'.format(gufi_common.TREESUMMARY)
-            T_APPARENT = '{0}.totsize'.format(gufi_common.TREESUMMARY)
-            if args.summarize:
-                query_cmd += summarize(T_APPARENT if args.apparent_size else T_ACTUAL)
+            if args.separate_dirs:
+                query_cmd += separate_dirs(args)
+            elif args.summarize:
+                query_cmd += summarize(args)
             else:
-                query_cmd += none(T_APPARENT if args.apparent_size else T_ACTUAL)
+                query_cmd += none(args)
 
         query_cmd += [fullpath]
 
@@ -265,13 +320,16 @@ def run(argv, config_path):
 
             rows += 1
 
-            raw = int(raw) # block count or octets
+            raw = int(raw)
 
-            # number of blocks used by this directory (including rounding up)
-            # or logical size
-            if not args.apparent_size:
-                raw *= 512
-            size = (raw // block_size) + ((raw % block_size) != 0) # round up
+            if args.inodes:
+                size = raw # count
+            else:
+                # number of blocks used by this directory (including rounding up)
+                # or logical size
+                if not args.apparent_size:
+                    raw *= 512
+                size = (raw // block_size) + ((raw % block_size) != 0) # round up
 
             # -s/--summarize removes individual prints
             if not args.summarize:
@@ -280,7 +338,7 @@ def run(argv, config_path):
             dir_size += size
 
             if args.total:
-                if (level == '0') and (isroot == '1'):
+                if args.separate_dirs or ((not args.separate_dirs) and (level == '0') and (isroot == '1')):
                     total_blocks += size
 
         # -s/--summarize prints a combined size at the end of the current input path