/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: Vincent Ladeuil
  • Date: 2018-05-24 08:15:15 UTC
  • mto: This revision was merged to the branch mainline in revision 6976.
  • Revision ID: v.ladeuil+brz@free.fr-20180524081515-bwyprs69c3g5o1ci
Define containers and commands for byoci.

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