/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: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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
    )
 
25
import os
 
26
import re
 
27
import stat
 
28
import tarfile
 
29
import zipfile
 
30
 
 
31
from . import urlutils
 
32
from .bzr import generate_ids
 
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 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
 
 
224
def import_zip(tree, zip_input):
 
225
    zip_file = ZipFileWrapper(zip_input, 'r')
 
226
    import_archive(tree, zip_file)
 
227
 
 
228
 
 
229
def import_dir(tree, dir_input):
 
230
    dir_file = DirWrapper(dir_input)
 
231
    import_archive(tree, dir_file)
 
232
 
 
233
 
 
234
def import_archive(tree, archive_file):
 
235
    with tree.get_transform() as tt:
 
236
        import_archive_to_transform(tree, archive_file, tt)
 
237
        tt.apply()
 
238
 
 
239
 
 
240
def import_archive_to_transform(tree, archive_file, tt):
 
241
    prefix = common_directory(names_of_files(archive_file))
 
242
    removed = set()
 
243
    for path, entry in tree.iter_entries_by_dir():
 
244
        if entry.parent_id is None:
 
245
            continue
 
246
        trans_id = tt.trans_id_tree_path(path)
 
247
        tt.delete_contents(trans_id)
 
248
        removed.add(path)
 
249
 
 
250
    added = set()
 
251
    implied_parents = set()
 
252
    seen = set()
 
253
    for member in archive_file.getmembers():
 
254
        if member.type == 'g':
 
255
            # type 'g' is a header
 
256
            continue
 
257
        # Inverse functionality in bzr uses utf-8.  We could also
 
258
        # interpret relative to fs encoding, which would match native
 
259
        # behaviour better.
 
260
        relative_path = member.name
 
261
        if not isinstance(relative_path, text_type):
 
262
            relative_path = relative_path.decode('utf-8')
 
263
        if prefix is not None:
 
264
            relative_path = relative_path[len(prefix) + 1:]
 
265
            relative_path = relative_path.rstrip('/')
 
266
        if relative_path == '':
 
267
            continue
 
268
        if should_ignore(relative_path):
 
269
            continue
 
270
        add_implied_parents(implied_parents, relative_path)
 
271
        trans_id = tt.trans_id_tree_path(relative_path)
 
272
        added.add(relative_path.rstrip('/'))
 
273
        path = tree.abspath(relative_path)
 
274
        if member.name in seen:
 
275
            if tt.final_kind(trans_id) == 'file':
 
276
                tt.set_executability(None, trans_id)
 
277
            tt.cancel_creation(trans_id)
 
278
        seen.add(member.name)
 
279
        if member.isreg():
 
280
            tt.create_file(file_iterator(archive_file.extractfile(member)),
 
281
                           trans_id)
 
282
            executable = (member.mode & 0o111) != 0
 
283
            tt.set_executability(executable, trans_id)
 
284
        elif member.isdir():
 
285
            do_directory(tt, trans_id, tree, relative_path, path)
 
286
        elif member.issym():
 
287
            tt.create_symlink(member.linkname, trans_id)
 
288
        else:
 
289
            continue
 
290
        if tt.tree_file_id(trans_id) is None:
 
291
            name = basename(member.name.rstrip('/'))
 
292
            file_id = generate_ids.gen_file_id(name)
 
293
            tt.version_file(file_id, trans_id)
 
294
 
 
295
    for relative_path in implied_parents.difference(added):
 
296
        if relative_path == "":
 
297
            continue
 
298
        trans_id = tt.trans_id_tree_path(relative_path)
 
299
        path = tree.abspath(relative_path)
 
300
        do_directory(tt, trans_id, tree, relative_path, path)
 
301
        if tt.tree_file_id(trans_id) is None:
 
302
            tt.version_file(trans_id, trans_id)
 
303
        added.add(relative_path)
 
304
 
 
305
    for path in removed.difference(added):
 
306
        tt.unversion_file(tt.trans_id_tree_path(path))
 
307
 
 
308
    for conflict in cook_conflicts(resolve_conflicts(tt), tt):
 
309
        warning(conflict)
 
310
 
 
311
 
 
312
def do_import(source, tree_directory=None):
 
313
    """Implementation of import command.  Intended for UI only"""
 
314
    if tree_directory is not None:
 
315
        try:
 
316
            tree = WorkingTree.open(tree_directory)
 
317
        except NotBranchError:
 
318
            if not os.path.exists(tree_directory):
 
319
                os.mkdir(tree_directory)
 
320
            branch = ControlDir.create_branch_convenience(tree_directory)
 
321
            tree = branch.controldir.open_workingtree()
 
322
    else:
 
323
        tree = WorkingTree.open_containing('.')[0]
 
324
    with tree.lock_write():
 
325
        if tree.changes_from(tree.basis_tree()).has_changed():
 
326
            raise BzrCommandError("Working tree has uncommitted changes.")
 
327
 
 
328
        try:
 
329
            archive, external_compressor = get_archive_type(source)
 
330
        except NotArchiveType:
 
331
            if file_kind(source) == 'directory':
 
332
                s = BytesIO(source.encode('utf-8'))
 
333
                s.seek(0)
 
334
                import_dir(tree, s)
 
335
            else:
 
336
                raise BzrCommandError('Unhandled import source')
 
337
        else:
 
338
            if archive == 'zip':
 
339
                import_zip(tree, open_from_url(source))
 
340
            elif archive == 'tar':
 
341
                try:
 
342
                    tar_input = open_from_url(source)
 
343
                    if external_compressor == 'bz2':
 
344
                        import bz2
 
345
                        tar_input = BytesIO(bz2.decompress(tar_input.read()))
 
346
                    elif external_compressor == 'lzma':
 
347
                        import lzma
 
348
                        tar_input = BytesIO(lzma.decompress(tar_input.read()))
 
349
                except IOError as e:
 
350
                    if e.errno == errno.ENOENT:
 
351
                        raise NoSuchFile(source)
 
352
                try:
 
353
                    import_tar(tree, tar_input)
 
354
                finally:
 
355
                    tar_input.close()
 
356
 
 
357
 
 
358
def get_archive_type(path):
 
359
    """Return the type of archive and compressor indicated by path name.
 
360
 
 
361
    Only external compressors are returned, so zip files are only
 
362
    ('zip', None).  .tgz is treated as ('tar', 'gz') and '.tar.xz' is treated
 
363
    as ('tar', 'lzma').
 
364
    """
 
365
    matches = re.match(r'.*\.(zip|tgz|tar(.(gz|bz2|lzma|xz))?)$', path)
 
366
    if not matches:
 
367
        raise NotArchiveType(path)
 
368
    external_compressor = None
 
369
    if matches.group(3) is not None:
 
370
        archive = 'tar'
 
371
        external_compressor = matches.group(3)
 
372
        if external_compressor == 'xz':
 
373
            external_compressor = 'lzma'
 
374
    elif matches.group(1) == 'tgz':
 
375
        return 'tar', 'gz'
 
376
    else:
 
377
        archive = matches.group(1)
 
378
    return archive, external_compressor