← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Martin Pool
  • Date: 2005-08-02 23:14:41 UTC
  • Revision ID: mbp@sourcefrog.net-20050802231441-d738a6e6ffd03c3e
- new error RevisionNotPresent

- raise this when trying to fetch a revision that's mentioned but not 
  in the revision store

- Store raises an IndexError from getitem method if key is not found

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
20
 
from sets import Set
21
 
import os.path, os, fnmatch
22
 
 
23
 
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
24
 
     joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
25
 
import errno
26
 
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
27
 
 
28
 
from inventory import Inventory
29
 
from trace import mutter, note
30
 
from errors import bailout
31
 
import branch
 
20
import os
32
21
 
33
22
import bzrlib
34
 
 
35
 
class Tree:
 
23
from bzrlib.trace import mutter, note
 
24
from bzrlib.errors import BzrError
 
25
from bzrlib.inventory import Inventory
 
26
from bzrlib.osutils import pumpfile, appendpath, fingerprint_file
 
27
 
 
28
 
 
29
exporters = {}
 
30
 
 
31
class Tree(object):
36
32
    """Abstract file tree.
37
33
 
38
34
    There are several subclasses:
63
59
 
64
60
    __contains__ = has_id
65
61
 
66
 
    def id_set(self):
67
 
        """Return set of all ids in this tree."""
68
 
        return self.inventory.id_set()
69
 
 
70
62
    def __iter__(self):
71
63
        return iter(self.inventory)
72
64
 
75
67
 
76
68
    def _get_inventory(self):
77
69
        return self._inventory
 
70
    
 
71
    def get_file_by_path(self, path):
 
72
        return self.get_file(self._inventory.path2id(path))
78
73
 
79
74
    inventory = property(_get_inventory,
80
75
                         doc="Inventory of this Tree")
85
80
        
86
81
        if ie.text_size != None:
87
82
            if ie.text_size != fp['size']:
88
 
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
83
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
89
84
                        ["inventory expects %d bytes" % ie.text_size,
90
85
                         "file is actually %d bytes" % fp['size'],
91
86
                         "store is probably damaged/corrupt"])
92
87
 
93
88
        if ie.text_sha1 != fp['sha1']:
94
 
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
89
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
95
90
                    ["inventory expects %s" % ie.text_sha1,
96
91
                     "file is actually %s" % fp['sha1'],
97
92
                     "store is probably damaged/corrupt"])
103
98
        pumpfile(self.get_file(fileid), sys.stdout)
104
99
        
105
100
        
106
 
    def export(self, dest):        
107
 
        """Export this tree to a new directory.
108
 
 
109
 
        `dest` should not exist, and will be created holding the
110
 
        contents of this tree.
111
 
 
112
 
        TODO: To handle subdirectories we need to create the
113
 
               directories first.
114
 
 
115
 
        :note: If the export fails, the destination directory will be
116
 
               left in a half-assed state.
117
 
        """
118
 
        os.mkdir(dest)
119
 
        mutter('export version %r' % self)
120
 
        inv = self.inventory
121
 
        for dp, ie in inv.iter_entries():
122
 
            kind = ie.kind
123
 
            fullpath = appendpath(dest, dp)
124
 
            if kind == 'directory':
125
 
                os.mkdir(fullpath)
126
 
            elif kind == 'file':
127
 
                pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
128
 
            else:
129
 
                bailout("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
130
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
 
101
    def export(self, dest, format='dir', root=None):
 
102
        """Export this tree."""
 
103
        try:
 
104
            exporter = exporters[format]
 
105
        except KeyError:
 
106
            from bzrlib.errors import BzrCommandError
 
107
            raise BzrCommandError("export format %r not supported" % format)
 
108
        exporter(self, dest, root)
131
109
 
132
110
 
133
111
 
245
223
        if old_name != new_name:
246
224
            yield (old_name, new_name)
247
225
            
 
226
 
 
227
 
 
228
######################################################################
 
229
# export
 
230
 
 
231
def dir_exporter(tree, dest, root):
 
232
    """Export this tree to a new directory.
 
233
 
 
234
    `dest` should not exist, and will be created holding the
 
235
    contents of this tree.
 
236
 
 
237
    TODO: To handle subdirectories we need to create the
 
238
           directories first.
 
239
 
 
240
    :note: If the export fails, the destination directory will be
 
241
           left in a half-assed state.
 
242
    """
 
243
    import os
 
244
    os.mkdir(dest)
 
245
    mutter('export version %r' % tree)
 
246
    inv = tree.inventory
 
247
    for dp, ie in inv.iter_entries():
 
248
        kind = ie.kind
 
249
        fullpath = appendpath(dest, dp)
 
250
        if kind == 'directory':
 
251
            os.mkdir(fullpath)
 
252
        elif kind == 'file':
 
253
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
 
254
        else:
 
255
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
 
256
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
 
257
exporters['dir'] = dir_exporter
 
258
 
 
259
try:
 
260
    import tarfile
 
261
except ImportError:
 
262
    pass
 
263
else:
 
264
    def get_root_name(dest):
 
265
        """Get just the root name for a tarball.
 
266
 
 
267
        >>> get_root_name('mytar.tar')
 
268
        'mytar'
 
269
        >>> get_root_name('mytar.tar.bz2')
 
270
        'mytar'
 
271
        >>> get_root_name('tar.tar.tar.tgz')
 
272
        'tar.tar.tar'
 
273
        >>> get_root_name('bzr-0.0.5.tar.gz')
 
274
        'bzr-0.0.5'
 
275
        >>> get_root_name('a/long/path/mytar.tgz')
 
276
        'mytar'
 
277
        >>> get_root_name('../parent/../dir/other.tbz2')
 
278
        'other'
 
279
        """
 
280
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
 
281
        dest = os.path.basename(dest)
 
282
        for end in endings:
 
283
            if dest.endswith(end):
 
284
                return dest[:-len(end)]
 
285
 
 
286
    def tar_exporter(tree, dest, root, compression=None):
 
287
        """Export this tree to a new tar file.
 
288
 
 
289
        `dest` will be created holding the contents of this tree; if it
 
290
        already exists, it will be clobbered, like with "tar -c".
 
291
        """
 
292
        from time import time
 
293
        now = time()
 
294
        compression = str(compression or '')
 
295
        if root is None:
 
296
            root = get_root_name(dest)
 
297
        try:
 
298
            ball = tarfile.open(dest, 'w:' + compression)
 
299
        except tarfile.CompressionError, e:
 
300
            raise BzrError(str(e))
 
301
        mutter('export version %r' % tree)
 
302
        inv = tree.inventory
 
303
        for dp, ie in inv.iter_entries():
 
304
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
 
305
            item = tarfile.TarInfo(os.path.join(root, dp))
 
306
            # TODO: would be cool to actually set it to the timestamp of the
 
307
            # revision it was last changed
 
308
            item.mtime = now
 
309
            if ie.kind == 'directory':
 
310
                item.type = tarfile.DIRTYPE
 
311
                fileobj = None
 
312
                item.name += '/'
 
313
                item.size = 0
 
314
                item.mode = 0755
 
315
            elif ie.kind == 'file':
 
316
                item.type = tarfile.REGTYPE
 
317
                fileobj = tree.get_file(ie.file_id)
 
318
                item.size = _find_file_size(fileobj)
 
319
                item.mode = 0644
 
320
            else:
 
321
                raise BzrError("don't know how to export {%s} of kind %r" %
 
322
                        (ie.file_id, ie.kind))
 
323
 
 
324
            ball.addfile(item, fileobj)
 
325
        ball.close()
 
326
    exporters['tar'] = tar_exporter
 
327
 
 
328
    def tgz_exporter(tree, dest, root):
 
329
        tar_exporter(tree, dest, root, compression='gz')
 
330
    exporters['tgz'] = tgz_exporter
 
331
 
 
332
    def tbz_exporter(tree, dest, root):
 
333
        tar_exporter(tree, dest, root, compression='bz2')
 
334
    exporters['tbz2'] = tbz_exporter
 
335
 
 
336
 
 
337
def _find_file_size(fileobj):
 
338
    offset = fileobj.tell()
 
339
    try:
 
340
        fileobj.seek(0, 2)
 
341
        size = fileobj.tell()
 
342
    except TypeError:
 
343
        # gzip doesn't accept second argument to seek()
 
344
        fileobj.seek(0)
 
345
        size = 0
 
346
        while True:
 
347
            nread = len(fileobj.read())
 
348
            if nread == 0:
 
349
                break
 
350
            size += nread
 
351
    fileobj.seek(offset)
 
352
    return size