← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit_signature_commands.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit_signature_commands.py
1
 
# Copyright (C) 2005, 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Command which looks for unsigned commits by the current user, and signs them.
18
18
"""
20
20
from bzrlib.lazy_import import lazy_import
21
21
lazy_import(globals(), """
22
22
from bzrlib import (
23
 
    config,
 
23
    bzrdir as _mod_bzrdir,
 
24
    errors,
24
25
    gpg,
 
26
    revision as _mod_revision,
25
27
    )
26
 
from bzrlib.bzrdir import BzrDir
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
class cmd_sign_my_commits(Command):
33
 
    """Sign all commits by a given committer.
 
34
    __doc__ = """Sign all commits by a given committer.
34
35
 
35
36
    If location is not specified the local tree is used.
36
37
    If committer is not specified the default committer is used.
41
42
    # (both mainline and merged), but not other revisions that may be in the
42
43
    # repository
43
44
 
44
 
    takes_options = [Option('dry-run'
45
 
                            , help='Don\'t actually sign anything, just print'
46
 
                                   ' the revisions that would be signed')
47
 
                    ]
 
45
    takes_options = [
 
46
            Option('dry-run',
 
47
                   help='Don\'t actually sign anything, just print'
 
48
                        ' the revisions that would be signed.'),
 
49
            ]
48
50
    takes_args = ['location?', 'committer?']
49
51
 
50
52
    def run(self, location=None, committer=None, dry_run=False):
51
53
        if location is None:
52
 
            bzrdir = BzrDir.open_containing('.')[0]
 
54
            bzrdir = _mod_bzrdir.BzrDir.open_containing('.')[0]
53
55
        else:
54
56
            # Passed in locations should be exact
55
 
            bzrdir = BzrDir.open(location)
 
57
            bzrdir = _mod_bzrdir.BzrDir.open(location)
56
58
        branch = bzrdir.open_branch()
57
59
        repo = branch.repository
58
60
        branch_config = branch.get_config()
64
66
        count = 0
65
67
        repo.lock_write()
66
68
        try:
67
 
            for rev_id in repo.get_ancestry(branch.last_revision())[1:]:
68
 
                if repo.has_signature_for_revision_id(rev_id):
69
 
                    continue
70
 
                rev = repo.get_revision(rev_id)
71
 
                if rev.committer != committer:
72
 
                    continue
73
 
                # We have a revision without a signature who has a 
74
 
                # matching committer, start signing
75
 
                print rev_id
76
 
                count += 1
77
 
                if not dry_run:
78
 
                    repo.sign_revision(rev_id, gpg_strategy)
 
69
            graph = repo.get_graph()
 
70
            repo.start_write_group()
 
71
            try:
 
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
 
79
                    if repo.has_signature_for_revision_id(rev_id):
 
80
                        continue
 
81
                    rev = repo.get_revision(rev_id)
 
82
                    if rev.committer != committer:
 
83
                        continue
 
84
                    # We have a revision without a signature who has a
 
85
                    # matching committer, start signing
 
86
                    print rev_id
 
87
                    count += 1
 
88
                    if not dry_run:
 
89
                        repo.sign_revision(rev_id, gpg_strategy)
 
90
            except:
 
91
                repo.abort_write_group()
 
92
                raise
 
93
            else:
 
94
                repo.commit_write_group()
79
95
        finally:
80
96
            repo.unlock()
81
97
        print 'Signed %d revisions' % (count,)
82
98
 
83
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=str,),
 
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 = _mod_bzrdir.BzrDir.open_containing(location)[0]
 
120
        branch = bzrdir.open_branch()
 
121
        repo = branch.repository
 
122
        branch_config = branch.get_config()
 
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
        def write_verbose(string):
 
130
            self.outf.write("  " + string + "\n")
 
131
 
 
132
        #get our list of revisions
 
133
        revisions = []
 
134
        if revision is not None:
 
135
            if len(revision) == 1:
 
136
                revno, rev_id = revision[0].in_history(branch)
 
137
                revisions.append(rev_id)
 
138
            elif len(revision) == 2:
 
139
                from_revno, from_revid = revision[0].in_history(branch)
 
140
                to_revno, to_revid = revision[1].in_history(branch)
 
141
                if to_revid is None:
 
142
                    to_revno = branch.revno()
 
143
                if from_revno is None or to_revno is None:
 
144
                    raise errors.BzrCommandError(gettext(
 
145
                    'Cannot verify a range of non-revision-history revisions'))
 
146
                for revno in range(from_revno, to_revno + 1):
 
147
                    revisions.append(branch.get_rev_id(revno))
 
148
        else:
 
149
            #all revisions by default including merges
 
150
            graph = repo.get_graph()
 
151
            revisions = []
 
152
            repo.lock_read()
 
153
            for rev_id, parents in graph.iter_ancestry(
 
154
                    [branch.last_revision()]):
 
155
                if _mod_revision.is_null(rev_id):
 
156
                    continue
 
157
                if parents is None:
 
158
                    # Ignore ghosts
 
159
                    continue
 
160
                revisions.append(rev_id)
 
161
            repo.unlock()
 
162
        count, result, all_verifiable =\
 
163
                                gpg_strategy.do_verifications(revisions, repo)
 
164
        if all_verifiable:
 
165
               write(gettext(
 
166
                            "All commits signed with verifiable keys"))
 
167
               if verbose:
 
168
                   write(gpg_strategy.verbose_valid_message(result))
 
169
               return 0
 
170
        else:
 
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
                    write_verbose(message)
 
184
            write(gpg_strategy.commit_not_valid_message(count))
 
185
            if verbose:
 
186
                for message in gpg_strategy.verbose_not_valid_message(result,
 
187
                                                                        repo):
 
188
                   write_verbose(message)
 
189
            write(gpg_strategy.commit_not_signed_message(count))
 
190
            if verbose:
 
191
                for message in gpg_strategy.verbose_not_signed_message(result,
 
192
                                                                          repo):
 
193
                    write_verbose(message)
 
194
            return 1