/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/commit_signature_commands.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/commit_signature_commands.py
1
 
# Copyright (C) 2006, 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2009, 2010, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Command which looks for unsigned commits by the current user, and signs them.
18
18
"""
19
19
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
from bzrlib import (
23
 
    config,
 
20
from __future__ import absolute_import
 
21
 
 
22
from . import (
 
23
    controldir,
 
24
    errors,
24
25
    gpg,
 
26
    revision as _mod_revision,
25
27
    )
26
 
from bzrlib.bzrdir import BzrDir
27
 
""")
28
 
from bzrlib.commands import Command
29
 
from bzrlib.option import Option
 
28
from .commands import Command
 
29
from .option import Option
 
30
from .i18n import gettext, ngettext
 
31
from .sixish import text_type
30
32
 
31
33
 
32
34
class cmd_sign_my_commits(Command):
50
52
 
51
53
    def run(self, location=None, committer=None, dry_run=False):
52
54
        if location is None:
53
 
            bzrdir = BzrDir.open_containing('.')[0]
 
55
            bzrdir = controldir.ControlDir.open_containing('.')[0]
54
56
        else:
55
57
            # Passed in locations should be exact
56
 
            bzrdir = BzrDir.open(location)
 
58
            bzrdir = controldir.ControlDir.open(location)
57
59
        branch = bzrdir.open_branch()
58
60
        repo = branch.repository
59
 
        branch_config = branch.get_config()
 
61
        branch_config = branch.get_config_stack()
60
62
 
61
63
        if committer is None:
62
 
            committer = branch_config.username()
 
64
            committer = branch_config.get('email')
63
65
        gpg_strategy = gpg.GPGStrategy(branch_config)
64
66
 
65
67
        count = 0
66
 
        repo.lock_write()
67
 
        try:
 
68
        with repo.lock_write():
 
69
            graph = repo.get_graph()
68
70
            repo.start_write_group()
69
71
            try:
70
 
                for rev_id in repo.get_ancestry(branch.last_revision())[1:]:
 
72
                for rev_id, parents in graph.iter_ancestry(
 
73
                        [branch.last_revision()]):
 
74
                    if _mod_revision.is_null(rev_id):
 
75
                        continue
 
76
                    if parents is None:
 
77
                        # Ignore ghosts
 
78
                        continue
71
79
                    if repo.has_signature_for_revision_id(rev_id):
72
80
                        continue
73
81
                    rev = repo.get_revision(rev_id)
75
83
                        continue
76
84
                    # We have a revision without a signature who has a
77
85
                    # matching committer, start signing
78
 
                    print rev_id
 
86
                    self.outf.write("%s\n" % rev_id)
79
87
                    count += 1
80
88
                    if not dry_run:
81
89
                        repo.sign_revision(rev_id, gpg_strategy)
84
92
                raise
85
93
            else:
86
94
                repo.commit_write_group()
87
 
        finally:
88
 
            repo.unlock()
89
 
        print 'Signed %d revisions' % (count,)
90
 
 
91
 
 
 
95
        self.outf.write(
 
96
            ngettext('Signed %d revision.\n', 'Signed %d revisions.\n', count) %
 
97
            count)
 
98
 
 
99
 
 
100
class cmd_verify_signatures(Command):
 
101
    __doc__ = """Verify all commit signatures.
 
102
 
 
103
    Verifies that all commits in the branch are signed by known GnuPG keys.
 
104
    """
 
105
 
 
106
    takes_options = [
 
107
            Option('acceptable-keys',
 
108
                   help='Comma separated list of GPG key patterns which are'
 
109
                        ' acceptable for verification.',
 
110
                   short_name='k',
 
111
                   type=text_type,),
 
112
            'revision',
 
113
            'verbose',
 
114
          ]
 
115
    takes_args = ['location?']
 
116
 
 
117
    def run(self, acceptable_keys=None, revision=None, verbose=None,
 
118
                                                            location=u'.'):
 
119
        bzrdir = controldir.ControlDir.open_containing(location)[0]
 
120
        branch = bzrdir.open_branch()
 
121
        repo = branch.repository
 
122
        branch_config = branch.get_config_stack()
 
123
        gpg_strategy = gpg.GPGStrategy(branch_config)
 
124
 
 
125
        gpg_strategy.set_acceptable_keys(acceptable_keys)
 
126
 
 
127
        def write(string):
 
128
            self.outf.write(string + "\n")
 
129
        def write_verbose(string):
 
130
            self.outf.write("  " + string + "\n")
 
131
 
 
132
        self.add_cleanup(repo.lock_read().unlock)
 
133
        #get our list of revisions
 
134
        revisions = []
 
135
        if revision is not None:
 
136
            if len(revision) == 1:
 
137
                revno, rev_id = revision[0].in_history(branch)
 
138
                revisions.append(rev_id)
 
139
            elif len(revision) == 2:
 
140
                from_revno, from_revid = revision[0].in_history(branch)
 
141
                to_revno, to_revid = revision[1].in_history(branch)
 
142
                if to_revid is None:
 
143
                    to_revno = branch.revno()
 
144
                if from_revno is None or to_revno is None:
 
145
                    raise errors.BzrCommandError(gettext(
 
146
                    'Cannot verify a range of non-revision-history revisions'))
 
147
                for revno in range(from_revno, to_revno + 1):
 
148
                    revisions.append(branch.get_rev_id(revno))
 
149
        else:
 
150
            #all revisions by default including merges
 
151
            graph = repo.get_graph()
 
152
            revisions = []
 
153
            for rev_id, parents in graph.iter_ancestry(
 
154
                    [branch.last_revision()]):
 
155
                if _mod_revision.is_null(rev_id):
 
156
                    continue
 
157
                if parents is None:
 
158
                    # Ignore ghosts
 
159
                    continue
 
160
                revisions.append(rev_id)
 
161
        count, result, all_verifiable = gpg.bulk_verify_signatures(
 
162
            repo, revisions, gpg_strategy)
 
163
        if all_verifiable:
 
164
               write(gettext("All commits signed with verifiable keys"))
 
165
               if verbose:
 
166
                   for message in gpg.verbose_valid_message(result):
 
167
                       write_verbose(message)
 
168
               return 0
 
169
        else:
 
170
            write(gpg.valid_commits_message(count))
 
171
            if verbose:
 
172
               for message in gpg.verbose_valid_message(result):
 
173
                   write_verbose(message)
 
174
            write(gpg.expired_commit_message(count))
 
175
            if verbose:
 
176
               for message in gpg.verbose_expired_key_message(result, repo):
 
177
                   write_verbose(message)
 
178
            write(gpg.unknown_key_message(count))
 
179
            if verbose:
 
180
                for message in gpg.verbose_missing_key_message(result):
 
181
                    write_verbose(message)
 
182
            write(gpg.commit_not_valid_message(count))
 
183
            if verbose:
 
184
                for message in gpg.verbose_not_valid_message(result, repo):
 
185
                   write_verbose(message)
 
186
            write(gpg.commit_not_signed_message(count))
 
187
            if verbose:
 
188
                for message in gpg.verbose_not_signed_message(result, repo):
 
189
                    write_verbose(message)
 
190
            return 1