File: //usr/bin/rdiff-backup-statistics
#!/usr/bin/python3
# rdiff-backup-statistics -- Summarize rdiff-backup statistics files
# Copyright 2005 Dean Gaudet, Ben Escoto
#
# This file is part of rdiff-backup.
#
# rdiff-backup is free software; you can redistribute it and/or modify
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.
#
# rdiff-backup is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with rdiff-backup; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA
import os
import sys
import re
import getopt
from rdiff_backup import (
Globals,
Time,
FilenameMapping,
robust,
rpath,
restore,
)
begin_time = None # Parse statistics at or after this time...
end_time = None # ... and at or before this time (epoch seconds)
min_ratio = 0.05 # report only files/directories over this number
separator = b"\n" # The line separator in file_statistics file
quiet = False # Suppress the "Processing statistics from session ..." lines
def parse_args():
global begin_time, end_time, min_ratio, separator, quiet
try:
optlist, args = getopt.getopt(
sys.argv[1:],
"",
["begin-time=", "end-time=", "minimum-ratio=", "null-separator", "quiet"],
)
except getopt.GetoptError as e:
sys.exit("Bad command line: " + str(e))
for opt, arg in optlist:
if opt == "--begin-time":
begin_time = Time.genstrtotime(arg)
elif opt == "--end-time":
end_time = Time.genstrtotime(arg)
elif opt == "--minimum-ratio":
min_ratio = float(arg)
elif opt == "--null-separator":
separator = b"\0"
elif opt == "--quiet":
quiet = True
else:
assert 0
if len(args) != 1:
sys.exit(
"Usage: %s [--begin-time <time>] [--end-time <time>] "
"[--minimum-ratio <float>] [--null-separator] <backup-dir>\n\n"
"See the rdiff-backup-statistics man page for more information."
% (sys.argv[0],)
)
Globals.rbdir = rpath.RPath(
Globals.local_connection,
os.path.join(os.fsencode(args[0]), b"rdiff-backup-data"),
)
if not Globals.rbdir.isdir():
sys.exit("Directory %s not found" % (Globals.rbdir.get_safepath(),))
def system(cmd):
sys.stdout.flush()
if os.system(cmd):
sys.exit("Error running command '%s'\n" % _safe_str(cmd))
class StatisticsRPaths:
"""Hold file_statistics and session_statistics rpaths"""
def __init__(self, rbdir):
"""Initializer - read increment files from rbdir"""
self.rbdir = rbdir
self.session_rps = self.get_sorted_inc_rps("session_statistics")
self.filestat_rps = self.get_sorted_inc_rps("file_statistics")
self.combined_pairs = self.get_combined_pairs()
def get_sorted_inc_rps(self, prefix):
"""Return list of sorted rps with given prefix"""
incs = restore.get_inclist(self.rbdir.append(prefix))
if begin_time:
incs = filter(lambda i: i.getinctime() >= begin_time, incs)
if end_time:
incs = filter(lambda i: i.getinctime() <= end_time, incs)
incs = list(incs)
incs.sort(key=lambda i: i.getinctime())
return incs
def get_combined_pairs(self):
"""Return list of matched (session_rp, file_rp) pairs"""
session_dict = {}
for inc in self.session_rps:
session_dict[inc.getinctime()] = inc
filestat_dict = {}
for inc in self.filestat_rps:
filestat_dict[inc.getinctime()] = inc
result = []
keylist = list(session_dict) # get a list of keys
keylist.sort()
for time in keylist:
if time in filestat_dict:
result.append((session_dict[time], filestat_dict[time]))
else:
sys.stderr.write(
"No file_statistics to match '%s'\n" % session_dict[time].get_safepath()
)
return result
def print_session_statistics(stat_rpaths):
print("Session statistics:")
system(
b'rdiff-backup --calculate-average "'
+ b'" "'.join([inc.path for inc in stat_rpaths.session_rps])
+ b'"'
)
class FileStatisticsTree:
"""Holds a tree of important files/directories, along with cutoffs"""
def __init__(self, cutoff_fs, fs_root):
"""Initialize with FileStat cutoff object, and root of tree"""
self.cutoff_fs = cutoff_fs
self.fs_root = fs_root
def __iadd__(self, other):
"""Add cutoffs, and merge the other's fs_root"""
self.cutoff_fs += other.cutoff_fs
self.merge_tree(self.fs_root, other.fs_root)
return self
def merge_tree(self, myfs, otherfs):
"""Add other_fs's tree to one of my fs trees"""
assert myfs.nametuple == otherfs.nametuple
total_children = {}
mine = dict([(child.nametuple, child) for child in myfs.children])
others = dict([(child.nametuple, child) for child in otherfs.children])
for name in list(mine.keys()) + list(others.keys()): # Remove duplicates
if name not in total_children:
total_children[name] = (mine.get(name), others.get(name))
# Subtract subdirectories so we can rebuild
for child in myfs.children:
myfs -= child
for child in otherfs.children:
otherfs -= child
myfs.children = []
for (name, (mychild, otherchild)) in total_children.items():
if mychild:
if otherchild:
self.merge_tree(mychild, otherchild)
myfs += mychild
myfs.children.append(mychild)
elif otherchild:
myfs += otherchild
myfs.children.append(otherchild)
else:
assert 0
myfs += otherfs
def get_top_fs(self, fs_func):
"""Process the FileStat tree and find everything above the cutoff
fs_func will be used to evaluate cutoff_fs and those in the
tree. Of course the root will be above the cutoff, but we try
to find the most specific directories still above the cutoff.
The value of any directories that make the cutoff will be
excluded from the value of parent directories.
"""
abs_cutoff = fs_func(self.cutoff_fs)
def helper(subtree):
"""Returns ([list of (top fs, value)], total excluded amount)"""
subtree_val = fs_func(subtree)
if subtree_val <= abs_cutoff:
return ([], 0)
top_children, total_excluded = [], 0
for child in subtree.children:
top_sublist, excluded = helper(child)
top_children.extend(top_sublist)
total_excluded += excluded
current_value = subtree_val - total_excluded
if current_value >= abs_cutoff:
return ([(subtree, current_value)] + top_children, subtree_val)
else:
return (top_children, total_excluded)
return helper(self.fs_root)[0]
def print_top_dirs(self, label, fs_func):
"""Print the top directories in sorted order"""
def print_line(fs, val):
percentage = float(val) / fs_func(self.fs_root) * 100
path = fs.nametuple and b"/".join(fs.nametuple) or b"."
print("%s (%02.1f%%)" % (path.decode(errors="replace"), percentage))
s = "Top directories by %s (percent of total)" % (label,)
print("\n%s\n%s" % (s, ("-" * len(s))))
top_fs_pair_list = self.get_top_fs(fs_func)
top_fs_pair_list.sort(key=lambda pair: pair[1], reverse=1)
for fs, val in top_fs_pair_list:
print_line(fs, val)
def make_fst(session_rp, filestat_rp):
"""Construct FileStatisticsTree given session and file stat rps
We would like a full tree, but this in general will take too much
memory. Instead we will build a tree that has only the
files/directories with some stat exceeding the min ratio.
"""
def get_ss_dict():
"""Parse session statistics file and return dictionary with ss data"""
fileobj = session_rp.open("rb", session_rp.isinccompressed())
return_val = {}
for line in fileobj:
if line.startswith(b"#"):
continue
comps = line.split()
if len(comps) < 2:
sys.stderr.write("Unable to parse session statistics line: " + line)
continue
return_val[comps[0]] = float(comps[1])
return return_val
def get_cutoff_fs(session_dict):
"""Return FileStat object set with absolute cutoffs
Any FileStat object that is bigger than the result in any
aspect will be considered "important".
"""
def get_min(attrib):
return min_ratio * session_dict[attrib]
min_changed = min_ratio * (
session_dict[b"NewFiles"]
+ session_dict[b"ChangedFiles"]
+ session_dict[b"NewFiles"]
)
return FileStat(
(), min_changed, get_min(b"SourceFileSize"), get_min(b"IncrementFileSize")
)
def yield_fs_objs(filestatsobj):
"""Iterate FileStats by processing file_statistics fileobj"""
r = re.compile(
b"^(.*) ([0-9]+) ([0-9]+|NA) ([0-9]+|NA) " b"([0-9]+|NA)%b?$" % (separator,)
)
for line in filestatsobj:
if line.startswith(b"#"):
continue
match = r.match(line)
if not match:
sys.stderr.write("Error parsing line: %s\n" % _safe_str(line))
continue
filename = match.group(1)
if filename == b".":
nametuple = ()
else:
nametuple = tuple(filename.split(b"/"))
sourcesize_str = match.group(3)
if sourcesize_str == b"NA":
sourcesize = 0
else:
sourcesize = int(sourcesize_str)
incsize_str = match.group(5)
if incsize_str == b"NA":
incsize = 0
else:
incsize = int(incsize_str)
yield FileStat(nametuple, int(match.group(2)), sourcesize, incsize)
def accumulate_fs(fs_iter):
"""Yield the FileStat objects in fs_iter, but with total statistics
In fs_iter, the statistics of directories FileStats only apply
to themselves. This will iterate the same FileStats, but
directories will include all the files under them. As a
result, the directories will come after the files in them
(e.g. '.' will be last.).
Naturally this would be written recursively, but profiler said
it was too slow in python.
"""
root = next(fs_iter)
assert root.nametuple == (), root
stack = [root]
try:
fs = next(fs_iter)
except StopIteration:
yield root
return
while 1:
if fs and fs.is_child(stack[-1]):
stack.append(fs)
try:
fs = next(fs_iter)
except StopIteration:
fs = None
else:
expired = stack.pop()
yield expired
if not stack:
return
else:
stack[-1].add_child(expired)
def make_tree_one_level(fs_iter, first_fs):
"""Populate a tree of FileStat objects from fs_iter
This function wants the fs_iter in the reverse direction as
usual, with the parent coming directly after all the children.
It will return the parent of first_fs.
"""
children = [first_fs]
fs = next(fs_iter)
while 1:
if first_fs.is_child(fs):
fs.children = children
return fs
elif first_fs.is_brother(fs):
children.append(fs)
fs = next(fs_iter)
else:
fs = make_tree_one_level(fs_iter, fs)
def make_root_tree(fs_iter):
"""Like make_tree, but assume fs_iter starts at the root"""
try:
fs = next(fs_iter)
except StopIteration:
sys.exit("No files in iterator")
while fs.nametuple != ():
fs = make_tree_one_level(fs_iter, fs)
return fs
cutoff_fs = get_cutoff_fs(get_ss_dict())
filestat_fileobj = ReadlineBuffer(filestat_rp)
accumulated_iter = accumulate_fs(yield_fs_objs(filestat_fileobj))
important_iter = filter(lambda fs: fs >= cutoff_fs, accumulated_iter)
trimmed_tree = make_root_tree(important_iter)
return FileStatisticsTree(cutoff_fs, trimmed_tree)
class FileStat:
"""Hold the information in one line of file_statistics
However, unlike file_statistics, a File can have subdirectories
under it. In that case, the information should be cumulative.
"""
def __init__(self, nametuple, changed, sourcesize, incsize):
self.nametuple = nametuple
self.changed = changed
self.sourcesize, self.incsize = sourcesize, incsize
self.children = []
def add_child(self, child):
self += child
def is_subdir(self, parent):
"""Return True if self is an eventual subdir of parent"""
return self.nametuple[: len(parent.nametuple)] == parent.nametuple
def is_child(self, parent):
"""Return True if self is an immediate child of parent"""
return self.nametuple and self.nametuple[:-1] == parent.nametuple
def is_brother(self, brother):
"""Return True if self is in same directory as brother"""
if not self.nametuple or not brother.nametuple:
return 0
return self.nametuple[:-1] == brother.nametuple[:-1]
def __str__(self):
return "%s %s %s %s" % (
self.nametuple,
self.changed,
self.sourcesize,
self.incsize,
)
def __eq__(self, other):
return (
self.changed == other.changed
and self.sourcesize == other.sourcesize
and self.incsize == other.incsize
)
def __ge__(self, other):
"""Note the 'or' -- this relation is not a well ordering"""
return (
self.changed >= other.changed
or self.sourcesize >= other.sourcesize
or self.incsize >= other.incsize
)
def __iadd__(self, other):
"""Add values of other to self"""
self.changed += other.changed
self.sourcesize += other.sourcesize
self.incsize += other.incsize
return self
def __isub__(self, other):
"""Subtract values of other from self"""
self.changed -= other.changed
self.sourcesize -= other.sourcesize
self.incsize -= other.incsize
return self
class ReadlineBuffer:
"""Iterate lines like a normal filelike obj
Use this because gzip doesn't provide any buffering, so readline()
is very slow.
"""
blocksize = 65536
def __init__(self, rp):
"""Initialize with rpath"""
self.buffer = [b""]
self.at_end = 0
if rp.isincfile():
self.fileobj = rp.open("rb", rp.isinccompressed())
else:
self.fileobj = rp.open("rb")
def __iter__(self):
"""Yield the lines in self.fileobj"""
while self.buffer or not self.at_end:
if len(self.buffer) > 1:
yield self.buffer.pop(0)
elif not self.at_end:
self.addtobuffer()
else:
last = self.buffer.pop()
if last:
yield last
def addtobuffer(self):
"""Read next block from fileobj, split and add to bufferlist"""
block = self.fileobj.read(self.blocksize)
if block:
split = block.split(separator)
self.buffer[0] += split[0]
self.buffer.extend(split[1:])
else:
self.at_end = 1
def sum_fst(rp_pairs):
"""Add the file statistics given as list of (session_rp, file_rp) pairs"""
global quiet
n = len(rp_pairs)
if not quiet:
print("Processing statistics from session 1 of %d" % (n,))
total_fst = make_fst(*rp_pairs[0])
for i in range(1, n):
if not quiet:
print("Processing statistics from session %d of %d" % (i + 1, n))
session_rp, filestat_rp = rp_pairs[i]
fst = make_fst(session_rp, filestat_rp)
total_fst += fst
return total_fst
def set_chars_to_quote():
ctq_rp = Globals.rbdir.append("chars_to_quote")
if ctq_rp.lstat():
Globals.chars_to_quote = ctq_rp.get_string()
if Globals.chars_to_quote:
Globals.must_escape_dos_devices = 0 # No DOS devices will be present
FilenameMapping.set_init_quote_vals()
Globals.rbdir = FilenameMapping.get_quotedrpath(Globals.rbdir)
def _safe_str(cmd):
"""Transform bytes into string without risk of conversion error"""
if isinstance(cmd, str):
return cmd
else:
return str(cmd, errors='replace')
def Main():
Time.setcurtime()
parse_args()
set_chars_to_quote()
srp = StatisticsRPaths(Globals.rbdir)
if not srp.combined_pairs:
sys.exit("No matching sessions found")
if len(srp.combined_pairs) == 1:
fst = make_fst(*srp.combined_pairs[0])
else:
fst = sum_fst(srp.combined_pairs)
print_session_statistics(srp)
fst.print_top_dirs("source size", lambda fs: fs.sourcesize)
fst.print_top_dirs("increment size", lambda fs: fs.incsize)
fst.print_top_dirs("number of files changed", lambda fs: fs.changed)
def error_check_Main():
"""Run Main on arglist, suppressing stack trace for routine errors"""
try:
Main()
except SystemExit:
raise
except KeyboardInterrupt:
print("User abort")
except (Exception, KeyboardInterrupt) as exc:
if robust.catch_error(exc):
print(exc)
else:
raise
if __name__ == "__main__":
error_check_Main()