← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/missing.py

(jameinel) Allow 'bzr serve' to interpret SIGHUP as a graceful shutdown.
 (bug #795025) (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/missing.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Display what revisions are missing in 'other' from 'this' and vice versa."""
18
18
 
19
19
from bzrlib import (
20
20
    log,
21
 
    repository as _mod_repository,
22
 
    tsort,
 
21
    symbol_versioning,
23
22
    )
24
23
import bzrlib.revision as _mod_revision
25
24
 
37
36
            revno, rev_id, merge_depth = rev
38
37
        rev = revision_source.get_revision(rev_id)
39
38
        if verbose:
40
 
            remote_tree = revision_source.revision_tree(rev_id)
41
 
            parent_rev_id = rev.parent_ids[0]
42
 
            if last_rev_id == parent_rev_id:
43
 
                parent_tree = last_tree
44
 
            else:
45
 
                parent_tree = revision_source.revision_tree(parent_rev_id)
46
 
            revision_tree = revision_source.revision_tree(rev_id)
47
 
            last_rev_id = rev_id
48
 
            last_tree = revision_tree
49
 
            delta = revision_tree.changes_from(parent_tree)
 
39
            delta = revision_source.get_revision_delta(rev_id)
50
40
        else:
51
41
            delta = None
52
42
        yield log.LogRevision(rev, revno, merge_depth, delta=delta)
53
43
 
54
44
 
55
45
def find_unmerged(local_branch, remote_branch, restrict='all',
56
 
                  include_merges=False, backward=False,
57
 
                  local_revid_range=None, remote_revid_range=None):
 
46
                  include_merged=None, backward=False,
 
47
                  local_revid_range=None, remote_revid_range=None,
 
48
                  include_merges=symbol_versioning.DEPRECATED_PARAMETER):
58
49
    """Find revisions from each side that have not been merged.
59
50
 
60
51
    :param local_branch: Compare the history of local_branch
64
55
        unique revisions from both sides. If 'local', we will return None
65
56
        for the remote revisions, similarly if 'remote' we will return None for
66
57
        the local revisions.
67
 
    :param include_merges: Show mainline revisions only if False,
 
58
    :param include_merged: Show mainline revisions only if False,
68
59
        all revisions otherwise.
69
60
    :param backward: Show oldest versions first when True, newest versions
70
61
        first when False.
72
63
        revisions (lower bound, upper bound)
73
64
    :param remote_revid_range: Revision-id range for filtering remote_branch
74
65
        revisions (lower bound, upper bound)
 
66
    :param include_merges: Deprecated historical alias for include_merged
75
67
 
76
68
    :return: A list of [(revno, revision_id)] for the mainline revisions on
77
69
        each side.
78
70
    """
 
71
    if symbol_versioning.deprecated_passed(include_merges):
 
72
        symbol_versioning.warn(
 
73
            'include_merges was deprecated in 2.5.'
 
74
            ' Use include_merged instead.',
 
75
            DeprecationWarning, stacklevel=2)
 
76
        if include_merged is None:
 
77
            include_merged = include_merges
 
78
    if include_merged is None:
 
79
        include_merged = False
79
80
    local_branch.lock_read()
80
81
    try:
81
82
        remote_branch.lock_read()
82
83
        try:
83
84
            return _find_unmerged(
84
85
                local_branch, remote_branch, restrict=restrict,
85
 
                include_merges=include_merges, backward=backward,
 
86
                include_merged=include_merged, backward=backward,
86
87
                local_revid_range=local_revid_range,
87
88
                remote_revid_range=remote_revid_range)
88
89
        finally:
99
100
    :param tip_revno: The revision number for the tip revision
100
101
    :param tip: The tip of mainline
101
102
    :param backward: Show oldest versions first when True, newest versions
102
 
        first when False. 
 
103
        first when False.
103
104
    :return: [(revno, revision_id)] for all revisions in ancestry that
104
105
        are left-hand parents from tip, or None if ancestry is None.
105
106
    """
138
139
    :param tip_revno: The revision number for the tip revision
139
140
    :param tip: The tip of the ancsetry
140
141
    :param backward: Show oldest versions first when True, newest versions
141
 
        first when False. 
 
142
        first when False.
142
143
    :return: [(revno, revision_id)] for all revisions in ancestry that
143
144
        are parents from tip, or None if ancestry is None.
144
145
    """
147
148
    if not ancestry: #Empty ancestry, no need to do any work
148
149
        return []
149
150
 
150
 
    mainline_revs, rev_nos, start_rev_id, end_rev_id = log._get_mainline_revs(
151
 
        branch, None, tip_revno)
152
 
    if not mainline_revs:
153
 
        return []
154
 
 
155
 
    # This asks for all mainline revisions, which is size-of-history and
156
 
    # should be addressed (but currently the only way to get correct
157
 
    # revnos).
158
 
 
159
 
    # mainline_revisions always includes an extra revision at the
160
 
    # beginning, so don't request it.
161
 
    parent_map = dict(((key, value) for key, value
162
 
                       in graph.iter_ancestry(mainline_revs[1:])
163
 
                       if value is not None))
164
 
    # filter out ghosts; merge_sort errors on ghosts. 
165
 
    # XXX: is this needed here ? -- vila080910
166
 
    rev_graph = _mod_repository._strip_NULL_ghosts(parent_map)
167
 
    # XXX: what if rev_graph is empty now ? -- vila080910
168
 
    merge_sorted_revisions = tsort.merge_sort(rev_graph, tip,
169
 
                                              mainline_revs,
170
 
                                              generate_revno=True)
 
151
    merge_sorted_revisions = branch.iter_merge_sorted_revisions()
171
152
    # Now that we got the correct revnos, keep only the relevant
172
153
    # revisions.
173
154
    merge_sorted_revisions = [
174
 
        (s, revid, n, d, e) for s, revid, n, d, e in merge_sorted_revisions
 
155
        # log.reverse_by_depth expects seq_num to be present, but it is
 
156
        # stripped by iter_merge_sorted_revisions()
 
157
        (0, revid, n, d, e) for revid, n, d, e in merge_sorted_revisions
175
158
        if revid in ancestry]
176
159
    if not backward:
177
160
        merge_sorted_revisions = log.reverse_by_depth(merge_sorted_revisions)
189
172
 
190
173
 
191
174
def _find_unmerged(local_branch, remote_branch, restrict,
192
 
                   include_merges, backward,
 
175
                   include_merged, backward,
193
176
                   local_revid_range=None, remote_revid_range=None):
194
177
    """See find_unmerged.
195
178
 
215
198
                             ' "remote": %r' % (restrict,))
216
199
        local_extra, remote_extra = graph.find_difference(local_revision_id,
217
200
                                                          remote_revision_id)
218
 
    if include_merges:
 
201
    if include_merged:
219
202
        locals = _enumerate_with_merges(local_branch, local_extra,
220
203
                                        graph, local_revno,
221
204
                                        local_revision_id, backward)