/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: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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
 
"""
19
 
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
from bzrlib import (
23
 
    config,
 
17
"""Command that signs unsigned commits by the current user. """
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
from . import (
 
22
    controldir,
 
23
    errors,
24
24
    gpg,
 
25
    repository as _mod_repository,
 
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
 
            repo.start_write_group()
69
 
            try:
70
 
                for rev_id in repo.get_ancestry(branch.last_revision())[1:]:
 
68
        with repo.lock_write():
 
69
            graph = repo.get_graph()
 
70
            with _mod_repository.WriteGroup(repo):
 
71
                for rev_id, parents in graph.iter_ancestry(
 
72
                        [branch.last_revision()]):
 
73
                    if _mod_revision.is_null(rev_id):
 
74
                        continue
 
75
                    if parents is None:
 
76
                        # Ignore ghosts
 
77
                        continue
71
78
                    if repo.has_signature_for_revision_id(rev_id):
72
79
                        continue
73
80
                    rev = repo.get_revision(rev_id)
75
82
                        continue
76
83
                    # We have a revision without a signature who has a
77
84
                    # matching committer, start signing
78
 
                    print rev_id
 
85
                    self.outf.write("%s\n" % rev_id)
79
86
                    count += 1
80
87
                    if not dry_run:
81
88
                        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
 
 
 
89
        self.outf.write(
 
90
            ngettext('Signed %d revision.\n', 'Signed %d revisions.\n',
 
91
                     count) % count)
 
92
 
 
93
 
 
94
class cmd_verify_signatures(Command):
 
95
    __doc__ = """Verify all commit signatures.
 
96
 
 
97
    Verifies that all commits in the branch are signed by known GnuPG keys.
 
98
    """
 
99
 
 
100
    takes_options = [
 
101
        Option('acceptable-keys',
 
102
               help='Comma separated list of GPG key patterns which are'
 
103
               ' acceptable for verification.',
 
104
               short_name='k',
 
105
               type=text_type,),
 
106
        'revision',
 
107
        'verbose',
 
108
        ]
 
109
    takes_args = ['location?']
 
110
 
 
111
    def run(self, acceptable_keys=None, revision=None, verbose=None,
 
112
            location=u'.'):
 
113
        bzrdir = controldir.ControlDir.open_containing(location)[0]
 
114
        branch = bzrdir.open_branch()
 
115
        repo = branch.repository
 
116
        branch_config = branch.get_config_stack()
 
117
        gpg_strategy = gpg.GPGStrategy(branch_config)
 
118
 
 
119
        gpg_strategy.set_acceptable_keys(acceptable_keys)
 
120
 
 
121
        def write(string):
 
122
            self.outf.write(string + "\n")
 
123
 
 
124
        def write_verbose(string):
 
125
            self.outf.write("  " + string + "\n")
 
126
 
 
127
        self.add_cleanup(repo.lock_read().unlock)
 
128
        # get our list of revisions
 
129
        revisions = []
 
130
        if revision is not None:
 
131
            if len(revision) == 1:
 
132
                revno, rev_id = revision[0].in_history(branch)
 
133
                revisions.append(rev_id)
 
134
            elif len(revision) == 2:
 
135
                from_revno, from_revid = revision[0].in_history(branch)
 
136
                to_revno, to_revid = revision[1].in_history(branch)
 
137
                if to_revid is None:
 
138
                    to_revno = branch.revno()
 
139
                if from_revno is None or to_revno is None:
 
140
                    raise errors.BzrCommandError(
 
141
                        gettext('Cannot verify a range of non-revision-history'
 
142
                                ' revisions'))
 
143
                for revno in range(from_revno, to_revno + 1):
 
144
                    revisions.append(branch.get_rev_id(revno))
 
145
        else:
 
146
            # all revisions by default including merges
 
147
            graph = repo.get_graph()
 
148
            revisions = []
 
149
            for rev_id, parents in graph.iter_ancestry(
 
150
                    [branch.last_revision()]):
 
151
                if _mod_revision.is_null(rev_id):
 
152
                    continue
 
153
                if parents is None:
 
154
                    # Ignore ghosts
 
155
                    continue
 
156
                revisions.append(rev_id)
 
157
        count, result, all_verifiable = gpg.bulk_verify_signatures(
 
158
            repo, revisions, gpg_strategy)
 
159
        if all_verifiable:
 
160
            write(gettext("All commits signed with verifiable keys"))
 
161
            if verbose:
 
162
                for message in gpg.verbose_valid_message(result):
 
163
                    write_verbose(message)
 
164
            return 0
 
165
        else:
 
166
            write(gpg.valid_commits_message(count))
 
167
            if verbose:
 
168
                for message in gpg.verbose_valid_message(result):
 
169
                    write_verbose(message)
 
170
            write(gpg.expired_commit_message(count))
 
171
            if verbose:
 
172
                for message in gpg.verbose_expired_key_message(result, repo):
 
173
                    write_verbose(message)
 
174
            write(gpg.unknown_key_message(count))
 
175
            if verbose:
 
176
                for message in gpg.verbose_missing_key_message(result):
 
177
                    write_verbose(message)
 
178
            write(gpg.commit_not_valid_message(count))
 
179
            if verbose:
 
180
                for message in gpg.verbose_not_valid_message(result, repo):
 
181
                    write_verbose(message)
 
182
            write(gpg.commit_not_signed_message(count))
 
183
            if verbose:
 
184
                for message in gpg.verbose_not_signed_message(result, repo):
 
185
                    write_verbose(message)
 
186
            return 1