/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/upstream_import.py

  • Committer: Jelmer Vernooij
  • Date: 2018-08-26 02:01:46 UTC
  • mto: This revision was merged to the branch mainline in revision 7087.
  • Revision ID: jelmer@jelmer.uk-20180826020146-owq7fxsr6ermorlh
Fix remaining warnings on Python 3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/upstream_import.py
 
1
# Copyright (C) 2006-2012 Aaron Bentley
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Import upstream source into a branch"""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
import errno
 
22
from io import (
 
23
    BytesIO,
 
24
    StringIO,
 
25
    )
 
26
import os
 
27
import re
 
28
import stat
 
29
import tarfile
 
30
import zipfile
 
31
 
 
32
from . import generate_ids, urlutils
 
33
from .controldir import ControlDir, is_control_filename
 
34
from .errors import (BzrError, NoSuchFile, BzrCommandError, NotBranchError)
 
35
from .osutils import (pathjoin, isdir, file_iterator, basename,
 
36
                      file_kind, splitpath)
 
37
from .sixish import (
 
38
    text_type,
 
39
    )
 
40
from .trace import warning
 
41
from .transform import TreeTransform, resolve_conflicts, cook_conflicts
 
42
from .transport import get_transport
 
43
from .workingtree import WorkingTree
 
44
 
 
45
 
 
46
# TODO(jelmer): Move this to transport.py ?
 
47
def open_from_url(location):
 
48
    location = urlutils.normalize_url(location)
 
49
    dirname, basename = urlutils.split(location)
 
50
    if location.endswith('/') and not basename.endswith('/'):
 
51
        basename += '/'
 
52
    return get_transport(dirname).get(basename)
 
53
 
 
54
 
 
55
class NotArchiveType(BzrError):
 
56
 
 
57
    _fmt = '%(path)s is not an archive.'
 
58
 
 
59
    def __init__(self, path):
 
60
        BzrError.__init__(self)
 
61
        self.path = path
 
62
 
 
63
 
 
64
class ZipFileWrapper(object):
 
65
 
 
66
    def __init__(self, fileobj, mode):
 
67
        self.zipfile = zipfile.ZipFile(fileobj, mode)
 
68
 
 
69
    def getmembers(self):
 
70
        for info in self.zipfile.infolist():
 
71
            yield ZipInfoWrapper(self.zipfile, info)
 
72
 
 
73
    def extractfile(self, infowrapper):
 
74
        return BytesIO(self.zipfile.read(infowrapper.name))
 
75
 
 
76
    def add(self, filename):
 
77
        if isdir(filename):
 
78
            self.zipfile.writestr(filename+'/', '')
 
79
        else:
 
80
            self.zipfile.write(filename)
 
81
 
 
82
    def close(self):
 
83
        self.zipfile.close()
 
84
 
 
85
 
 
86
class ZipInfoWrapper(object):
 
87
 
 
88
    def __init__(self, zipfile, info):
 
89
        self.info = info
 
90
        self.type = None
 
91
        self.name = info.filename
 
92
        self.zipfile = zipfile
 
93
        self.mode = 0o666
 
94
 
 
95
    def isdir(self):
 
96
        # Really? Eeeew!
 
97
        return bool(self.name.endswith('/'))
 
98
 
 
99
    def isreg(self):
 
100
        # Really? Eeeew!
 
101
        return not self.isdir()
 
102
 
 
103
 
 
104
class DirWrapper(object):
 
105
 
 
106
    def __init__(self, fileobj, mode='r'):
 
107
        if mode != 'r':
 
108
            raise AssertionError(
 
109
                'only readonly supported')
 
110
        self.root = os.path.realpath(fileobj.read().decode('utf-8'))
 
111
 
 
112
    def __repr__(self):
 
113
        return 'DirWrapper(%r)' % self.root
 
114
 
 
115
    def getmembers(self, subdir=None):
 
116
        if subdir is not None:
 
117
            mydir = pathjoin(self.root, subdir)
 
118
        else:
 
119
            mydir = self.root
 
120
        for child in os.listdir(mydir):
 
121
            if subdir is not None:
 
122
                child = pathjoin(subdir, child)
 
123
            fi = FileInfo(self.root, child)
 
124
            yield fi
 
125
            if fi.isdir():
 
126
                for v in self.getmembers(child):
 
127
                    yield v
 
128
 
 
129
    def extractfile(self, member):
 
130
        return open(member.fullpath, 'rb')
 
131
 
 
132
 
 
133
class FileInfo(object):
 
134
 
 
135
    def __init__(self, root, filepath):
 
136
        self.fullpath = pathjoin(root, filepath)
 
137
        self.root = root
 
138
        if filepath != '':
 
139
            self.name = pathjoin(basename(root), filepath)
 
140
        else:
 
141
            print('root %r' % root)
 
142
            self.name = basename(root)
 
143
        self.type = None
 
144
        stat = os.lstat(self.fullpath)
 
145
        self.mode = stat.st_mode
 
146
        if self.isdir():
 
147
            self.name += '/'
 
148
 
 
149
    def __repr__(self):
 
150
        return 'FileInfo(%r)' % self.name
 
151
 
 
152
    def isreg(self):
 
153
        return stat.S_ISREG(self.mode)
 
154
 
 
155
    def isdir(self):
 
156
        return stat.S_ISDIR(self.mode)
 
157
 
 
158
    def issym(self):
 
159
        if stat.S_ISLNK(self.mode):
 
160
            self.linkname = os.readlink(self.fullpath)
 
161
            return True
 
162
        else:
 
163
            return False
 
164
 
 
165
 
 
166
def top_path(path):
 
167
    """Return the top directory given in a path."""
 
168
    components = splitpath(path)
 
169
    if len(components) > 0:
 
170
        return components[0]
 
171
    else:
 
172
        return ''
 
173
 
 
174
 
 
175
def common_directory(names):
 
176
    """Determine a single directory prefix from a list of names"""
 
177
    possible_prefix = None
 
178
    for name in names:
 
179
        name_top = top_path(name)
 
180
        if name_top == '':
 
181
            return None
 
182
        if possible_prefix is None:
 
183
            possible_prefix = name_top
 
184
        else:
 
185
            if name_top != possible_prefix:
 
186
                return None
 
187
    return possible_prefix
 
188
 
 
189
 
 
190
def do_directory(tt, trans_id, tree, relative_path, path):
 
191
    if isdir(path) and tree.is_versioned(relative_path):
 
192
        tt.cancel_deletion(trans_id)
 
193
    else:
 
194
        tt.create_directory(trans_id)
 
195
 
 
196
 
 
197
def add_implied_parents(implied_parents, path):
 
198
    """Update the set of implied parents from a path"""
 
199
    parent = os.path.dirname(path)
 
200
    if parent in implied_parents:
 
201
        return
 
202
    implied_parents.add(parent)
 
203
    add_implied_parents(implied_parents, parent)
 
204
 
 
205
 
 
206
def names_of_files(tar_file):
 
207
    for member in tar_file.getmembers():
 
208
        if member.type != "g":
 
209
            yield member.name
 
210
 
 
211
 
 
212
def should_ignore(relative_path):
 
213
    return is_control_filename(top_path(relative_path))
 
214
 
 
215
 
 
216
def import_tar(tree, tar_input):
 
217
    """Replace the contents of a working directory with tarfile contents.
 
218
    The tarfile may be a gzipped stream.  File ids will be updated.
 
219
    """
 
220
    tar_file = tarfile.open('lala', 'r', tar_input)
 
221
    import_archive(tree, tar_file)
 
222
 
 
223
def import_zip(tree, zip_input):
 
224
    zip_file = ZipFileWrapper(zip_input, 'r')
 
225
    import_archive(tree, zip_file)
 
226
 
 
227
 
 
228
def import_dir(tree, dir_input):
 
229
    dir_file = DirWrapper(dir_input)
 
230
    import_archive(tree, dir_file)
 
231
 
 
232
 
 
233
def import_archive(tree, archive_file):
 
234
    tt = TreeTransform(tree)
 
235
    try:
 
236
        import_archive_to_transform(tree, archive_file, tt)
 
237
        tt.apply()
 
238
    finally:
 
239
        tt.finalize()
 
240
 
 
241
 
 
242
def import_archive_to_transform(tree, archive_file, tt):
 
243
    prefix = common_directory(names_of_files(archive_file))
 
244
    removed = set()
 
245
    for path, entry in tree.iter_entries_by_dir():
 
246
        if entry.parent_id is None:
 
247
            continue
 
248
        trans_id = tt.trans_id_tree_path(path)
 
249
        tt.delete_contents(trans_id)
 
250
        removed.add(path)
 
251
 
 
252
    added = set()
 
253
    implied_parents = set()
 
254
    seen = set()
 
255
    for member in archive_file.getmembers():
 
256
        if member.type == 'g':
 
257
            # type 'g' is a header
 
258
            continue
 
259
        # Inverse functionality in bzr uses utf-8.  We could also
 
260
        # interpret relative to fs encoding, which would match native
 
261
        # behaviour better.
 
262
        relative_path = member.name
 
263
        if not isinstance(relative_path, text_type):
 
264
            relative_path = relative_path.decode('utf-8')
 
265
        if prefix is not None:
 
266
            relative_path = relative_path[len(prefix)+1:]
 
267
            relative_path = relative_path.rstrip('/')
 
268
        if relative_path == '':
 
269
            continue
 
270
        if should_ignore(relative_path):
 
271
            continue
 
272
        add_implied_parents(implied_parents, relative_path)
 
273
        trans_id = tt.trans_id_tree_path(relative_path)
 
274
        added.add(relative_path.rstrip('/'))
 
275
        path = tree.abspath(relative_path)
 
276
        if member.name in seen:
 
277
            if tt.final_kind(trans_id) == 'file':
 
278
                tt.set_executability(None, trans_id)
 
279
            tt.cancel_creation(trans_id)
 
280
        seen.add(member.name)
 
281
        if member.isreg():
 
282
            tt.create_file(file_iterator(archive_file.extractfile(member)),
 
283
                           trans_id)
 
284
            executable = (member.mode & 0o111) != 0
 
285
            tt.set_executability(executable, trans_id)
 
286
        elif member.isdir():
 
287
            do_directory(tt, trans_id, tree, relative_path, path)
 
288
        elif member.issym():
 
289
            tt.create_symlink(member.linkname, trans_id)
 
290
        else:
 
291
            continue
 
292
        if tt.tree_file_id(trans_id) is None:
 
293
            name = basename(member.name.rstrip('/'))
 
294
            file_id = generate_ids.gen_file_id(name)
 
295
            tt.version_file(file_id, trans_id)
 
296
 
 
297
    for relative_path in implied_parents.difference(added):
 
298
        if relative_path == "":
 
299
            continue
 
300
        trans_id = tt.trans_id_tree_path(relative_path)
 
301
        path = tree.abspath(relative_path)
 
302
        do_directory(tt, trans_id, tree, relative_path, path)
 
303
        if tt.tree_file_id(trans_id) is None:
 
304
            tt.version_file(trans_id, trans_id)
 
305
        added.add(relative_path)
 
306
 
 
307
    for path in removed.difference(added):
 
308
        tt.unversion_file(tt.trans_id_tree_path(path))
 
309
 
 
310
    for conflict in cook_conflicts(resolve_conflicts(tt), tt):
 
311
        warning(conflict)
 
312
 
 
313
 
 
314
def do_import(source, tree_directory=None):
 
315
    """Implementation of import command.  Intended for UI only"""
 
316
    if tree_directory is not None:
 
317
        try:
 
318
            tree = WorkingTree.open(tree_directory)
 
319
        except NotBranchError:
 
320
            if not os.path.exists(tree_directory):
 
321
                os.mkdir(tree_directory)
 
322
            branch = ControlDir.create_branch_convenience(tree_directory)
 
323
            tree = branch.controldir.open_workingtree()
 
324
    else:
 
325
        tree = WorkingTree.open_containing('.')[0]
 
326
    with tree.lock_write():
 
327
        if tree.changes_from(tree.basis_tree()).has_changed():
 
328
            raise BzrCommandError("Working tree has uncommitted changes.")
 
329
 
 
330
        try:
 
331
            archive, external_compressor = get_archive_type(source)
 
332
        except NotArchiveType:
 
333
            if file_kind(source) == 'directory':
 
334
                s = BytesIO(source.encode('utf-8'))
 
335
                s.seek(0)
 
336
                import_dir(tree, s)
 
337
            else:
 
338
                raise BzrCommandError('Unhandled import source')
 
339
        else:
 
340
            if archive == 'zip':
 
341
                import_zip(tree, open_from_url(source))
 
342
            elif archive == 'tar':
 
343
                try:
 
344
                    tar_input = open_from_url(source)
 
345
                    if external_compressor == 'bz2':
 
346
                        import bz2
 
347
                        tar_input = BytesIO(bz2.decompress(tar_input.read()))
 
348
                    elif external_compressor == 'lzma':
 
349
                        import lzma
 
350
                        tar_input = BytesIO(lzma.decompress(tar_input.read()))
 
351
                except IOError as e:
 
352
                    if e.errno == errno.ENOENT:
 
353
                        raise NoSuchFile(source)
 
354
                try:
 
355
                    import_tar(tree, tar_input)
 
356
                finally:
 
357
                    tar_input.close()
 
358
 
 
359
 
 
360
def get_archive_type(path):
 
361
    """Return the type of archive and compressor indicated by path name.
 
362
 
 
363
    Only external compressors are returned, so zip files are only
 
364
    ('zip', None).  .tgz is treated as ('tar', 'gz') and '.tar.xz' is treated
 
365
    as ('tar', 'lzma').
 
366
    """
 
367
    matches = re.match(r'.*\.(zip|tgz|tar(.(gz|bz2|lzma|xz))?)$', path)
 
368
    if not matches:
 
369
        raise NotArchiveType(path)
 
370
    external_compressor = None
 
371
    if matches.group(3) is not None:
 
372
        archive = 'tar'
 
373
        external_compressor = matches.group(3)
 
374
        if external_compressor == 'xz':
 
375
            external_compressor = 'lzma'
 
376
    elif matches.group(1) == 'tgz':
 
377
        return 'tar', 'gz'
 
378
    else:
 
379
        archive = matches.group(1)
 
380
    return archive, external_compressor