/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 breezy/export.py

  • Committer: Jelmer Vernooij
  • Date: 2019-01-13 17:32:22 UTC
  • mto: This revision was merged to the branch mainline in revision 7248.
  • Revision ID: jelmer@jelmer.uk-20190113173222-dteocq7209l6y0m6
https://launchpad.net/bugs/262261
Use tree timestamp when exporting.

This helps generate consistent hashes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/export.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Export functionality, which can take a Tree and create a different representation.
18
 
 
19
 
Such as non-controlled directories, tarfiles, zipfiles, etc.
 
17
"""Export trees to tarballs, non-controlled directories, zipfiles, etc.
20
18
"""
21
19
 
 
20
from __future__ import absolute_import
 
21
 
 
22
import errno
22
23
import os
23
 
import bzrlib.errors as errors
24
 
 
25
 
# Maps format name => export function
26
 
_exporters = {}
27
 
# Maps filename extensions => export format name
28
 
_exporter_extensions = {}
29
 
 
30
 
def register_exporter(format, extensions, func, override=False):
31
 
    """Register an exporter.
32
 
 
33
 
    :param format: This is the name of the format, such as 'tgz' or 'zip'
34
 
    :param extensions: Extensions which should be used in the case that a
35
 
                       format was not explicitly specified.
36
 
    :type extensions: List
37
 
    :param func: The function. It will be called with (tree, dest, root)
38
 
    :param override: Whether to override an object which already exists.
39
 
                     Frequently plugins will want to provide functionality
40
 
                     until it shows up in mainline, so the default is False.
41
 
    """
42
 
    global _exporters, _exporter_extensions
43
 
 
44
 
    if (format not in _exporters) or override:
45
 
        _exporters[format] = func
46
 
 
47
 
    for ext in extensions:
48
 
        if (ext not in _exporter_extensions) or override:
49
 
            _exporter_extensions[ext] = format
50
 
 
51
 
 
52
 
def register_lazy_exporter(scheme, extensions, module, funcname):
53
 
    """Register lazy-loaded exporter function.
54
 
 
55
 
    When requesting a specific type of export, load the respective path.
56
 
    """
57
 
    def _loader(tree, dest, root, subdir, filtered, per_file_timestamps):
58
 
        mod = __import__(module, globals(), locals(), [funcname])
59
 
        func = getattr(mod, funcname)
60
 
        return func(tree, dest, root, subdir, filtered=filtered,
61
 
                    per_file_timestamps=per_file_timestamps)
62
 
    register_exporter(scheme, extensions, _loader)
63
 
 
64
 
 
65
 
def export(tree, dest, format=None, root=None, subdir=None, filtered=False,
66
 
           per_file_timestamps=False):
 
24
import sys
 
25
import time
 
26
 
 
27
from . import (
 
28
    archive,
 
29
    errors,
 
30
    osutils,
 
31
    trace,
 
32
    )
 
33
 
 
34
 
 
35
def export(tree, dest, format=None, root=None, subdir=None,
 
36
           per_file_timestamps=False, fileobj=None):
67
37
    """Export the given Tree to the specific destination.
68
38
 
69
39
    :param tree: A Tree (such as RevisionTree) to export
80
50
    :param subdir: A starting directory within the tree. None means to export
81
51
        the entire tree, and anything else should specify the relative path to
82
52
        a directory to start exporting from.
83
 
    :param filtered: If True, content filtering is applied to the
84
 
                     files exported.
85
 
    :param per_file_timestamps: Whether to use the timestamp stored in the 
86
 
        tree rather than now(). This will do a revision lookup 
 
53
    :param per_file_timestamps: Whether to use the timestamp stored in the
 
54
        tree rather than now(). This will do a revision lookup
87
55
        for every file so will be significantly slower.
 
56
    :param fileobj: Optional file object to use
88
57
    """
89
 
    global _exporters, _exporter_extensions
90
 
 
91
 
    if format is None:
92
 
        for ext in _exporter_extensions:
93
 
            if dest.endswith(ext):
94
 
                format = _exporter_extensions[ext]
95
 
                break
 
58
    if format is None and dest is not None:
 
59
        format = guess_format(dest)
96
60
 
97
61
    # Most of the exporters will just have to call
98
62
    # this function anyway, so why not do it for them
99
63
    if root is None:
100
64
        root = get_root_name(dest)
101
65
 
102
 
    if format not in _exporters:
103
 
        raise errors.NoSuchExportFormat(format)
104
 
    tree.lock_read()
105
 
    try:
106
 
        return _exporters[format](tree, dest, root, subdir, filtered=filtered,
107
 
                                  per_file_timestamps=per_file_timestamps)
108
 
    finally:
109
 
        tree.unlock()
 
66
    if not per_file_timestamps:
 
67
        if getattr(tree, '_repository', None):
 
68
            force_mtime = tree._repository.get_revision(
 
69
                tree.get_revision_id()).timestamp
 
70
        else:
 
71
            force_mtime = time.time()
 
72
    else:
 
73
        force_mtime = None
 
74
 
 
75
    trace.mutter('export version %r', tree)
 
76
 
 
77
    if format == 'dir':
 
78
        # TODO(jelmer): If the tree is remote (e.g. HPSS, Git Remote),
 
79
        # then we should stream a tar file and unpack that on the fly.
 
80
        with tree.lock_read():
 
81
            for unused in dir_exporter_generator(tree, dest, root, subdir,
 
82
                                                 force_mtime):
 
83
                pass
 
84
        return
 
85
 
 
86
    with tree.lock_read():
 
87
        chunks = tree.archive(format, dest, root=root,
 
88
                              subdir=subdir, force_mtime=force_mtime)
 
89
        if dest == '-':
 
90
            for chunk in chunks:
 
91
                getattr(sys.stdout, 'buffer', sys.stdout).write(chunk)
 
92
        elif fileobj is not None:
 
93
            for chunk in chunks:
 
94
                fileobj.write(chunk)
 
95
        else:
 
96
            with open(dest, 'wb') as f:
 
97
                for chunk in chunks:
 
98
                    f.write(chunk)
 
99
 
 
100
 
 
101
def guess_format(filename, default='dir'):
 
102
    """Guess the export format based on a file name.
 
103
 
 
104
    :param filename: Filename to guess from
 
105
    :param default: Default format to fall back to
 
106
    :return: format name
 
107
    """
 
108
    format = archive.format_registry.get_format_from_filename(filename)
 
109
    if format is None:
 
110
        format = default
 
111
    return format
110
112
 
111
113
 
112
114
def get_root_name(dest):
113
115
    """Get just the root name for an export.
114
116
 
115
 
    >>> get_root_name('../mytest.tar')
116
 
    'mytest'
117
 
    >>> get_root_name('mytar.tar')
118
 
    'mytar'
119
 
    >>> get_root_name('mytar.tar.bz2')
120
 
    'mytar'
121
 
    >>> get_root_name('tar.tar.tar.tgz')
122
 
    'tar.tar.tar'
123
 
    >>> get_root_name('bzr-0.0.5.tar.gz')
124
 
    'bzr-0.0.5'
125
 
    >>> get_root_name('bzr-0.0.5.zip')
126
 
    'bzr-0.0.5'
127
 
    >>> get_root_name('bzr-0.0.5')
128
 
    'bzr-0.0.5'
129
 
    >>> get_root_name('a/long/path/mytar.tgz')
130
 
    'mytar'
131
 
    >>> get_root_name('../parent/../dir/other.tbz2')
132
 
    'other'
133
117
    """
134
118
    global _exporter_extensions
 
119
    if dest == '-':
 
120
        # Exporting to -/foo doesn't make sense so use relative paths.
 
121
        return ''
135
122
    dest = os.path.basename(dest)
136
 
    for ext in _exporter_extensions:
 
123
    for ext in archive.format_registry.extensions:
137
124
        if dest.endswith(ext):
138
125
            return dest[:-len(ext)]
139
126
    return dest
140
127
 
141
128
 
142
 
def _export_iter_entries(tree, subdir):
 
129
def _export_iter_entries(tree, subdir, skip_special=True):
143
130
    """Iter the entries for tree suitable for exporting.
144
131
 
145
132
    :param tree: A tree object.
146
133
    :param subdir: None or the path of an entry to start exporting from.
 
134
    :param skip_special: Whether to skip .bzr files.
 
135
    :return: iterator over tuples with final path, tree path and inventory
 
136
        entry for each entry to export
147
137
    """
148
 
    inv = tree.inventory
149
 
    if subdir is None:
150
 
        subdir_object = None
151
 
    else:
152
 
        subdir_id = inv.path2id(subdir)
153
 
        if subdir_id is not None:
154
 
            subdir_object = inv[subdir_id]
155
 
        # XXX: subdir is path not an id, so NoSuchId isn't proper error
156
 
        else:
157
 
            raise errors.NoSuchId(tree, subdir)
158
 
    if subdir_object is not None and subdir_object.kind != 'directory':
159
 
        yield subdir_object.name, subdir_object
160
 
        return
161
 
    else:
162
 
        entries = inv.iter_entries(subdir_object)
163
 
    if subdir is None:
164
 
        entries.next() # skip root
165
 
    for entry in entries:
 
138
    if subdir == '':
 
139
        subdir = None
 
140
    if subdir is not None:
 
141
        subdir = subdir.rstrip('/')
 
142
    entries = tree.iter_entries_by_dir()
 
143
    for path, entry in entries:
 
144
        if path == '':
 
145
            continue
 
146
 
166
147
        # The .bzr* namespace is reserved for "magic" files like
167
148
        # .bzrignore and .bzrrules - do not export these
168
 
        if entry[0].startswith(".bzr"):
169
 
            continue
170
 
        if subdir is None:
171
 
            if not tree.has_filename(entry[0]):
172
 
                continue
173
 
        else:
174
 
            if not tree.has_filename(os.path.join(subdir, entry[0])):
175
 
                continue
176
 
        yield entry
177
 
 
178
 
 
179
 
register_lazy_exporter(None, [], 'bzrlib.export.dir_exporter', 'dir_exporter')
180
 
register_lazy_exporter('dir', [], 'bzrlib.export.dir_exporter', 'dir_exporter')
181
 
register_lazy_exporter('tar', ['.tar'], 'bzrlib.export.tar_exporter', 'tar_exporter')
182
 
register_lazy_exporter('tgz', ['.tar.gz', '.tgz'], 'bzrlib.export.tar_exporter', 'tgz_exporter')
183
 
register_lazy_exporter('tbz2', ['.tar.bz2', '.tbz2'], 'bzrlib.export.tar_exporter', 'tbz_exporter')
184
 
register_lazy_exporter('zip', ['.zip'], 'bzrlib.export.zip_exporter', 'zip_exporter')
185
 
 
 
149
        if skip_special and path.startswith(".bzr"):
 
150
            continue
 
151
        if path == subdir:
 
152
            if entry.kind == 'directory':
 
153
                continue
 
154
            final_path = entry.name
 
155
        elif subdir is not None:
 
156
            if path.startswith(subdir + '/'):
 
157
                final_path = path[len(subdir) + 1:]
 
158
            else:
 
159
                continue
 
160
        else:
 
161
            final_path = path
 
162
        if not tree.has_filename(path):
 
163
            continue
 
164
 
 
165
        yield final_path, path, entry
 
166
 
 
167
 
 
168
def dir_exporter_generator(tree, dest, root, subdir=None,
 
169
                           force_mtime=None, fileobj=None):
 
170
    """Return a generator that exports this tree to a new directory.
 
171
 
 
172
    `dest` should either not exist or should be empty. If it does not exist it
 
173
    will be created holding the contents of this tree.
 
174
 
 
175
    :note: If the export fails, the destination directory will be
 
176
           left in an incompletely exported state: export is not transactional.
 
177
    """
 
178
    try:
 
179
        os.mkdir(dest)
 
180
    except OSError as e:
 
181
        if e.errno == errno.EEXIST:
 
182
            # check if directory empty
 
183
            if os.listdir(dest) != []:
 
184
                raise errors.BzrError(
 
185
                    "Can't export tree to non-empty directory.")
 
186
        else:
 
187
            raise
 
188
    # Iterate everything, building up the files we will want to export, and
 
189
    # creating the directories and symlinks that we need.
 
190
    # This tracks (file_id, (destination_path, executable))
 
191
    # This matches the api that tree.iter_files_bytes() wants
 
192
    # Note in the case of revision trees, this does trigger a double inventory
 
193
    # lookup, hopefully it isn't too expensive.
 
194
    to_fetch = []
 
195
    for dp, tp, ie in _export_iter_entries(tree, subdir):
 
196
        file_id = getattr(ie, 'file_id', None)
 
197
        fullpath = osutils.pathjoin(dest, dp)
 
198
        if ie.kind == "file":
 
199
            to_fetch.append((tp, (dp, tp, file_id)))
 
200
        elif ie.kind in ("directory", "tree-reference"):
 
201
            os.mkdir(fullpath)
 
202
        elif ie.kind == "symlink":
 
203
            try:
 
204
                symlink_target = tree.get_symlink_target(tp)
 
205
                os.symlink(symlink_target, fullpath)
 
206
            except OSError as e:
 
207
                raise errors.BzrError(
 
208
                    "Failed to create symlink %r -> %r, error: %s"
 
209
                    % (fullpath, symlink_target, e))
 
210
        else:
 
211
            raise errors.BzrError("don't know how to export {%s} of kind %r" %
 
212
                                  (tp, ie.kind))
 
213
 
 
214
        yield
 
215
    # The data returned here can be in any order, but we've already created all
 
216
    # the directories
 
217
    flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | getattr(os, 'O_BINARY', 0)
 
218
    for (relpath, treepath, file_id), chunks in tree.iter_files_bytes(to_fetch):
 
219
        fullpath = osutils.pathjoin(dest, relpath)
 
220
        # We set the mode and let the umask sort out the file info
 
221
        mode = 0o666
 
222
        if tree.is_executable(treepath):
 
223
            mode = 0o777
 
224
        with os.fdopen(os.open(fullpath, flags, mode), 'wb') as out:
 
225
            out.writelines(chunks)
 
226
        if force_mtime is not None:
 
227
            mtime = force_mtime
 
228
        else:
 
229
            mtime = tree.get_file_mtime(treepath)
 
230
        os.utime(fullpath, (mtime, mtime))
 
231
 
 
232
        yield