/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Command which looks for unsigned commits by the current user, and signs them.
18
 
"""
 
17
"""Command that signs unsigned commits by the current user. """
19
18
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
from bzrlib import (
23
 
    config,
 
19
from . import (
 
20
    controldir,
 
21
    errors,
24
22
    gpg,
 
23
    repository as _mod_repository,
 
24
    revision as _mod_revision,
25
25
    )
26
 
from bzrlib.bzrdir import BzrDir
27
 
""")
28
 
from bzrlib.commands import Command
29
 
from bzrlib.option import Option
 
26
from .commands import Command
 
27
from .option import Option
 
28
from .i18n import gettext, ngettext
30
29
 
31
30
 
32
31
class cmd_sign_my_commits(Command):
42
41
    # repository
43
42
 
44
43
    takes_options = [
45
 
            Option('dry-run',
46
 
                   help='Don\'t actually sign anything, just print'
47
 
                        ' the revisions that would be signed.'),
48
 
            ]
 
44
        Option('dry-run',
 
45
               help='Don\'t actually sign anything, just print'
 
46
               ' the revisions that would be signed.'),
 
47
        ]
49
48
    takes_args = ['location?', 'committer?']
50
49
 
51
50
    def run(self, location=None, committer=None, dry_run=False):
52
51
        if location is None:
53
 
            bzrdir = BzrDir.open_containing('.')[0]
 
52
            bzrdir = controldir.ControlDir.open_containing('.')[0]
54
53
        else:
55
54
            # Passed in locations should be exact
56
 
            bzrdir = BzrDir.open(location)
 
55
            bzrdir = controldir.ControlDir.open(location)
57
56
        branch = bzrdir.open_branch()
58
57
        repo = branch.repository
59
 
        branch_config = branch.get_config()
 
58
        branch_config = branch.get_config_stack()
60
59
 
61
60
        if committer is None:
62
 
            committer = branch_config.username()
 
61
            committer = branch_config.get('email')
63
62
        gpg_strategy = gpg.GPGStrategy(branch_config)
64
63
 
65
64
        count = 0
66
 
        repo.lock_write()
67
 
        try:
68
 
            repo.start_write_group()
69
 
            try:
70
 
                for rev_id in repo.get_ancestry(branch.last_revision())[1:]:
 
65
        with repo.lock_write():
 
66
            graph = repo.get_graph()
 
67
            with _mod_repository.WriteGroup(repo):
 
68
                for rev_id, parents in graph.iter_ancestry(
 
69
                        [branch.last_revision()]):
 
70
                    if _mod_revision.is_null(rev_id):
 
71
                        continue
 
72
                    if parents is None:
 
73
                        # Ignore ghosts
 
74
                        continue
71
75
                    if repo.has_signature_for_revision_id(rev_id):
72
76
                        continue
73
77
                    rev = repo.get_revision(rev_id)
75
79
                        continue
76
80
                    # We have a revision without a signature who has a
77
81
                    # matching committer, start signing
78
 
                    print rev_id
 
82
                    self.outf.write("%s\n" % rev_id)
79
83
                    count += 1
80
84
                    if not dry_run:
81
85
                        repo.sign_revision(rev_id, gpg_strategy)
82
 
            except:
83
 
                repo.abort_write_group()
84
 
                raise
85
 
            else:
86
 
                repo.commit_write_group()
87
 
        finally:
88
 
            repo.unlock()
89
 
        print 'Signed %d revisions' % (count,)
90
 
 
91
 
 
 
86
        self.outf.write(
 
87
            ngettext('Signed %d revision.\n', 'Signed %d revisions.\n',
 
88
                     count) % count)
 
89
 
 
90
 
 
91
class cmd_verify_signatures(Command):
 
92
    __doc__ = """Verify all commit signatures.
 
93
 
 
94
    Verifies that all commits in the branch are signed by known GnuPG keys.
 
95
    """
 
96
 
 
97
    takes_options = [
 
98
        Option('acceptable-keys',
 
99
               help='Comma separated list of GPG key patterns which are'
 
100
               ' acceptable for verification.',
 
101
               short_name='k',
 
102
               type=str,),
 
103
        'revision',
 
104
        'verbose',
 
105
        ]
 
106
    takes_args = ['location?']
 
107
 
 
108
    def run(self, acceptable_keys=None, revision=None, verbose=None,
 
109
            location=u'.'):
 
110
        bzrdir = controldir.ControlDir.open_containing(location)[0]
 
111
        branch = bzrdir.open_branch()
 
112
        repo = branch.repository
 
113
        branch_config = branch.get_config_stack()
 
114
        gpg_strategy = gpg.GPGStrategy(branch_config)
 
115
 
 
116
        gpg_strategy.set_acceptable_keys(acceptable_keys)
 
117
 
 
118
        def write(string):
 
119
            self.outf.write(string + "\n")
 
120
 
 
121
        def write_verbose(string):
 
122
            self.outf.write("  " + string + "\n")
 
123
 
 
124
        self.add_cleanup(repo.lock_read().unlock)
 
125
        # get our list of revisions
 
126
        revisions = []
 
127
        if revision is not None:
 
128
            if len(revision) == 1:
 
129
                revno, rev_id = revision[0].in_history(branch)
 
130
                revisions.append(rev_id)
 
131
            elif len(revision) == 2:
 
132
                from_revno, from_revid = revision[0].in_history(branch)
 
133
                to_revno, to_revid = revision[1].in_history(branch)
 
134
                if to_revid is None:
 
135
                    to_revno = branch.revno()
 
136
                if from_revno is None or to_revno is None:
 
137
                    raise errors.CommandError(
 
138
                        gettext('Cannot verify a range of non-revision-history'
 
139
                                ' revisions'))
 
140
                for revno in range(from_revno, to_revno + 1):
 
141
                    revisions.append(branch.get_rev_id(revno))
 
142
        else:
 
143
            # all revisions by default including merges
 
144
            graph = repo.get_graph()
 
145
            revisions = []
 
146
            for rev_id, parents in graph.iter_ancestry(
 
147
                    [branch.last_revision()]):
 
148
                if _mod_revision.is_null(rev_id):
 
149
                    continue
 
150
                if parents is None:
 
151
                    # Ignore ghosts
 
152
                    continue
 
153
                revisions.append(rev_id)
 
154
        count, result, all_verifiable = gpg.bulk_verify_signatures(
 
155
            repo, revisions, gpg_strategy)
 
156
        if all_verifiable:
 
157
            write(gettext("All commits signed with verifiable keys"))
 
158
            if verbose:
 
159
                for message in gpg.verbose_valid_message(result):
 
160
                    write_verbose(message)
 
161
            return 0
 
162
        else:
 
163
            write(gpg.valid_commits_message(count))
 
164
            if verbose:
 
165
                for message in gpg.verbose_valid_message(result):
 
166
                    write_verbose(message)
 
167
            write(gpg.expired_commit_message(count))
 
168
            if verbose:
 
169
                for message in gpg.verbose_expired_key_message(result, repo):
 
170
                    write_verbose(message)
 
171
            write(gpg.unknown_key_message(count))
 
172
            if verbose:
 
173
                for message in gpg.verbose_missing_key_message(result):
 
174
                    write_verbose(message)
 
175
            write(gpg.commit_not_valid_message(count))
 
176
            if verbose:
 
177
                for message in gpg.verbose_not_valid_message(result, repo):
 
178
                    write_verbose(message)
 
179
            write(gpg.commit_not_signed_message(count))
 
180
            if verbose:
 
181
                for message in gpg.verbose_not_signed_message(result, repo):
 
182
                    write_verbose(message)
 
183
            return 1