32
34
class StoreError(Exception):
36
"""This class represents the abstract storage layout for saving information.
38
class ImmutableStore(object):
39
"""Store that holds files indexed by unique names.
41
Files can be added, but not modified once they are in. Typically
42
the hash is used as the name, or something else known to be unique,
45
>>> st = ImmutableScratchStore()
47
>>> st.add(StringIO('hello'), 'aa')
53
You are not allowed to add an id that is already present.
55
Entries can be retrieved as files, which may then be read.
57
>>> st.add(StringIO('goodbye'), '123123')
58
>>> st['123123'].read()
61
TODO: Atomic add by writing to a temporary file and renaming.
63
In bzr 0.0.5 and earlier, files within the store were marked
64
readonly on disk. This is no longer done but existing stores need
39
_max_buffered_requests = 10
41
def __init__(self, transport):
42
assert isinstance(transport, bzrlib.transport.Transport)
43
self._transport = transport
68
def __init__(self, basedir):
69
self._basedir = basedir
71
def _path(self, entry_id):
72
if not isinstance(entry_id, basestring):
73
raise TypeError(type(entry_id))
74
if '\\' in entry_id or '/' in entry_id:
75
raise ValueError("invalid store id %r" % entry_id)
76
return os.path.join(self._basedir, entry_id)
45
78
def __repr__(self):
46
if self._transport is None:
47
return "%s(None)" % (self.__class__.__name__)
79
return "%s(%r)" % (self.__class__.__name__, self._basedir)
81
def add(self, f, fileid, compressed=True):
82
"""Add contents of a file into the store.
84
f -- An open file, or file-like object."""
85
# FIXME: Only works on files that will fit in memory
87
from bzrlib.atomicfile import AtomicFile
89
mutter("add store entry %r" % (fileid))
90
if isinstance(f, types.StringTypes):
49
return "%s(%r)" % (self.__class__.__name__, self._transport.base)
54
raise NotImplementedError('Children should define their length')
56
def __getitem__(self, fileid):
57
"""Returns a file reading from a particular entry."""
58
raise NotImplementedError
60
def __contains__(self, fileid):
62
raise NotImplementedError
65
raise NotImplementedError
67
def add(self, f, fileid):
68
"""Add a file object f to the store accessible from the given fileid"""
69
raise NotImplementedError('Children of Store must define their method of adding entries.')
71
def add_multi(self, entries):
72
"""Add a series of file-like or string objects to the store with the given
75
:param entries: A list of tuples of file,id pairs [(file1, id1), (file2, id2), ...]
76
This could also be a generator yielding (file,id) pairs.
78
for f, fileid in entries:
81
def has(self, fileids):
82
"""Return True/False for each entry in fileids.
84
:param fileids: A List or generator yielding file ids.
85
:return: A generator or list returning True/False for each entry.
87
for fileid in fileids:
95
p = self._path(fileid)
96
if os.access(p, os.F_OK) or os.access(p + '.gz', os.F_OK):
97
raise BzrError("store %r already contains id %r" % (self._basedir, fileid))
103
af = AtomicFile(fn, 'wb')
106
gf = gzip.GzipFile(mode='wb', fileobj=af)
93
def get(self, fileids, ignore_missing=False, pb=None):
94
"""Return a set of files, one for each requested entry.
96
:param ignore_missing: If true, return None for entries which do not
98
:return: A list or generator of file-like objects, one for each id.
100
for fileid in fileids:
109
def copy_multi(self, other, ids, pb=None, permit_failure=False):
116
def copy_multi(self, other, ids, permit_failure=False):
110
117
"""Copy texts for ids from other into self.
112
If an id is present in self, it is skipped. A count of copied
113
ids is returned, which may be less than len(ids).
119
If an id is present in self, it is skipped.
115
:param other: Another Store object
116
:param ids: A list of entry ids to be copied
117
:param pb: A ProgressBar object, if none is given, the default will be created.
118
:param permit_failure: Allow missing entries to be ignored
119
:return: (n_copied, [failed]) The number of entries copied successfully,
120
followed by a list of entries which could not be copied (because they
121
Returns (count_copied, failed), where failed is a collection of ids
122
that could not be copied.
124
pb = bzrlib.ui.ui_factory.progress_bar()
126
ids = list(ids) # Make sure we don't have a generator, since we iterate 2 times
124
pb = bzrlib.ui.ui_factory.progress_bar()
127
126
pb.update('preparing to copy')
129
for file_id, has in zip(ids, self.has(ids)):
131
to_copy.append(file_id)
132
return self._do_copy(other, to_copy, pb, permit_failure=permit_failure)
134
def _do_copy(self, other, to_copy, pb, permit_failure=False):
135
"""This is the standard copying mechanism, just get them one at
136
a time from remote, and store them locally.
138
:param other: Another Store object
139
:param to_copy: A list of entry ids to copy
140
:param pb: A ProgressBar object to display completion status.
141
:param permit_failure: Allow missing entries to be ignored
142
:return: (n_copied, [failed])
143
The number of entries copied, and a list of failed entries.
145
# This should be updated to use add_multi() rather than
146
# the current methods of buffering requests.
147
# One question, is it faster to queue up 1-10 and then copy 1-10
148
# then queue up 11-20, copy 11-20
149
# or to queue up 1-10, copy 1, queue 11, copy 2, etc?
150
# sort of pipeline versus batch.
152
# We can't use self._transport.copy_to because we don't know
153
# whether the local tree is in the same format as other
127
to_copy = [id for id in ids if id not in self]
128
if isinstance(other, ImmutableStore):
129
return self.copy_multi_immutable(other, to_copy, pb)
155
def buffer_requests():
157
buffered_requests = []
158
for fileid in to_copy:
134
pb.update('copy', count, len(to_copy))
135
if not permit_failure:
136
self.add(other[id], id)
145
if not permit_failure:
146
assert count == len(to_copy)
150
def copy_multi_immutable(self, other, to_copy, pb, permit_failure=False):
151
from shutil import copyfile
156
other_p = other._path(id)
160
if e.errno == errno.ENOENT:
161
if not permit_failure:
162
copyfile(other_p+".gz", p+".gz")
168
buffered_requests.append((f, fileid))
169
if len(buffered_requests) > self._max_buffered_requests:
170
yield buffered_requests.pop(0)
172
pb.update('copy', count, len(to_copy))
174
for req in buffered_requests:
177
pb.update('copy', count, len(to_copy))
179
assert count == len(to_copy)
181
self.add_multi(buffer_requests())
165
copyfile(other_p+".gz", p+".gz")
167
if e.errno == errno.ENOENT:
175
pb.update('copy', count, len(to_copy))
176
assert count == len(to_copy)
184
return len(to_copy), failed
181
def __contains__(self, fileid):
183
p = self._path(fileid)
184
return (os.access(p, os.R_OK)
185
or os.access(p + '.gz', os.R_OK))
187
# TODO: Guard against the same thing being stored twice,
188
# compressed and uncompressed
191
for f in os.listdir(self._basedir):
193
# TODO: case-insensitive?
199
return len(os.listdir(self._basedir))
202
def __getitem__(self, fileid):
203
"""Returns a file reading from a particular entry."""
204
p = self._path(fileid)
206
return gzip.GzipFile(p + '.gz', 'rb')
208
if e.errno != errno.ENOENT:
214
if e.errno != errno.ENOENT:
217
raise IndexError(fileid)
220
def total_size(self):
221
"""Return (count, bytes)
223
This is the (compressed) size stored on disk, not the size of
231
total += os.stat(p)[ST_SIZE]
233
total += os.stat(p + '.gz')[ST_SIZE]
240
class ImmutableScratchStore(ImmutableStore):
241
"""Self-destructing test subclass of ImmutableStore.
243
The Store only exists for the lifetime of the Python object.
244
Obviously you should not put anything precious in it.
247
ImmutableStore.__init__(self, tempfile.mkdtemp())
250
for f in os.listdir(self._basedir):
251
fpath = os.path.join(self._basedir, f)
252
# needed on windows, and maybe some other filesystems
253
os.chmod(fpath, 0600)
255
os.rmdir(self._basedir)
256
mutter("%r destroyed" % self)
added
removed
bzrlib/store.py
