Merge lp:~jelmer/brz/no-more-ftp into lp:brz

[Jelmer Vernooij]

Drop support for FTP.

Drop support for FTP.

* Our testing situation for FTP isn't great
* FTP is not as commonly used anymore as when Bazaar was started
* Breezy operations over FTP are slower than over other transports, so we
  should steer users away from it
* FTP isn't well defined in some areas, resulting in lots of annoying corner case bugs
* FTP connections are almost always insecure

[Martin Packman (gz)]

I'm a little sad about this (my first patch to bzr was fixing some dumb ftp thing), but I agree with your reasoning. Along with ftp being discouraged as a whole (see also https://lwn.net/Articles/720856/ for instance), removing support altogether seems correct.

review: Approve

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

Merging failed
https://ci.breezy-vcs.org/job/brz-dev/151/

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

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-dev/152/

[Vincent Ladeuil (vila)]

Die ftp die, like Martin, a bit sad, but meh, ftp needs to die anyway.
Plus that will make fullermd happy.

review: Approve

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

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-dev/153/

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

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-dev/154/

=== modified file 'breezy/help_topics/en/authentication.txt'
--- breezy/help_topics/en/authentication.txt	2017-05-21 14:47:52 +0000
+++ breezy/help_topics/en/authentication.txt	2018-05-11 10:19:44 +0000
@@ -24,16 +24,16 @@
 
 Instead of using::
 
-  brz branch ftp://joe:[e-mail]/path/to/my/branch
+  brz branch sftp://joe:[e-mail]/path/to/my/branch
 
 you simply use::
 
-  brz branch ftp://host.com/path/to/my/branch
+  brz branch sftp://host.com/path/to/my/branch
 
 provided you have created the following ``authentication.conf`` file::
 
   [myprojects]
-  scheme=ftp
+  scheme=sftp
   host=host.com
   user=joe
   password=secret

=== modified file 'breezy/lockdir.py'
--- breezy/lockdir.py	2017-10-28 12:56:32 +0000
+++ breezy/lockdir.py	2018-05-11 10:19:44 +0000
@@ -374,9 +374,6 @@
                 # another locker within the 'held' directory.  do a slower
                 # deletion where we list the directory and remove everything
                 # within it.
-                #
-                # Maybe this should be broader to allow for ftp servers with
-                # non-specific error messages?
                 self._trace("doing recursive deletion of non-empty directory "
                         "%s", tmpname)
                 self.transport.delete_tree(tmpname)

=== modified file 'breezy/plugins/git/tests/test_dir.py'
--- breezy/plugins/git/tests/test_dir.py	2018-03-28 01:51:03 +0000
+++ breezy/plugins/git/tests/test_dir.py	2018-05-11 10:19:44 +0000
@@ -91,5 +91,5 @@
         self.assertEquals(self.format, format2)
         self.assertEquals(self.format, self.format)
         bzr_format = controldir.format_registry.make_controldir("default")
-        self.assertNotEquals(self.format, bzr_format)
+        self.assertNotEqual(self.format, bzr_format)
 

=== modified file 'breezy/plugins/upload/__init__.py'
--- breezy/plugins/upload/__init__.py	2017-07-30 16:59:50 +0000
+++ breezy/plugins/upload/__init__.py	2018-05-11 10:19:44 +0000
@@ -107,7 +107,7 @@
 It is possible to upload to a remote location from another remote location by
 specifying it with the --directory option:
 
-    brz upload ftp://public.example.com --directory sftp://private.example.com 
+    brz upload sftp://public.example.com --directory sftp://private.example.com 
 
 This, together with --auto, can be used to upload when you push to your
 central branch, rather than when you commit to your local branch.

=== modified file 'breezy/plugins/upload/tests/test_upload.py'
--- breezy/plugins/upload/tests/test_upload.py	2018-02-18 15:21:06 +0000
+++ breezy/plugins/upload/tests/test_upload.py	2018-05-11 10:19:44 +0000
@@ -34,9 +34,6 @@
     per_branch,
     per_transport,
     )
-from ....transport import (
-    ftp,
-    )
 from .. import (
     cmds,
     )
@@ -46,7 +43,7 @@
     result = []
     basis = per_transport.transport_test_permutations()
     # Keep only the interesting ones for upload
-    usable_classes = {ftp.FtpTransport}
+    usable_classes = set()
     if features.paramiko.available():
         from ....transport import sftp
         usable_classes.add(sftp.SFTPTransport)
@@ -54,27 +51,6 @@
         t_class = d['transport_class']
         if t_class in usable_classes:
             result.append((name, d))
-    try:
-        import breezy.plugins.local_test_server
-        from breezy.plugins.local_test_server import test_server
-        if False:
-            # XXX: Disable since we can't get chmod working for anonymous
-            # user
-            scenario = ('vsftpd',
-                        {'transport_class': test_server.FtpTransport,
-                         'transport_server': test_server.Vsftpd,
-                         })
-            result.append(scenario)
-        from test_server import ProftpdFeature
-        if ProftpdFeature().available():
-            scenario = ('proftpd',
-                        {'transport_class': test_server.FtpTransport,
-                         'transport_server': test_server.Proftpd,
-                         })
-            result.append(scenario)
-        # XXX: add support for pyftpdlib
-    except ImportError:
-        pass
     return result
 
 

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2018-05-07 17:17:22 +0000
+++ breezy/tests/__init__.py	2018-05-11 10:19:44 +0000
@@ -179,11 +179,6 @@
     'NO_PROXY': None,
     'all_proxy': None,
     'ALL_PROXY': None,
-    # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
-    # least. If you do (care), please update this comment
-    # -- vila 20080401
-    'ftp_proxy': None,
-    'FTP_PROXY': None,
     'BZR_REMOTE_PATH': None,
     # Generally speaking, we don't want apport reporting on crashes in
     # the test envirnoment unless we're specifically testing apport,
@@ -3948,7 +3943,6 @@
         'breezy.tests.test_fifo_cache',
         'breezy.tests.test_filters',
         'breezy.tests.test_filter_tree',
-        'breezy.tests.test_ftp_transport',
         'breezy.tests.test_foreign',
         'breezy.tests.test_generate_docs',
         'breezy.tests.test_generate_ids',

=== modified file 'breezy/tests/blackbox/test_help.py'
--- breezy/tests/blackbox/test_help.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/blackbox/test_help.py	2018-05-11 10:19:44 +0000
@@ -66,11 +66,9 @@
     def test_help_urlspec(self):
         """Smoke test for 'brz help urlspec'"""
         out, err = self.run_bzr('help urlspec')
-        self.assertContainsRe(out, 'aftp://')
         self.assertContainsRe(out, 'bzr://')
         self.assertContainsRe(out, 'bzr\+ssh://')
         self.assertContainsRe(out, 'file://')
-        self.assertContainsRe(out, 'ftp://')
         self.assertContainsRe(out, 'http://')
         self.assertContainsRe(out, 'https://')
         self.assertContainsRe(out, 'sftp://')

=== removed directory 'breezy/tests/ftp_server'
=== removed file 'breezy/tests/ftp_server/__init__.py'
--- breezy/tests/ftp_server/__init__.py	2017-06-11 13:22:31 +0000
+++ breezy/tests/ftp_server/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,82 +0,0 @@
-# Copyright (C) 2009, 2010 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
-
-"""
-Facilities to use ftp test servers.
-"""
-
-import sys
-
-from breezy import tests
-from breezy.tests import (
-    features,
-    )
-
-
-try:
-    import pyftpdlib
-except ImportError:
-    pyftpdlib_available = False
-else:
-    pyftpdlib_available = True
-
-
-class _FTPServerFeature(features.Feature):
-    """Some tests want an FTP Server, check if one is available.
-
-    Right now, the only way this is available is if one of the following is
-    installed:
-
-    - 'pyftpdlib': http://code.google.com/p/pyftpdlib/
-    """
-
-    def _probe(self):
-        return pyftpdlib_available
-
-    def feature_name(self):
-        return 'FTPServer'
-
-
-FTPServerFeature = _FTPServerFeature()
-
-
-class UnavailableFTPTestServer(object):
-    """Dummy ftp test server.
-
-    This allows the test suite report the number of tests needing that
-    feature. We raise UnavailableFeature from methods before the test server is
-    being used. Doing so in the setUp method has bad side-effects (tearDown is
-    never called).
-    """
-
-    def start_server(self, vfs_server=None):
-        pass
-
-    def stop_server(self):
-        pass
-
-    def get_url(self):
-        raise tests.UnavailableFeature(FTPServerFeature)
-
-    def get_bogus_url(self):
-        raise tests.UnavailableFeature(FTPServerFeature)
-
-
-if pyftpdlib_available:
-    from . import pyftpdlib_based
-    FTPTestServer = pyftpdlib_based.FTPTestServer
-else:
-    FTPTestServer = UnavailableFTPTestServer

=== removed file 'breezy/tests/ftp_server/pyftpdlib_based.py'
--- breezy/tests/ftp_server/pyftpdlib_based.py	2017-06-11 13:36:02 +0000
+++ breezy/tests/ftp_server/pyftpdlib_based.py	1970-01-01 00:00:00 +0000
@@ -1,223 +0,0 @@
-# Copyright (C) 2009, 2010 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
-"""
-FTP test server.
-
-Based on pyftpdlib: http://code.google.com/p/pyftpdlib/
-"""
-
-import errno
-import logging
-import os
-import pyftpdlib
-import sys
-from pyftpdlib.authorizers import (
-    AuthorizerError,
-    DummyAuthorizer,
-    )
-from pyftpdlib.filesystems import AbstractedFS
-from pyftpdlib.handlers import (
-    FTPHandler,
-    proto_cmds,
-    )
-from pyftpdlib.servers import FTPServer
-import select
-import threading
-
-
-from breezy import (
-    osutils,
-    tests,
-    trace,
-    )
-from breezy.tests import test_server
-
-
-class NullHandler(logging.Handler):
-
-    def emit(self, record):
-        pass
-
-# Shut up very verbose pyftpdlib
-logging.getLogger('pyftpdlib').addHandler(NullHandler())
-
-
-# Convert the pyftplib string version into a tuple to avoid traps in string
-# comparison.
-pyftplib_version = tuple(map(int, pyftpdlib.__ver__.split('.')))
-
-
-class AnonymousWithWriteAccessAuthorizer(DummyAuthorizer):
-
-    def _check_permissions(self, username, perm):
-        # Like base implementation but don't warn about write permissions
-        # assigned to anonymous, since that's exactly our purpose.
-        for p in perm:
-            if p not in self.read_perms + self.write_perms:
-                raise AuthorizerError('No such permission "%s"' %p)
-
-
-class BzrConformingFS(AbstractedFS):
-
-    def chmod(self, path, mode):
-        return os.chmod(path, mode)
-
-    def listdir(self, path):
-        """List the content of a directory."""
-        return [osutils.safe_utf8(s) for s in os.listdir(path)]
-
-    def fs2ftp(self, fspath):
-        p = AbstractedFS.fs2ftp(self, osutils.safe_unicode(fspath))
-        return osutils.safe_utf8(p)
-
-    def ftp2fs(self, ftppath):
-        p = osutils.safe_unicode(ftppath)
-        return AbstractedFS.ftp2fs(self, p)
-
-
-class BzrConformingFTPHandler(FTPHandler):
-
-    abstracted_fs = BzrConformingFS
-
-    def __init__(self, conn, server, ioloop=None):
-        FTPHandler.__init__(self, conn, server)
-        self.authorizer = server.authorizer
-
-    def ftp_SIZE(self, path):
-        # bzr is overly picky here, but we want to make the test suite pass
-        # first. This may need to be revisited -- vila 20090226
-        line = self.fs.fs2ftp(path)
-        if self.fs.isdir(self.fs.realpath(path)):
-            why = "%s is a directory" % line
-            self.log('FAIL SIZE "%s". %s.' % (line, why))
-            self.respond("550 %s."  %why)
-        else:
-            FTPHandler.ftp_SIZE(self, path)
-
-    def ftp_NLST(self, path):
-        # bzr is overly picky here, but we want to make the test suite pass
-        # first. This may need to be revisited -- vila 20090226
-        line = self.fs.fs2ftp(path)
-        if self.fs.isfile(self.fs.realpath(path)):
-            why = "Not a directory: %s" % line
-            self.log('FAIL NLST "%s". %s.' % (line, why))
-            self.respond("550 %s."  %why)
-        else:
-            FTPHandler.ftp_NLST(self, path)
-
-    def log_cmd(self, cmd, arg, respcode, respstr):
-        # base class version choke on unicode, the alternative is to just
-        # provide an empty implementation and relies on the client to do
-        # the logging for debugging purposes. Not worth the trouble so far
-        # -- vila 20110607
-        if cmd in ("DELE", "RMD", "RNFR", "RNTO", "MKD"):
-            line = '"%s" %s' % (' '.join([cmd, unicode(arg)]).strip(), respcode)
-            self.log(line)
-
-
-# An empty password is valid, hence the arg is neither mandatory nor forbidden
-proto_cmds['PASS']['arg'] = None
-
-class ftp_server(FTPServer):
-
-    def __init__(self, address, handler, authorizer):
-        FTPServer.__init__(self, address, handler)
-        self.authorizer = authorizer
-        # Worth backporting upstream ?
-        self.addr = self.socket.getsockname()
-
-
-class FTPTestServer(test_server.TestServer):
-    """Common code for FTP server facilities."""
-
-    def __init__(self):
-        self._root = None
-        self._ftp_server = None
-        self._port = None
-        self._async_thread = None
-        # ftp server logs
-        self.logs = []
-        self._ftpd_running = False
-
-    def get_url(self):
-        """Calculate an ftp url to this server."""
-        return 'ftp://anonymous@localhost:%d/' % (self._port)
-
-    def get_bogus_url(self):
-        """Return a URL which cannot be connected to."""
-        return 'ftp://127.0.0.1:1/'
-
-    def log(self, message):
-        """This is used by ftp_server to log connections, etc."""
-        self.logs.append(message)
-
-    def start_server(self, vfs_server=None):
-        if not (vfs_server is None or isinstance(vfs_server,
-                                                 test_server.LocalURLServer)):
-            raise AssertionError(
-                "FTPServer currently assumes local transport, got %s"
-                % vfs_server)
-        self._root = osutils.getcwd()
-
-        address = ('localhost', 0) # bind to a random port
-        authorizer = AnonymousWithWriteAccessAuthorizer()
-        authorizer.add_anonymous(self._root, perm='elradfmwM')
-        self._ftp_server = ftp_server(address, BzrConformingFTPHandler,
-                                      authorizer)
-
-        self._port = self._ftp_server.socket.getsockname()[1]
-        self._ftpd_starting = threading.Lock()
-        self._ftpd_starting.acquire() # So it can be released by the server
-        self._ftpd_thread = threading.Thread(target=self._run_server,)
-        self._ftpd_thread.start()
-        if 'threads' in tests.selftest_debug_flags:
-            sys.stderr.write('Thread started: %s\n'
-                             % (self._ftpd_thread.ident,))
-        # Wait for the server thread to start (i.e release the lock)
-        self._ftpd_starting.acquire()
-        self._ftpd_starting.release()
-
-    def stop_server(self):
-        """See breezy.transport.Server.stop_server."""
-        # Tell the server to stop, but also close the server socket for tests
-        # that start the server but never initiate a connection. Closing the
-        # socket should be done first though, to avoid further connections.
-        self._ftp_server.close()
-        self._ftpd_running = False
-        self._ftpd_thread.join()
-        if 'threads' in tests.selftest_debug_flags:
-            sys.stderr.write('Thread  joined: %s\n'
-                             % (self._ftpd_thread.ident,))
-
-    def _run_server(self):
-        """Run the server until stop_server is called.
-
-        Shut it down properly then.
-        """
-        self._ftpd_running = True
-        self._ftpd_starting.release()
-        while self._ftpd_running:
-            try:
-                self._ftp_server.serve_forever(timeout=0.1)
-            except select.error as e:
-                if e.args[0] != errno.EBADF:
-                    raise
-        self._ftp_server.close_all()
-
-    def add_user(self, user, password):
-        """Add a user with write access."""
-        self._ftp_server.authorizer.add_user(user, password, self._root,
-                                             perm='elradfmwM')

=== removed file 'breezy/tests/test_ftp_transport.py'
--- breezy/tests/test_ftp_transport.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_ftp_transport.py	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-# Copyright (C) 2006, 2007, 2009, 2010, 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
-
-import ftplib
-import getpass
-
-from .. import (
-    config,
-    errors,
-    tests,
-    transport,
-    ui,
-    urlutils,
-    )
-
-from ..transport import ftp
-
-from . import ftp_server
-
-
-class TestCaseWithFTPServer(tests.TestCaseWithTransport):
-
-    _test_needs_features = [ftp_server.FTPServerFeature]
-
-    def setUp(self):
-        self.transport_server = ftp_server.FTPTestServer
-        super(TestCaseWithFTPServer, self).setUp()
-
-
-class TestCaseAFTP(tests.TestCaseWithTransport):
-    """Test aftp transport."""
-
-    def test_aftp_degrade(self):
-        t = transport.get_transport_from_url('aftp://host/path')
-        self.assertTrue(t.is_active)
-        parent = t.clone('..')
-        self.assertTrue(parent.is_active)
-
-        self.assertEqual('aftp://host/path', t.abspath(''))
-
-
-class TestFTPTestServer(TestCaseWithFTPServer):
-
-    def test_basic_exists(self):
-        url = self.get_url()
-        self.assertStartsWith(url, 'ftp://')
-
-        t = self.get_transport()
-        t.put_bytes('foo', 'test bytes\n')
-        self.assertEqual('test bytes\n', t.get_bytes('foo'))
-
-    def test__reconnect(self):
-        t = self.get_transport()
-        t.put_bytes('foo', 'test bytes\n')
-        self.assertEqual('test bytes\n', t.get_bytes('foo'))
-        t._reconnect()
-        t.put_bytes('foo', 'test more bytes\n')
-        self.assertEqual('test more bytes\n', t.get_bytes('foo'))
-
-
-class TestFTPTestServerUI(TestCaseWithFTPServer):
-
-    def setUp(self):
-        super(TestFTPTestServerUI, self).setUp()
-        self.user = 'joe'
-        self.password = 'secret'
-        self.get_server().add_user(self.user, self.password)
-
-    def get_url(self, relpath=None):
-        """Overrides get_url to inject our user."""
-        base = super(TestFTPTestServerUI, self).get_url(relpath)
-        parsed_url = transport.ConnectedTransport._split_url(base)
-        new_url = parsed_url.clone()
-        new_url.user = self.user
-        new_url.quoted_user = urlutils.quote(self.user)
-        new_url.password = self.password
-        new_url.quoted_password = urlutils.quote(self.password)
-        return str(new_url)
-
-    def test_no_prompt_for_username(self):
-        """ensure getpass.getuser() is used if there's no username in the 
-        configuration.""",
-        self.get_server().add_user(getpass.getuser(), self.password)
-        t = self.get_transport()
-        ui.ui_factory = ui.CannedInputUIFactory([self.password])
-        # Issue a request to the server to connect
-        t.put_bytes('foo', 'test bytes\n')
-        self.assertEqual('test bytes\n', t.get_bytes('foo'))
-        # Only the password should've been read
-        ui.ui_factory.assert_all_input_consumed()
-
-    def test_prompt_for_password(self):
-        t = self.get_transport()
-        ui.ui_factory = ui.CannedInputUIFactory([self.password])
-        # Issue a request to the server to connect
-        t.has('whatever/not/existing')
-        # stdin should be empty (the provided password have been consumed)
-        ui.ui_factory.assert_all_input_consumed()
-
-    def test_no_prompt_for_password_when_using_auth_config(self):
-        t = self.get_transport()
-        ui.ui_factory = ui.CannedInputUIFactory([])
-        # Create a config file with the right password
-        conf = config.AuthenticationConfig()
-        conf._get_config().update({'ftptest': {'scheme': 'ftp',
-                                               'user': self.user,
-                                               'password': self.password}})
-        conf._save()
-        # Issue a request to the server to connect
-        t.put_bytes('foo', 'test bytes\n')
-        self.assertEqual('test bytes\n', t.get_bytes('foo'))
-
-    def test_empty_password(self):
-        # Override the default user/password from setUp
-        self.user = 'jim'
-        self.password = ''
-        self.get_server().add_user(self.user, self.password)
-        t = self.get_transport()
-        ui.ui_factory = ui.CannedInputUIFactory([self.password])
-        # Issue a request to the server to connect
-        t.has('whatever/not/existing')
-        # stdin should be empty (the provided password have been consumed),
-        # even if the password is empty, it's followed by a newline.
-        ui.ui_factory.assert_all_input_consumed()
-
-
-class TestFTPErrorTranslation(tests.TestCase):
-
-    def test_translate_directory_not_empty(self):
-        # https://bugs.launchpad.net/bugs/528722
-        
-        t = ftp.FtpTransport("ftp://none/")
-
-        try:
-            raise ftplib.error_temp("Rename/move failure: Directory not empty")
-        except Exception as e:
-            e = self.assertRaises(errors.DirectoryNotEmpty,
-                t._translate_ftp_error, e, "/path")

=== modified file 'breezy/tests/test_http.py'
--- breezy/tests/test_http.py	2018-04-01 02:54:41 +0000
+++ breezy/tests/test_http.py	2018-05-11 10:19:44 +0000
@@ -1895,9 +1895,9 @@
     def test_redirected_to_same_host_different_protocol(self):
         t = self._transport('http://www.example.com/foo')
         r = t._redirected_to('http://www.example.com/foo',
-                             'ftp://www.example.com/foo')
+                             'bzr://www.example.com/foo')
         self.assertNotEqual(type(r), type(t))
-        self.assertEqual('ftp://www.example.com/foo/', r.external_url())
+        self.assertEqual('bzr://www.example.com/foo/', r.external_url())
 
     def test_redirected_to_same_host_specific_implementation(self):
         t = self._transport('http://www.example.com/foo')

=== modified file 'breezy/tests/test_smart_transport.py'
--- breezy/tests/test_smart_transport.py	2018-03-25 11:34:51 +0000
+++ breezy/tests/test_smart_transport.py	2018-05-11 10:19:44 +0000
@@ -4310,7 +4310,7 @@
     def test_redirected_to_same_host_different_protocol(self):
         t = remote.RemoteHTTPTransport('bzr+http://[e-mail]/foo')
         r = t._redirected_to('http://www.example.com/foo',
-                             'ftp://www.example.com/foo')
+                             'bzr://www.example.com/foo')
         self.assertNotEqual(type(r), type(t))
 
 

=== modified file 'breezy/tests/transport_util.py'
--- breezy/tests/transport_util.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/transport_util.py	2018-05-11 10:19:44 +0000
@@ -15,24 +15,14 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 from . import features
-
-# SFTPTransport offers better performances but relies on paramiko, if paramiko
-# is not available, we fallback to FtpTransport
-if features.paramiko.available():
-    from . import test_sftp_transport
-    from ..transport import sftp, Transport
-    _backing_scheme = 'sftp'
-    _backing_transport_class = sftp.SFTPTransport
-    _backing_test_class = test_sftp_transport.TestCaseWithSFTPServer
-else:
-    from ..transport import ftp, Transport
-    from . import test_ftp_transport
-    _backing_scheme = 'ftp'
-    _backing_transport_class = ftp.FtpTransport
-    _backing_test_class = test_ftp_transport.TestCaseWithFTPServer
-
-
-class TestCaseWithConnectionHookedTransport(_backing_test_class):
+from . import TestCaseWithTransport
+from ..transport import Transport
+
+# SFTPTransport is the only bundled transport that properly counts connections
+# at the moment.
+from . import test_sftp_transport
+
+class TestCaseWithConnectionHookedTransport(test_sftp_transport.TestCaseWithSFTPServer):
 
     def setUp(self):
         super(TestCaseWithConnectionHookedTransport, self).setUp()
@@ -44,4 +34,3 @@
 
     def reset_connections(self):
         self.connections = []
-

=== modified file 'breezy/transport/__init__.py'
--- breezy/transport/__init__.py	2018-05-05 20:39:37 +0000
+++ breezy/transport/__init__.py	2018-05-11 10:19:44 +0000
@@ -1686,33 +1686,10 @@
 register_lazy_transport('https://', 'breezy.transport.http',
                         'HttpTransport')
 
-register_transport_proto('ftp://', help="Access using passive FTP.")
-register_lazy_transport('ftp://', 'breezy.transport.ftp', 'FtpTransport')
-register_transport_proto('aftp://', help="Access using active FTP.")
-register_lazy_transport('aftp://', 'breezy.transport.ftp', 'FtpTransport')
 register_transport_proto('gio+', help="Access using any GIO supported protocols.")
 register_lazy_transport('gio+', 'breezy.transport.gio_transport', 'GioTransport')
 
 
-# Default to trying GSSAPI authentication (if the kerberos module is
-# available)
-register_transport_proto('ftp+gssapi://', register_netloc=True)
-register_transport_proto('aftp+gssapi://', register_netloc=True)
-register_transport_proto('ftp+nogssapi://', register_netloc=True)
-register_transport_proto('aftp+nogssapi://', register_netloc=True)
-register_lazy_transport('ftp+gssapi://', 'breezy.transport.ftp._gssapi',
-                        'GSSAPIFtpTransport')
-register_lazy_transport('aftp+gssapi://', 'breezy.transport.ftp._gssapi',
-                        'GSSAPIFtpTransport')
-register_lazy_transport('ftp://', 'breezy.transport.ftp._gssapi',
-                        'GSSAPIFtpTransport')
-register_lazy_transport('aftp://', 'breezy.transport.ftp._gssapi',
-                        'GSSAPIFtpTransport')
-register_lazy_transport('ftp+nogssapi://', 'breezy.transport.ftp',
-                        'FtpTransport')
-register_lazy_transport('aftp+nogssapi://', 'breezy.transport.ftp',
-                        'FtpTransport')
-
 register_transport_proto('memory://')
 register_lazy_transport('memory://', 'breezy.transport.memory',
                         'MemoryTransport')

=== removed directory 'breezy/transport/ftp'
=== removed file 'breezy/transport/ftp/__init__.py'
--- breezy/transport/ftp/__init__.py	2017-11-12 13:53:51 +0000
+++ breezy/transport/ftp/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,638 +0,0 @@
-# Copyright (C) 2005-2010 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
-
-"""Implementation of Transport over ftp.
-
-Written by Daniel Silverstone <[e-mail]> with serious
-cargo-culting from the sftp transport and the http transport.
-
-It provides the ftp:// and aftp:// protocols where ftp:// is passive ftp
-and aftp:// is active ftp. Most people will want passive ftp for traversing
-NAT and other firewalls, so it's best to use it unless you explicitly want
-active, in which case aftp:// will be your friend.
-"""
-
-from __future__ import absolute_import
-
-import ftplib
-import getpass
-import os
-import random
-import socket
-import stat
-import time
-
-from ... import (
-    config,
-    errors,
-    osutils,
-    urlutils,
-    )
-from ...sixish import (
-    BytesIO,
-    )
-from ...trace import mutter, warning
-from ...transport import (
-    AppendBasedFileStream,
-    ConnectedTransport,
-    _file_streams,
-    register_urlparse_netloc_protocol,
-    Server,
-    )
-
-
-register_urlparse_netloc_protocol('aftp')
-
-
-class FtpPathError(errors.PathError):
-    """FTP failed for path: %(path)s%(extra)s"""
-
-
-class FtpStatResult(object):
-
-    def __init__(self, f, abspath):
-        try:
-            self.st_size = f.size(abspath)
-            self.st_mode = stat.S_IFREG
-        except ftplib.error_perm:
-            pwd = f.pwd()
-            try:
-                f.cwd(abspath)
-                self.st_mode = stat.S_IFDIR
-            finally:
-                f.cwd(pwd)
-
-
-_number_of_retries = 2
-_sleep_between_retries = 5
-
-# FIXME: there are inconsistencies in the way temporary errors are
-# handled. Sometimes we reconnect, sometimes we raise an exception. Care should
-# be taken to analyze the implications for write operations (read operations
-# are safe to retry). Overall even some read operations are never
-# retried. --vila 20070720 (Bug #127164)
-class FtpTransport(ConnectedTransport):
-    """This is the transport agent for ftp:// access."""
-
-    def __init__(self, base, _from_transport=None):
-        """Set the base path where files will be stored."""
-        if not (base.startswith('ftp://') or base.startswith('aftp://')):
-            raise ValueError(base)
-        super(FtpTransport, self).__init__(base,
-                                           _from_transport=_from_transport)
-        self._unqualified_scheme = 'ftp'
-        if self._parsed_url.scheme == 'aftp':
-            self.is_active = True
-        else:
-            self.is_active = False
-
-        # Most modern FTP servers support the APPE command. If ours doesn't, we
-        # (re)set this flag accordingly later.
-        self._has_append = True
-
-    def _get_FTP(self):
-        """Return the ftplib.FTP instance for this object."""
-        # Ensures that a connection is established
-        connection = self._get_connection()
-        if connection is None:
-            # First connection ever
-            connection, credentials = self._create_connection()
-            self._set_connection(connection, credentials)
-        return connection
-
-    connection_class = ftplib.FTP
-
-    def _create_connection(self, credentials=None):
-        """Create a new connection with the provided credentials.
-
-        :param credentials: The credentials needed to establish the connection.
-
-        :return: The created connection and its associated credentials.
-
-        The input credentials are only the password as it may have been
-        entered interactively by the user and may be different from the one
-        provided in base url at transport creation time.  The returned
-        credentials are username, password.
-        """
-        if credentials is None:
-            user, password = self._user, self._password
-        else:
-            user, password = credentials
-
-        auth = config.AuthenticationConfig()
-        if user is None:
-            user = auth.get_user('ftp', self._host, port=self._port,
-                                 default=getpass.getuser())
-        mutter("Constructing FTP instance against %r" %
-               ((self._host, self._port, user, '********',
-                self.is_active),))
-        try:
-            connection = self.connection_class()
-            connection.connect(host=self._host, port=self._port)
-            self._login(connection, auth, user, password)
-            connection.set_pasv(not self.is_active)
-            # binary mode is the default
-            connection.voidcmd('TYPE I')
-        except socket.error as e:
-            raise errors.SocketConnectionError(self._host, self._port,
-                                               msg='Unable to connect to',
-                                               orig_error= e)
-        except ftplib.error_perm as e:
-            raise errors.TransportError(msg="Error setting up connection:"
-                                        " %s" % str(e), orig_error=e)
-        return connection, (user, password)
-
-    def _login(self, connection, auth, user, password):
-        # '' is a valid password
-        if user and user != 'anonymous' and password is None:
-            password = auth.get_password('ftp', self._host,
-                                         user, port=self._port)
-        connection.login(user=user, passwd=password)
-
-    def _reconnect(self):
-        """Create a new connection with the previously used credentials"""
-        credentials = self._get_credentials()
-        connection, credentials = self._create_connection(credentials)
-        self._set_connection(connection, credentials)
-
-    def disconnect(self):
-        connection = self._get_connection()
-        if connection is not None:
-            connection.close()
-
-    def _translate_ftp_error(self, err, path, extra=None,
-                              unknown_exc=FtpPathError):
-        """Try to translate an ftplib exception to a breezy exception.
-
-        :param err: The error to translate into a bzr error
-        :param path: The path which had problems
-        :param extra: Extra information which can be included
-        :param unknown_exc: If None, we will just raise the original exception
-                    otherwise we raise unknown_exc(path, extra=extra)
-        """
-        # ftp error numbers are very generic, like "451: Requested action aborted,
-        # local error in processing" so unfortunately we have to match by
-        # strings.
-        s = str(err).lower()
-        if not extra:
-            extra = str(err)
-        else:
-            extra += ': ' + str(err)
-        if ('no such file' in s
-            or 'could not open' in s
-            or 'no such dir' in s
-            or 'could not create file' in s # vsftpd
-            or 'file doesn\'t exist' in s
-            or 'rnfr command failed.' in s # vsftpd RNFR reply if file not found
-            or 'file/directory not found' in s # filezilla server
-            # Microsoft FTP-Service RNFR reply if file not found
-            or (s.startswith('550 ') and 'unable to rename to' in extra)
-            # if containing directory doesn't exist, suggested by
-            # <https://bugs.launchpad.net/bzr/+bug/224373>
-            or (s.startswith('550 ') and "can't find folder" in s)
-            ):
-            raise errors.NoSuchFile(path, extra=extra)
-        elif ('file exists' in s):
-            raise errors.FileExists(path, extra=extra)
-        elif ('not a directory' in s):
-            raise errors.PathError(path, extra=extra)
-        elif 'directory not empty' in s:
-            raise errors.DirectoryNotEmpty(path, extra=extra)
-
-        mutter('unable to understand error for path: %s: %s', path, err)
-
-        if unknown_exc:
-            raise unknown_exc(path, extra=extra)
-        # TODO: jam 20060516 Consider re-raising the error wrapped in
-        #       something like TransportError, but this loses the traceback
-        #       Also, 'sftp' has a generic 'Failure' mode, which we use failure_exc
-        #       to handle. Consider doing something like that here.
-        #raise TransportError(msg='Error for path: %s' % (path,), orig_error=e)
-        raise
-
-    def has(self, relpath):
-        """Does the target location exist?"""
-        # FIXME jam 20060516 We *do* ask about directories in the test suite
-        #       We don't seem to in the actual codebase
-        # XXX: I assume we're never asked has(dirname) and thus I use
-        # the FTP size command and assume that if it doesn't raise,
-        # all is good.
-        abspath = self._remote_path(relpath)
-        try:
-            f = self._get_FTP()
-            mutter('FTP has check: %s => %s', relpath, abspath)
-            s = f.size(abspath)
-            mutter("FTP has: %s", abspath)
-            return True
-        except ftplib.error_perm as e:
-            if ('is a directory' in str(e).lower()):
-                mutter("FTP has dir: %s: %s", abspath, e)
-                return True
-            mutter("FTP has not: %s: %s", abspath, e)
-            return False
-
-    def get(self, relpath, retries=0):
-        """Get the file at the given relative path.
-
-        :param relpath: The relative path to the file
-        :param retries: Number of retries after temporary failures so far
-                        for this operation.
-
-        We're meant to return a file-like object which bzr will
-        then read from. For now we do this via the magic of BytesIO
-        """
-        try:
-            mutter("FTP get: %s", self._remote_path(relpath))
-            f = self._get_FTP()
-            ret = BytesIO()
-            f.retrbinary('RETR '+self._remote_path(relpath), ret.write, 8192)
-            ret.seek(0)
-            return ret
-        except ftplib.error_perm as e:
-            raise errors.NoSuchFile(self.abspath(relpath), extra=str(e))
-        except ftplib.error_temp as e:
-            if retries > _number_of_retries:
-                raise errors.TransportError(msg="FTP temporary error during GET %s. Aborting."
-                                     % self.abspath(relpath),
-                                     orig_error=e)
-            else:
-                warning("FTP temporary error: %s. Retrying.", str(e))
-                self._reconnect()
-                return self.get(relpath, retries+1)
-        except EOFError as e:
-            if retries > _number_of_retries:
-                raise errors.TransportError("FTP control connection closed during GET %s."
-                                     % self.abspath(relpath),
-                                     orig_error=e)
-            else:
-                warning("FTP control connection closed. Trying to reopen.")
-                time.sleep(_sleep_between_retries)
-                self._reconnect()
-                return self.get(relpath, retries+1)
-
-    def put_file(self, relpath, fp, mode=None, retries=0):
-        """Copy the file-like or string object into the location.
-
-        :param relpath: Location to put the contents, relative to base.
-        :param fp:       File-like or string object.
-        :param retries: Number of retries after temporary failures so far
-                        for this operation.
-
-        TODO: jam 20051215 ftp as a protocol seems to support chmod, but
-        ftplib does not
-        """
-        abspath = self._remote_path(relpath)
-        tmp_abspath = '%s.tmp.%.9f.%d.%d' % (abspath, time.time(),
-                        os.getpid(), random.randint(0, 0x7FFFFFFF))
-        bytes = None
-        if getattr(fp, 'read', None) is None:
-            # hand in a string IO
-            bytes = fp
-            fp = BytesIO(bytes)
-        else:
-            # capture the byte count; .read() may be read only so
-            # decorate it.
-            class byte_counter(object):
-                def __init__(self, fp):
-                    self.fp = fp
-                    self.counted_bytes = 0
-                def read(self, count):
-                    result = self.fp.read(count)
-                    self.counted_bytes += len(result)
-                    return result
-            fp = byte_counter(fp)
-        try:
-            mutter("FTP put: %s", abspath)
-            f = self._get_FTP()
-            try:
-                f.storbinary('STOR '+tmp_abspath, fp)
-                self._rename_and_overwrite(tmp_abspath, abspath, f)
-                self._setmode(relpath, mode)
-                if bytes is not None:
-                    return len(bytes)
-                else:
-                    return fp.counted_bytes
-            except (ftplib.error_temp, EOFError) as e:
-                warning("Failure during ftp PUT of %s: %s. Deleting temporary file."
-                    % (tmp_abspath, e, ))
-                try:
-                    f.delete(tmp_abspath)
-                except:
-                    warning("Failed to delete temporary file on the"
-                            " server.\nFile: %s", tmp_abspath)
-                    raise e
-                raise
-        except ftplib.error_perm as e:
-            self._translate_ftp_error(e, abspath, extra='could not store',
-                                       unknown_exc=errors.NoSuchFile)
-        except ftplib.error_temp as e:
-            if retries > _number_of_retries:
-                raise errors.TransportError(
-                    "FTP temporary error during PUT %s: %s. Aborting."
-                    % (self.abspath(relpath), e), orig_error=e)
-            else:
-                warning("FTP temporary error: %s. Retrying.", str(e))
-                self._reconnect()
-                self.put_file(relpath, fp, mode, retries+1)
-        except EOFError:
-            if retries > _number_of_retries:
-                raise errors.TransportError("FTP control connection closed during PUT %s."
-                                     % self.abspath(relpath), orig_error=e)
-            else:
-                warning("FTP control connection closed. Trying to reopen.")
-                time.sleep(_sleep_between_retries)
-                self._reconnect()
-                self.put_file(relpath, fp, mode, retries+1)
-
-    def mkdir(self, relpath, mode=None):
-        """Create a directory at the given path."""
-        abspath = self._remote_path(relpath)
-        try:
-            mutter("FTP mkd: %s", abspath)
-            f = self._get_FTP()
-            try:
-                f.mkd(abspath)
-            except ftplib.error_reply as e:
-                # <https://bugs.launchpad.net/bzr/+bug/224373> Microsoft FTP
-                # server returns "250 Directory created." which is kind of
-                # reasonable, 250 meaning "requested file action OK", but not what
-                # Python's ftplib expects.
-                if e[0][:3] == '250':
-                    pass
-                else:
-                    raise
-            self._setmode(relpath, mode)
-        except ftplib.error_perm as e:
-            self._translate_ftp_error(e, abspath,
-                unknown_exc=errors.FileExists)
-
-    def open_write_stream(self, relpath, mode=None):
-        """See Transport.open_write_stream."""
-        self.put_bytes(relpath, "", mode)
-        result = AppendBasedFileStream(self, relpath)
-        _file_streams[self.abspath(relpath)] = result
-        return result
-
-    def recommended_page_size(self):
-        """See Transport.recommended_page_size().
-
-        For FTP we suggest a large page size to reduce the overhead
-        introduced by latency.
-        """
-        return 64 * 1024
-
-    def rmdir(self, rel_path):
-        """Delete the directory at rel_path"""
-        abspath = self._remote_path(rel_path)
-        try:
-            mutter("FTP rmd: %s", abspath)
-            f = self._get_FTP()
-            f.rmd(abspath)
-        except ftplib.error_perm as e:
-            self._translate_ftp_error(e, abspath, unknown_exc=errors.PathError)
-
-    def append_file(self, relpath, f, mode=None):
-        """Append the text in the file-like object into the final
-        location.
-        """
-        text = f.read()
-        abspath = self._remote_path(relpath)
-        if self.has(relpath):
-            ftp = self._get_FTP()
-            result = ftp.size(abspath)
-        else:
-            result = 0
-
-        if self._has_append:
-            mutter("FTP appe to %s", abspath)
-            self._try_append(relpath, text, mode)
-        else:
-            self._fallback_append(relpath, text, mode)
-
-        return result
-
-    def _try_append(self, relpath, text, mode=None, retries=0):
-        """Try repeatedly to append the given text to the file at relpath.
-
-        This is a recursive function. On errors, it will be called until the
-        number of retries is exceeded.
-        """
-        try:
-            abspath = self._remote_path(relpath)
-            mutter("FTP appe (try %d) to %s", retries, abspath)
-            ftp = self._get_FTP()
-            cmd = "APPE %s" % abspath
-            conn = ftp.transfercmd(cmd)
-            conn.sendall(text)
-            conn.close()
-            self._setmode(relpath, mode)
-            ftp.getresp()
-        except ftplib.error_perm as e:
-            # Check whether the command is not supported (reply code 502)
-            if str(e).startswith('502 '):
-                warning("FTP server does not support file appending natively. "
-                        "Performance may be severely degraded! (%s)", e)
-                self._has_append = False
-                self._fallback_append(relpath, text, mode)
-            else:
-                self._translate_ftp_error(e, abspath, extra='error appending',
-                    unknown_exc=errors.NoSuchFile)
-        except ftplib.error_temp as e:
-            if retries > _number_of_retries:
-                raise errors.TransportError(
-                    "FTP temporary error during APPEND %s. Aborting."
-                    % abspath, orig_error=e)
-            else:
-                warning("FTP temporary error: %s. Retrying.", str(e))
-                self._reconnect()
-                self._try_append(relpath, text, mode, retries+1)
-
-    def _fallback_append(self, relpath, text, mode = None):
-        remote = self.get(relpath)
-        remote.seek(0, os.SEEK_END)
-        remote.write(text)
-        remote.seek(0)
-        return self.put_file(relpath, remote, mode)
-
-    def _setmode(self, relpath, mode):
-        """Set permissions on a path.
-
-        Only set permissions if the FTP server supports the 'SITE CHMOD'
-        extension.
-        """
-        if mode:
-            try:
-                mutter("FTP site chmod: setting permissions to %s on %s",
-                       oct(mode), self._remote_path(relpath))
-                ftp = self._get_FTP()
-                cmd = "SITE CHMOD %s %s" % (oct(mode),
-                                            self._remote_path(relpath))
-                ftp.sendcmd(cmd)
-            except ftplib.error_perm as e:
-                # Command probably not available on this server
-                warning("FTP Could not set permissions to %s on %s. %s",
-                        oct(mode), self._remote_path(relpath), str(e))
-
-    # TODO: jam 20060516 I believe ftp allows you to tell an ftp server
-    #       to copy something to another machine. And you may be able
-    #       to give it its own address as the 'to' location.
-    #       So implement a fancier 'copy()'
-
-    def rename(self, rel_from, rel_to):
-        abs_from = self._remote_path(rel_from)
-        abs_to = self._remote_path(rel_to)
-        mutter("FTP rename: %s => %s", abs_from, abs_to)
-        f = self._get_FTP()
-        return self._rename(abs_from, abs_to, f)
-
-    def _rename(self, abs_from, abs_to, f):
-        try:
-            f.rename(abs_from, abs_to)
-        except (ftplib.error_temp, ftplib.error_perm) as e:
-            self._translate_ftp_error(e, abs_from,
-                ': unable to rename to %r' % (abs_to))
-
-    def move(self, rel_from, rel_to):
-        """Move the item at rel_from to the location at rel_to"""
-        abs_from = self._remote_path(rel_from)
-        abs_to = self._remote_path(rel_to)
-        try:
-            mutter("FTP mv: %s => %s", abs_from, abs_to)
-            f = self._get_FTP()
-            self._rename_and_overwrite(abs_from, abs_to, f)
-        except ftplib.error_perm as e:
-            self._translate_ftp_error(e, abs_from,
-                extra='unable to rename to %r' % (rel_to,),
-                unknown_exc=errors.PathError)
-
-    def _rename_and_overwrite(self, abs_from, abs_to, f):
-        """Do a fancy rename on the remote server.
-
-        Using the implementation provided by osutils.
-        """
-        osutils.fancy_rename(abs_from, abs_to,
-            rename_func=lambda p1, p2: self._rename(p1, p2, f),
-            unlink_func=lambda p: self._delete(p, f))
-
-    def delete(self, relpath):
-        """Delete the item at relpath"""
-        abspath = self._remote_path(relpath)
-        f = self._get_FTP()
-        self._delete(abspath, f)
-
-    def _delete(self, abspath, f):
-        try:
-            mutter("FTP rm: %s", abspath)
-            f.delete(abspath)
-        except ftplib.error_perm as e:
-            self._translate_ftp_error(e, abspath, 'error deleting',
-                unknown_exc=errors.NoSuchFile)
-
-    def external_url(self):
-        """See breezy.transport.Transport.external_url."""
-        # FTP URL's are externally usable.
-        return self.base
-
-    def listable(self):
-        """See Transport.listable."""
-        return True
-
-    def list_dir(self, relpath):
-        """See Transport.list_dir."""
-        basepath = self._remote_path(relpath)
-        mutter("FTP nlst: %s", basepath)
-        f = self._get_FTP()
-        try:
-            try:
-                paths = f.nlst(basepath)
-            except ftplib.error_perm as e:
-                self._translate_ftp_error(e, relpath,
-                                           extra='error with list_dir')
-            except ftplib.error_temp as e:
-                # xs4all's ftp server raises a 450 temp error when listing an
-                # empty directory. Check for that and just return an empty list
-                # in that case. See bug #215522
-                if str(e).lower().startswith('450 no files found'):
-                    mutter('FTP Server returned "%s" for nlst.'
-                           ' Assuming it means empty directory',
-                           str(e))
-                    return []
-                raise
-        finally:
-            # Restore binary mode as nlst switch to ascii mode to retrieve file
-            # list
-            f.voidcmd('TYPE I')
-
-        # If FTP.nlst returns paths prefixed by relpath, strip 'em
-        if paths and paths[0].startswith(basepath):
-            entries = [path[len(basepath)+1:] for path in paths]
-        else:
-            entries = paths
-        # Remove . and .. if present
-        return [urlutils.escape(entry) for entry in entries
-                if entry not in ('.', '..')]
-
-    def iter_files_recursive(self):
-        """See Transport.iter_files_recursive.
-
-        This is cargo-culted from the SFTP transport"""
-        mutter("FTP iter_files_recursive")
-        queue = list(self.list_dir("."))
-        while queue:
-            relpath = queue.pop(0)
-            st = self.stat(relpath)
-            if stat.S_ISDIR(st.st_mode):
-                for i, basename in enumerate(self.list_dir(relpath)):
-                    queue.insert(i, relpath+"/"+basename)
-            else:
-                yield relpath
-
-    def stat(self, relpath):
-        """Return the stat information for a file."""
-        abspath = self._remote_path(relpath)
-        try:
-            mutter("FTP stat: %s", abspath)
-            f = self._get_FTP()
-            return FtpStatResult(f, abspath)
-        except ftplib.error_perm as e:
-            self._translate_ftp_error(e, abspath, extra='error w/ stat')
-
-    def lock_read(self, relpath):
-        """Lock the given file for shared (read) access.
-        :return: A lock object, which should be passed to Transport.unlock()
-        """
-        # The old RemoteBranch ignore lock for reading, so we will
-        # continue that tradition and return a bogus lock object.
-        class BogusLock(object):
-            def __init__(self, path):
-                self.path = path
-            def unlock(self):
-                pass
-        return BogusLock(relpath)
-
-    def lock_write(self, relpath):
-        """Lock the given file for exclusive (write) access.
-        WARNING: many transports do not support this, so trying avoid using it
-
-        :return: A lock object, which should be passed to Transport.unlock()
-        """
-        return self.lock_read(relpath)
-
-
-def get_test_permutations():
-    """Return the permutations to be used in testing."""
-    from ...tests import ftp_server
-    return [(FtpTransport, ftp_server.FTPTestServer)]

=== removed file 'breezy/transport/ftp/_gssapi.py'
--- breezy/transport/ftp/_gssapi.py	2018-05-07 12:48:12 +0000
+++ breezy/transport/ftp/_gssapi.py	1970-01-01 00:00:00 +0000
@@ -1,128 +0,0 @@
-# Copyright (C) 2008, 2009, 2010 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
-
-"""Support for secure authentication using GSSAPI over FTP.
-
-See RFC2228 for details.
-"""
-
-from __future__ import absolute_import
-
-import base64, ftplib
-
-from ... import (
-    errors,
-    )
-from ...i18n import gettext
-from ...trace import (
-    mutter,
-    note,
-    )
-from ..ftp import FtpTransport
-
-try:
-    import kerberos
-except ImportError as e:
-    mutter('failed to import kerberos lib: %s', str(e))
-    raise errors.DependencyNotPresent('kerberos', e)
-
-if getattr(kerberos, "authGSSClientWrap", None) is None:
-    raise errors.DependencyNotPresent('kerberos',
-        "missing encryption function authGSSClientWrap")
-
-
-class GSSAPIFtp(ftplib.FTP):
-    """Extended version of ftplib.FTP that can authenticate using GSSAPI."""
-
-    def mic_putcmd(self, line):
-        rc = kerberos.authGSSClientWrap(self.vc, base64.b64encode(line))
-        wrapped = kerberos.authGSSClientResponse(self.vc)
-        ftplib.FTP.putcmd(self, "MIC " + wrapped)
-
-    def mic_getline(self):
-        resp = ftplib.FTP.getline(self)
-        if resp[:4] != '631 ':
-            raise AssertionError
-        rc = kerberos.authGSSClientUnwrap(self.vc, resp[4:].strip("\r\n"))
-        response = base64.b64decode(kerberos.authGSSClientResponse(self.vc))
-        return response
-
-    def gssapi_login(self, user):
-        # Try GSSAPI login first
-
-        # Used FTP response codes:
-        # 235 [ADAT=base64data] - indicates that the security data exchange
-        #     completed successfully.
-        # 334 [ADAT=base64data] - indicates that the requested security
-        #     mechanism is ok, and includes security data to be used by the
-        #     client to construct the next command.
-        # 335 [ADAT=base64data] - indicates that the security data is
-        #     acceptable, and more is required to complete the security
-        #     data exchange.
-
-        resp = self.sendcmd('AUTH GSSAPI')
-        if resp.startswith('334 '):
-            rc, self.vc = kerberos.authGSSClientInit("ftp@%s" % self.host)
-            if kerberos.authGSSClientStep(self.vc, "") != 1:
-                while resp[:4] in ('334 ', '335 '):
-                    authdata = kerberos.authGSSClientResponse(self.vc)
-                    resp = self.sendcmd('ADAT ' + authdata)
-                    if resp[:9] in ('235 ADAT=', '335 ADAT='):
-                        rc = kerberos.authGSSClientStep(self.vc, resp[9:])
-                        if not ((resp.startswith('235 ') and rc == 1) or
-                                (resp.startswith('335 ') and rc == 0)):
-                            raise ftplib.error_reply(resp)
-            note(gettext("Authenticated as %s") %
-                 kerberos.authGSSClientUserName(self.vc))
-
-            # Monkey patch ftplib
-            self.putcmd = self.mic_putcmd
-            self.getline = self.mic_getline
-            self.sendcmd('USER ' + user)
-            return resp
-        mutter("Unable to use GSSAPI authentication: %s", resp)
-
-
-class GSSAPIFtpTransport(FtpTransport):
-    """FTP transport implementation that will try to use GSSAPI authentication.
-
-    """
-
-    connection_class = GSSAPIFtp
-
-    def _login(self, connection, auth, user, password):
-        """Login with GSSAPI Authentication.
-
-        The password is used if GSSAPI Authentication is not available.
-
-        The username and password can both be None, in which case the
-        credentials specified in the URL or provided by the
-        AuthenticationConfig() are used.
-        """
-        try:
-            connection.gssapi_login(user=user)
-        except ftplib.error_perm as e:
-            super(GSSAPIFtpTransport, self)._login(connection, auth,
-                                                   user, password)
-
-
-def get_test_permutations():
-    """Return the permutations to be used in testing."""
-    from ...tests import ftp_server
-    if ftp_server.FTPServerFeature.available():
-        return [(GSSAPIFtpTransport, ftp_server.FTPTestServer)]
-    else:
-        return []