~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/store.py

  • Committer: Martin Pool
  • Date: 2005-03-15 05:19:54 UTC
  • Revision ID: mbp@sourcefrog.net-20050315051954-e4bdd6dfd26f8ecf
witty comment

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 by Canonical Development Ltd
 
1
#! /usr/bin/env python
 
2
# -*- coding: UTF-8 -*-
2
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
# TODO: Could remember a bias towards whether a particular store is typically
18
 
# compressed or not.
19
 
 
20
 
"""
21
 
Stores are the main data-storage mechanism for Bazaar-NG.
 
18
"""Stores are the main data-storage mechanism for Bazaar-NG.
22
19
 
23
20
A store is a simple write-once container indexed by a universally
24
 
unique ID.
25
 
"""
26
 
 
27
 
import os
28
 
from cStringIO import StringIO
29
 
import urllib
30
 
from zlib import adler32
31
 
 
32
 
import bzrlib
33
 
import bzrlib.errors as errors
34
 
from bzrlib.errors import BzrError, UnlistableStore, TransportNotPossible
35
 
from bzrlib.symbol_versioning import *
36
 
from bzrlib.trace import mutter
37
 
from bzrlib.transport import Transport, urlescape
38
 
from bzrlib.transport.local import LocalTransport
 
21
unique ID, which is typically the SHA-1 of the content."""
 
22
 
 
23
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
 
24
__author__ = "Martin Pool <mbp@canonical.com>"
 
25
 
 
26
import os, tempfile, types, osutils
 
27
from StringIO import StringIO
 
28
from trace import mutter
 
29
 
39
30
 
40
31
######################################################################
41
32
# stores
44
35
    pass
45
36
 
46
37
 
47
 
class Store(object):
48
 
    """This class represents the abstract storage layout for saving information.
49
 
    
 
38
class ImmutableStore:
 
39
    """Store that holds files indexed by unique names.
 
40
 
50
41
    Files can be added, but not modified once they are in.  Typically
51
42
    the hash is used as the name, or something else known to be unique,
52
43
    such as a UUID.
 
44
 
 
45
    >>> st = ImmutableScratchStore()
 
46
 
 
47
    >>> st.add(StringIO('hello'), 'aa')
 
48
    >>> 'aa' in st
 
49
    True
 
50
    >>> 'foo' in st
 
51
    False
 
52
 
 
53
    You are not allowed to add an id that is already present.
 
54
 
 
55
    Entries can be retrieved as files, which may then be read.
 
56
 
 
57
    >>> st.add(StringIO('goodbye'), '123123')
 
58
    >>> st['123123'].read()
 
59
    'goodbye'
 
60
 
 
61
    :todo: Atomic add by writing to a temporary file and renaming.
 
62
 
 
63
    :todo: Perhaps automatically transform to/from XML in a method?
 
64
           Would just need to tell the constructor what class to
 
65
           use...
 
66
 
 
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.
 
70
 
53
71
    """
54
72
 
55
 
    def __len__(self):
56
 
        raise NotImplementedError('Children should define their length')
57
 
 
58
 
    def get(self, fileid, suffix=None):
59
 
        """Returns a file reading from a particular entry.
60
 
        
61
 
        If suffix is present, retrieve the named suffix for fileid.
62
 
        """
63
 
        raise NotImplementedError
64
 
 
65
 
    def __getitem__(self, fileid):
66
 
        """DEPRECATED. Please use .get(fileid) instead."""
67
 
        raise NotImplementedError
68
 
 
69
 
    #def __contains__(self, fileid):
70
 
    #    """Deprecated, please use has_id"""
71
 
    #    raise NotImplementedError
72
 
 
73
 
    def __iter__(self):
74
 
        raise NotImplementedError
 
73
    def __init__(self, basedir):
 
74
        """ImmutableStore constructor."""
 
75
        self._basedir = basedir
 
76
 
 
77
    def _path(self, id):
 
78
        return os.path.join(self._basedir, id)
 
79
 
 
80
    def __repr__(self):
 
81
        return "%s(%r)" % (self.__class__.__name__, self._basedir)
75
82
 
76
83
    def add(self, f, fileid):
77
 
        """Add a file object f to the store accessible from the given fileid"""
78
 
        raise NotImplementedError('Children of Store must define their method of adding entries.')
79
 
 
80
 
    def has_id(self, fileid, suffix=None):
81
 
        """Return True or false for the presence of fileid in the store.
82
 
        
83
 
        suffix, if present, is a per file suffix, i.e. for digital signature 
84
 
        data."""
85
 
        raise NotImplementedError
86
 
 
87
 
    def listable(self):
88
 
        """Return True if this store is able to be listed."""
89
 
        return hasattr(self, "__iter__")
90
 
 
91
 
    def copy_all_ids(self, store_from, pb=None):
92
 
        """Copy all the file ids from store_from into self."""
93
 
        if not store_from.listable():
94
 
            raise UnlistableStore(store_from)
95
 
        ids = []
96
 
        for count, file_id in enumerate(store_from):
97
 
            if pb:
98
 
                pb.update('listing files', count, count)
99
 
            ids.append(file_id)
100
 
        if pb:
101
 
            pb.clear()
102
 
        mutter('copy_all ids: %r', ids)
103
 
        self.copy_multi(store_from, ids, pb=pb)
104
 
 
105
 
    def copy_multi(self, other, ids, pb=None, permit_failure=False):
106
 
        """Copy texts for ids from other into self.
107
 
 
108
 
        If an id is present in self, it is skipped.  A count of copied
109
 
        ids is returned, which may be less than len(ids).
110
 
 
111
 
        :param other: Another Store object
112
 
        :param ids: A list of entry ids to be copied
113
 
        :param pb: A ProgressBar object, if none is given, the default will be created.
114
 
        :param permit_failure: Allow missing entries to be ignored
115
 
        :return: (n_copied, [failed]) The number of entries copied successfully,
116
 
            followed by a list of entries which could not be copied (because they
117
 
            were missing)
118
 
        """
119
 
        if pb:
120
 
            pb.update('preparing to copy')
121
 
        failed = set()
122
 
        count = 0
123
 
        ids = list(ids) # get the list for showing a length.
124
 
        for fileid in ids:
125
 
            count += 1
126
 
            if self.has_id(fileid):
127
 
                continue
128
 
            try:
129
 
                self._copy_one(fileid, None, other, pb)
130
 
                for suffix in self._suffixes:
131
 
                    try:
132
 
                        self._copy_one(fileid, suffix, other, pb)
133
 
                    except KeyError:
134
 
                        pass
135
 
                if pb:
136
 
                    pb.update('copy', count, len(ids))
137
 
            except KeyError:
138
 
                if permit_failure:
139
 
                    failed.add(fileid)
140
 
                else:
141
 
                    raise
142
 
        assert count == len(ids)
143
 
        if pb:
144
 
            pb.clear()
145
 
        return count, failed
146
 
 
147
 
    def _copy_one(self, fileid, suffix, other, pb):
148
 
        """Most generic copy-one object routine.
149
 
        
150
 
        Subclasses can override this to provide an optimised
151
 
        copy between their own instances. Such overriden routines
152
 
        should call this if they have no optimised facility for a 
153
 
        specific 'other'.
154
 
        """
155
 
        mutter('Store._copy_one: %r', fileid)
156
 
        f = other.get(fileid, suffix)
157
 
        self.add(f, fileid, suffix)
158
 
 
159
 
 
160
 
class TransportStore(Store):
161
 
    """A TransportStore is a Store superclass for Stores that use Transports."""
162
 
 
163
 
    def add(self, f, fileid, suffix=None):
164
84
        """Add contents of a file into the store.
165
85
 
166
 
        f -- A file-like object, or string
167
 
        """
168
 
        mutter("add store entry %r", fileid)
169
 
        
170
 
        names = self._id_to_names(fileid, suffix)
171
 
        if self._transport.has_any(names):
172
 
            raise BzrError("store %r already contains id %r" 
173
 
                           % (self._transport.base, fileid))
174
 
 
175
 
        # Most of the time, just adding the file will work
176
 
        # if we find a time where it fails, (because the dir
177
 
        # doesn't exist), then create the dir, and try again
178
 
        self._add(names[0], f)
179
 
 
180
 
 
181
 
    def _add(self, relpath, f):
182
 
        """Actually add the file to the given location.
183
 
        This should be overridden by children.
184
 
        """
185
 
        raise NotImplementedError('children need to implement this function.')
186
 
 
187
 
    def _check_fileid(self, fileid):
188
 
        if not isinstance(fileid, basestring):
189
 
            raise TypeError('Fileids should be a string type: %s %r' % (type(fileid), fileid))
190
 
        if '\\' in fileid or '/' in fileid:
191
 
            raise ValueError("invalid store id %r" % fileid)
192
 
 
193
 
    def _id_to_names(self, fileid, suffix):
194
 
        """Return the names in the expected order"""
195
 
        if suffix is not None:
196
 
            fn = self._relpath(fileid, [suffix])
197
 
        else:
198
 
            fn = self._relpath(fileid)
199
 
 
200
 
        # FIXME RBC 20051128 this belongs in TextStore.
201
 
        fn_gz = fn + '.gz'
202
 
        if self._compressed:
203
 
            return fn_gz, fn
204
 
        else:
205
 
            return fn, fn_gz
206
 
 
207
 
    def has_id(self, fileid, suffix=None):
208
 
        """See Store.has_id."""
209
 
        return self._transport.has_any(self._id_to_names(fileid, suffix))
210
 
 
211
 
    def _get_name(self, fileid, suffix=None):
212
 
        """A special check, which returns the name of an existing file.
213
 
        
214
 
        This is similar in spirit to 'has_id', but it is designed
215
 
        to return information about which file the store has.
216
 
        """
217
 
        for name in self._id_to_names(fileid, suffix=suffix):
218
 
            if self._transport.has(name):
219
 
                return name
220
 
        return None
221
 
 
222
 
    def _get(self, filename):
223
 
        """Return an vanilla file stream for clients to read from.
224
 
 
225
 
        This is the body of a template method on 'get', and should be 
226
 
        implemented by subclasses.
227
 
        """
228
 
        raise NotImplementedError
229
 
 
230
 
    def get(self, fileid, suffix=None):
231
 
        """See Store.get()."""
232
 
        names = self._id_to_names(fileid, suffix)
233
 
        for name in names:
234
 
            try:
235
 
                return self._get(name)
236
 
            except errors.NoSuchFile:
237
 
                pass
238
 
        raise KeyError(fileid)
239
 
 
240
 
    def __init__(self, a_transport, prefixed=False, compressed=False,
241
 
                 dir_mode=None, file_mode=None,
242
 
                 escaped=False):
243
 
        assert isinstance(a_transport, Transport)
244
 
        super(TransportStore, self).__init__()
245
 
        self._transport = a_transport
246
 
        self._prefixed = prefixed
247
 
        # FIXME RBC 20051128 this belongs in TextStore.
248
 
        self._compressed = compressed
249
 
        self._suffixes = set()
250
 
        self._escaped = escaped
251
 
 
252
 
        # It is okay for these to be None, it just means they
253
 
        # will just use the filesystem defaults
254
 
        self._dir_mode = dir_mode
255
 
        self._file_mode = file_mode
256
 
 
257
 
    def _unescape(self, file_id):
258
 
        """If filename escaping is enabled for this store, unescape and return the filename."""
259
 
        if self._escaped:
260
 
            return urllib.unquote(file_id)
261
 
        else:
262
 
            return file_id
263
 
 
264
 
    def _iter_files_recursive(self):
265
 
        """Iterate through the files in the transport."""
266
 
        for quoted_relpath in self._transport.iter_files_recursive():
267
 
            # transport iterator always returns quoted paths, regardless of
268
 
            # escaping
269
 
            yield urllib.unquote(quoted_relpath)
 
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
 
89
        # computing the sum.
 
90
        mutter("add store entry %r" % (fileid))
 
91
        if isinstance(f, types.StringTypes):
 
92
            content = f
 
93
        else:
 
94
            content = f.read()
 
95
        if fileid not in self:
 
96
            filename = self._path(fileid)
 
97
            f = file(filename, 'wb')
 
98
            f.write(content)
 
99
            f.flush()
 
100
            os.fsync(f.fileno())
 
101
            f.close()
 
102
            osutils.make_readonly(filename)
 
103
 
 
104
 
 
105
    def __contains__(self, fileid):
 
106
        """"""
 
107
        return os.access(self._path(fileid), os.R_OK)
 
108
 
270
109
 
271
110
    def __iter__(self):
272
 
        for relpath in self._iter_files_recursive():
273
 
            # worst case is one of each suffix.
274
 
            name = os.path.basename(relpath)
275
 
            if name.endswith('.gz'):
276
 
                name = name[:-3]
277
 
            skip = False
278
 
            for count in range(len(self._suffixes)):
279
 
                for suffix in self._suffixes:
280
 
                    if name.endswith('.' + suffix):
281
 
                        skip = True
282
 
            if not skip:
283
 
                yield self._unescape(name)
284
 
 
285
 
    def __len__(self):
286
 
        return len(list(self.__iter__()))
287
 
 
288
 
    def _relpath(self, fileid, suffixes=None):
289
 
        self._check_fileid(fileid)
290
 
        if suffixes:
291
 
            for suffix in suffixes:
292
 
                if not suffix in self._suffixes:
293
 
                    raise ValueError("Unregistered suffix %r" % suffix)
294
 
                self._check_fileid(suffix)
295
 
        else:
296
 
            suffixes = []
297
 
        if self._prefixed:
298
 
            # hash_prefix adds the '/' separator
299
 
            prefix = self.hash_prefix(fileid)
300
 
        else:
301
 
            prefix = ''
302
 
        fileid = self._escape_file_id(fileid)
303
 
        path = prefix + fileid
304
 
        full_path = u'.'.join([path] + suffixes)
305
 
        return urlescape(full_path)
306
 
 
307
 
    def _escape_file_id(self, file_id):
308
 
        """Turn a file id into a filesystem safe string.
309
 
 
310
 
        This is similar to a plain urllib.quote, except
311
 
        it uses specific safe characters, so that it doesn't
312
 
        have to translate a lot of valid file ids.
313
 
        """
314
 
        if not self._escaped:
315
 
            return file_id
316
 
        if isinstance(file_id, unicode):
317
 
            file_id = file_id.encode('utf-8')
318
 
        # @ does not get escaped. This is because it is a valid
319
 
        # filesystem character we use all the time, and it looks
320
 
        # a lot better than seeing %40 all the time.
321
 
        safe = "abcdefghijklmnopqrstuvwxyz0123456789-_@,."
322
 
        r = [((c in safe) and c or ('%%%02x' % ord(c)))
323
 
             for c in file_id]
324
 
        return ''.join(r)
325
 
 
326
 
    def hash_prefix(self, fileid):
327
 
        # fileid should be unescaped
328
 
        if self._escaped:
329
 
            fileid = self._escape_file_id(fileid)
330
 
        return "%02x/" % (adler32(fileid) & 0xff)
331
 
 
332
 
    def __repr__(self):
333
 
        if self._transport is None:
334
 
            return "%s(None)" % (self.__class__.__name__)
335
 
        else:
336
 
            return "%s(%r)" % (self.__class__.__name__, self._transport.base)
337
 
 
338
 
    __str__ = __repr__
339
 
 
340
 
    def listable(self):
341
 
        """Return True if this store is able to be listed."""
342
 
        return self._transport.listable()
343
 
 
344
 
    def register_suffix(self, suffix):
345
 
        """Register a suffix as being expected in this store."""
346
 
        self._check_fileid(suffix)
347
 
        if suffix == 'gz':
348
 
            raise ValueError('You cannot register the "gz" suffix.')
349
 
        self._suffixes.add(suffix)
350
 
 
351
 
    def total_size(self):
352
 
        """Return (count, bytes)
353
 
 
354
 
        This is the (compressed) size stored on disk, not the size of
355
 
        the content."""
356
 
        total = 0
357
 
        count = 0
358
 
        for relpath in self._transport.iter_files_recursive():
359
 
            count += 1
360
 
            total += self._transport.stat(relpath).st_size
361
 
                
362
 
        return count, total
363
 
 
364
 
 
365
 
@deprecated_function(zero_eight)
366
 
def copy_all(store_from, store_to, pb=None):
367
 
    """Copy all ids from one store to another."""
368
 
    store_to.copy_all_ids(store_from, pb)
 
111
        return iter(os.listdir(self._basedir))
 
112
 
 
113
    def __getitem__(self, fileid):
 
114
        """Returns a file reading from a particular entry."""
 
115
        return file(self._path(fileid), 'rb')
 
116
 
 
117
    def delete_all(self):
 
118
        for fileid in self:
 
119
            self.delete(fileid)
 
120
 
 
121
    def delete(self, fileid):
 
122
        """Remove nominated store entry.
 
123
 
 
124
        Most stores will be add-only."""
 
125
        filename = self._path(fileid)
 
126
        ## osutils.make_writable(filename)
 
127
        os.remove(filename)
 
128
 
 
129
    def destroy(self):
 
130
        """Remove store; only allowed if it is empty."""
 
131
        os.rmdir(self._basedir)
 
132
        mutter("%r destroyed" % self)
 
133
 
 
134
 
 
135
 
 
136
class ImmutableScratchStore(ImmutableStore):
 
137
    """Self-destructing test subclass of ImmutableStore.
 
138
 
 
139
    The Store only exists for the lifetime of the Python object.
 
140
    Obviously you should not put anything precious in it.
 
141
    """
 
142
    def __init__(self):
 
143
        ImmutableStore.__init__(self, tempfile.mkdtemp())
 
144
 
 
145
    def __del__(self):
 
146
        self.delete_all()
 
147
        self.destroy()