/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-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

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):
42
44
    # repository
43
45
 
44
46
    takes_options = [
45
 
            Option('dry-run',
46
 
                   help='Don\'t actually sign anything, just print'
47
 
                        ' the revisions that would be signed.'),
48
 
            ]
 
47
        Option('dry-run',
 
48
               help='Don\'t actually sign anything, just print'
 
49
               ' the revisions that would be signed.'),
 
50
        ]
49
51
    takes_args = ['location?', 'committer?']
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
 
 
130
        def write_verbose(string):
 
131
            self.outf.write("  " + string + "\n")
 
132
 
 
133
        self.add_cleanup(repo.lock_read().unlock)
 
134
        # get our list of revisions
 
135
        revisions = []
 
136
        if revision is not None:
 
137
            if len(revision) == 1:
 
138
                revno, rev_id = revision[0].in_history(branch)
 
139
                revisions.append(rev_id)
 
140
            elif len(revision) == 2:
 
141
                from_revno, from_revid = revision[0].in_history(branch)
 
142
                to_revno, to_revid = revision[1].in_history(branch)
 
143
                if to_revid is None:
 
144
                    to_revno = branch.revno()
 
145
                if from_revno is None or to_revno is None:
 
146
                    raise errors.BzrCommandError(gettext(
 
147
                        'Cannot verify a range of non-revision-history revisions'))
 
148
                for revno in range(from_revno, to_revno + 1):
 
149
                    revisions.append(branch.get_rev_id(revno))
 
150
        else:
 
151
            # all revisions by default including merges
 
152
            graph = repo.get_graph()
 
153
            revisions = []
 
154
            for rev_id, parents in graph.iter_ancestry(
 
155
                    [branch.last_revision()]):
 
156
                if _mod_revision.is_null(rev_id):
 
157
                    continue
 
158
                if parents is None:
 
159
                    # Ignore ghosts
 
160
                    continue
 
161
                revisions.append(rev_id)
 
162
        count, result, all_verifiable = gpg.bulk_verify_signatures(
 
163
            repo, revisions, gpg_strategy)
 
164
        if all_verifiable:
 
165
            write(gettext("All commits signed with verifiable keys"))
 
166
            if verbose:
 
167
                for message in gpg.verbose_valid_message(result):
 
168
                    write_verbose(message)
 
169
            return 0
 
170
        else:
 
171
            write(gpg.valid_commits_message(count))
 
172
            if verbose:
 
173
                for message in gpg.verbose_valid_message(result):
 
174
                    write_verbose(message)
 
175
            write(gpg.expired_commit_message(count))
 
176
            if verbose:
 
177
                for message in gpg.verbose_expired_key_message(result, repo):
 
178
                    write_verbose(message)
 
179
            write(gpg.unknown_key_message(count))
 
180
            if verbose:
 
181
                for message in gpg.verbose_missing_key_message(result):
 
182
                    write_verbose(message)
 
183
            write(gpg.commit_not_valid_message(count))
 
184
            if verbose:
 
185
                for message in gpg.verbose_not_valid_message(result, repo):
 
186
                    write_verbose(message)
 
187
            write(gpg.commit_not_signed_message(count))
 
188
            if verbose:
 
189
                for message in gpg.verbose_not_signed_message(result, repo):
 
190
                    write_verbose(message)
 
191
            return 1