Merge lp:~jelmer/brz/move-mergeable into lp:brz

[Jelmer Vernooij]

Split mergeable bits out of breezy.bundle.

Split mergeable bits out of breezy.bundle.

[Martin Packman (gz)]

Thanks!

review: Approve

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/276/

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/283/

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/299/

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2019-05-28 21:53:23 +0000
+++ breezy/builtins.py	2019-05-29 03:29:58 +0000
@@ -33,7 +33,6 @@
 from breezy import (
     branch as _mod_branch,
     bugtracker,
-    bundle,
     cache_utf8,
     controldir,
     directory_service,
@@ -46,6 +45,7 @@
     lazy_regex,
     log,
     merge as _mod_merge,
+    mergeable as _mod_mergeable,
     merge_directive,
     osutils,
     reconfigure,
@@ -1210,8 +1210,8 @@
         possible_transports = []
         if location is not None:
             try:
-                mergeable = bundle.read_mergeable_from_url(location,
-                                                           possible_transports=possible_transports)
+                mergeable = _mod_mergeable.read_mergeable_from_url(
+                    location, possible_transports=possible_transports)
             except errors.NotABundle:
                 mergeable = None
 
@@ -4438,8 +4438,8 @@
         self.add_cleanup(tree.lock_write().unlock)
         if location is not None:
             try:
-                mergeable = bundle.read_mergeable_from_url(location,
-                                                           possible_transports=possible_transports)
+                mergeable = _mod_mergeable.read_mergeable_from_url(
+                    location, possible_transports=possible_transports)
             except errors.NotABundle:
                 mergeable = None
             else:
 
=== modified file 'breezy/bundle/__init__.py'
--- breezy/bundle/__init__.py	2018-11-11 04:08:32 +0000
+++ breezy/bundle/__init__.py	2019-05-29 03:29:58 +0000
@@ -15,75 +15,3 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 from __future__ import absolute_import
-
-
-from ..lazy_import import lazy_import
-lazy_import(globals(), """
-from breezy import (
-    errors,
-    transport as _mod_transport,
-    urlutils,
-    )
-from breezy.bundle import serializer as _serializer
-from breezy.merge_directive import MergeDirective
-from breezy.i18n import gettext
-""")
-from ..sixish import (
-    BytesIO,
-    )
-from ..trace import note
-
-
-def read_mergeable_from_url(url, _do_directive=True, possible_transports=None):
-    """Read mergable object from a given URL.
-
-    :return: An object supporting get_target_revision.  Raises NotABundle if
-        the target is not a mergeable type.
-    """
-    child_transport = _mod_transport.get_transport(url,
-                                                   possible_transports=possible_transports)
-    transport = child_transport.clone('..')
-    filename = transport.relpath(child_transport.base)
-    mergeable, transport = read_mergeable_from_transport(transport, filename,
-                                                         _do_directive)
-    return mergeable
-
-
-def read_mergeable_from_transport(transport, filename, _do_directive=True):
-    def get_bundle(transport):
-        return BytesIO(transport.get_bytes(filename)), transport
-
-    def redirected_transport(transport, exception, redirection_notice):
-        note(redirection_notice)
-        url, filename = urlutils.split(exception.target,
-                                       exclude_trailing_slash=False)
-        if not filename:
-            raise errors.NotABundle(gettext('A directory cannot be a bundle'))
-        return _mod_transport.get_transport_from_url(url)
-
-    try:
-        bytef, transport = _mod_transport.do_catching_redirections(
-            get_bundle, transport, redirected_transport)
-    except errors.TooManyRedirections:
-        raise errors.NotABundle(transport.clone(filename).base)
-    except (errors.ConnectionReset, errors.ConnectionError) as e:
-        raise
-    except (errors.TransportError, errors.PathError) as e:
-        raise errors.NotABundle(str(e))
-    except (IOError,) as e:
-        # jam 20060707
-        # Abstraction leakage, SFTPTransport.get('directory')
-        # doesn't always fail at get() time. Sometimes it fails
-        # during read. And that raises a generic IOError with
-        # just the string 'Failure'
-        # StubSFTPServer does fail during get() (because of prefetch)
-        # so it has an opportunity to translate the error.
-        raise errors.NotABundle(str(e))
-
-    if _do_directive:
-        try:
-            return MergeDirective.from_lines(bytef), transport
-        except errors.NotAMergeDirective:
-            bytef.seek(0)
-
-    return _serializer.read_bundle(bytef), transport
 
=== modified file 'breezy/bundle/commands.py'
--- breezy/bundle/commands.py	2018-11-11 04:08:32 +0000
+++ breezy/bundle/commands.py	2019-05-29 03:29:58 +0000
@@ -53,7 +53,7 @@
 
     def run(self, location, verbose=False):
         from breezy.bundle.serializer import read_bundle
-        from breezy.bundle import read_mergeable_from_url
+        from breezy.mergeable import read_mergeable_from_url
         from breezy import osutils
         term_encoding = osutils.get_terminal_encoding()
         bundle_info = read_mergeable_from_url(location)
 
=== added file 'breezy/mergeable.py'
--- breezy/mergeable.py	1970-01-01 00:00:00 +0000
+++ breezy/mergeable.py	2019-05-29 03:29:58 +0000
@@ -0,0 +1,107 @@
+# 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
+
+from __future__ import absolute_import
+
+from .lazy_import import lazy_import
+lazy_import(globals(), """
+from breezy import (
+    errors,
+    transport as _mod_transport,
+    urlutils,
+    )
+from breezy.bundle import serializer as _serializer
+from breezy.merge_directive import MergeDirective
+from breezy.i18n import gettext
+""")
+
+from .sixish import (
+    BytesIO,
+    )
+from .trace import note
+
+
+class Mergeable(object):
+    """A mergeable object."""
+
+    def install_revisions(self, repository):
+        """Install the data from this mergeable into the specified repository.
+
+        :param repository: Repository
+        """
+        raise NotImplementedError(self.install_revisions)
+
+    def get_merge_request(self, repository):
+        """Extract merge request data.
+
+        :return: tuple with (base_revision_id, target_revision_id, verified)
+        """
+        raise NotImplementedError(self.get_merge_request)
+
+
+def read_mergeable_from_url(url, _do_directive=True, possible_transports=None):
+    """Read mergable object from a given URL.
+
+    :return: An object supporting get_target_revision.  Raises NotABundle if
+        the target is not a mergeable type.
+    """
+    child_transport = _mod_transport.get_transport(
+        url, possible_transports=possible_transports)
+    transport = child_transport.clone('..')
+    filename = transport.relpath(child_transport.base)
+    mergeable, transport = read_mergeable_from_transport(transport, filename,
+                                                         _do_directive)
+    return mergeable
+
+
+def read_mergeable_from_transport(transport, filename, _do_directive=True):
+    def get_bundle(transport):
+        return BytesIO(transport.get_bytes(filename)), transport
+
+    def redirected_transport(transport, exception, redirection_notice):
+        note(redirection_notice)
+        url, filename = urlutils.split(exception.target,
+                                       exclude_trailing_slash=False)
+        if not filename:
+            raise errors.NotABundle(gettext('A directory cannot be a bundle'))
+        return _mod_transport.get_transport_from_url(url)
+
+    try:
+        bytef, transport = _mod_transport.do_catching_redirections(
+            get_bundle, transport, redirected_transport)
+    except errors.TooManyRedirections:
+        raise errors.NotABundle(transport.clone(filename).base)
+    except (errors.ConnectionReset, errors.ConnectionError) as e:
+        raise
+    except (errors.TransportError, errors.PathError) as e:
+        raise errors.NotABundle(str(e))
+    except (IOError,) as e:
+        # jam 20060707
+        # Abstraction leakage, SFTPTransport.get('directory')
+        # doesn't always fail at get() time. Sometimes it fails
+        # during read. And that raises a generic IOError with
+        # just the string 'Failure'
+        # StubSFTPServer does fail during get() (because of prefetch)
+        # so it has an opportunity to translate the error.
+        raise errors.NotABundle(str(e))
+
+    if _do_directive:
+        try:
+            return MergeDirective.from_lines(bytef), transport
+        except errors.NotAMergeDirective:
+            bytef.seek(0)
+
+    return _serializer.read_bundle(bytef), transport
 
=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2019-03-12 05:18:19 +0000
+++ breezy/tests/__init__.py	2019-05-29 03:29:58 +0000
@@ -4141,6 +4141,7 @@
         'breezy.tests.test_memorytree',
         'breezy.tests.test_merge',
         'breezy.tests.test_merge3',
+        'breezy.tests.test_mergeable',
         'breezy.tests.test_merge_core',
         'breezy.tests.test_merge_directive',
         'breezy.tests.test_mergetools',
 
=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2019-02-09 02:59:15 +0000
+++ breezy/tests/test_bundle.py	2019-05-29 03:29:58 +0000
@@ -17,10 +17,6 @@
 import bz2
 from io import BytesIO
 import os
-try:
-    import socketserver
-except ImportError:
-    import SocketServer as socketserver
 import sys
 
 from .. import (
@@ -36,10 +32,8 @@
     bzrdir,
     inventory,
     )
-from ..bundle import read_mergeable_from_url
 from ..bundle.apply_bundle import install_bundle, merge_bundle
 from ..bundle.bundle_data import BundleTree
-from ..directory_service import directories
 from ..bundle.serializer import write_bundle, read_bundle, v09, v4
 from ..bundle.serializer.v08 import BundleSerializerV08
 from ..bundle.serializer.v09 import BundleSerializerV09
@@ -48,8 +42,6 @@
 from . import (
     features,
     test_commit,
-    test_read_bundle,
-    test_server,
     )
 from ..transform import TreeTransform
 
@@ -1836,63 +1828,3 @@
         self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
                           'info', None, None), record)
         self.assertRaises(errors.BadBundle, next, record_iter)
-
-
-class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
-
-    def test_read_mergeable_skips_local(self):
-        """A local bundle named like the URL should not be read.
-        """
-        out, wt = test_read_bundle.create_bundle_file(self)
-
-        class FooService(object):
-            """A directory service that always returns source"""
-
-            def look_up(self, name, url, purpose=None):
-                return 'source'
-        directories.register('foo:', FooService, 'Testing directory service')
-        self.addCleanup(directories.remove, 'foo:')
-        self.build_tree_contents([('./foo:bar', out.getvalue())])
-        self.assertRaises(errors.NotABundle, read_mergeable_from_url,
-                          'foo:bar')
-
-    def test_infinite_redirects_are_not_a_bundle(self):
-        """If a URL causes TooManyRedirections then NotABundle is raised.
-        """
-        from .blackbox.test_push import RedirectingMemoryServer
-        server = RedirectingMemoryServer()
-        self.start_server(server)
-        url = server.get_url() + 'infinite-loop'
-        self.assertRaises(errors.NotABundle, read_mergeable_from_url, url)
-
-    def test_smart_server_connection_reset(self):
-        """If a smart server connection fails during the attempt to read a
-        bundle, then the ConnectionReset error should be propagated.
-        """
-        # Instantiate a server that will provoke a ConnectionReset
-        sock_server = DisconnectingServer()
-        self.start_server(sock_server)
-        # We don't really care what the url is since the server will close the
-        # connection without interpreting it
-        url = sock_server.get_url()
-        self.assertRaises(errors.ConnectionReset, read_mergeable_from_url, url)
-
-
-class DisconnectingHandler(socketserver.BaseRequestHandler):
-    """A request handler that immediately closes any connection made to it."""
-
-    def handle(self):
-        self.request.close()
-
-
-class DisconnectingServer(test_server.TestingTCPServerInAThread):
-
-    def __init__(self):
-        super(DisconnectingServer, self).__init__(
-            ('127.0.0.1', 0),
-            test_server.TestingTCPServer,
-            DisconnectingHandler)
-
-    def get_url(self):
-        """Return the url of the server"""
-        return "bzr://%s:%d/" % self.server.server_address
 
=== added file 'breezy/tests/test_mergeable.py'
--- breezy/tests/test_mergeable.py	1970-01-01 00:00:00 +0000
+++ breezy/tests/test_mergeable.py	2019-05-29 03:29:58 +0000
@@ -0,0 +1,91 @@
+# Copyright (C) 2005-2013, 2016 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
+
+try:
+    import socketserver
+except ImportError:
+    import SocketServer as socketserver
+
+from ..mergeable import read_mergeable_from_url
+from ..directory_service import directories
+from .. import (
+    errors,
+    tests,
+    )
+from . import (
+    test_read_bundle,
+    test_server,
+    )
+
+
+class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
+
+    def test_read_mergeable_skips_local(self):
+        """A local bundle named like the URL should not be read.
+        """
+        out, wt = test_read_bundle.create_bundle_file(self)
+
+        class FooService(object):
+            """A directory service that always returns source"""
+
+            def look_up(self, name, url):
+                return 'source'
+        directories.register('foo:', FooService, 'Testing directory service')
+        self.addCleanup(directories.remove, 'foo:')
+        self.build_tree_contents([('./foo:bar', out.getvalue())])
+        self.assertRaises(errors.NotABundle, read_mergeable_from_url,
+                          'foo:bar')
+
+    def test_infinite_redirects_are_not_a_bundle(self):
+        """If a URL causes TooManyRedirections then NotABundle is raised.
+        """
+        from .blackbox.test_push import RedirectingMemoryServer
+        server = RedirectingMemoryServer()
+        self.start_server(server)
+        url = server.get_url() + 'infinite-loop'
+        self.assertRaises(errors.NotABundle, read_mergeable_from_url, url)
+
+    def test_smart_server_connection_reset(self):
+        """If a smart server connection fails during the attempt to read a
+        bundle, then the ConnectionReset error should be propagated.
+        """
+        # Instantiate a server that will provoke a ConnectionReset
+        sock_server = DisconnectingServer()
+        self.start_server(sock_server)
+        # We don't really care what the url is since the server will close the
+        # connection without interpreting it
+        url = sock_server.get_url()
+        self.assertRaises(errors.ConnectionReset, read_mergeable_from_url, url)
+
+
+class DisconnectingHandler(socketserver.BaseRequestHandler):
+    """A request handler that immediately closes any connection made to it."""
+
+    def handle(self):
+        self.request.close()
+
+
+class DisconnectingServer(test_server.TestingTCPServerInAThread):
+
+    def __init__(self):
+        super(DisconnectingServer, self).__init__(
+            ('127.0.0.1', 0),
+            test_server.TestingTCPServer,
+            DisconnectingHandler)
+
+    def get_url(self):
+        """Return the url of the server"""
+        return "bzr://%s:%d/" % self.server.server_address
 
=== modified file 'breezy/tests/test_read_bundle.py'
--- breezy/tests/test_read_bundle.py	2018-11-12 01:41:38 +0000
+++ breezy/tests/test_read_bundle.py	2019-05-29 03:29:58 +0000
@@ -16,7 +16,7 @@
 
 """Test read_bundle works properly across various transports."""
 
-import breezy.bundle
+import breezy.mergeable
 from ..bundle.serializer import write_bundle
 import breezy.bzr.bzrdir
 from .. import errors
@@ -71,7 +71,7 @@
         self.create_test_bundle()
 
     def read_mergeable_from_url(self, url):
-        return breezy.bundle.read_mergeable_from_url(
+        return breezy.mergeable.read_mergeable_from_url(
             url, possible_transports=self.possible_transports)
 
     def get_url(self, relpath=''):