1
# Copyright (C) 2006-2010 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tree creators for kernel-like trees"""
29
from bzrlib.benchmarks.tree_creator import TreeCreator
32
class KernelLikeTreeCreator(TreeCreator):
33
"""Create a basic tree with ~10k unversioned files"""
35
def __init__(self, test, link_working=False, url=None):
36
super(KernelLikeTreeCreator, self).__init__(test,
37
tree_name='kernel_like_tree',
38
link_working=link_working,
43
def create(self, root):
44
"""Create all the kernel files in the given location.
46
This is overloaded for compatibility reasons.
48
if self._url is not None:
49
b = bzrdir.BzrDir.create_branch_convenience(self._url)
50
d = bzrdir.BzrDir.create(root)
51
bzrlib.branch.BranchReferenceFormat().initialize(d,
53
tree = d.create_workingtree()
55
tree = bzrdir.BzrDir.create_standalone_workingtree(root)
57
if not self._link_working or not self.is_caching_enabled():
58
# Turns out that 'shutil.copytree()' is no faster than
59
# just creating them. Probably the python overhead.
60
# Plain _make_kernel_files takes 3-5s
62
# using hardlinks takes < 1s.
63
self._create_tree(root=root, in_cache=False)
67
cache_dir = self._get_cache_dir()
68
osutils.copy_tree(cache_dir, root,
69
handlers={'file':os.link})
72
def _create_tree(self, root, in_cache=False):
73
# a kernel tree has ~10000 and 500 directory, with most files around
75
# we simulate this by three levels of dirs named 0-7, givin 512 dirs,
78
for outer in range(8):
79
files.append("%s/" % outer)
80
for middle in range(8):
81
files.append("%s/%s/" % (outer, middle))
82
for inner in range(8):
83
prefix = "%s/%s/%s/" % (outer, middle, inner)
85
files.extend([prefix + str(foo) for foo in range(20)])
86
cwd = osutils.getcwd()
90
if e.errno not in (errno.EEXIST,):
93
self._test.build_tree(files)
96
self._protect_files(root)
99
class KernelLikeAddedTreeCreator(TreeCreator):
100
"""Create a tree with ~10k versioned but not committed files"""
102
def __init__(self, test, link_working=False, hot_cache=True):
103
super(KernelLikeAddedTreeCreator, self).__init__(test,
104
tree_name='kernel_like_added_tree',
105
link_working=link_working,
109
def _create_tree(self, root, in_cache=False):
110
"""Create a kernel-like tree with the all files added
112
:param root: The root directory to create the files
113
:param in_cache: Is this being created in the cache dir?
115
kernel_creator = KernelLikeTreeCreator(self._test,
116
link_working=in_cache)
117
tree = kernel_creator.create(root=root)
119
# Add everything to it
122
tree.smart_add([root], recurse=True, save=True)
124
self._protect_files(root+'/.bzr')
130
class KernelLikeCommittedTreeCreator(TreeCreator):
131
"""Create a tree with ~10K files, and a single commit adding all of them"""
133
def __init__(self, test, link_working=False, link_bzr=False,
135
super(KernelLikeCommittedTreeCreator, self).__init__(test,
136
tree_name='kernel_like_committed_tree',
137
link_working=link_working,
141
def _create_tree(self, root, in_cache=False):
142
"""Create a kernel-like tree with all files committed
144
:param root: The root directory to create the files
145
:param in_cache: Is this being created in the cache dir?
147
kernel_creator = KernelLikeAddedTreeCreator(self._test,
148
link_working=in_cache,
149
hot_cache=(not in_cache))
150
tree = kernel_creator.create(root=root)
151
tree.commit('first post', rev_id='r1')
154
self._protect_files(root+'/.bzr')
158
class KernelLikeInventoryCreator(TreeCreator):
159
"""Return just the memory representation of a committed kernel-like tree"""
161
def __init__(self, test):
162
super(KernelLikeInventoryCreator, self).__init__(test,
163
tree_name='kernel_like_inventory',
168
def ensure_cached(self):
169
"""Make sure we have a cached version of the kernel-like inventory"""
170
cache_dir = self._get_cache_dir()
171
if cache_dir is None:
177
committed_creator = KernelLikeCommittedTreeCreator(self._test,
181
committed_creator.ensure_cached()
182
committed_cache_dir = committed_creator._get_cache_dir()
183
committed_tree = workingtree.WorkingTree.open(committed_cache_dir)
184
rev_tree = committed_tree.basis_tree()
186
f = open(cache_dir+'/inventory', 'wb')
188
xml5.serializer_v5.write_inventory(rev_tree.inventory, f)
192
def create(self, root=None):
193
"""Create a kernel like inventory
195
:param root: Exists to mimic the base class, but this class
196
returns only an in-memory Inventory, so it should always be None.
197
:return: An Inventory object.
199
cache_dir = self._get_cache_dir()
200
if cache_dir is None:
201
return self._create_and_return()
204
return self._open_cached(cache_dir)
206
def _create_and_return(self):
207
"""Create a kernel-like tree, and return its inventory"""
208
creator = KernelLikeCommittedTreeCreator(self._test,
212
tree = creator.create('.')
213
basis = tree.basis_tree()
216
return basis.inventory
220
def _open_cached(self, cache_dir):
221
f = open(cache_dir + '/inventory', 'rb')
223
return xml5.serializer_v5.read_inventory(f)
added
removed
bzrlib/benchmarks/tree_creator/kernel_like.py
