Merge lp:~mbp/bzr/704195-plugin-warnings into lp:bzr/2.3

[Martin Pool]

This stops bzr spamming you about out-of-date plugins. Telling people on every single invocation is not helpful. Now we just tell you on in `bzr plugins`.

As a follow-on in bug 704238 we can try to load them anyhow.

=== modified file 'bzr'
--- bzr	2010-11-26 17:59:08 +0000
+++ bzr	2011-01-19 00:31:58 +0000
@@ -23,7 +23,7 @@
 import warnings
 
 # update this on each release
-_script_version = (2, 3, 0)
+_script_version = (2, 4, 0)
 
 try:
     version_info = sys.version_info

=== modified file 'bzrlib/__init__.py'
--- bzrlib/__init__.py	2011-01-14 23:20:15 +0000
+++ bzrlib/__init__.py	2011-01-19 00:31:58 +0000
@@ -52,10 +52,10 @@
 # Python version 2.0 is (2, 0, 0, 'final', 0)."  Additionally we use a
 # releaselevel of 'dev' for unreleased under-development code.
 
-version_info = (2, 3, 0, 'dev', 6)
+version_info = (2, 4, 0, 'dev', 1)
 
 # API compatibility version
-api_minimum_version = (2, 3, 0)
+api_minimum_version = (2, 4, 0)
 
 
 def _format_version_tuple(version_info):

=== modified file 'bzrlib/branch.py'
--- bzrlib/branch.py	2011-01-12 01:01:53 +0000
+++ bzrlib/branch.py	2011-01-19 00:31:58 +0000
@@ -2664,7 +2664,7 @@
         result.target_branch = target
         result.old_revno, result.old_revid = target.last_revision_info()
         self.update_references(target)
-        if result.old_revid != self.last_revision():
+        if result.old_revid != stop_revision:
             # We assume that during 'push' this repository is closer than
             # the target.
             graph = self.repository.get_graph(target.repository)

=== modified file 'bzrlib/builtins.py'
--- bzrlib/builtins.py	2011-01-12 01:01:53 +0000
+++ bzrlib/builtins.py	2011-01-19 00:31:58 +0000
@@ -4581,26 +4581,9 @@
 
     @display_command
     def run(self, verbose=False):
-        import bzrlib.plugin
-        from inspect import getdoc
-        result = []
-        for name, plugin in bzrlib.plugin.plugins().items():
-            version = plugin.__version__
-            if version == 'unknown':
-                version = ''
-            name_ver = '%s %s' % (name, version)
-            d = getdoc(plugin.module)
-            if d:
-                doc = d.split('\n')[0]
-            else:
-                doc = '(no description)'
-            result.append((name_ver, doc, plugin.path()))
-        for name_ver, doc, path in sorted(result):
-            self.outf.write("%s\n" % name_ver)
-            self.outf.write("   %s\n" % doc)
-            if verbose:
-                self.outf.write("   %s\n" % path)
-            self.outf.write("\n")
+        from bzrlib import plugin
+        self.outf.writelines(
+            plugin.describe_loaded_plugins(show_paths=verbose))
 
 
 class cmd_testament(Command):

=== modified file 'bzrlib/crash.py'
--- bzrlib/crash.py	2010-09-28 18:51:47 +0000
+++ bzrlib/crash.py	2011-01-19 00:31:58 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2009, 2010 Canonical Ltd
+# Copyright (C) 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
@@ -254,11 +254,7 @@
 
 
 def _format_plugin_list():
-    plugin_lines = []
-    for name, a_plugin in sorted(plugin.plugins().items()):
-        plugin_lines.append("  %-20s %s [%s]" %
-            (name, a_plugin.path(), a_plugin.__version__))
-    return '\n'.join(plugin_lines)
+    return ''.join(plugin.describe_loaded_plugins(show_paths=True))
 
 
 def _format_module_list():

=== modified file 'bzrlib/fetch.py'
--- bzrlib/fetch.py	2011-01-10 22:20:12 +0000
+++ bzrlib/fetch.py	2011-01-19 00:31:58 +0000
@@ -28,6 +28,7 @@
 from bzrlib.lazy_import import lazy_import
 lazy_import(globals(), """
 from bzrlib import (
+    graph,
     tsort,
     versionedfile,
     )
@@ -93,7 +94,8 @@
         try:
             pb.update("Finding revisions", 0, 2)
             search = self._revids_to_fetch()
-            if search is None:
+            mutter('fetching: %s', search)
+            if search.is_empty():
                 return
             pb.update("Fetching revisions", 1, 2)
             self._fetch_everything_for_search(search)
@@ -148,17 +150,33 @@
         """Determines the exact revisions needed from self.from_repository to
         install self._last_revision in self.to_repository.
 
-        If no revisions need to be fetched, then this just returns None.
+        :returns: A SearchResult of some sort.  (Possibly a
+        PendingAncestryResult, EmptySearchResult, etc.)
         """
-        if self._fetch_spec is not None:
+        mutter("self._fetch_spec, self._last_revision: %r, %r",
+                self._fetch_spec, self._last_revision)
+        get_search_result = getattr(self._fetch_spec, 'get_search_result', None)
+        if get_search_result is not None:
+            mutter(
+                'resolving fetch_spec into search result: %s', self._fetch_spec)
+            # This is EverythingNotInOther or a similar kind of fetch_spec.
+            # Turn it into a search result.
+            return get_search_result()
+        elif self._fetch_spec is not None:
+            # The fetch spec is already a concrete search result.
             return self._fetch_spec
-        mutter('fetch up to rev {%s}', self._last_revision)
-        if self._last_revision is NULL_REVISION:
+        elif self._last_revision == NULL_REVISION:
+            # fetch_spec is None + last_revision is null => empty fetch.
             # explicit limit of no revisions needed
-            return None
-        return self.to_repository.search_missing_revision_ids(
-            self.from_repository, self._last_revision,
-            find_ghosts=self.find_ghosts)
+            return graph.EmptySearchResult()
+        elif self._last_revision is not None:
+            return graph.NotInOtherForRevs(self.to_repository,
+                self.from_repository, [self._last_revision],
+                find_ghosts=self.find_ghosts).get_search_result()
+        else: # self._last_revision is None:
+            return graph.EverythingNotInOther(self.to_repository,
+                self.from_repository,
+                find_ghosts=self.find_ghosts).get_search_result()
 
 
 class Inter1and2Helper(object):

=== modified file 'bzrlib/graph.py'
--- bzrlib/graph.py	2011-01-10 22:20:12 +0000
+++ bzrlib/graph.py	2011-01-19 00:31:58 +0000
@@ -1536,7 +1536,57 @@
             return revs, ghosts
 
 
-class SearchResult(object):
+class AbstractSearchResult(object):
+
+    def get_recipe(self):
+        """Return a recipe that can be used to replay this search.
+
+        The recipe allows reconstruction of the same results at a later date.
+
+        :return: A tuple of (search_kind_str, *details).  The details vary by
+            kind of search result.
+        """
+        raise NotImplementedError(self.get_recipe)
+
+    def get_network_struct(self):
+        """Return a tuple that can be transmitted via the HPSS protocol."""
+        raise NotImplementedError(self.get_network_struct)
+
+    def get_keys(self):
+        """Return the keys found in this search.
+
+        :return: A set of keys.
+        """
+        raise NotImplementedError(self.get_keys)
+
+    def is_empty(self):
+        """Return false if the search lists 1 or more revisions."""
+        raise NotImplementedError(self.is_empty)
+
+    def refine(self, seen, referenced):
+        """Create a new search by refining this search.
+
+        :param seen: Revisions that have been satisfied.
+        :param referenced: Revision references observed while satisfying some
+            of this search.
+        :return: A search result.
+        """
+        raise NotImplementedError(self.refine)
+
+
+class AbstractSearch(object):
+
+    def get_search_result(self):
+        """Construct a network-ready search result from this search description.
+
+        This may take some time to search repositories, etc.
+
+        :return: A search result.
+        """
+        raise NotImplementedError(self.get_search_result)
+
+
+class SearchResult(AbstractSearchResult):
     """The result of a breadth first search.
 
     A SearchResult provides the ability to reconstruct the search or access a
@@ -1557,6 +1607,19 @@
         self._recipe = ('search', start_keys, exclude_keys, key_count)
         self._keys = frozenset(keys)
 
+    def __repr__(self):
+        kind, start_keys, exclude_keys, key_count = self._recipe
+        if len(start_keys) > 5:
+            start_keys_repr = repr(list(start_keys)[:5])[:-1] + ', ...]'
+        else:
+            start_keys_repr = repr(start_keys)
+        if len(exclude_keys) > 5:
+            exclude_keys_repr = repr(list(exclude_keys)[:5])[:-1] + ', ...]'
+        else:
+            exclude_keys_repr = repr(exclude_keys)
+        return '<%s %s:(%s, %s, %d)>' % (self.__class__.__name__,
+            kind, start_keys_repr, exclude_keys_repr, key_count)
+
     def get_recipe(self):
         """Return a recipe that can be used to replay this search.
 
@@ -1580,6 +1643,12 @@
         """
         return self._recipe
 
+    def get_network_struct(self):
+        start_keys = ' '.join(self._recipe[1])
+        stop_keys = ' '.join(self._recipe[2])
+        count = str(self._recipe[3])
+        return (self._recipe[0], '\n'.join((start_keys, stop_keys, count)))
+
     def get_keys(self):
         """Return the keys found in this search.
 
@@ -1617,7 +1686,7 @@
         return SearchResult(pending_refs, exclude, count, keys)
 
 
-class PendingAncestryResult(object):
+class PendingAncestryResult(AbstractSearchResult):
     """A search result that will reconstruct the ancestry for some graph heads.
 
     Unlike SearchResult, this doesn't hold the complete search result in
@@ -1634,6 +1703,14 @@
         self.heads = frozenset(heads)
         self.repo = repo
 
+    def __repr__(self):
+        if len(self.heads) > 5:
+            heads_repr = repr(list(self.heads)[:5] + ', ...]')
+        else:
+            heads_repr = repr(self.heads)
+        return '<%s heads:%s repo:%r>' % (
+            self.__class__.__name__, heads_repr, self.repo)
+
     def get_recipe(self):
         """Return a recipe that can be used to replay this search.
 
@@ -1647,6 +1724,11 @@
         """
         return ('proxy-search', self.heads, set(), -1)
 
+    def get_network_struct(self):
+        parts = ['ancestry-of']
+        parts.extend(self.heads)
+        return parts
+
     def get_keys(self):
         """See SearchResult.get_keys.
 
@@ -1679,6 +1761,104 @@
         return PendingAncestryResult(referenced - seen, self.repo)
 
 
+class EmptySearchResult(AbstractSearchResult):
+    """An empty search result."""
+
+    def is_empty(self):
+        return True
+    
+
+class EverythingResult(AbstractSearchResult):
+    """A search result that simply requests everything in the repository."""
+
+    def __init__(self, repo):
+        self._repo = repo
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self._repo)
+
+    def get_recipe(self):
+        raise NotImplementedError(self.get_recipe)
+
+    def get_network_struct(self):
+        return ('everything',)
+
+    def get_keys(self):
+        if 'evil' in debug.debug_flags:
+            from bzrlib import remote
+            if isinstance(self._repo, remote.RemoteRepository):
+                # warn developers (not users) not to do this
+                trace.mutter_callsite(
+                    2, "EverythingResult(RemoteRepository).get_keys() is slow.")
+        return self._repo.all_revision_ids()
+
+    def is_empty(self):
+        # It's ok for this to wrongly return False: the worst that can happen
+        # is that RemoteStreamSource will initiate a get_stream on an empty
+        # repository.  And almost all repositories are non-empty.
+        return False
+
+    def refine(self, seen, referenced):
+        heads = set(self._repo.all_revision_ids())
+        heads.difference_update(seen)
+        heads.update(referenced)
+        return PendingAncestryResult(heads, self._repo)
+
+
+class EverythingNotInOther(AbstractSearch):
+    """Find all revisions in that are in one repo but not the other."""
+
+    def __init__(self, to_repo, from_repo, find_ghosts=False):
+        self.to_repo = to_repo
+        self.from_repo = from_repo
+        self.find_ghosts = find_ghosts
+
+    def get_search_result(self):
+        return self.to_repo.search_missing_revision_ids(
+            self.from_repo, find_ghosts=self.find_ghosts)
+
+
+class NotInOtherForRevs(AbstractSearch):
+    """Find all revisions missing in one repo for a some specific heads."""
+
+    def __init__(self, to_repo, from_repo, required_ids, if_present_ids=None,
+            find_ghosts=False):
+        """Constructor.
+
+        :param required_ids: revision IDs of heads that must be found, or else
+            the search will fail with NoSuchRevision.  All revisions in their
+            ancestry not already in the other repository will be included in
+            the search result.
+        :param if_present_ids: revision IDs of heads that may be absent in the
+            source repository.  If present, then their ancestry not already
+            found in other will be included in the search result.
+        """
+        self.to_repo = to_repo
+        self.from_repo = from_repo
+        self.find_ghosts = find_ghosts
+        self.required_ids = required_ids
+        self.if_present_ids = if_present_ids
+
+    def __repr__(self):
+        if len(self.required_ids) > 5:
+            reqd_revs_repr = repr(list(self.required_ids)[:5])[:-1] + ', ...]'
+        else:
+            reqd_revs_repr = repr(self.required_ids)
+        if self.if_present_ids and len(self.if_present_ids) > 5:
+            ifp_revs_repr = repr(list(self.if_present_ids)[:5])[:-1] + ', ...]'
+        else:
+            ifp_revs_repr = repr(self.if_present_ids)
+
+        return "<%s from:%r to:%r find_ghosts:%r req'd:%r if-present:%r>" % (
+            self.__class__.__name__, self.from_repo, self.to_repo,
+            self.find_ghosts, reqd_revs_repr, ifp_revs_repr)
+
+    def get_search_result(self):
+        return self.to_repo.search_missing_revision_ids(
+            self.from_repo, revision_ids=self.required_ids,
+            if_present_ids=self.if_present_ids, find_ghosts=self.find_ghosts)
+
+
 def collapse_linear_regions(parent_map):
     """Collapse regions of the graph that are 'linear'.
 

=== modified file 'bzrlib/plugin.py'
--- bzrlib/plugin.py	2010-06-11 08:02:42 +0000
+++ bzrlib/plugin.py	2011-01-19 00:31:58 +0000
@@ -1,4 +1,4 @@
-# Copyright (C) 2005-2010 Canonical Ltd
+# Copyright (C) 2005-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
@@ -63,6 +63,11 @@
 _plugins_disabled = False
 
 
+plugin_warnings = {}
+# Map from plugin name, to list of string warnings about eg plugin
+# dependencies.
+
+
 def are_plugins_disabled():
     return _plugins_disabled
 
@@ -77,6 +82,40 @@
     load_plugins([])
 
 
+def describe_loaded_plugins(show_paths=False):
+    """Generate text description of loaded plugins.
+
+    :param show_paths: If true,
+    :returns: Iterator of text lines (including newlines.)
+    """
+    from inspect import getdoc
+    unreported_warnings = plugin_warnings.copy()
+    for name, plugin in sorted(plugins().items()):
+        version = plugin.__version__
+        if version == 'unknown':
+            version = ''
+        name_ver = '%s %s' % (name, version)
+        d = getdoc(plugin.module)
+        if d:
+            doc = d.split('\n')[0]
+        else:
+            doc = '(no description)'
+        yield ("%s\n" % name_ver)
+        yield ("   %s\n" % doc)
+        if show_paths:
+            yield ("   %s\n" % plugin.path())
+        if name in unreported_warnings:
+            for line in unreported_warnings[name]:
+                yield "  ** " + line + '\n'
+            del unreported_warnings[name]
+        yield ("\n")
+    for name in sorted(unreported_warnings.keys()):
+        yield "%s (failed to load)\n" % name
+        for line in unreported_warnings[name]:
+            yield "  ** " + line + '\n'
+        yield '\n'
+
+
 def _strip_trailing_sep(path):
     return path.rstrip("\\/")
 
@@ -327,6 +366,11 @@
     return None, None, (None, None, None)
 
 
+def record_plugin_warning(plugin_name, warning_message):
+    trace.mutter(warning_message)
+    plugin_warnings.setdefault(plugin_name, []).append(warning_message)
+
+
 def _load_plugin_module(name, dir):
     """Load plugin name from dir.
 
@@ -340,10 +384,12 @@
     except KeyboardInterrupt:
         raise
     except errors.IncompatibleAPI, e:
-        trace.warning("Unable to load plugin %r. It requested API version "
+        warning_message = (
+            "Unable to load plugin %r. It requested API version "
             "%s of module %s but the minimum exported version is %s, and "
             "the maximum is %s" %
             (name, e.wanted, e.api, e.minimum, e.current))
+        record_plugin_warning(name, warning_message)
     except Exception, e:
         trace.warning("%s" % e)
         if re.search('\.|-| ', name):
@@ -354,7 +400,9 @@
                     "file path isn't a valid module name; try renaming "
                     "it to %r." % (name, dir, sanitised_name))
         else:
-            trace.warning('Unable to load plugin %r from %r' % (name, dir))
+            record_plugin_warning(
+                name,
+                'Unable to load plugin %r from %r' % (name, dir))
         trace.log_exception_quietly()
         if 'error' in debug.debug_flags:
             trace.print_exception(sys.exc_info(), sys.stderr)

=== modified file 'bzrlib/plugins/launchpad/lp_propose.py'
--- bzrlib/plugins/launchpad/lp_propose.py	2010-12-02 10:41:05 +0000
+++ bzrlib/plugins/launchpad/lp_propose.py	2011-01-19 00:31:58 +0000
@@ -14,21 +14,22 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
-
-import webbrowser
-
 from bzrlib import (
     errors,
     hooks,
+    )
+from bzrlib.lazy_import import lazy_import
+lazy_import(globals(), """
+import webbrowser
+
+from bzrlib import (
     msgeditor,
 )
 from bzrlib.plugins.launchpad import (
     lp_api,
     lp_registration,
 )
-from bzrlib.plugins.launchpad.lp_api import canonical_url
-
-from lazr.restfulclient import errors as restful_errors
+""")
 
 
 class ProposeMergeHooks(hooks.Hooks):
@@ -153,7 +154,7 @@
             if mp.target_branch.self_link == self.target_branch.lp.self_link:
                 raise errors.BzrCommandError(
                     'There is already a branch merge proposal: %s' %
-                    canonical_url(mp))
+                    lp_api.canonical_url(mp))
 
     def _get_prerequisite_branch(self):
         hooks = self.hooks['get_prerequisite']
@@ -174,6 +175,7 @@
         :param **kwargs: **kwargs for the call.
         :return: The result of calling call(*args, *kwargs).
         """
+        from lazr.restfulclient import errors as restful_errors
         try:
             return call(*args, **kwargs)
         except restful_errors.HTTPError, e:
@@ -208,7 +210,7 @@
             review_types=review_types)
         if self.approve:
             self.call_webservice(mp.setStatus, status='Approved')
-        webbrowser.open(canonical_url(mp))
+        webbrowser.open(lp_api.canonical_url(mp))
 
 
 def modified_files(old_tree, new_tree):

=== modified file 'bzrlib/remote.py'
--- bzrlib/remote.py	2011-01-10 22:20:12 +0000
+++ bzrlib/remote.py	2011-01-19 00:31:58 +0000
@@ -1348,15 +1348,29 @@
         return result
 
     @needs_read_lock
-    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
+    def search_missing_revision_ids(self, other,
+            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
+            find_ghosts=True, revision_ids=None, if_present_ids=None):
         """Return the revision ids that other has that this does not.
 
         These are returned in topological order.
 
         revision_id: only return revision ids included by revision_id.
         """
-        return repository.InterRepository.get(
-            other, self).search_missing_revision_ids(revision_id, find_ghosts)
+        if symbol_versioning.deprecated_passed(revision_id):
+            symbol_versioning.warn(
+                'search_missing_revision_ids(revision_id=...) was '
+                'deprecated in 2.3.  Use revision_ids=[...] instead.',
+                DeprecationWarning, stacklevel=2)
+            if revision_ids is not None:
+                raise AssertionError(
+                    'revision_ids is mutually exclusive with revision_id')
+            if revision_id is not None:
+                revision_ids = [revision_id]
+        inter_repo = repository.InterRepository.get(other, self)
+        return inter_repo.search_missing_revision_ids(
+            find_ghosts=find_ghosts, revision_ids=revision_ids,
+            if_present_ids=if_present_ids)
 
     def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
             fetch_spec=None):
@@ -1763,12 +1777,7 @@
         return '\n'.join((start_keys, stop_keys, count))
 
     def _serialise_search_result(self, search_result):
-        if isinstance(search_result, graph.PendingAncestryResult):
-            parts = ['ancestry-of']
-            parts.extend(search_result.heads)
-        else:
-            recipe = search_result.get_recipe()
-            parts = [recipe[0], self._serialise_search_recipe(recipe)]
+        parts = search_result.get_network_struct()
         return '\n'.join(parts)
 
     def autopack(self):
@@ -1968,6 +1977,7 @@
         candidate_verbs = [
             ('Repository.get_stream_1.19', (1, 19)),
             ('Repository.get_stream', (1, 13))]
+
         found_verb = False
         for verb, version in candidate_verbs:
             if medium._is_remote_before(version):
@@ -1977,6 +1987,17 @@
                     verb, args, search_bytes)
             except errors.UnknownSmartMethod:
                 medium._remember_remote_is_before(version)
+            except errors.UnknownErrorFromSmartServer, e:
+                if isinstance(search, graph.EverythingResult):
+                    error_verb = e.error_from_smart_server.error_verb
+                    if error_verb == 'BadSearch':
+                        # Pre-2.3 servers don't support this sort of search.
+                        # XXX: perhaps falling back to VFS on BadSearch is a
+                        # good idea in general?  It might provide a little bit
+                        # of protection against client-side bugs.
+                        medium._remember_remote_is_before((2, 3))
+                        break
+                raise
             else:
                 response_tuple, response_handler = response
                 found_verb = True

=== modified file 'bzrlib/repofmt/knitrepo.py'
--- bzrlib/repofmt/knitrepo.py	2010-11-20 21:41:05 +0000
+++ bzrlib/repofmt/knitrepo.py	2011-01-19 00:31:58 +0000
@@ -43,6 +43,7 @@
     RepositoryFormat,
     RootCommitBuilder,
     )
+from bzrlib import symbol_versioning
 
 
 class _KnitParentsProvider(object):
@@ -534,16 +535,23 @@
         return are_knits and InterRepository._same_model(source, target)
 
     @needs_read_lock
-    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
-        """See InterRepository.missing_revision_ids()."""
-        if revision_id is not None:
-            source_ids = self.source.get_ancestry(revision_id)
-            if source_ids[0] is not None:
-                raise AssertionError()
-            source_ids.pop(0)
-        else:
-            source_ids = self.source.all_revision_ids()
-        source_ids_set = set(source_ids)
+    def search_missing_revision_ids(self,
+            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
+            find_ghosts=True, revision_ids=None, if_present_ids=None):
+        """See InterRepository.search_missing_revision_ids()."""
+        if symbol_versioning.deprecated_passed(revision_id):
+            symbol_versioning.warn(
+                'search_missing_revision_ids(revision_id=...) was '
+                'deprecated in 2.3.  Use revision_ids=[...] instead.',
+                DeprecationWarning, stacklevel=2)
+            if revision_ids is not None:
+                raise AssertionError(
+                    'revision_ids is mutually exclusive with revision_id')
+            if revision_id is not None:
+                revision_ids = [revision_id]
+        del revision_id
+        source_ids_set = self._present_source_revisions_for(
+            revision_ids, if_present_ids)
         # source_ids is the worst possible case we may need to pull.
         # now we want to filter source_ids against what we actually
         # have in target, but don't try to check for existence where we know
@@ -553,7 +561,7 @@
         actually_present_revisions = set(
             self.target._eliminate_revisions_not_present(possibly_present_revisions))
         required_revisions = source_ids_set.difference(actually_present_revisions)
-        if revision_id is not None:
+        if revision_ids is not None:
             # we used get_ancestry to determine source_ids then we are assured all
             # revisions referenced are present as they are installed in topological order.
             # and the tip revision was validated by get_ancestry.

=== modified file 'bzrlib/repofmt/weaverepo.py'
--- bzrlib/repofmt/weaverepo.py	2011-01-13 00:41:19 +0000
+++ bzrlib/repofmt/weaverepo.py	2011-01-19 00:31:58 +0000
@@ -40,6 +40,7 @@
     lockable_files,
     lockdir,
     osutils,
+    symbol_versioning,
     trace,
     tuned_gzip,
     urlutils,
@@ -488,6 +489,7 @@
     _versionedfile_class = weave.WeaveFile
     supports_ghosts = False
     supports_chks = False
+    supports_funky_characters = False
 
     _fetch_order = 'topological'
     _fetch_reconcile = True
@@ -806,8 +808,10 @@
             self.target.fetch(self.source, revision_id=revision_id)
 
     @needs_read_lock
-    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
-        """See InterRepository.missing_revision_ids()."""
+    def search_missing_revision_ids(self,
+            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
+            find_ghosts=True, revision_ids=None, if_present_ids=None):
+        """See InterRepository.search_missing_revision_ids()."""
         # we want all revisions to satisfy revision_id in source.
         # but we don't want to stat every file here and there.
         # we want then, all revisions other needs to satisfy revision_id
@@ -819,14 +823,19 @@
         # disk format scales terribly for push anyway due to rewriting
         # inventory.weave, this is considered acceptable.
         # - RBC 20060209
-        if revision_id is not None:
-            source_ids = self.source.get_ancestry(revision_id)
-            if source_ids[0] is not None:
-                raise AssertionError()
-            source_ids.pop(0)
-        else:
-            source_ids = self.source._all_possible_ids()
-        source_ids_set = set(source_ids)
+        if symbol_versioning.deprecated_passed(revision_id):
+            symbol_versioning.warn(
+                'search_missing_revision_ids(revision_id=...) was '
+                'deprecated in 2.3.  Use revision_ids=[...] instead.',
+                DeprecationWarning, stacklevel=2)
+            if revision_ids is not None:
+                raise AssertionError(
+                    'revision_ids is mutually exclusive with revision_id')
+            if revision_id is not None:
+                revision_ids = [revision_id]
+        del revision_id
+        source_ids_set = self._present_source_revisions_for(
+            revision_ids, if_present_ids)
         # source_ids is the worst possible case we may need to pull.
         # now we want to filter source_ids against what we actually
         # have in target, but don't try to check for existence where we know
@@ -836,7 +845,7 @@
         actually_present_revisions = set(
             self.target._eliminate_revisions_not_present(possibly_present_revisions))
         required_revisions = source_ids_set.difference(actually_present_revisions)
-        if revision_id is not None:
+        if revision_ids is not None:
             # we used get_ancestry to determine source_ids then we are assured all
             # revisions referenced are present as they are installed in topological order.
             # and the tip revision was validated by get_ancestry.

=== modified file 'bzrlib/repository.py'
--- bzrlib/repository.py	2011-01-13 00:41:19 +0000
+++ bzrlib/repository.py	2011-01-19 00:31:58 +0000
@@ -42,7 +42,6 @@
     pyutils,
     revision as _mod_revision,
     static_tuple,
-    symbol_versioning,
     trace,
     tsort,
     versionedfile,
@@ -57,6 +56,7 @@
 from bzrlib import (
     errors,
     registry,
+    symbol_versioning,
     ui,
     )
 from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
@@ -1597,15 +1597,28 @@
         return ret
 
     @needs_read_lock
-    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
+    def search_missing_revision_ids(self, other,
+            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
+            find_ghosts=True, revision_ids=None, if_present_ids=None):
         """Return the revision ids that other has that this does not.
 
         These are returned in topological order.
 
         revision_id: only return revision ids included by revision_id.
         """
+        if symbol_versioning.deprecated_passed(revision_id):
+            symbol_versioning.warn(
+                'search_missing_revision_ids(revision_id=...) was '
+                'deprecated in 2.3.  Use revision_ids=[...] instead.',
+                DeprecationWarning, stacklevel=3)
+            if revision_ids is not None:
+                raise AssertionError(
+                    'revision_ids is mutually exclusive with revision_id')
+            if revision_id is not None:
+                revision_ids = [revision_id]
         return InterRepository.get(other, self).search_missing_revision_ids(
-            revision_id, find_ghosts)
+            find_ghosts=find_ghosts, revision_ids=revision_ids,
+            if_present_ids=if_present_ids)
 
     @staticmethod
     def open(base):
@@ -3436,7 +3449,7 @@
                                fetch_spec=fetch_spec,
                                find_ghosts=find_ghosts)
 
-    def _walk_to_common_revisions(self, revision_ids):
+    def _walk_to_common_revisions(self, revision_ids, if_present_ids=None):
         """Walk out from revision_ids in source to revisions target has.
 
         :param revision_ids: The start point for the search.
@@ -3444,10 +3457,14 @@
         """
         target_graph = self.target.get_graph()
         revision_ids = frozenset(revision_ids)
+        if if_present_ids:
+            all_wanted_revs = revision_ids.union(if_present_ids)
+        else:
+            all_wanted_revs = revision_ids
         missing_revs = set()
         source_graph = self.source.get_graph()
         # ensure we don't pay silly lookup costs.
-        searcher = source_graph._make_breadth_first_searcher(revision_ids)
+        searcher = source_graph._make_breadth_first_searcher(all_wanted_revs)
         null_set = frozenset([_mod_revision.NULL_REVISION])
         searcher_exhausted = False
         while True:
@@ -3489,30 +3506,79 @@
         return searcher.get_result()
 
     @needs_read_lock
-    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
+    def search_missing_revision_ids(self,
+            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
+            find_ghosts=True, revision_ids=None, if_present_ids=None):
         """Return the revision ids that source has that target does not.
 
         :param revision_id: only return revision ids included by this
-                            revision_id.
+            revision_id.
+        :param revision_ids: return revision ids included by these
+            revision_ids.  NoSuchRevision will be raised if any of these
+            revisions are not present.
+        :param if_present_ids: like revision_ids, but will not cause
+            NoSuchRevision if any of these are absent, instead they will simply
+            not be in the result.  This is useful for e.g. finding revisions
+            to fetch for tags, which may reference absent revisions.
         :param find_ghosts: If True find missing revisions in deep history
             rather than just finding the surface difference.
         :return: A bzrlib.graph.SearchResult.
         """
+        if symbol_versioning.deprecated_passed(revision_id):
+            symbol_versioning.warn(
+                'search_missing_revision_ids(revision_id=...) was '
+                'deprecated in 2.3.  Use revision_ids=[...] instead.',
+                DeprecationWarning, stacklevel=2)
+            if revision_ids is not None:
+                raise AssertionError(
+                    'revision_ids is mutually exclusive with revision_id')
+            if revision_id is not None:
+                revision_ids = [revision_id]
+        del revision_id
         # stop searching at found target revisions.
-        if not find_ghosts and revision_id is not None:
-            return self._walk_to_common_revisions([revision_id])
+        if not find_ghosts and (revision_ids is not None or if_present_ids is
+                not None):
+            return self._walk_to_common_revisions(revision_ids,
+                    if_present_ids=if_present_ids)
         # generic, possibly worst case, slow code path.
         target_ids = set(self.target.all_revision_ids())
-        if revision_id is not None:
-            source_ids = self.source.get_ancestry(revision_id)
-            if source_ids[0] is not None:
-                raise AssertionError()
-            source_ids.pop(0)
-        else:
-            source_ids = self.source.all_revision_ids()
+        source_ids = self._present_source_revisions_for(
+            revision_ids, if_present_ids)
         result_set = set(source_ids).difference(target_ids)
         return self.source.revision_ids_to_search_result(result_set)
 
+    def _present_source_revisions_for(self, revision_ids, if_present_ids=None):
+        """Returns set of all revisions in ancestry of revision_ids present in
+        the source repo.
+
+        :param revision_ids: if None, all revisions in source are returned.
+        :param if_present_ids: like revision_ids, but if any/all of these are
+            absent no error is raised.
+        """
+        if revision_ids is not None or if_present_ids is not None:
+            # First, ensure all specified revisions exist.  Callers expect
+            # NoSuchRevision when they pass absent revision_ids here.
+            if revision_ids is None:
+                revision_ids = set()
+            if if_present_ids is None:
+                if_present_ids = set()
+            revision_ids = set(revision_ids)
+            if_present_ids = set(if_present_ids)
+            all_wanted_ids = revision_ids.union(if_present_ids)
+            graph = self.source.get_graph()
+            present_revs = set(graph.get_parent_map(all_wanted_ids))
+            missing = revision_ids.difference(present_revs)
+            if missing:
+                raise errors.NoSuchRevision(self.source, missing.pop())
+            found_ids = all_wanted_ids.intersection(present_revs)
+            source_ids = [rev_id for (rev_id, parents) in
+                          graph.iter_ancestry(found_ids)
+                          if rev_id != _mod_revision.NULL_REVISION
+                          and parents is not None]
+        else:
+            source_ids = self.source.all_revision_ids()
+        return set(source_ids)
+
     @staticmethod
     def _same_model(source, target):
         """True if source and target have the same data representation.
@@ -3836,7 +3902,13 @@
             fetch_spec=None):
         """See InterRepository.fetch()."""
         if fetch_spec is not None:
-            raise AssertionError("Not implemented yet...")
+            if (isinstance(fetch_spec, graph.NotInOtherForRevs) and
+                    len(fetch_spec.required_ids) == 1 and not
+                    fetch_spec.if_present_ids):
+                revision_id = list(fetch_spec.required_ids)[0]
+                del fetch_spec
+            else:
+                raise AssertionError("Not implemented yet...")
         ui.ui_factory.warn_experimental_format_fetch(self)
         if (not self.source.supports_rich_root()
             and self.target.supports_rich_root()):
@@ -3849,8 +3921,12 @@
             ui.ui_factory.show_user_warning('cross_format_fetch',
                 from_format=self.source._format,
                 to_format=self.target._format)
+        if revision_id:
+            search_revision_ids = [revision_id]
+        else:
+            search_revision_ids = None
         revision_ids = self.target.search_missing_revision_ids(self.source,
-            revision_id, find_ghosts=find_ghosts).get_keys()
+            revision_ids=search_revision_ids, find_ghosts=find_ghosts).get_keys()
         if not revision_ids:
             return 0, 0
         revision_ids = tsort.topo_sort(

=== modified file 'bzrlib/smart/repository.py'
--- bzrlib/smart/repository.py	2010-11-16 06:06:11 +0000
+++ bzrlib/smart/repository.py	2011-01-19 00:31:58 +0000
@@ -81,6 +81,8 @@
             recreate_search trusts that clients will look for missing things
             they expected and get it from elsewhere.
         """
+        if search_bytes == 'everything':
+            return graph.EverythingResult(repository), None
         lines = search_bytes.split('\n')
         if lines[0] == 'ancestry-of':
             heads = lines[1:]
@@ -412,6 +414,13 @@
     def do_repository_request(self, repository, to_network_name):
         """Get a stream for inserting into a to_format repository.
 
+        The request body is 'search_bytes', a description of the revisions
+        being requested.
+
+        In 2.3 this verb added support for search_bytes == 'everything'.  Older
+        implementations will respond with a BadSearch error, and clients should
+        catch this and fallback appropriately.
+
         :param repository: The repository to stream from.
         :param to_network_name: The network name of the format of the target
             repository.
@@ -489,6 +498,13 @@
 
 
 class SmartServerRepositoryGetStream_1_19(SmartServerRepositoryGetStream):
+    """The same as Repository.get_stream, but will return stream CHK formats to
+    clients.
+
+    See SmartServerRepositoryGetStream._should_fake_unknown.
+    
+    New in 1.19.
+    """
 
     def _should_fake_unknown(self):
         """Returns False; we don't need to workaround bugs in 1.19+ clients."""

=== modified file 'bzrlib/smart/server.py'
--- bzrlib/smart/server.py	2010-07-01 15:25:41 +0000
+++ bzrlib/smart/server.py	2011-01-19 00:31:58 +0000
@@ -18,7 +18,6 @@
 
 import errno
 import os.path
-import select
 import socket
 import sys
 import threading
@@ -27,7 +26,6 @@
 from bzrlib import (
     errors,
     trace,
-    transport,
 )
 from bzrlib.lazy_import import lazy_import
 lazy_import(globals(), """
@@ -178,7 +176,7 @@
 
     def get_url(self):
         """Return the url of the server"""
-        return "bzr://%s:%d/" % self._sockname
+        return "bzr://%s:%s/" % (self._sockname[0], self._sockname[1])
 
     def serve_conn(self, conn, thread_name_suffix):
         # For WIN32, where the timeout value from the listening socket

=== modified file 'bzrlib/tests/blackbox/test_serve.py'
--- bzrlib/tests/blackbox/test_serve.py	2011-01-10 22:20:12 +0000
+++ bzrlib/tests/blackbox/test_serve.py	2011-01-19 00:31:58 +0000
@@ -18,16 +18,12 @@
 """Tests of the bzr serve command."""
 
 import os
-import os.path
 import signal
-import subprocess
-import sys
 import thread
 import threading
 
 from bzrlib import (
     builtins,
-    debug,
     errors,
     osutils,
     revision as _mod_revision,
@@ -37,11 +33,13 @@
 from bzrlib.branch import Branch
 from bzrlib.bzrdir import BzrDir
 from bzrlib.smart import client, medium
-from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
+from bzrlib.smart.server import (
+    BzrServerFactory,
+    SmartTCPServer,
+    )
 from bzrlib.tests import (
     TestCaseWithMemoryTransport,
     TestCaseWithTransport,
-    TestSkipped,
     )
 from bzrlib.trace import mutter
 from bzrlib.transport import remote
@@ -53,9 +51,9 @@
                                 *func_args, **func_kwargs):
         """Run 'bzr serve', and run the given func in a thread once the server
         has started.
-        
+
         When 'func' terminates, the server will be terminated too.
-        
+
         Returns stdout and stderr.
         """
         # install hook
@@ -164,7 +162,7 @@
         url = 'bzr://localhost:%d/' % port
         self.permit_url(url)
         return process, url
-    
+
     def test_bzr_serve_quiet(self):
         self.make_branch('.')
         args = ['--port', 'localhost:0', '--quiet']
@@ -334,4 +332,3 @@
         self.assertEqual(base_url, self.bzr_serve_transport.base)
         self.assertEqual(base_dir,
             server_maker.get_base_path(self.bzr_serve_transport))
-

=== modified file 'bzrlib/tests/per_branch/test_push.py'
--- bzrlib/tests/per_branch/test_push.py	2011-01-13 01:02:53 +0000
+++ bzrlib/tests/per_branch/test_push.py	2011-01-19 00:31:58 +0000
@@ -170,6 +170,21 @@
         self.assertEqual(tree.branch.last_revision(),
                          to_branch.last_revision())
 
+    def test_push_overwrite_with_older_mainline_rev(self):
+        """Pushing an older mainline revision with overwrite.
+
+        This was <https://bugs.launchpad.net/bzr/+bug/386576>.
+        """
+        source = self.make_branch_and_tree('source')
+        target = self.make_branch('target')
+
+        source.commit('1st commit')
+        source.commit('2nd commit', rev_id='rev-2')
+        source.commit('3rd commit')
+        source.branch.push(target)
+        source.branch.push(target, stop_revision='rev-2', overwrite=True)
+        self.assertEqual('rev-2', target.last_revision())
+
     def test_push_overwrite_of_non_tip_with_stop_revision(self):
         """Combining the stop_revision and overwrite options works.
 

=== modified file 'bzrlib/tests/per_interrepository/test_interrepository.py'
--- bzrlib/tests/per_interrepository/test_interrepository.py	2011-01-13 00:41:19 +0000
+++ bzrlib/tests/per_interrepository/test_interrepository.py	2011-01-19 00:31:58 +0000
@@ -131,9 +131,15 @@
         self.assertFalse(repo_b.has_revision('pizza'))
         # Asking specifically for an absent revision errors.
         self.assertRaises(errors.NoSuchRevision,
-            repo_b.search_missing_revision_ids, repo_a, revision_id='pizza',
+            repo_b.search_missing_revision_ids, repo_a, revision_ids=['pizza'],
             find_ghosts=True)
         self.assertRaises(errors.NoSuchRevision,
+            repo_b.search_missing_revision_ids, repo_a, revision_ids=['pizza'],
+            find_ghosts=False)
+        self.callDeprecated(
+            ['search_missing_revision_ids(revision_id=...) was deprecated in '
+             '2.3.  Use revision_ids=[...] instead.'],
+            self.assertRaises, errors.NoSuchRevision,
             repo_b.search_missing_revision_ids, repo_a, revision_id='pizza',
             find_ghosts=False)
 
@@ -143,7 +149,8 @@
         # make a repository to compare against that is empty
         repo_b = self.make_to_repository('empty')
         repo_a = self.bzrdir.open_repository()
-        result = repo_b.search_missing_revision_ids(repo_a, revision_id='rev1')
+        result = repo_b.search_missing_revision_ids(
+            repo_a, revision_ids=['rev1'])
         self.assertEqual(set(['rev1']), result.get_keys())
         self.assertEqual(('search', set(['rev1']), set([NULL_REVISION]), 1),
             result.get_recipe())

=== modified file 'bzrlib/tests/per_repository_reference/test_fetch.py'
--- bzrlib/tests/per_repository_reference/test_fetch.py	2009-06-01 18:13:46 +0000
+++ bzrlib/tests/per_repository_reference/test_fetch.py	2011-01-19 00:31:58 +0000
@@ -18,6 +18,7 @@
 from bzrlib import (
     branch,
     errors,
+    graph,
     )
 from bzrlib.smart import (
     server,
@@ -25,7 +26,7 @@
 from bzrlib.tests.per_repository import TestCaseWithRepository
 
 
-class TestFetch(TestCaseWithRepository):
+class TestFetchBase(TestCaseWithRepository):
 
     def make_source_branch(self):
         # It would be nice if there was a way to force this to be memory-only
@@ -51,6 +52,9 @@
         self.addCleanup(source_b.unlock)
         return content, source_b
 
+
+class TestFetch(TestFetchBase):
+
     def test_sprout_from_stacked_with_short_history(self):
         content, source_b = self.make_source_branch()
         # Split the generated content into a base branch, and a stacked branch
@@ -149,3 +153,38 @@
         source_b.lock_read()
         self.addCleanup(source_b.unlock)
         stacked.pull(source_b, stop_revision='B-id')
+
+
+class TestFetchFromRepoWithUnconfiguredFallbacks(TestFetchBase):
+
+    def make_stacked_source_repo(self):
+        _, source_b = self.make_source_branch()
+        # Use 'make_branch' which gives us a bzr:// branch when appropriate,
+        # rather than creating a branch-on-disk
+        stack_b = self.make_branch('stack-on')
+        stack_b.pull(source_b, stop_revision='B-id')
+        stacked_b = self.make_branch('stacked')
+        stacked_b.set_stacked_on_url('../stack-on')
+        stacked_b.pull(source_b, stop_revision='C-id')
+        return stacked_b.repository
+
+    def test_fetch_everything_includes_parent_invs(self):
+        stacked = self.make_stacked_source_repo()
+        repo_missing_fallbacks = stacked.bzrdir.open_repository()
+        self.addCleanup(repo_missing_fallbacks.lock_read().unlock)
+        target = self.make_repository('target')
+        self.addCleanup(target.lock_write().unlock)
+        target.fetch(
+            repo_missing_fallbacks,
+            fetch_spec=graph.EverythingResult(repo_missing_fallbacks))
+        self.assertEqual(repo_missing_fallbacks.revisions.keys(),
+            target.revisions.keys())
+        self.assertEqual(repo_missing_fallbacks.inventories.keys(),
+            target.inventories.keys())
+        self.assertEqual(['C-id'],
+            sorted(k[-1] for k in target.revisions.keys()))
+        self.assertEqual(['B-id', 'C-id'],
+            sorted(k[-1] for k in target.inventories.keys()))
+
+
+

=== modified file 'bzrlib/tests/test_crash.py'
--- bzrlib/tests/test_crash.py	2011-01-12 01:01:53 +0000
+++ bzrlib/tests/test_crash.py	2011-01-19 00:31:58 +0000
@@ -26,6 +26,7 @@
     config,
     crash,
     osutils,
+    plugin,
     tests,
     )
 
@@ -42,6 +43,11 @@
         self.overrideEnv('APPORT_CRASH_DIR', crash_dir)
         self.assertEquals(crash_dir, config.crash_dir())
 
+        self.overrideAttr(
+            plugin,
+            'plugin_warnings',
+            {'example': ['Failed to load plugin foo']})
+
         stderr = StringIO()
 
         try:
@@ -71,3 +77,6 @@
         self.assertContainsRe(report, 'test_apport_report')
         # should also be in there
         self.assertContainsRe(report, '(?m)^CommandLine:')
+        self.assertContainsRe(
+            report,
+            'Failed to load plugin foo')

=== modified file 'bzrlib/tests/test_plugins.py'
--- bzrlib/tests/test_plugins.py	2011-01-10 22:20:12 +0000
+++ bzrlib/tests/test_plugins.py	2011-01-19 00:31:58 +0000
@@ -267,8 +267,14 @@
             stream.close()
 
     def test_plugin_with_bad_api_version_reports(self):
-        # This plugin asks for bzrlib api version 1.0.0, which is not supported
-        # anymore.
+        """Try loading a plugin that requests an unsupported api.
+        
+        Up to bzr 2.2, the plugin just didn't load.  But now we prefer to let
+        it load, and record a warning that can be shown in error messages.
+
+        See https://bugs.launchpad.net/bzr/+bug/704195
+        """
+        self.overrideAttr(plugin, 'plugin_warnings', {})
         name = 'wants100.py'
         f = file(name, 'w')
         try:
@@ -276,9 +282,14 @@
                 "bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
         finally:
             f.close()
-
         log = self.load_and_capture(name)
-        self.assertContainsRe(log,
+        self.assertNotContainsRe(log,
+            r"It requested API version")
+        self.assertEquals(
+            ['wants100'],
+            plugin.plugin_warnings.keys())
+        self.assertContainsRe(
+            plugin.plugin_warnings['wants100'][0],
             r"It requested API version")
 
     def test_plugin_with_bad_name_does_not_load(self):
@@ -847,6 +858,9 @@
         self.create_plugin_package('test_foo', dir='standard/test_foo')
         # All the tests will load the 'test_foo' plugin from various locations
         self.addCleanup(self._unregister_plugin, 'test_foo')
+        # Unfortunately there's global cached state for the specific
+        # registered paths.
+        self.addCleanup(plugin.PluginImporter.reset)
 
     def assertTestFooLoadedFrom(self, path):
         self.assertPluginKnown('test_foo')

=== modified file 'bzrlib/tests/test_remote.py'
--- bzrlib/tests/test_remote.py	2011-01-12 01:01:53 +0000
+++ bzrlib/tests/test_remote.py	2011-01-19 00:31:58 +0000
@@ -57,9 +57,12 @@
     )
 from bzrlib.repofmt import groupcompress_repo, pack_repo
 from bzrlib.revision import NULL_REVISION
-from bzrlib.smart import medium
+from bzrlib.smart import medium, request
 from bzrlib.smart.client import _SmartClient
-from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
+from bzrlib.smart.repository import (
+    SmartServerRepositoryGetParentMap,
+    SmartServerRepositoryGetStream_1_19,
+    )
 from bzrlib.tests import (
     test_server,
     )
@@ -3180,11 +3183,63 @@
 
     def test_copy_content_into_avoids_revision_history(self):
         local = self.make_branch('local')
-        remote_backing_tree = self.make_branch_and_tree('remote')
-        remote_backing_tree.commit("Commit.")
+        builder = self.make_branch_builder('remote')
+        builder.build_commit(message="Commit.")
         remote_branch_url = self.smart_server.get_url() + 'remote'
         remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
         local.repository.fetch(remote_branch.repository)
         self.hpss_calls = []
         remote_branch.copy_content_into(local)
         self.assertFalse('Branch.revision_history' in self.hpss_calls)
+
+    def test_fetch_everything_needs_just_one_call(self):
+        local = self.make_branch('local')
+        builder = self.make_branch_builder('remote')
+        builder.build_commit(message="Commit.")
+        remote_branch_url = self.smart_server.get_url() + 'remote'
+        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
+        self.hpss_calls = []
+        local.repository.fetch(remote_branch.repository,
+                fetch_spec=graph.EverythingResult(remote_branch.repository))
+        self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
+
+    def override_verb(self, verb_name, verb):
+        request_handlers = request.request_handlers
+        orig_verb = request_handlers.get(verb_name)
+        request_handlers.register(verb_name, verb, override_existing=True)
+        self.addCleanup(request_handlers.register, verb_name, orig_verb,
+                override_existing=True)
+
+    def test_fetch_everything_backwards_compat(self):
+        """Can fetch with EverythingResult even with pre 2.3 servers.
+        
+        Pre-2.3 do not support 'everything' searches with the
+        Repository.get_stream_1.19 verb.
+        """
+        verb_log = []
+        class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
+            """A version of the Repository.get_stream_1.19 verb patched to
+            reject 'everything' searches the way 2.2 and earlier do.
+            """
+            def recreate_search(self, repository, search_bytes, discard_excess=False):
+                verb_log.append(search_bytes.split('\n', 1)[0])
+                if search_bytes == 'everything':
+                    return (None, request.FailedSmartServerResponse(('BadSearch',)))
+                return super(OldGetStreamVerb,
+                        self).recreate_search(repository, search_bytes,
+                            discard_excess=discard_excess)
+        self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
+        local = self.make_branch('local')
+        builder = self.make_branch_builder('remote')
+        builder.build_commit(message="Commit.")
+        remote_branch_url = self.smart_server.get_url() + 'remote'
+        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
+        self.hpss_calls = []
+        local.repository.fetch(remote_branch.repository,
+                fetch_spec=graph.EverythingResult(remote_branch.repository))
+        # make sure the overridden verb was used
+        self.assertLength(1, verb_log)
+        # more than one HPSS call is needed, but because it's a VFS callback
+        # its hard to predict exactly how many.
+        self.assertTrue(len(self.hpss_calls) > 1)
+

=== modified file 'bzrlib/tests/test_repository.py'
--- bzrlib/tests/test_repository.py	2010-11-22 22:27:58 +0000
+++ bzrlib/tests/test_repository.py	2011-01-19 00:31:58 +0000
@@ -1659,7 +1659,7 @@
         self.orig_pack = target.pack
         target.pack = self.log_pack
         search = target.search_missing_revision_ids(
-            source_tree.branch.repository, tip)
+            source_tree.branch.repository, revision_ids=[tip])
         stream = source.get_stream(search)
         from_format = source_tree.branch.repository._format
         sink = target._get_sink()

=== modified file 'bzrlib/tests/test_server.py'
--- bzrlib/tests/test_server.py	2011-01-12 01:01:53 +0000
+++ bzrlib/tests/test_server.py	2011-01-19 00:31:58 +0000
@@ -694,8 +694,6 @@
         server.SmartTCPServer.__init__(self, backing_transport,
                                        root_client_path)
     def serve(self):
-        # FIXME: No test are exercising the hooks for the test server
-        # -- vila 20100618
         self.run_server_started_hooks()
         try:
             TestingThreadingTCPServer.serve(self)
@@ -803,7 +801,3 @@
         """Get a backing transport from a server we are decorating."""
         url = 'readonly+' + backing_transport_server.get_url()
         return transport.get_transport(url)
-
-
-
-

=== modified file 'bzrlib/tests/test_smart.py'
--- bzrlib/tests/test_smart.py	2011-01-12 01:01:53 +0000
+++ bzrlib/tests/test_smart.py	2011-01-19 00:31:58 +0000
@@ -41,6 +41,7 @@
     repository as smart_repo,
     packrepository as smart_packrepo,
     request as smart_req,
+    server,
     vfs,
     )
 from bzrlib.tests import test_server
@@ -1469,7 +1470,7 @@
             request.execute('stacked', 1, (3, r3)))
 
 
-class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
+class GetStreamTestBase(tests.TestCaseWithMemoryTransport):
 
     def make_two_commit_repo(self):
         tree = self.make_branch_and_memory_tree('.')
@@ -1481,6 +1482,9 @@
         repo = tree.branch.repository
         return repo, r1, r2
 
+
+class TestSmartServerRepositoryGetStream(GetStreamTestBase):
+
     def test_ancestry_of(self):
         """The search argument may be a 'ancestry-of' some heads'."""
         backing = self.get_transport()
@@ -1507,6 +1511,18 @@
         stream_bytes = ''.join(response.body_stream)
         self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
 
+    def test_search_everything(self):
+        """A search of 'everything' returns a stream."""
+        backing = self.get_transport()
+        request = smart_repo.SmartServerRepositoryGetStream_1_19(backing)
+        repo, r1, r2 = self.make_two_commit_repo()
+        serialised_fetch_spec = 'everything'
+        request.execute('', repo._format.network_name())
+        response = request.do_body(serialised_fetch_spec)
+        self.assertEqual(('ok',), response.args)
+        stream_bytes = ''.join(response.body_stream)
+        self.assertStartsWith(stream_bytes, 'Bazaar pack format 1')
+
 
 class TestSmartServerRequestHasRevision(tests.TestCaseWithMemoryTransport):
 
@@ -1906,6 +1922,8 @@
             smart_repo.SmartServerRepositoryGetRevisionGraph)
         self.assertHandlerEqual('Repository.get_stream',
             smart_repo.SmartServerRepositoryGetStream)
+        self.assertHandlerEqual('Repository.get_stream_1.19',
+            smart_repo.SmartServerRepositoryGetStream_1_19)
         self.assertHandlerEqual('Repository.has_revision',
             smart_repo.SmartServerRequestHasRevision)
         self.assertHandlerEqual('Repository.insert_stream',
@@ -1922,3 +1940,50 @@
             smart_repo.SmartServerRepositoryUnlock)
         self.assertHandlerEqual('Transport.is_readonly',
             smart_req.SmartServerIsReadonly)
+
+
+class SmartTCPServerHookTests(tests.TestCaseWithMemoryTransport):
+    """Tests for SmartTCPServer hooks."""
+
+    def setUp(self):
+        super(SmartTCPServerHookTests, self).setUp()
+        self.server = server.SmartTCPServer(self.get_transport())
+
+    def test_run_server_started_hooks(self):
+        """Test the server started hooks get fired properly."""
+        started_calls = []
+        server.SmartTCPServer.hooks.install_named_hook('server_started',
+            lambda backing_urls, url: started_calls.append((backing_urls, url)),
+            None)
+        started_ex_calls = []
+        server.SmartTCPServer.hooks.install_named_hook('server_started_ex',
+            lambda backing_urls, url: started_ex_calls.append((backing_urls, url)),
+            None)
+        self.server._sockname = ('example.com', 42)
+        self.server.run_server_started_hooks()
+        self.assertEquals(started_calls,
+            [([self.get_transport().base], 'bzr://example.com:42/')])
+        self.assertEquals(started_ex_calls,
+            [([self.get_transport().base], self.server)])
+
+    def test_run_server_started_hooks_ipv6(self):
+        """Test that socknames can contain 4-tuples."""
+        self.server._sockname = ('::', 42, 0, 0)
+        started_calls = []
+        server.SmartTCPServer.hooks.install_named_hook('server_started',
+            lambda backing_urls, url: started_calls.append((backing_urls, url)),
+            None)
+        self.server.run_server_started_hooks()
+        self.assertEquals(started_calls,
+                [([self.get_transport().base], 'bzr://:::42/')])
+
+    def test_run_server_stopped_hooks(self):
+        """Test the server stopped hooks."""
+        self.server._sockname = ('example.com', 42)
+        stopped_calls = []
+        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
+            lambda backing_urls, url: stopped_calls.append((backing_urls, url)),
+            None)
+        self.server.run_server_stopped_hooks()
+        self.assertEquals(stopped_calls,
+            [([self.get_transport().base], 'bzr://example.com:42/')])

=== added file 'doc/developers/fetch.txt'
--- doc/developers/fetch.txt	1970-01-01 00:00:00 +0000
+++ doc/developers/fetch.txt	2011-01-19 00:31:58 +0000
@@ -0,0 +1,86 @@
+=============
+Fetching data
+=============
+
+Overview of a fetch
+===================
+
+Inside bzr, a typical fetch happens like this:
+
+* a user runs a command like ``bzr branch`` or ``bzr pull``
+
+* ``Repository.fetch`` is called (by a higher-level method such as
+  ``ControlDir.sprout``, ``Branch.fetch``, etc).
+
+* An ``InterRepository`` object is created.  The exact implementation of
+  ``InterRepository`` chosen depends on the format/capabilities of the
+  source and target repos.
+
+* The source and target repositories are compared to determine which data
+  needs to be transferred.
+
+* The repository data is copied.  Often this is done by creating a
+  ``StreamSource`` and ``StreamSink`` from the source and target
+  repositories and feeding the stream from the source into the sink, but
+  some ``InterRepository`` implementations do differently.
+
+
+How objects to be transferred are determined
+============================================
+
+See ``InterRepository._walk_to_common_revisions``.  The basic idea is to
+do a breadth-first search in the source repository's revision graph
+(starting from the head or heads the caller asked for), and look in the
+target repository to see if those revisions are already present.
+Eventually this will find the common ancestors in both graphs, and thus
+the set of revisions to be copied has been identified.
+
+All inventories for the copied revisions need to be present (and all
+parent inventories at the stacking boundary too, to support stacking).
+
+All texts versions introduced by those inventories need to be transferred
+(but see also stacking constraints).
+
+Fetch specs
+===========
+
+The most ``fetch`` methods accept a ``fetch_spec`` parameter.  This is how
+the caller controls what is fetched: e.g. all revisions for a given head
+(that aren't already present in the target), the full ancestry for one or
+more heads, or even the full contents of the source repository.
+
+The ``fetch_spec`` parameter is an object that implements the interface
+defined by ``AbstractSearchResult`` in ``bzrlib.graph``.  It describes
+which keys should be fetched.  Current implementations are
+``SearchResult``, ``PendingAncestryResult``, ``EmptySearchResult``, and
+``EverythingResult``.  Some have options controlling if missing revisions
+cause errors or not, etc.
+
+There are also some “search” objects, which can be used to conveniently
+construct a search result for common cases: ``EverythingNotInOther`` and
+``NotInOtherForRevs``.  They provide an ``execute`` method that performs
+the search and returns a search result.
+
+Also, ``Graph._make_breadth_first_searcher`` returns an object with a
+``get_result`` method that returns a search result.
+
+
+Streams
+=======
+
+A **stream** is an iterable of (substream type, substream) pairs.
+The **substream type** is a ``str`` that will be one of ``texts``,
+``inventories``, ``inventory-deltas``, ``chk_bytes``, ``revisions`` or
+``signatures``.  A **substream** is a record stream.  The format of those
+records depends on the repository format being streamed, except for
+``inventory-deltas`` records which are format-independent.
+
+A stream source can be constructed with ``repo._get_source(to_format)``,
+and it provides a ``get_stream(search)`` method (among others).  A stream
+sink can be constructed with ``repo._get_sink()``, and provides an
+``insert_stream(stream, src_format, resume_tokens)`` method (among
+others).
+
+
+..
+   vim: ft=rst tw=74 ai

=== modified file 'doc/developers/index.txt'
--- doc/developers/index.txt	2010-10-13 04:13:48 +0000
+++ doc/developers/index.txt	2011-01-19 00:31:58 +0000
@@ -38,6 +38,7 @@
 
    transports
    ui
+   fetch
 
 Releasing and Packaging
 =======================

=== modified file 'doc/en/release-notes/bzr-2.3.txt'
--- doc/en/release-notes/bzr-2.3.txt	2011-01-15 17:29:41 +0000
+++ doc/en/release-notes/bzr-2.3.txt	2011-01-19 00:31:58 +0000
@@ -32,6 +32,11 @@
 .. Fixes for situations where bzr would previously crash or give incorrect
    or undesirable results.
 
+* Plugins incompatible with bzr no longer produce a warning on every
+  command invocation.  Instead, a message is shown by ``bzr plugins`` and
+  in crash reports.
+  (#704195, Martin Pool)
+
 Documentation
 *************
 
@@ -275,6 +280,11 @@
   crashes when encountering private bugs (they are just displayed as such).
   (Vincent Ladeuil, #354985)
 
+* The ``revision_id`` parameter of
+  ``Repository.search_missing_revision_ids`` and
+  ``InterRepository.search_missing_revision_ids`` is deprecated.  It is
+  replaced by the ``revision_ids`` parameter.  (Andrew Bennetts)
+
 Internals
 *********
 

=== added file 'doc/en/release-notes/bzr-2.4.txt'
--- doc/en/release-notes/bzr-2.4.txt	1970-01-01 00:00:00 +0000
+++ doc/en/release-notes/bzr-2.4.txt	2011-01-19 00:31:58 +0000
@@ -0,0 +1,64 @@
+####################
+Bazaar Release Notes
+####################
+
+.. toctree::
+   :maxdepth: 1
+
+bzr 2.4b1
+#########
+
+:2.4b1: NOT RELEASED YET
+
+External Compatibility Breaks
+*****************************
+
+.. These may require users to change the way they use Bazaar.
+
+New Features
+************
+
+.. New commands, options, etc that users may wish to try out.
+
+Improvements
+************
+
+.. Improvements to existing commands, especially improved performance 
+   or memory usage, or better results.
+
+Bug Fixes
+*********
+
+.. Fixes for situations where bzr would previously crash or give incorrect
+   or undesirable results.
+
+* ``bzr push --overwrite`` with an older revision specified will now correctly
+  roll back the target branch. (Jelmer Vernooij, #386576)
+
+* ``bzr serve`` no longer crashes when a server_started hook is installed and IPv6
+  support is available on the system. (Jelmer Vernooij, #293697)
+
+Documentation
+*************
+
+.. Improved or updated documentation.
+
+API Changes
+***********
+
+.. Changes that may require updates in plugins or other code that uses
+   bzrlib.
+
+Internals
+*********
+
+.. Major internal changes, unlikely to be visible to users or plugin 
+   developers, but interesting for bzr developers.
+
+Testing
+*******
+
+.. Fixes and changes that are only relevant to bzr's test framework and 
+   suite.  This can include new facilities for writing tests, fixes to 
+   spurious test failures and changes to the way things should be tested.
+

=== added file 'doc/en/whats-new/whats-new-in-2.4.txt'
--- doc/en/whats-new/whats-new-in-2.4.txt	1970-01-01 00:00:00 +0000
+++ doc/en/whats-new/whats-new-in-2.4.txt	2011-01-19 00:31:58 +0000
@@ -0,0 +1,33 @@
+*************************
+What's New in Bazaar 2.4?
+*************************
+
+Bazaar 2.4 is still under development, and will be released in August 2011.
+This document accumulates a high level summary of what's changed.  See the
+:doc:`../release-notes/index` for a full list.
+
+Users are encouraged to upgrade from the other stable series.  This
+document outlines the improvements in Bazaar 2.4 vs Bazaar 2.3. As well as
+summarizing improvements made to the core product, it highlights
+enhancements within the broader Bazaar world of potential interest to
+those upgrading.
+
+Bazaar 2.4.0 is fully compatible both locally and on the network with 2.0
+2.1, 2.2 and 2.3, and can read and write repositories generated by all
+previous versions.
+
+
+Further information
+*******************
+
+For more detailed information on the changes made, see the the
+:doc:`../release-notes/index` for:
+
+* the interim bzr `milestones <https://launchpad.net/bzr/2.4>`_
+* the plugins you use.
+
+For a summary of changes made in earlier releases, see:
+
+* :doc:`whats-new-in-2.1`
+* :doc:`whats-new-in-2.2`
+* :doc:`whats-new-in-2.3`