/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 bzrlib/commit_signature_commands.py

Merge bzr.dev, update to use new hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit_signature_commands.py
17
17
"""Command which looks for unsigned commits by the current user, and signs them.
18
18
"""
19
19
 
20
 
from __future__ import absolute_import
21
 
 
 
20
from bzrlib.lazy_import import lazy_import
 
21
lazy_import(globals(), """
22
22
from bzrlib import (
23
23
    controldir,
24
24
    errors,
25
25
    gpg,
26
26
    revision as _mod_revision,
27
27
    )
 
28
""")
28
29
from bzrlib.commands import Command
29
30
from bzrlib.option import Option
30
31
from bzrlib.i18n import gettext, ngettext
31
32
 
32
 
 
33
33
class cmd_sign_my_commits(Command):
34
34
    __doc__ = """Sign all commits by a given committer.
35
35
 
57
57
            bzrdir = controldir.ControlDir.open(location)
58
58
        branch = bzrdir.open_branch()
59
59
        repo = branch.repository
60
 
        branch_config = branch.get_config_stack()
 
60
        branch_config = branch.get_config()
61
61
 
62
62
        if committer is None:
63
 
            committer = branch_config.get('email')
 
63
            committer = branch_config.username()
64
64
        gpg_strategy = gpg.GPGStrategy(branch_config)
65
65
 
66
66
        count = 0
83
83
                        continue
84
84
                    # We have a revision without a signature who has a
85
85
                    # matching committer, start signing
86
 
                    self.outf.write("%s\n" % rev_id)
 
86
                    print rev_id
87
87
                    count += 1
88
88
                    if not dry_run:
89
89
                        repo.sign_revision(rev_id, gpg_strategy)
94
94
                repo.commit_write_group()
95
95
        finally:
96
96
            repo.unlock()
97
 
        self.outf.write(
98
 
            ngettext('Signed %d revision.\n', 'Signed %d revisions.\n', count) %
99
 
            count)
 
97
        print 'Signed %d revisions' % (count,)
100
98
 
101
99
 
102
100
class cmd_verify_signatures(Command):
111
109
                        ' acceptable for verification.',
112
110
                   short_name='k',
113
111
                   type=str,),
114
 
            'revision',
 
112
            'revision', 
115
113
            'verbose',
116
114
          ]
117
115
    takes_args = ['location?']
121
119
        bzrdir = controldir.ControlDir.open_containing(location)[0]
122
120
        branch = bzrdir.open_branch()
123
121
        repo = branch.repository
124
 
        branch_config = branch.get_config_stack()
 
122
        branch_config = branch.get_config()
125
123
        gpg_strategy = gpg.GPGStrategy(branch_config)
126
124
 
127
125
        gpg_strategy.set_acceptable_keys(acceptable_keys)
131
129
        def write_verbose(string):
132
130
            self.outf.write("  " + string + "\n")
133
131
 
134
 
        self.add_cleanup(repo.lock_read().unlock)
135
132
        #get our list of revisions
136
133
        revisions = []
137
134
        if revision is not None:
152
149
            #all revisions by default including merges
153
150
            graph = repo.get_graph()
154
151
            revisions = []
 
152
            repo.lock_read()
155
153
            for rev_id, parents in graph.iter_ancestry(
156
154
                    [branch.last_revision()]):
157
155
                if _mod_revision.is_null(rev_id):
160
158
                    # Ignore ghosts
161
159
                    continue
162
160
                revisions.append(rev_id)
163
 
        count, result, all_verifiable = gpg.bulk_verify_signatures(
164
 
            repo, revisions, gpg_strategy)
 
161
            repo.unlock()
 
162
        count, result, all_verifiable =\
 
163
                                gpg_strategy.do_verifications(revisions, repo)
165
164
        if all_verifiable:
166
 
               write(gettext("All commits signed with verifiable keys"))
 
165
               write(gettext(
 
166
                            "All commits signed with verifiable keys"))
167
167
               if verbose:
168
 
                   for message in gpg.verbose_valid_message(result):
169
 
                       write_verbose(message)
 
168
                   write(gpg_strategy.verbose_valid_message(result))
170
169
               return 0
171
170
        else:
172
 
            write(gpg.valid_commits_message(count))
173
 
            if verbose:
174
 
               for message in gpg.verbose_valid_message(result):
175
 
                   write_verbose(message)
176
 
            write(gpg.expired_commit_message(count))
177
 
            if verbose:
178
 
               for message in gpg.verbose_expired_key_message(result, repo):
179
 
                   write_verbose(message)
180
 
            write(gpg.unknown_key_message(count))
181
 
            if verbose:
182
 
                for message in gpg.verbose_missing_key_message(result):
 
171
            write(gpg_strategy.valid_commits_message(count))
 
172
            if verbose:
 
173
               for message in gpg_strategy.verbose_valid_message(result):
 
174
                   write_verbose(message)
 
175
            write(gpg_strategy.expired_commit_message(count))
 
176
            if verbose:
 
177
               for message in gpg_strategy.verbose_expired_key_message(result,
 
178
                                                                          repo):
 
179
                   write_verbose(message)
 
180
            write(gpg_strategy.unknown_key_message(count))
 
181
            if verbose:
 
182
                for message in gpg_strategy.verbose_missing_key_message(result):
183
183
                    write_verbose(message)
184
 
            write(gpg.commit_not_valid_message(count))
 
184
            write(gpg_strategy.commit_not_valid_message(count))
185
185
            if verbose:
186
 
                for message in gpg.verbose_not_valid_message(result, repo):
 
186
                for message in gpg_strategy.verbose_not_valid_message(result,
 
187
                                                                        repo):
187
188
                   write_verbose(message)
188
 
            write(gpg.commit_not_signed_message(count))
 
189
            write(gpg_strategy.commit_not_signed_message(count))
189
190
            if verbose:
190
 
                for message in gpg.verbose_not_signed_message(result, repo):
 
191
                for message in gpg_strategy.verbose_not_signed_message(result,
 
192
                                                                          repo):
191
193
                    write_verbose(message)
192
194
            return 1