1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
# Copyright (C) 2005 Canonical Ltd
# This program is free software; you can redistribute it and/or modify
# it 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.
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from bzrlib.control_files import ControlFiles
from tree import EmptyTree
from bzrlib.revision import NULL_REVISION
from bzrlib.store.weave import WeaveStore
from bzrlib.store.compressed_text import CompressedTextStore
from bzrlib.store.text import TextStore
from cStringIO import StringIO
import bzrlib.xml5
from bzrlib.tree import RevisionTree
from errors import InvalidRevisionId
from bzrlib.testament import Testament
def needs_read_lock(unbound):
"""Decorate unbound to take out and release a read lock."""
def decorated(self, *args, **kwargs):
self.control_files.lock_read()
try:
return unbound(self, *args, **kwargs)
finally:
self.control_files.unlock()
return decorated
def needs_write_lock(unbound):
"""Decorate unbound to take out and release a write lock."""
def decorated(self, *args, **kwargs):
self.control_files.lock_write()
try:
return unbound(self, *args, **kwargs)
finally:
self.control_files.unlock()
return decorated
class RevisionStorage(object):
def __init__(self, transport, branch_format):
object.__init__(self)
self.control_files = ControlFiles(transport, 'storage-lock')
def get_weave(name, prefixed=False):
relpath = self.control_files._rel_controlfilename(name)
weave_transport = self.control_files.make_transport(relpath)
ws = WeaveStore(weave_transport, prefixed=prefixed)
if self.control_files._transport.should_cache():
ws.enable_cache = True
return ws
def get_store(name, compressed=True, prefixed=False):
# FIXME: This approach of assuming stores are all entirely compressed
# or entirely uncompressed is tidy, but breaks upgrade from
# some existing branches where there's a mixture; we probably
# still want the option to look for both.
relpath = self.control_files._rel_controlfilename(name)
if compressed:
store = CompressedTextStore(
self.control_files.make_transport(relpath),
prefixed=prefixed)
else:
store = TextStore(self.control_files.make_transport(relpath),
prefixed=prefixed)
#if self._transport.should_cache():
# cache_path = os.path.join(self.cache_root, name)
# os.mkdir(cache_path)
# store = bzrlib.store.CachedStore(store, cache_path)
return store
if branch_format == 4:
self.inventory_store = get_store('inventory-store')
self.text_store = get_store('text-store')
self.revision_store = get_store('revision-store')
elif branch_format == 5:
self.control_weaves = get_weave('')
self.weave_store = get_weave('weaves')
self.revision_store = get_store('revision-store', compressed=False)
elif branch_format == 6:
self.control_weaves = get_weave('')
self.weave_store = get_weave('weaves', prefixed=True)
self.revision_store = get_store('revision-store', compressed=False,
prefixed=True)
self.revision_store.register_suffix('sig')
def lock_write(self):
self.control_files.lock_write()
def lock_read(self):
self.control_files.lock_read()
def unlock(self):
self.control_files.unlock()
def has_revision(self, revision_id):
"""True if this branch has a copy of the revision.
This does not necessarily imply the revision is merge
or on the mainline."""
return (revision_id is None
or self.revision_store.has_id(revision_id))
@needs_read_lock
def get_revision_xml_file(self, revision_id):
"""Return XML file object for revision object."""
if not revision_id or not isinstance(revision_id, basestring):
raise InvalidRevisionId(revision_id=revision_id, branch=self)
try:
return self.revision_store.get(revision_id)
except (IndexError, KeyError):
raise bzrlib.errors.NoSuchRevision(self, revision_id)
#deprecated
get_revision_xml = get_revision_xml_file
def get_revision_xml(self, revision_id):
return self.get_revision_xml_file(revision_id).read()
def get_revision(self, revision_id):
"""Return the Revision object for a named revision"""
xml_file = self.get_revision_xml_file(revision_id)
try:
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
except SyntaxError, e:
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
[revision_id,
str(e)])
assert r.revision_id == revision_id
return r
def get_revision_sha1(self, revision_id):
"""Hash the stored value of a revision, and return it."""
# In the future, revision entries will be signed. At that
# point, it is probably best *not* to include the signature
# in the revision hash. Because that lets you re-sign
# the revision, (add signatures/remove signatures) and still
# have all hash pointers stay consistent.
# But for now, just hash the contents.
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
@needs_write_lock
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
revision_id, "sig")
def get_inventory_weave(self):
return self.control_weaves.get_weave('inventory',
self.get_transaction())
def get_inventory(self, revision_id):
"""Get Inventory object by hash."""
xml = self.get_inventory_xml(revision_id)
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
def get_inventory_xml(self, revision_id):
"""Get inventory XML as a file object."""
try:
assert isinstance(revision_id, basestring), type(revision_id)
iw = self.get_inventory_weave()
return iw.get_text(iw.lookup(revision_id))
except IndexError:
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
def get_inventory_sha1(self, revision_id):
"""Return the sha1 hash of the inventory entry
"""
return self.get_revision(revision_id).inventory_sha1
def get_revision_inventory(self, revision_id):
"""Return inventory of a past revision."""
# TODO: Unify this with get_inventory()
# bzr 0.0.6 and later imposes the constraint that the inventory_id
# must be the same as its revision, so this is trivial.
if revision_id == None:
# This does not make sense: if there is no revision,
# then it is the current tree inventory surely ?!
# and thus get_root_id() is something that looks at the last
# commit on the branch, and the get_root_id is an inventory check.
raise NotImplementedError
# return Inventory(self.get_root_id())
else:
return self.get_inventory(revision_id)
def revision_tree(self, revision_id):
"""Return Tree for a revision on this branch.
`revision_id` may be None for the null revision, in which case
an `EmptyTree` is returned."""
# TODO: refactor this to use an existing revision object
# so we don't need to read it in twice.
if revision_id == None or revision_id == NULL_REVISION:
return EmptyTree()
else:
inv = self.get_revision_inventory(revision_id)
return RevisionTree(self.weave_store, inv, revision_id)
@needs_read_lock
def print_file(self, file, revision_id):
"""Print `file` to stdout."""
tree = self.revision_tree(revision_id)
# use inventory as it was in that revision
file_id = tree.inventory.path2id(file)
if not file_id:
raise BzrError("%r is not present in revision %s" % (file, revno))
tree.print_file(file_id)
def get_transaction(self):
return self.control_files.get_transaction()
def sign_revision(self, revision_id, gpg_strategy):
plaintext = Testament.from_revision(self, revision_id).as_short_text()
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
|