/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: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/upstream_import.py
16
16
 
17
17
"""Import upstream source into a branch"""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import errno
20
 
from io import (
21
 
    BytesIO,
22
 
    )
23
22
import os
24
23
import re
 
24
from StringIO import StringIO
25
25
import stat
26
26
import tarfile
27
27
import zipfile
28
28
 
29
 
from . import urlutils
30
 
from .bzr import generate_ids
 
29
from . import generate_ids, urlutils
31
30
from .controldir import ControlDir, is_control_filename
32
 
from .errors import (BzrError, NoSuchFile, CommandError, NotBranchError)
 
31
from .errors import (BzrError, NoSuchFile, BzrCommandError, NotBranchError)
33
32
from .osutils import (pathjoin, isdir, file_iterator, basename,
34
33
                      file_kind, splitpath)
35
34
from .trace import warning
36
 
from .transform import resolve_conflicts
 
35
from .transform import TreeTransform, resolve_conflicts, cook_conflicts
37
36
from .transport import get_transport
38
37
from .workingtree import WorkingTree
39
38
 
66
65
            yield ZipInfoWrapper(self.zipfile, info)
67
66
 
68
67
    def extractfile(self, infowrapper):
69
 
        return BytesIO(self.zipfile.read(infowrapper.name))
 
68
        return StringIO(self.zipfile.read(infowrapper.name))
70
69
 
71
70
    def add(self, filename):
72
71
        if isdir(filename):
73
 
            self.zipfile.writestr(filename + '/', '')
 
72
            self.zipfile.writestr(filename+'/', '')
74
73
        else:
75
74
            self.zipfile.write(filename)
76
75
 
85
84
        self.type = None
86
85
        self.name = info.filename
87
86
        self.zipfile = zipfile
88
 
        self.mode = 0o666
 
87
        self.mode = 0666
89
88
 
90
89
    def isdir(self):
91
90
        # Really? Eeeew!
102
101
        if mode != 'r':
103
102
            raise AssertionError(
104
103
                'only readonly supported')
105
 
        self.root = os.path.realpath(fileobj.read().decode('utf-8'))
 
104
        self.root = os.path.realpath(fileobj.read())
106
105
 
107
106
    def __repr__(self):
108
107
        return 'DirWrapper(%r)' % self.root
122
121
                    yield v
123
122
 
124
123
    def extractfile(self, member):
125
 
        return open(member.fullpath, 'rb')
 
124
        return open(member.fullpath)
126
125
 
127
126
 
128
127
class FileInfo(object):
133
132
        if filepath != '':
134
133
            self.name = pathjoin(basename(root), filepath)
135
134
        else:
136
 
            print('root %r' % root)
 
135
            print 'root %r' % root
137
136
            self.name = basename(root)
138
137
        self.type = None
139
138
        stat = os.lstat(self.fullpath)
183
182
 
184
183
 
185
184
def do_directory(tt, trans_id, tree, relative_path, path):
186
 
    if isdir(path) and tree.is_versioned(relative_path):
 
185
    if isdir(path) and tree.path2id(relative_path) is not None:
187
186
        tt.cancel_deletion(trans_id)
188
187
    else:
189
188
        tt.create_directory(trans_id)
215
214
    tar_file = tarfile.open('lala', 'r', tar_input)
216
215
    import_archive(tree, tar_file)
217
216
 
218
 
 
219
217
def import_zip(tree, zip_input):
220
218
    zip_file = ZipFileWrapper(zip_input, 'r')
221
219
    import_archive(tree, zip_file)
222
220
 
223
 
 
224
221
def import_dir(tree, dir_input):
225
222
    dir_file = DirWrapper(dir_input)
226
223
    import_archive(tree, dir_file)
227
224
 
228
225
 
229
226
def import_archive(tree, archive_file):
230
 
    with tree.transform() as tt:
 
227
    tt = TreeTransform(tree)
 
228
    try:
231
229
        import_archive_to_transform(tree, archive_file, tt)
232
230
        tt.apply()
 
231
    finally:
 
232
        tt.finalize()
233
233
 
234
234
 
235
235
def import_archive_to_transform(tree, archive_file, tt):
252
252
        # Inverse functionality in bzr uses utf-8.  We could also
253
253
        # interpret relative to fs encoding, which would match native
254
254
        # behaviour better.
255
 
        relative_path = member.name
256
 
        if not isinstance(relative_path, str):
257
 
            relative_path = relative_path.decode('utf-8')
 
255
        relative_path = member.name.decode('utf-8')
258
256
        if prefix is not None:
259
 
            relative_path = relative_path[len(prefix) + 1:]
 
257
            relative_path = relative_path[len(prefix)+1:]
260
258
            relative_path = relative_path.rstrip('/')
261
259
        if relative_path == '':
262
260
            continue
274
272
        if member.isreg():
275
273
            tt.create_file(file_iterator(archive_file.extractfile(member)),
276
274
                           trans_id)
277
 
            executable = (member.mode & 0o111) != 0
 
275
            executable = (member.mode & 0111) != 0
278
276
            tt.set_executability(executable, trans_id)
279
277
        elif member.isdir():
280
278
            do_directory(tt, trans_id, tree, relative_path, path)
285
283
        if tt.tree_file_id(trans_id) is None:
286
284
            name = basename(member.name.rstrip('/'))
287
285
            file_id = generate_ids.gen_file_id(name)
288
 
            tt.version_file(trans_id, file_id=file_id)
 
286
            tt.version_file(file_id, trans_id)
289
287
 
290
288
    for relative_path in implied_parents.difference(added):
291
289
        if relative_path == "":
294
292
        path = tree.abspath(relative_path)
295
293
        do_directory(tt, trans_id, tree, relative_path, path)
296
294
        if tt.tree_file_id(trans_id) is None:
297
 
            tt.version_file(trans_id, file_id=trans_id)
 
295
            tt.version_file(trans_id, trans_id)
298
296
        added.add(relative_path)
299
297
 
300
298
    for path in removed.difference(added):
301
299
        tt.unversion_file(tt.trans_id_tree_path(path))
302
300
 
303
 
    for conflict in tt.cook_conflicts(resolve_conflicts(tt)):
 
301
    for conflict in cook_conflicts(resolve_conflicts(tt), tt):
304
302
        warning(conflict)
305
303
 
306
304
 
316
314
            tree = branch.controldir.open_workingtree()
317
315
    else:
318
316
        tree = WorkingTree.open_containing('.')[0]
319
 
    with tree.lock_write():
 
317
    tree.lock_write()
 
318
    try:
320
319
        if tree.changes_from(tree.basis_tree()).has_changed():
321
 
            raise CommandError("Working tree has uncommitted changes.")
 
320
            raise BzrCommandError("Working tree has uncommitted changes.")
322
321
 
323
322
        try:
324
323
            archive, external_compressor = get_archive_type(source)
325
324
        except NotArchiveType:
326
325
            if file_kind(source) == 'directory':
327
 
                s = BytesIO(source.encode('utf-8'))
 
326
                s = StringIO(source)
328
327
                s.seek(0)
329
328
                import_dir(tree, s)
330
329
            else:
331
 
                raise CommandError('Unhandled import source')
 
330
                raise BzrCommandError('Unhandled import source')
332
331
        else:
333
332
            if archive == 'zip':
334
333
                import_zip(tree, open_from_url(source))
337
336
                    tar_input = open_from_url(source)
338
337
                    if external_compressor == 'bz2':
339
338
                        import bz2
340
 
                        tar_input = BytesIO(bz2.decompress(tar_input.read()))
 
339
                        tar_input = StringIO(bz2.decompress(tar_input.read()))
341
340
                    elif external_compressor == 'lzma':
342
341
                        import lzma
343
 
                        tar_input = BytesIO(lzma.decompress(tar_input.read()))
344
 
                except IOError as e:
 
342
                        tar_input = StringIO(lzma.decompress(tar_input.read()))
 
343
                except IOError, e:
345
344
                    if e.errno == errno.ENOENT:
346
345
                        raise NoSuchFile(source)
347
346
                try:
348
347
                    import_tar(tree, tar_input)
349
348
                finally:
350
349
                    tar_input.close()
 
350
    finally:
 
351
        tree.unlock()
351
352
 
352
353
 
353
354
def get_archive_type(path):