1
# Copyright (C) 2007, 2008, 2009 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
"""Utility for create branches with particular contents."""
19
from __future__ import absolute_import
33
class BranchBuilder(object):
34
r"""A BranchBuilder aids creating Branches with particular shapes.
36
The expected way to use BranchBuilder is to construct a
37
BranchBuilder on the transport you want your branch on, and then call
38
appropriate build_ methods on it to get the shape of history you want.
40
This is meant as a helper for the test suite, not as a general class for
45
>>> from breezy.transport.memory import MemoryTransport
46
>>> builder = BranchBuilder(MemoryTransport("memory:///"))
47
>>> builder.start_series()
48
>>> builder.build_snapshot(None, [
49
... ('add', ('', b'root-id', 'directory', '')),
50
... ('add', ('filename', b'f-id', 'file', 'content\n'))],
51
... revision_id=b'rev-id')
53
>>> builder.build_snapshot(['rev-id'],
54
... [('modify', (b'f-id', 'new-content\n'))],
55
... revision_id=b'rev2-id')
57
>>> builder.finish_series()
58
>>> branch = builder.get_branch()
60
:ivar _tree: This is a private member which is not meant to be modified by
61
users of this class. While a 'series' is in progress, it should hold a
62
MemoryTree with the contents of the last commit (ready to be modified
63
by the next build_snapshot command) with a held write lock. Outside of
64
a series in progress, it should be None.
67
def __init__(self, transport=None, format=None, branch=None):
68
"""Construct a BranchBuilder on transport.
70
:param transport: The transport the branch should be created on.
71
If the path of the transport does not exist but its parent does
73
:param format: Either a BzrDirFormat, or the name of a format in the
74
controldir format registry for the branch to be built.
75
:param branch: An already constructed branch to use. This param is
76
mutually exclusive with the transport and format params.
78
if branch is not None:
79
if format is not None:
81
"branch and format kwargs are mutually exclusive")
82
if transport is not None:
84
"branch and transport kwargs are mutually exclusive")
87
if not transport.has('.'):
91
if isinstance(format, str):
92
format = controldir.format_registry.make_controldir(format)
93
self._branch = controldir.ControlDir.create_branch_convenience(
94
transport.base, format=format, force_new_tree=False)
97
def build_commit(self, parent_ids=None, allow_leftmost_as_ghost=False,
99
"""Build a commit on the branch.
101
This makes a commit with no real file content for when you only want
102
to look at the revision graph structure.
104
:param commit_kwargs: Arguments to pass through to commit, such as
107
if parent_ids is not None:
108
if len(parent_ids) == 0:
109
base_id = revision.NULL_REVISION
111
base_id = parent_ids[0]
112
if base_id != self._branch.last_revision():
113
self._move_branch_pointer(base_id,
114
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
115
tree = self._branch.create_memorytree()
118
if parent_ids is not None:
119
tree.set_parent_ids(parent_ids,
120
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
122
return self._do_commit(tree, **commit_kwargs)
126
def _do_commit(self, tree, message=None, message_callback=None, **kwargs):
127
reporter = commit.NullCommitReporter()
128
if message is None and message_callback is None:
129
message = u'commit %d' % (self._branch.revno() + 1,)
130
return tree.commit(message, message_callback=message_callback,
134
def _move_branch_pointer(self, new_revision_id,
135
allow_leftmost_as_ghost=False):
136
"""Point self._branch to a different revision id."""
137
self._branch.lock_write()
139
# We don't seem to have a simple set_last_revision(), so we
141
cur_revno, cur_revision_id = self._branch.last_revision_info()
143
g = self._branch.repository.get_graph()
144
new_revno = g.find_distance_to_null(new_revision_id,
145
[(cur_revision_id, cur_revno)])
146
self._branch.set_last_revision_info(new_revno, new_revision_id)
147
except errors.GhostRevisionsHaveNoRevno:
148
if not allow_leftmost_as_ghost:
152
self._branch.unlock()
153
if self._tree is not None:
154
# We are currently processing a series, but when switching branch
155
# pointers, it is easiest to just create a new memory tree.
156
# That way we are sure to have the right files-on-disk
157
# We are cheating a little bit here, and locking the new tree
158
# before the old tree is unlocked. But that way the branch stays
160
new_tree = self._branch.create_memorytree()
161
new_tree.lock_write()
163
self._tree = new_tree
165
def start_series(self):
166
"""We will be creating a series of commits.
168
This allows us to hold open the locks while we are processing.
170
Make sure to call 'finish_series' when you are done.
172
if self._tree is not None:
173
raise AssertionError('You cannot start a new series while a'
174
' series is already going.')
175
self._tree = self._branch.create_memorytree()
176
self._tree.lock_write()
178
def finish_series(self):
179
"""Call this after start_series to unlock the various objects."""
183
def build_snapshot(self, parent_ids, actions, message=None, timestamp=None,
184
allow_leftmost_as_ghost=False, committer=None, timezone=None,
185
message_callback=None, revision_id=None):
186
"""Build a commit, shaped in a specific way.
188
Most of the actions are self-explanatory. 'flush' is special action to
189
break a series of actions into discrete steps so that complex changes
190
(such as unversioning a file-id and re-adding it with a different kind)
191
can be expressed in a way that will clearly work.
193
:param parent_ids: A list of parent_ids to use for the commit.
194
It can be None, which indicates to use the last commit.
195
:param actions: A list of actions to perform. Supported actions are:
196
('add', ('path', 'file-id', 'kind', 'content' or None))
197
('modify', ('path', 'new-content'))
198
('unversion', 'path')
199
('rename', ('orig-path', 'new-path'))
201
:param message: An optional commit message, if not supplied, a default
202
commit message will be written.
203
:param message_callback: A message callback to use for the commit, as
204
per mutabletree.commit.
205
:param timestamp: If non-None, set the timestamp of the commit to this
207
:param timezone: An optional timezone for timestamp.
208
:param committer: An optional username to use for commit
209
:param allow_leftmost_as_ghost: True if the leftmost parent should be
210
permitted to be a ghost.
211
:param revision_id: The handle for the new commit, can be None
212
:return: The revision_id of the new commit
214
if parent_ids is not None:
215
if len(parent_ids) == 0:
216
base_id = revision.NULL_REVISION
218
base_id = parent_ids[0]
219
if base_id != self._branch.last_revision():
220
self._move_branch_pointer(base_id,
221
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
223
if self._tree is not None:
226
tree = self._branch.create_memorytree()
227
with tree.lock_write():
228
if parent_ids is not None:
229
tree.set_parent_ids(parent_ids,
230
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
231
# Unfortunately, MemoryTree.add(directory) just creates an
232
# inventory entry. And the only public function to create a
233
# directory is MemoryTree.mkdir() which creates the directory, but
234
# also always adds it. So we have to use a multi-pass setup.
235
pending = _PendingActions()
236
for action, info in actions:
238
path, file_id, kind, content = info
239
if kind == 'directory':
240
pending.to_add_directories.append((path, file_id))
242
pending.to_add_files.append(path)
243
pending.to_add_file_ids.append(file_id)
244
pending.to_add_kinds.append(kind)
245
if content is not None:
246
pending.new_contents[path] = content
247
elif action == 'modify':
249
pending.new_contents[path] = content
250
elif action == 'unversion':
251
pending.to_unversion_paths.add(info)
252
elif action == 'rename':
253
from_relpath, to_relpath = info
254
pending.to_rename.append((from_relpath, to_relpath))
255
elif action == 'flush':
256
self._flush_pending(tree, pending)
257
pending = _PendingActions()
259
raise ValueError('Unknown build action: "%s"' % (action,))
260
self._flush_pending(tree, pending)
261
return self._do_commit(tree, message=message, rev_id=revision_id,
262
timestamp=timestamp, timezone=timezone, committer=committer,
263
message_callback=message_callback)
265
def _flush_pending(self, tree, pending):
266
"""Flush the pending actions in 'pending', i.e. apply them to 'tree'."""
267
for path, file_id in pending.to_add_directories:
269
if tree.has_filename(path) and path in pending.to_unversion_paths:
270
# We're overwriting this path, no need to unversion
271
pending.to_unversion_paths.discard(path)
272
# Special case, because the path already exists
273
tree.add([path], [file_id], ['directory'])
275
tree.mkdir(path, file_id)
276
for from_relpath, to_relpath in pending.to_rename:
277
tree.rename_one(from_relpath, to_relpath)
278
if pending.to_unversion_paths:
279
tree.unversion(pending.to_unversion_paths)
280
tree.add(pending.to_add_files, pending.to_add_file_ids, pending.to_add_kinds)
281
for path, content in viewitems(pending.new_contents):
282
tree.put_file_bytes_non_atomic(path, content)
284
def get_branch(self):
285
"""Return the branch created by the builder."""
289
class _PendingActions(object):
290
"""Pending actions for build_snapshot to take.
292
This is just a simple class to hold a bunch of the intermediate state of
293
build_snapshot in single object.
297
self.to_add_directories = []
298
self.to_add_files = []
299
self.to_add_file_ids = []
300
self.to_add_kinds = []
301
self.new_contents = {}
302
self.to_unversion_paths = set()
added
removed
breezy/branchbuilder.py
