34
34
class StoreError(Exception):
38
"""This class represents the abstract storage layout for saving information.
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
:todo: Perhaps automatically transform to/from XML in a method?
64
Would just need to tell the constructor what class to
67
:todo: Even within a simple disk store like this, we could
68
gzip the files. But since many are less than one disk
69
block, that might not help a lot.
41
_max_buffered_requests = 10
43
def __init__(self, transport):
44
assert isinstance(transport, bzrlib.transport.Transport)
45
self._transport = transport
73
def __init__(self, basedir):
74
"""ImmutableStore constructor."""
75
self._basedir = basedir
78
return os.path.join(self._basedir, id)
47
80
def __repr__(self):
48
if self._transport is None:
49
return "%s(None)" % (self.__class__.__name__)
51
return "%s(%r)" % (self.__class__.__name__, self._transport.base)
81
return "%s(%r)" % (self.__class__.__name__, self._basedir)
83
def add(self, f, fileid, compressed=True):
84
"""Add contents of a file into the store.
86
:param f: An open file, or file-like object."""
87
# FIXME: Only works on smallish files
88
# TODO: Can be optimized by copying at the same time as
90
mutter("add store entry %r" % (fileid))
91
if isinstance(f, types.StringTypes):
96
p = self._path(fileid)
97
if os.access(p, os.F_OK) or os.access(p + '.gz', os.F_OK):
98
bailout("store %r already contains id %r" % (self._basedir, fileid))
101
f = gzip.GzipFile(p + '.gz', 'wb')
102
os.chmod(p + '.gz', 0444)
111
def __contains__(self, fileid):
113
p = self._path(fileid)
114
return (os.access(p, os.R_OK)
115
or os.access(p + '.gz', os.R_OK))
117
# TODO: Guard against the same thing being stored twice, compressed and uncompresse
120
for f in os.listdir(self._basedir):
122
# TODO: case-insensitive?
55
127
def __len__(self):
56
raise NotImplementedError('Children should define their length')
128
return len(os.listdir(self._basedir))
58
130
def __getitem__(self, fileid):
59
131
"""Returns a file reading from a particular entry."""
60
raise NotImplementedError
62
def __contains__(self, fileid):
64
raise NotImplementedError
67
raise NotImplementedError
69
def add(self, f, fileid):
70
"""Add a file object f to the store accessible from the given fileid"""
71
raise NotImplementedError('Children of Store must define their method of adding entries.')
73
def add_multi(self, entries):
74
"""Add a series of file-like or string objects to the store with the given
77
:param entries: A list of tuples of file,id pairs [(file1, id1), (file2, id2), ...]
78
This could also be a generator yielding (file,id) pairs.
80
for f, fileid in entries:
83
def has(self, fileids):
84
"""Return True/False for each entry in fileids.
86
:param fileids: A List or generator yielding file ids.
87
:return: A generator or list returning True/False for each entry.
89
for fileid in fileids:
132
p = self._path(fileid)
134
return gzip.GzipFile(p + '.gz', 'rb')
136
if e.errno == errno.ENOENT:
95
def get(self, fileids, permit_failure=False, pb=None):
96
"""Return a set of files, one for each requested entry.
98
:param permit_failure: If true, return None for entries which do not
100
:return: A list or generator of file-like objects, one for each id.
102
for fileid in fileids:
141
def total_size(self):
142
"""Return (count, bytes)
144
This is the (compressed) size stored on disk, not the size of
111
def copy_multi(self, other, ids, pb=None, permit_failure=False):
112
"""Copy texts for ids from other into self.
114
If an id is present in self, it is skipped. A count of copied
115
ids is returned, which may be less than len(ids).
117
:param other: Another Store object
118
:param ids: A list of entry ids to be copied
119
:param pb: A ProgressBar object, if none is given, the default will be created.
120
:param permit_failure: Allow missing entries to be ignored
121
:return: (n_copied, [failed]) The number of entries copied successfully,
122
followed by a list of entries which could not be copied (because they
126
pb = bzrlib.ui.ui_factory.progress_bar()
128
ids = list(ids) # Make sure we don't have a generator, since we iterate 2 times
129
pb.update('preparing to copy')
131
for file_id, has in zip(ids, self.has(ids)):
133
to_copy.append(file_id)
134
return self._do_copy(other, to_copy, pb, permit_failure=permit_failure)
136
def _do_copy(self, other, to_copy, pb, permit_failure=False):
137
"""This is the standard copying mechanism, just get them one at
138
a time from remote, and store them locally.
140
:param other: Another Store object
141
:param to_copy: A list of entry ids to copy
142
:param pb: A ProgressBar object to display completion status.
143
:param permit_failure: Allow missing entries to be ignored
144
:return: (n_copied, [failed])
145
The number of entries copied, and a list of failed entries.
147
# This should be updated to use add_multi() rather than
148
# the current methods of buffering requests.
149
# One question, is it faster to queue up 1-10 and then copy 1-10
150
# then queue up 11-20, copy 11-20
151
# or to queue up 1-10, copy 1, queue 11, copy 2, etc?
152
# sort of pipeline versus batch.
154
# We can't use self._transport.copy_to because we don't know
155
# whether the local tree is in the same format as other
157
def buffer_requests():
159
buffered_requests = []
160
for fileid in to_copy:
170
buffered_requests.append((f, fileid))
171
if len(buffered_requests) > self._max_buffered_requests:
172
yield buffered_requests.pop(0)
174
pb.update('copy', count, len(to_copy))
176
for req in buffered_requests:
179
pb.update('copy', count, len(to_copy))
181
assert count == len(to_copy)
183
self.add_multi(buffer_requests())
186
return len(to_copy), failed
188
def copy_all(store_from, store_to):
189
"""Copy all ids from one store to another."""
190
if not hasattr(store_from, "__iter__"):
191
raise UnlistableStore(store_from)
193
ids = [f for f in store_from]
194
except (NotImplementedError, TransportNotPossible):
195
raise UnlistableStore(store_from)
196
store_to.copy_multi(store_from, ids)
152
total += os.stat(p)[ST_SIZE]
154
total += os.stat(p + '.gz')[ST_SIZE]
161
class ImmutableScratchStore(ImmutableStore):
162
"""Self-destructing test subclass of ImmutableStore.
164
The Store only exists for the lifetime of the Python object.
165
Obviously you should not put anything precious in it.
168
ImmutableStore.__init__(self, tempfile.mkdtemp())
171
for f in os.listdir(self._basedir):
172
fpath = os.path.join(self._basedir, f)
173
# needed on windows, and maybe some other filesystems
174
os.chmod(fpath, 0600)
176
os.rmdir(self._basedir)
177
mutter("%r destroyed" % self)
added
removed
bzrlib/store.py
