/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/store.py

  • Committer: Robert Collins
  • Date: 2005-09-30 02:54:51 UTC
  • mfrom: (1395)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20050930025451-47b9e412202be44b
symlink and weaves, whaddya know

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/store.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
# TODO: Could remember a bias towards whether a particular store is typically
 
18
# compressed or not.
 
19
 
17
20
"""
18
21
Stores are the main data-storage mechanism for Bazaar-NG.
19
22
 
21
24
unique ID.
22
25
"""
23
26
 
24
 
import os, tempfile, types, osutils, gzip, errno
 
27
import errno
 
28
import gzip
 
29
import os
 
30
import tempfile
 
31
import types
25
32
from stat import ST_SIZE
26
33
from StringIO import StringIO
27
 
from trace import mutter
 
34
 
 
35
from bzrlib.errors import BzrError, UnlistableStore
 
36
from bzrlib.trace import mutter
 
37
import bzrlib.ui
 
38
import bzrlib.osutils as osutils
 
39
#circular import
 
40
#from bzrlib.remotebranch import get_url
 
41
import urllib2
 
42
 
28
43
 
29
44
######################################################################
30
45
# stores
33
48
    pass
34
49
 
35
50
 
36
 
class ImmutableStore(object):
37
 
    """Store that holds files indexed by unique names.
 
51
class Store(object):
 
52
    """An abstract store that holds files indexed by unique names.
38
53
 
39
54
    Files can be added, but not modified once they are in.  Typically
40
55
    the hash is used as the name, or something else known to be unique,
55
70
    >>> st.add(StringIO('goodbye'), '123123')
56
71
    >>> st['123123'].read()
57
72
    'goodbye'
 
73
    """
 
74
 
 
75
    def total_size(self):
 
76
        """Return (count, bytes)
 
77
 
 
78
        This is the (compressed) size stored on disk, not the size of
 
79
        the content."""
 
80
        total = 0
 
81
        count = 0
 
82
        for fid in self:
 
83
            count += 1
 
84
            total += self._item_size(fid)
 
85
        return count, total
 
86
 
 
87
 
 
88
class ImmutableStore(Store):
 
89
    """Store that stores files on disk.
58
90
 
59
91
    TODO: Atomic add by writing to a temporary file and renaming.
 
92
    TODO: Guard against the same thing being stored twice, compressed and
 
93
          uncompressed during copy_multi_immutable - the window is for a
 
94
          matching store with some crack code that lets it offer a 
 
95
          non gz FOO and then a fz FOO.
60
96
 
61
97
    In bzr 0.0.5 and earlier, files within the store were marked
62
98
    readonly on disk.  This is no longer done but existing stores need
64
100
    """
65
101
 
66
102
    def __init__(self, basedir):
 
103
        super(ImmutableStore, self).__init__()
67
104
        self._basedir = basedir
68
105
 
69
 
    def _path(self, id):
70
 
        if '\\' in id or '/' in id:
71
 
            raise ValueError("invalid store id %r" % id)
72
 
        return os.path.join(self._basedir, id)
 
106
    def _path(self, entry_id):
 
107
        if not isinstance(entry_id, basestring):
 
108
            raise TypeError(type(entry_id))
 
109
        if '\\' in entry_id or '/' in entry_id:
 
110
            raise ValueError("invalid store id %r" % entry_id)
 
111
        return os.path.join(self._basedir, entry_id)
73
112
 
74
113
    def __repr__(self):
75
114
        return "%s(%r)" % (self.__class__.__name__, self._basedir)
90
129
            
91
130
        p = self._path(fileid)
92
131
        if os.access(p, os.F_OK) or os.access(p + '.gz', os.F_OK):
93
 
            from bzrlib.errors import bailout
94
132
            raise BzrError("store %r already contains id %r" % (self._basedir, fileid))
95
133
 
96
134
        fn = p
110
148
            af.close()
111
149
 
112
150
 
113
 
    def copy_multi(self, other, ids):
 
151
    def copy_multi(self, other, ids, permit_failure=False):
114
152
        """Copy texts for ids from other into self.
115
153
 
116
 
        If an id is present in self, it is skipped.  A count of copied
117
 
        ids is returned, which may be less than len(ids).
 
154
        If an id is present in self, it is skipped.
 
155
 
 
156
        Returns (count_copied, failed), where failed is a collection of ids
 
157
        that could not be copied.
118
158
        """
119
 
        from bzrlib.progress import ProgressBar
120
 
        pb = ProgressBar()
 
159
        pb = bzrlib.ui.ui_factory.progress_bar()
 
160
        
121
161
        pb.update('preparing to copy')
122
162
        to_copy = [id for id in ids if id not in self]
123
163
        if isinstance(other, ImmutableStore):
124
 
            return self.copy_multi_immutable(other, to_copy, pb)
 
164
            return self.copy_multi_immutable(other, to_copy, pb, 
 
165
                                             permit_failure=permit_failure)
125
166
        count = 0
 
167
        failed = set()
126
168
        for id in to_copy:
127
169
            count += 1
128
170
            pb.update('copy', count, len(to_copy))
129
 
            self.add(other[id], id)
130
 
        assert count == len(to_copy)
 
171
            if not permit_failure:
 
172
                self.add(other[id], id)
 
173
            else:
 
174
                try:
 
175
                    entry = other[id]
 
176
                except KeyError:
 
177
                    failed.add(id)
 
178
                    continue
 
179
                self.add(entry, id)
 
180
                
 
181
        if not permit_failure:
 
182
            assert count == len(to_copy)
131
183
        pb.clear()
132
 
        return count
133
 
 
134
 
 
135
 
    def copy_multi_immutable(self, other, to_copy, pb):
136
 
        from shutil import copyfile
 
184
        return count, failed
 
185
 
 
186
    def copy_multi_immutable(self, other, to_copy, pb, permit_failure=False):
137
187
        count = 0
 
188
        failed = set()
138
189
        for id in to_copy:
139
190
            p = self._path(id)
140
191
            other_p = other._path(id)
141
192
            try:
142
 
                copyfile(other_p, p)
143
 
            except IOError, e:
 
193
                osutils.link_or_copy(other_p, p)
 
194
            except (IOError, OSError), e:
144
195
                if e.errno == errno.ENOENT:
145
 
                    copyfile(other_p+".gz", p+".gz")
 
196
                    if not permit_failure:
 
197
                        osutils.link_or_copy(other_p+".gz", p+".gz")
 
198
                    else:
 
199
                        try:
 
200
                            osutils.link_or_copy(other_p+".gz", p+".gz")
 
201
                        except IOError, e:
 
202
                            if e.errno == errno.ENOENT:
 
203
                                failed.add(id)
 
204
                            else:
 
205
                                raise
146
206
                else:
147
207
                    raise
148
208
            
150
210
            pb.update('copy', count, len(to_copy))
151
211
        assert count == len(to_copy)
152
212
        pb.clear()
153
 
        return count
154
 
    
 
213
        return count, failed
155
214
 
156
215
    def __contains__(self, fileid):
157
216
        """"""
159
218
        return (os.access(p, os.R_OK)
160
219
                or os.access(p + '.gz', os.R_OK))
161
220
 
162
 
    # TODO: Guard against the same thing being stored twice, compressed and uncompresse
 
221
    def _item_size(self, fid):
 
222
        p = self._path(fid)
 
223
        try:
 
224
            return os.stat(p)[ST_SIZE]
 
225
        except OSError:
 
226
            return os.stat(p + '.gz')[ST_SIZE]
 
227
 
 
228
    # TODO: Guard against the same thing being stored twice,
 
229
    # compressed and uncompressed
163
230
 
164
231
    def __iter__(self):
165
232
        for f in os.listdir(self._basedir):
172
239
    def __len__(self):
173
240
        return len(os.listdir(self._basedir))
174
241
 
175
 
 
176
242
    def __getitem__(self, fileid):
177
243
        """Returns a file reading from a particular entry."""
178
244
        p = self._path(fileid)
188
254
            if e.errno != errno.ENOENT:
189
255
                raise
190
256
 
191
 
        raise IndexError(fileid)
192
 
 
193
 
 
194
 
    def total_size(self):
195
 
        """Return (count, bytes)
196
 
 
197
 
        This is the (compressed) size stored on disk, not the size of
198
 
        the content."""
199
 
        total = 0
200
 
        count = 0
201
 
        for fid in self:
202
 
            count += 1
203
 
            p = self._path(fid)
204
 
            try:
205
 
                total += os.stat(p)[ST_SIZE]
206
 
            except OSError:
207
 
                total += os.stat(p + '.gz')[ST_SIZE]
208
 
                
209
 
        return count, total
210
 
 
211
 
 
 
257
        raise KeyError(fileid)
212
258
 
213
259
 
214
260
class ImmutableScratchStore(ImmutableStore):
218
264
 Obviously you should not put anything precious in it.
219
265
    """
220
266
    def __init__(self):
221
 
        ImmutableStore.__init__(self, tempfile.mkdtemp())
 
267
        super(ImmutableScratchStore, self).__init__(tempfile.mkdtemp())
222
268
 
223
269
    def __del__(self):
224
270
        for f in os.listdir(self._basedir):
228
274
            os.remove(fpath)
229
275
        os.rmdir(self._basedir)
230
276
        mutter("%r destroyed" % self)
 
277
 
 
278
 
 
279
class ImmutableMemoryStore(Store):
 
280
    """A memory only store."""
 
281
 
 
282
    def __init__(self):
 
283
        super(ImmutableMemoryStore, self).__init__()
 
284
        self._contents = {}
 
285
 
 
286
    def add(self, stream, fileid, compressed=True):
 
287
        if self._contents.has_key(fileid):
 
288
            raise StoreError("fileid %s already in the store" % fileid)
 
289
        self._contents[fileid] = stream.read()
 
290
 
 
291
    def __getitem__(self, fileid):
 
292
        """Returns a file reading from a particular entry."""
 
293
        if not self._contents.has_key(fileid):
 
294
            raise IndexError
 
295
        return StringIO(self._contents[fileid])
 
296
 
 
297
    def _item_size(self, fileid):
 
298
        return len(self._contents[fileid])
 
299
 
 
300
    def __iter__(self):
 
301
        return iter(self._contents.keys())
 
302
 
 
303
 
 
304
class RemoteStore(object):
 
305
 
 
306
    def __init__(self, baseurl):
 
307
        self._baseurl = baseurl
 
308
 
 
309
    def _path(self, name):
 
310
        if '/' in name:
 
311
            raise ValueError('invalid store id', name)
 
312
        return self._baseurl + '/' + name
 
313
        
 
314
    def __getitem__(self, fileid):
 
315
        # circular import.
 
316
        from bzrlib.remotebranch import get_url
 
317
        p = self._path(fileid)
 
318
        try:
 
319
            return get_url(p, compressed=True)
 
320
        except urllib2.URLError:
 
321
            pass
 
322
        try:
 
323
            return get_url(p, compressed=False)
 
324
        except urllib2.URLError:
 
325
            raise KeyError(fileid)
 
326
 
 
327
    def __contains__(self, fileid):
 
328
        try:
 
329
            self[fileid]
 
330
            return True
 
331
        except KeyError:
 
332
            return False
 
333
        
 
334
 
 
335
class CachedStore:
 
336
    """A store that caches data locally, to avoid repeated downloads.
 
337
    The precacache method should be used to avoid server round-trips for
 
338
    every piece of data.
 
339
    """
 
340
 
 
341
    def __init__(self, store, cache_dir):
 
342
        self.source_store = store
 
343
        self.cache_store = ImmutableStore(cache_dir)
 
344
 
 
345
    def __getitem__(self, id):
 
346
        mutter("Cache add %s" % id)
 
347
        if id not in self.cache_store:
 
348
            self.cache_store.add(self.source_store[id], id)
 
349
        return self.cache_store[id]
 
350
 
 
351
    def prefetch(self, ids):
 
352
        """Copy a series of ids into the cache, before they are used.
 
353
        For remote stores that support pipelining or async downloads, this can
 
354
        increase speed considerably.
 
355
        Failures while prefetching are ignored.
 
356
        """
 
357
        mutter("Prefetch of ids %s" % ",".join(ids))
 
358
        self.cache_store.copy_multi(self.source_store, ids,
 
359
                                    permit_failure=True)
 
360
 
 
361
 
 
362
def copy_all(store_from, store_to):
 
363
    """Copy all ids from one store to another."""
 
364
    if not hasattr(store_from, "__iter__"):
 
365
        raise UnlistableStore(store_from)
 
366
    ids = [f for f in store_from]
 
367
    store_to.copy_multi(store_from, ids)