Return to maketree.py CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / testhelp

Annotation of embedaddon/rsync/testhelp/maketree.py, revision 1.1.1.1

1.1       misho       1: #! /usr/bin/python2.2
                      2: 
                      3: # Copyright (C) 2002 by Martin Pool <mbp@samba.org>
                      4: 
                      5: # This program is free software; you can redistribute it and/or modify
                      6: # it under the terms of the GNU General Public License version
                      7: # 2 as published by the Free Software Foundation.
                      8: #
                      9: # This program is distributed in the hope that it will be useful, but
                     10: # WITHOUT ANY WARRANTY; without even the implied warranty of
                     11: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     12: # Lesser General Public License for more details.
                     13: # 
                     14: # You should have received a copy of the GNU Lesser General Public
                     15: # License along with this program; if not, write to the Free Software
                     16: # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
                     17: 
                     18: # Populate a tree with pseudo-randomly distributed files to test
                     19: # rsync.
                     20: 
                     21: from __future__ import generators
                     22: import random, string, os, os.path
                     23: 
                     24: nfiles = 10000
                     25: depth = 5
                     26: n_children = 20
                     27: n_files = 20
                     28: n_symlinks = 10
                     29: 
                     30: name_chars = string.digits + string.letters
                     31: 
                     32: abuffer = 'a' * 1024
                     33: 
                     34: def random_name_chars():
                     35:     a = ""
                     36:     for i in range(10):
                     37:         a = a + random.choice(name_chars)
                     38:     return a
                     39: 
                     40:     
                     41: def generate_names():
                     42:     n = 0
                     43:     while 1:
                     44:         yield "%05d_%s" % (n, random_name_chars())
                     45:         n += 1
                     46: 
                     47: 
                     48: class TreeBuilder:
                     49:     def __init__(self):
                     50:         self.n_children = 20
                     51:         self.n_files = 100
                     52:         self.total_entries = 100000 # long(1e8)
                     53:         self.actual_size = 0
                     54:         self.name_gen = generate_names()
                     55:         self.all_files = []
                     56:         self.all_dirs = []
                     57:         self.all_symlinks = []
                     58: 
                     59: 
                     60:     def random_size(self):
                     61:         return random.lognormvariate(4, 4)
                     62: 
                     63: 
                     64:     def random_symlink_target(self):
                     65:         what = random.choice(['directory', 'file', 'symlink', 'none'])
                     66:         try:
                     67:             if what == 'directory':
                     68:                 return random.choice(self.all_dirs)
                     69:             elif what == 'file':
                     70:                 return random.choice(self.all_files)
                     71:             elif what == 'symlink':
                     72:                 return random.choice(self.all_symlinks)
                     73:             elif what == 'none':
                     74:                 return self.name_gen.next()
                     75:         except IndexError:
                     76:             return self.name_gen.next()
                     77: 
                     78: 
                     79:     def can_continue(self):
                     80:         self.total_entries -= 1
                     81:         return self.total_entries > 0
                     82: 
                     83:         
                     84:     def build_tree(self, prefix, depth):
                     85:         """Generate a breadth-first tree"""
                     86:         for count, function in [[n_files, self.make_file],
                     87:                                 [n_children, self.make_child_recurse],
                     88:                                 [n_symlinks, self.make_symlink]]:
                     89:             for i in range(count):
                     90:                 if not self.can_continue():
                     91:                     return
                     92:                 name = os.path.join(prefix, self.name_gen.next())
                     93:                 function(name, depth)
                     94: 
                     95: 
                     96:     def print_summary(self):
                     97:         print "total bytes: %d" % self.actual_size
                     98: 
                     99: 
                    100:     def make_child_recurse(self, dname, depth):
                    101:         if depth > 1:
                    102:             self.make_dir(dname)
                    103:             self.build_tree(dname, depth-1)
                    104: 
                    105: 
                    106:     def make_dir(self, dname, depth='ignore'):
                    107:         print "%s/" % (dname)
                    108:         os.mkdir(dname)
                    109:         self.all_dirs.append(dname)
                    110: 
                    111: 
                    112:     def make_symlink(self, lname, depth='ignore'):
                    113:         print "%s -> %s" % (lname, self.random_symlink_target())
                    114: 
                    115: 
                    116:     def make_file(self, fname, depth='ignore'):
                    117:         size = long(self.random_size())
                    118:         print "%-70s %d" % (fname, size)
                    119:         f = open(fname, 'w')
                    120:         f.truncate(size)
                    121:         self.fill_file(f, size)
                    122:         self.all_files.append(fname)
                    123:         self.actual_size += size
                    124: 
                    125:     def fill_file(self, f, size):
                    126:         while size > 0:
                    127:             f.write(abuffer[:size])
                    128:             size -= len(abuffer)
                    129: 
                    130:     
                    131: tb = TreeBuilder()
                    132: tb.build_tree('/tmp/foo', 3)
                    133: tb.print_summary()