← 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: Vincent Ladeuil
  • Date: 2016-02-07 18:23:13 UTC
  • mto: (6615.3.1 2.7)
  • mto: This revision was merged to the branch mainline in revision 6620.
  • Revision ID: v.ladeuil+lp@free.fr-20160207182313-jwz7z3vj4mpyjn7y
Ensure http://pad.lv/1323805 won't come back.

Since the 2.6.0 release pypi policy changed and release tarballs can't be
hosted on launchpad anymore, they have to be uploaded to
http://pypi.python.org/pypi


This fixes setup.py sdist to generate the right tarball with nearly the same
content as the one produced for 2.7.0.

Such a tarball have been uploaded to pypi properly signed and tested for
installation in venv.

Show diffs side-by-side

added added

removed removed

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