Merge lp:~jelmer/brz/import into lp:brz

[Jelmer Vernooij]

Import the 'import' command from bzrtools.

Import the 'import' command from bzrtools.

[Martin Packman (gz)]

Inclusion seems find to me. Can either do a s/StringIO/BytesIO/g now or stick that on my list todo. :)

review: Approve

[The Breezy Bot (the-breezy-bot)]

A commit message must be set
http://10.242.247.184:8080/job/brz-dev/18/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
http://10.242.247.184:8080/job/brz-dev/19/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
http://10.242.247.184:8080/job/brz-dev/23/

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2017-05-30 19:32:13 +0000
+++ breezy/builtins.py	2017-05-30 22:09:44 +0000
@@ -6690,6 +6690,27 @@
         export_pot(self.outf, plugin, include_duplicates)
 
 
+class cmd_import(Command):
+    __doc__ = """Import sources from a directory, tarball or zip file
+
+    This command will import a directory, tarball or zip file into a bzr
+    tree, replacing any versioned files already present.  If a directory is
+    specified, it is used as the target.  If the directory does not exist, or
+    is not versioned, it is created.
+
+    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
+
+    If the tarball or zip has a single root directory, that directory is
+    stripped when extracting the tarball.  This is not done for directories.
+    """
+
+    takes_args = ['source', 'tree?']
+
+    def run(self, source, tree=None):
+        from .upstream_import import do_import
+        do_import(source, tree)
+
+
 def _register_lazy_builtins():
     # register lazy builtins from other modules; called at startup and should
     # be only called once.

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2017-05-30 19:32:13 +0000
+++ breezy/tests/__init__.py	2017-05-30 22:09:44 +0000
@@ -4060,6 +4060,7 @@
         'breezy.tests.test_uncommit',
         'breezy.tests.test_upgrade',
         'breezy.tests.test_upgrade_stacked',
+        'breezy.tests.test_upstream_import',
         'breezy.tests.test_urlutils',
         'breezy.tests.test_utextwrap',
         'breezy.tests.test_version',

=== modified file 'breezy/tests/blackbox/__init__.py'
--- breezy/tests/blackbox/__init__.py	2017-05-30 19:16:23 +0000
+++ breezy/tests/blackbox/__init__.py	2017-05-30 22:09:44 +0000
@@ -66,6 +66,7 @@
                      'test_find_merge_base',
                      'test_help',
                      'test_hooks',
+                     'test_import',
                      'test_ignore',
                      'test_ignored',
                      'test_info',

=== added file 'breezy/tests/blackbox/test_import.py'
--- breezy/tests/blackbox/test_import.py	1970-01-01 00:00:00 +0000
+++ breezy/tests/blackbox/test_import.py	2017-05-30 22:09:44 +0000
@@ -0,0 +1,85 @@
+# Copyright (C) 2006-2012 Aaron Bentley
+#
+# 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
+#
+
+"""Tests of the 'brz import' command."""
+
+import os
+
+from ... import (
+    osutils,
+    tests,
+    urlutils,
+    )
+from .. import (
+    features,
+    script,
+    )
+
+
+LzmaFeature = features.ModuleAvailableFeature("lzma")
+
+
+class TestImport(tests.TestCaseWithTransport):
+
+    def test_import_upstream(self):
+        self.run_bzr('init source')
+        os.mkdir('source/src')
+        f = file('source/src/myfile', 'wb')
+        f.write('hello?')
+        f.close()
+        os.chdir('source')
+        self.run_bzr('add')
+        self.run_bzr('commit -m hello')
+        self.run_bzr('export ../source-0.1.tar.gz')
+        self.run_bzr('export ../source-0.1.tar.bz2')
+        self.run_bzr('export ../source-0.1')
+        self.run_bzr('init ../import')
+        os.chdir('../import')
+        self.run_bzr('import ../source-0.1.tar.gz')
+        self.assertPathExists('src/myfile')
+        result = self.run_bzr('import ../source-0.1.tar.gz', retcode=3)[1]
+        self.assertContainsRe(result, 'Working tree has uncommitted changes')
+        self.run_bzr('commit -m commit')
+        self.run_bzr('import ../source-0.1.tar.gz')
+        os.chdir('..')
+        self.run_bzr('init import2')
+        self.run_bzr('import source-0.1.tar.gz import2')
+        self.assertPathExists('import2/src/myfile')
+        self.run_bzr('import source-0.1.tar.gz import3')
+        self.assertPathExists('import3/src/myfile')
+        self.run_bzr('import source-0.1.tar.bz2 import4')
+        self.assertPathExists('import4/src/myfile')
+        self.run_bzr('import source-0.1 import5')
+        self.assertPathExists('import5/src/myfile')
+
+    def test_import_upstream_lzma(self):
+        self.requireFeature(LzmaFeature)
+        self.run_bzr('init source')
+        os.mkdir('source/src')
+        f = file('source/src/myfile', 'wb')
+        f.write('hello?')
+        f.close()
+        os.chdir('source')
+        self.run_bzr('add')
+        self.run_bzr('commit -m hello')
+        self.run_bzr('export ../source-0.1.tar.lzma')
+        self.run_bzr('export ../source-0.1.tar.xz')
+        os.chdir('..')
+        self.run_bzr('import source-0.1.tar.lzma import1')
+        self.assertPathExists('import1/src/myfile')
+        self.run_bzr('import source-0.1.tar.xz import2')
+        self.assertPathExists('import2/src/myfile')

=== added file 'breezy/tests/test_upstream_import.py'
--- breezy/tests/test_upstream_import.py	1970-01-01 00:00:00 +0000
+++ breezy/tests/test_upstream_import.py	2017-05-30 22:09:44 +0000
@@ -0,0 +1,319 @@
+# Copyright (C) 2006-2012 Aaron Bentley
+#
+# 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
+
+import os
+from StringIO import StringIO
+from shutil import rmtree, copy2, copytree
+import tarfile
+import tempfile
+import warnings
+
+from .. import (
+    osutils,
+    revision as _mod_revision,
+    transform
+    )
+from ..bzrdir import BzrDir
+from ..export import export
+from ..upstream_import import (
+    common_directory,
+    get_archive_type,
+    import_archive,
+    import_tar,
+    import_zip,
+    import_dir,
+    NotArchiveType,
+    top_path,
+    ZipFileWrapper,
+)
+from . import (
+    TestCaseInTempDir,
+    TestCaseWithTransport,
+    )
+from .features import UnicodeFilenameFeature
+
+
+def import_tar_broken(tree, tar_input):
+    """
+    Import a tarfile with names that that end in //, e.g. Feisty Python 2.5
+    """
+    tar_file = tarfile.open('lala', 'r', tar_input)
+    for member in tar_file.members:
+        if member.name.endswith('/'):
+            member.name += '/'
+    import_archive(tree, tar_file)
+
+
+class DirFileWriter(object):
+
+    def __init__(self, fileobj, mode):
+        # We may be asked to 'append'.  If so, fileobj already has a path.
+        # So we copy the existing tree, and overwrite afterward.
+        fileobj.seek(0)
+        existing = fileobj.read()
+        fileobj.seek(0)
+        path = tempfile.mkdtemp(dir=os.getcwd())
+        if existing != '':
+            # copytree requires the directory not to exist
+            os.rmdir(path)
+            copytree(existing, path)
+        fileobj.write(path)
+        self.root = path
+
+    def add(self, path):
+        target_path = os.path.join(self.root, path)
+        parent = osutils.dirname(target_path)
+        if not os.path.exists(parent):
+            os.makedirs(parent)
+        kind = osutils.file_kind(path)
+        if kind == 'file':
+            copy2(path, target_path)
+        if kind == 'directory':
+            os.mkdir(target_path)
+
+    def close(self):
+        pass
+
+
+class TestImport(TestCaseInTempDir):
+
+    def make_tar(self, mode='w'):
+        def maker(fileobj):
+            return tarfile.open('project-0.1.tar', mode, fileobj)
+        return self.make_archive(maker)
+
+    def make_archive(self, maker, subdir=True):
+        result = StringIO()
+        archive_file = maker(result)
+        try:
+            os.mkdir('project-0.1')
+            if subdir:
+                prefix='project-0.1/'
+                archive_file.add('project-0.1')
+            else:
+                prefix=''
+                os.chdir('project-0.1')
+            os.mkdir(prefix + 'junk')
+            archive_file.add(prefix + 'junk')
+
+            f = file(prefix + 'README', 'wb')
+            f.write('What?')
+            f.close()
+            archive_file.add(prefix + 'README')
+
+            f = file(prefix + 'FEEDME', 'wb')
+            f.write('Hungry!!')
+            f.close()
+            archive_file.add(prefix + 'FEEDME')
+
+            archive_file.close()
+        finally:
+            if not subdir:
+                os.chdir('..')
+            rmtree('project-0.1')
+        result.seek(0)
+        return result
+
+    def make_archive2(self, builder, subdir):
+        result = StringIO()
+        archive_file = builder(result)
+        os.mkdir('project-0.2')
+        try:
+            if subdir:
+                prefix='project-0.2/'
+                archive_file.add('project-0.2')
+            else:
+                prefix=''
+                os.chdir('project-0.2')
+
+            os.mkdir(prefix + 'junk')
+            archive_file.add(prefix + 'junk')
+
+            f = file(prefix + 'README', 'wb')
+            f.write('Now?')
+            f.close()
+            archive_file.add(prefix + 'README')
+
+            f = file(prefix + 'README', 'wb')
+            f.write('Wow?')
+            f.close()
+            # Add a second entry for README with different contents.
+            archive_file.add(prefix + 'README')
+            archive_file.close()
+
+        finally:
+            if not subdir:
+                os.chdir('..')
+        result.seek(0)
+        return result
+
+    def make_messed_tar(self):
+        result = StringIO()
+        tar_file = tarfile.open('project-0.1.tar', 'w', result)
+        os.mkdir('project-0.1')
+        tar_file.add('project-0.1')
+
+        os.mkdir('project-0.2')
+        tar_file.add('project-0.2')
+
+        f = file('project-0.1/README', 'wb')
+        f.write('What?')
+        f.close()
+        tar_file.add('project-0.1/README')
+        tar_file.close()
+        rmtree('project-0.1')
+        result.seek(0)
+        return result
+
+    def make_zip(self):
+        def maker(fileobj):
+            return ZipFileWrapper(fileobj, 'w')
+        return self.make_archive(maker)
+
+    def make_tar_with_bzrdir(self):
+        result = StringIO()
+        tar_file = tarfile.open('tar-with-bzrdir.tar', 'w', result)
+        os.mkdir('toplevel-dir')
+        tar_file.add('toplevel-dir')
+        os.mkdir('toplevel-dir/.bzr')
+        tar_file.add('toplevel-dir/.bzr')
+        tar_file.close()
+        rmtree('toplevel-dir')
+        result.seek(0)
+        return result
+
+    def test_top_path(self):
+        self.assertEqual(top_path('ab/b/c'), 'ab')
+        self.assertEqual(top_path('etc'), 'etc')
+        self.assertEqual(top_path('project-0.1'), 'project-0.1')
+
+    def test_common_directory(self):
+        self.assertEqual(common_directory(['ab/c/d', 'ab/c/e']), 'ab')
+        self.assertIs(common_directory(['ab/c/d', 'ac/c/e']), None)
+        self.assertEqual('FEEDME', common_directory(['FEEDME']))
+
+    def test_untar(self):
+        def builder(fileobj, mode='w'):
+            return tarfile.open('project-0.1.tar', mode, fileobj)
+        self.archive_test(builder, import_tar)
+
+    def test_broken_tar(self):
+        def builder(fileobj, mode='w'):
+            return tarfile.open('project-0.1.tar', mode, fileobj)
+        self.archive_test(builder, import_tar_broken, subdir=True)
+
+    def test_unzip(self):
+        def builder(fileobj, mode='w'):
+            return ZipFileWrapper(fileobj, mode)
+        self.archive_test(builder, import_zip)
+
+    def test_copydir_nosub(self):
+        def builder(fileobj, mode='w'):
+            return DirFileWriter(fileobj, mode)
+        # It would be bogus to test with the result in a subdirectory,
+        # because for directories, the input root is always the output root.
+        self.archive_test(builder, import_dir)
+
+    def archive_test(self, builder, importer, subdir=False):
+        archive_file = self.make_archive(builder, subdir)
+        tree = BzrDir.create_standalone_workingtree('tree')
+        tree.lock_write()
+        try:
+            importer(tree, archive_file)
+            self.assertTrue(tree.path2id('README') is not None)
+            self.assertTrue(tree.path2id('FEEDME') is not None)
+            self.assertTrue(os.path.isfile(tree.abspath('README')))
+            self.assertEqual(tree.stored_kind(tree.path2id('README')),
+                'file')
+            self.assertEqual(tree.stored_kind(tree.path2id('FEEDME')),
+                'file')
+            f = file(tree.abspath('junk/food'), 'wb')
+            f.write('I like food\n')
+            f.close()
+
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                archive_file = self.make_archive2(builder, subdir)
+                importer(tree, archive_file)
+            self.assertTrue(tree.path2id('README') is not None)
+            # Ensure the second version of the file is used.
+            self.assertEqual(tree.get_file_text(tree.path2id('README')),
+                             'Wow?')
+            self.assertTrue(not os.path.exists(tree.abspath('FEEDME')))
+        finally:
+            tree.unlock()
+
+
+    def test_untar2(self):
+        tar_file = self.make_messed_tar()
+        tree = BzrDir.create_standalone_workingtree('tree')
+        import_tar(tree, tar_file)
+        self.assertTrue(tree.path2id('project-0.1/README') is not None)
+
+    def test_untar_gzip(self):
+        tar_file = self.make_tar(mode='w:gz')
+        tree = BzrDir.create_standalone_workingtree('tree')
+        import_tar(tree, tar_file)
+        self.assertTrue(tree.path2id('README') is not None)
+
+    def test_no_crash_with_bzrdir(self):
+        tar_file = self.make_tar_with_bzrdir()
+        tree = BzrDir.create_standalone_workingtree('tree')
+        import_tar(tree, tar_file)
+        # So long as it did not crash, that should be ok
+
+    def test_get_archive_type(self):
+        self.assertEqual(('tar', None), get_archive_type('foo.tar'))
+        self.assertEqual(('zip', None), get_archive_type('foo.zip'))
+        self.assertRaises(NotArchiveType, get_archive_type, 'foo.gif')
+        self.assertEqual(('tar', 'gz'), get_archive_type('foo.tar.gz'))
+        self.assertRaises(NotArchiveType, get_archive_type,
+                          'foo.zip.gz')
+        self.assertEqual(('tar', 'gz'), get_archive_type('foo.tgz'))
+        self.assertEqual(('tar', 'lzma'), get_archive_type('foo.tar.lzma'))
+        self.assertEqual(('tar', 'lzma'), get_archive_type('foo.tar.xz'))
+        self.assertEqual(('tar', 'bz2'), get_archive_type('foo.tar.bz2'))
+
+
+class TestWithStuff(TestCaseWithTransport):
+
+    def transform_to_tar(self, tt):
+        stream = StringIO()
+        export(tt.get_preview_tree(), root='', fileobj=stream, format='tar',
+               dest=None)
+        return stream
+
+    def get_empty_tt(self):
+        b = self.make_repository('foo')
+        null_tree = b.revision_tree(_mod_revision.NULL_REVISION)
+        tt = transform.TransformPreview(null_tree)
+        root = tt.new_directory('', transform.ROOT_PARENT, 'tree-root')
+        tt.fixup_new_roots()
+        self.addCleanup(tt.finalize)
+        return tt
+
+    def test_nonascii_paths(self):
+        self.requireFeature(UnicodeFilenameFeature)
+        tt = self.get_empty_tt()
+        encoded_file = tt.new_file(
+            u'\u1234file', tt.root, 'contents', 'new-file')
+        encoded_file = tt.new_file(
+            'other', tt.root, 'contents', 'other-file')
+        tarfile = self.transform_to_tar(tt)
+        tarfile.seek(0)
+        tree = self.make_branch_and_tree('bar')
+        import_tar(tree, tarfile)
+        self.assertPathExists(u'bar/\u1234file')

=== added file 'breezy/upstream_import.py'
--- breezy/upstream_import.py	1970-01-01 00:00:00 +0000
+++ breezy/upstream_import.py	2017-05-30 22:09:44 +0000
@@ -0,0 +1,374 @@
+# Copyright (C) 2006-2012 Aaron Bentley
+#
+# 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
+
+"""Import upstream source into a branch"""
+
+from __future__ import absolute_import
+
+import errno
+import os
+import re
+from StringIO import StringIO
+import stat
+import tarfile
+import zipfile
+
+from . import generate_ids, urlutils
+from .bzrdir import BzrDir
+from .errors import (BzrError, NoSuchFile, BzrCommandError, NotBranchError)
+from .osutils import (pathjoin, isdir, file_iterator, basename,
+                      file_kind, splitpath)
+from .trace import warning
+from .transform import TreeTransform, resolve_conflicts, cook_conflicts
+from .transport import get_transport
+from .workingtree import WorkingTree
+
+
+# TODO(jelmer): Move this to transport.py ?
+def open_from_url(location):
+    location = urlutils.normalize_url(location)
+    dirname, basename = urlutils.split(location)
+    if location.endswith('/') and not basename.endswith('/'):
+        basename += '/'
+    return get_transport(dirname).get(basename)
+
+
+class NotArchiveType(BzrError):
+
+    _fmt = '%(path)s is not an archive.'
+
+    def __init__(self, path):
+        BzrError.__init__(self)
+        self.path = path
+
+
+class ZipFileWrapper(object):
+
+    def __init__(self, fileobj, mode):
+        self.zipfile = zipfile.ZipFile(fileobj, mode)
+
+    def getmembers(self):
+        for info in self.zipfile.infolist():
+            yield ZipInfoWrapper(self.zipfile, info)
+
+    def extractfile(self, infowrapper):
+        return StringIO(self.zipfile.read(infowrapper.name))
+
+    def add(self, filename):
+        if isdir(filename):
+            self.zipfile.writestr(filename+'/', '')
+        else:
+            self.zipfile.write(filename)
+
+    def close(self):
+        self.zipfile.close()
+
+
+class ZipInfoWrapper(object):
+
+    def __init__(self, zipfile, info):
+        self.info = info
+        self.type = None
+        self.name = info.filename
+        self.zipfile = zipfile
+        self.mode = 0666
+
+    def isdir(self):
+        # Really? Eeeew!
+        return bool(self.name.endswith('/'))
+
+    def isreg(self):
+        # Really? Eeeew!
+        return not self.isdir()
+
+
+class DirWrapper(object):
+
+    def __init__(self, fileobj, mode='r'):
+        if mode != 'r':
+            raise AssertionError(
+                'only readonly supported')
+        self.root = os.path.realpath(fileobj.read())
+
+    def __repr__(self):
+        return 'DirWrapper(%r)' % self.root
+
+    def getmembers(self, subdir=None):
+        if subdir is not None:
+            mydir = pathjoin(self.root, subdir)
+        else:
+            mydir = self.root
+        for child in os.listdir(mydir):
+            if subdir is not None:
+                child = pathjoin(subdir, child)
+            fi = FileInfo(self.root, child)
+            yield fi
+            if fi.isdir():
+                for v in self.getmembers(child):
+                    yield v
+
+    def extractfile(self, member):
+        return open(member.fullpath)
+
+
+class FileInfo(object):
+
+    def __init__(self, root, filepath):
+        self.fullpath = pathjoin(root, filepath)
+        self.root = root
+        if filepath != '':
+            self.name = pathjoin(basename(root), filepath)
+        else:
+            print 'root %r' % root
+            self.name = basename(root)
+        self.type = None
+        stat = os.lstat(self.fullpath)
+        self.mode = stat.st_mode
+        if self.isdir():
+            self.name += '/'
+
+    def __repr__(self):
+        return 'FileInfo(%r)' % self.name
+
+    def isreg(self):
+        return stat.S_ISREG(self.mode)
+
+    def isdir(self):
+        return stat.S_ISDIR(self.mode)
+
+    def issym(self):
+        if stat.S_ISLNK(self.mode):
+            self.linkname = os.readlink(self.fullpath)
+            return True
+        else:
+            return False
+
+
+def top_path(path):
+    """Return the top directory given in a path."""
+    components = splitpath(path)
+    if len(components) > 0:
+        return components[0]
+    else:
+        return ''
+
+
+def common_directory(names):
+    """Determine a single directory prefix from a list of names"""
+    possible_prefix = None
+    for name in names:
+        name_top = top_path(name)
+        if name_top == '':
+            return None
+        if possible_prefix is None:
+            possible_prefix = name_top
+        else:
+            if name_top != possible_prefix:
+                return None
+    return possible_prefix
+
+
+def do_directory(tt, trans_id, tree, relative_path, path):
+    if isdir(path) and tree.path2id(relative_path) is not None:
+        tt.cancel_deletion(trans_id)
+    else:
+        tt.create_directory(trans_id)
+
+
+def add_implied_parents(implied_parents, path):
+    """Update the set of implied parents from a path"""
+    parent = os.path.dirname(path)
+    if parent in implied_parents:
+        return
+    implied_parents.add(parent)
+    add_implied_parents(implied_parents, parent)
+
+
+def names_of_files(tar_file):
+    for member in tar_file.getmembers():
+        if member.type != "g":
+            yield member.name
+
+
+def should_ignore(relative_path):
+    return top_path(relative_path) == '.bzr'
+
+
+def import_tar(tree, tar_input):
+    """Replace the contents of a working directory with tarfile contents.
+    The tarfile may be a gzipped stream.  File ids will be updated.
+    """
+    tar_file = tarfile.open('lala', 'r', tar_input)
+    import_archive(tree, tar_file)
+
+def import_zip(tree, zip_input):
+    zip_file = ZipFileWrapper(zip_input, 'r')
+    import_archive(tree, zip_file)
+
+def import_dir(tree, dir_input):
+    dir_file = DirWrapper(dir_input)
+    import_archive(tree, dir_file)
+
+
+def import_archive(tree, archive_file):
+    tt = TreeTransform(tree)
+    try:
+        import_archive_to_transform(tree, archive_file, tt)
+        tt.apply()
+    finally:
+        tt.finalize()
+
+
+def import_archive_to_transform(tree, archive_file, tt):
+    prefix = common_directory(names_of_files(archive_file))
+    removed = set()
+    for path, entry in tree.iter_entries_by_dir():
+        if entry.parent_id is None:
+            continue
+        trans_id = tt.trans_id_tree_path(path)
+        tt.delete_contents(trans_id)
+        removed.add(path)
+
+    added = set()
+    implied_parents = set()
+    seen = set()
+    for member in archive_file.getmembers():
+        if member.type == 'g':
+            # type 'g' is a header
+            continue
+        # Inverse functionality in bzr uses utf-8.  We could also
+        # interpret relative to fs encoding, which would match native
+        # behaviour better.
+        relative_path = member.name.decode('utf-8')
+        if prefix is not None:
+            relative_path = relative_path[len(prefix)+1:]
+            relative_path = relative_path.rstrip('/')
+        if relative_path == '':
+            continue
+        if should_ignore(relative_path):
+            continue
+        add_implied_parents(implied_parents, relative_path)
+        trans_id = tt.trans_id_tree_path(relative_path)
+        added.add(relative_path.rstrip('/'))
+        path = tree.abspath(relative_path)
+        if member.name in seen:
+            if tt.final_kind(trans_id) == 'file':
+                tt.set_executability(None, trans_id)
+            tt.cancel_creation(trans_id)
+        seen.add(member.name)
+        if member.isreg():
+            tt.create_file(file_iterator(archive_file.extractfile(member)),
+                           trans_id)
+            executable = (member.mode & 0111) != 0
+            tt.set_executability(executable, trans_id)
+        elif member.isdir():
+            do_directory(tt, trans_id, tree, relative_path, path)
+        elif member.issym():
+            tt.create_symlink(member.linkname, trans_id)
+        else:
+            continue
+        if tt.tree_file_id(trans_id) is None:
+            name = basename(member.name.rstrip('/'))
+            file_id = generate_ids.gen_file_id(name)
+            tt.version_file(file_id, trans_id)
+
+    for relative_path in implied_parents.difference(added):
+        if relative_path == "":
+            continue
+        trans_id = tt.trans_id_tree_path(relative_path)
+        path = tree.abspath(relative_path)
+        do_directory(tt, trans_id, tree, relative_path, path)
+        if tt.tree_file_id(trans_id) is None:
+            tt.version_file(trans_id, trans_id)
+        added.add(relative_path)
+
+    for path in removed.difference(added):
+        tt.unversion_file(tt.trans_id_tree_path(path))
+
+    for conflict in cook_conflicts(resolve_conflicts(tt), tt):
+        warning(conflict)
+
+
+def do_import(source, tree_directory=None):
+    """Implementation of import command.  Intended for UI only"""
+    if tree_directory is not None:
+        try:
+            tree = WorkingTree.open(tree_directory)
+        except NotBranchError:
+            if not os.path.exists(tree_directory):
+                os.mkdir(tree_directory)
+            branch = BzrDir.create_branch_convenience(tree_directory)
+            tree = branch.bzrdir.open_workingtree()
+    else:
+        tree = WorkingTree.open_containing('.')[0]
+    tree.lock_write()
+    try:
+        if tree.changes_from(tree.basis_tree()).has_changed():
+            raise BzrCommandError("Working tree has uncommitted changes.")
+
+        try:
+            archive, external_compressor = get_archive_type(source)
+        except NotArchiveType:
+            if file_kind(source) == 'directory':
+                s = StringIO(source)
+                s.seek(0)
+                import_dir(tree, s)
+            else:
+                raise BzrCommandError('Unhandled import source')
+        else:
+            if archive == 'zip':
+                import_zip(tree, open_from_url(source))
+            elif archive == 'tar':
+                try:
+                    tar_input = open_from_url(source)
+                    if external_compressor == 'bz2':
+                        import bz2
+                        tar_input = StringIO(bz2.decompress(tar_input.read()))
+                    elif external_compressor == 'lzma':
+                        import lzma
+                        tar_input = StringIO(lzma.decompress(tar_input.read()))
+                except IOError, e:
+                    if e.errno == errno.ENOENT:
+                        raise NoSuchFile(source)
+                try:
+                    import_tar(tree, tar_input)
+                finally:
+                    tar_input.close()
+    finally:
+        tree.unlock()
+
+
+def get_archive_type(path):
+    """Return the type of archive and compressor indicated by path name.
+
+    Only external compressors are returned, so zip files are only
+    ('zip', None).  .tgz is treated as ('tar', 'gz') and '.tar.xz' is treated
+    as ('tar', 'lzma').
+    """
+    matches = re.match(r'.*\.(zip|tgz|tar(.(gz|bz2|lzma|xz))?)$', path)
+    if not matches:
+        raise NotArchiveType(path)
+    external_compressor = None
+    if matches.group(3) is not None:
+        archive = 'tar'
+        external_compressor = matches.group(3)
+        if external_compressor == 'xz':
+            external_compressor = 'lzma'
+    elif matches.group(1) == 'tgz':
+        return 'tar', 'gz'
+    else:
+        archive = matches.group(1)
+    return archive, external_compressor

=== modified file 'doc/en/release-notes/brz-3.0.txt'
--- doc/en/release-notes/brz-3.0.txt	2017-05-30 19:32:13 +0000
+++ doc/en/release-notes/brz-3.0.txt	2017-05-30 22:09:44 +0000
@@ -26,9 +26,13 @@
 ************
 
  * The 'bisect' plugin is now shipped with bzr. (Jelmer Vernooij)
+
  * The 'fastimport' plugin is now bundled with Bazaar.
    (Jelmer Vernooij)
 
+ * The 'import' command is now bundled with brz.
+   Imported from bzrtools by Aaron Bentley. (Jelmer Vernooij, #773241)
+
 Improvements
 ************