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