← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/sign_my_commits.py

  • Committer: Vincent Ladeuil
  • Date: 2007-07-18 09:43:41 UTC
  • mto: (2778.5.1 vila)
  • mto: This revision was merged to the branch mainline in revision 2789.
  • Revision ID: v.ladeuil+lp@free.fr-20070718094341-edmgsog3el06yqow
Add performance analysis of missing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/sign_my_commits.py
1
 
# Copyright (C) 2006, 2007, 2009, 2010, 2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
 
    bzrdir as _mod_bzrdir,
24
 
    errors,
 
23
    config,
25
24
    gpg,
26
 
    revision as _mod_revision,
27
25
    )
 
26
from bzrlib.bzrdir import BzrDir
28
27
""")
29
28
from bzrlib.commands import Command
30
29
from bzrlib.option import Option
31
 
from bzrlib.i18n import gettext, ngettext
 
30
 
32
31
 
33
32
class cmd_sign_my_commits(Command):
34
 
    __doc__ = """Sign all commits by a given committer.
 
33
    """Sign all commits by a given committer.
35
34
 
36
35
    If location is not specified the local tree is used.
37
36
    If committer is not specified the default committer is used.
51
50
 
52
51
    def run(self, location=None, committer=None, dry_run=False):
53
52
        if location is None:
54
 
            bzrdir = _mod_bzrdir.BzrDir.open_containing('.')[0]
 
53
            bzrdir = BzrDir.open_containing('.')[0]
55
54
        else:
56
55
            # Passed in locations should be exact
57
 
            bzrdir = _mod_bzrdir.BzrDir.open(location)
 
56
            bzrdir = BzrDir.open(location)
58
57
        branch = bzrdir.open_branch()
59
58
        repo = branch.repository
60
59
        branch_config = branch.get_config()
66
65
        count = 0
67
66
        repo.lock_write()
68
67
        try:
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()
 
68
            for rev_id in repo.get_ancestry(branch.last_revision())[1:]:
 
69
                if repo.has_signature_for_revision_id(rev_id):
 
70
                    continue
 
71
                rev = repo.get_revision(rev_id)
 
72
                if rev.committer != committer:
 
73
                    continue
 
74
                # We have a revision without a signature who has a 
 
75
                # matching committer, start signing
 
76
                print rev_id
 
77
                count += 1
 
78
                if not dry_run:
 
79
                    repo.sign_revision(rev_id, gpg_strategy)
95
80
        finally:
96
81
            repo.unlock()
97
82
        print 'Signed %d revisions' % (count,)
98
83
 
99
84
 
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('Cannot verify a range of '\
145
 
                                               '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.unknown_key_message(count))
176
 
            if verbose:
177
 
                for message in gpg_strategy.verbose_missing_key_message(result):
178
 
                    write_verbose(message)
179
 
            write(gpg_strategy.commit_not_valid_message(count))
180
 
            if verbose:
181
 
                for message in gpg_strategy.verbose_not_valid_message(result,
182
 
                                                                        repo):
183
 
                   write_verbose(message)
184
 
            write(gpg_strategy.commit_not_signed_message(count))
185
 
            if verbose:
186
 
                for message in gpg_strategy.verbose_not_signed_message(result,
187
 
                                                                          repo):
188
 
                    write_verbose(message)
189
 
            return 1