| """distutils.command.upload |
| |
| Implements the Distutils 'upload' subcommand (upload package to PyPI).""" |
| import os |
| import socket |
| import platform |
| from urllib2 import urlopen, Request, HTTPError |
| from base64 import standard_b64encode |
| import urlparse |
| import cStringIO as StringIO |
| from hashlib import md5 |
| |
| from distutils.errors import DistutilsOptionError |
| from distutils.core import PyPIRCCommand |
| from distutils.spawn import spawn |
| from distutils import log |
| |
| class upload(PyPIRCCommand): |
| |
| description = "upload binary package to PyPI" |
| |
| user_options = PyPIRCCommand.user_options + [ |
| ('sign', 's', |
| 'sign files to upload using gpg'), |
| ('identity=', 'i', 'GPG identity used to sign files'), |
| ] |
| |
| boolean_options = PyPIRCCommand.boolean_options + ['sign'] |
| |
| def initialize_options(self): |
| PyPIRCCommand.initialize_options(self) |
| self.username = '' |
| self.password = '' |
| self.show_response = 0 |
| self.sign = False |
| self.identity = None |
| |
| def finalize_options(self): |
| PyPIRCCommand.finalize_options(self) |
| if self.identity and not self.sign: |
| raise DistutilsOptionError( |
| "Must use --sign for --identity to have meaning" |
| ) |
| config = self._read_pypirc() |
| if config != {}: |
| self.username = config['username'] |
| self.password = config['password'] |
| self.repository = config['repository'] |
| self.realm = config['realm'] |
| |
| # getting the password from the distribution |
| # if previously set by the register command |
| if not self.password and self.distribution.password: |
| self.password = self.distribution.password |
| |
| def run(self): |
| if not self.distribution.dist_files: |
| raise DistutilsOptionError("No dist file created in earlier command") |
| for command, pyversion, filename in self.distribution.dist_files: |
| self.upload_file(command, pyversion, filename) |
| |
| def upload_file(self, command, pyversion, filename): |
| # Makes sure the repository URL is compliant |
| schema, netloc, url, params, query, fragments = \ |
| urlparse.urlparse(self.repository) |
| if params or query or fragments: |
| raise AssertionError("Incompatible url %s" % self.repository) |
| |
| if schema not in ('http', 'https'): |
| raise AssertionError("unsupported schema " + schema) |
| |
| # Sign if requested |
| if self.sign: |
| gpg_args = ["gpg", "--detach-sign", "-a", filename] |
| if self.identity: |
| gpg_args[2:2] = ["--local-user", self.identity] |
| spawn(gpg_args, |
| dry_run=self.dry_run) |
| |
| # Fill in the data - send all the meta-data in case we need to |
| # register a new release |
| f = open(filename,'rb') |
| try: |
| content = f.read() |
| finally: |
| f.close() |
| meta = self.distribution.metadata |
| data = { |
| # action |
| ':action': 'file_upload', |
| 'protcol_version': '1', |
| |
| # identify release |
| 'name': meta.get_name(), |
| 'version': meta.get_version(), |
| |
| # file content |
| 'content': (os.path.basename(filename),content), |
| 'filetype': command, |
| 'pyversion': pyversion, |
| 'md5_digest': md5(content).hexdigest(), |
| |
| # additional meta-data |
| 'metadata_version' : '1.0', |
| 'summary': meta.get_description(), |
| 'home_page': meta.get_url(), |
| 'author': meta.get_contact(), |
| 'author_email': meta.get_contact_email(), |
| 'license': meta.get_licence(), |
| 'description': meta.get_long_description(), |
| 'keywords': meta.get_keywords(), |
| 'platform': meta.get_platforms(), |
| 'classifiers': meta.get_classifiers(), |
| 'download_url': meta.get_download_url(), |
| # PEP 314 |
| 'provides': meta.get_provides(), |
| 'requires': meta.get_requires(), |
| 'obsoletes': meta.get_obsoletes(), |
| } |
| comment = '' |
| if command == 'bdist_rpm': |
| dist, version, id = platform.dist() |
| if dist: |
| comment = 'built for %s %s' % (dist, version) |
| elif command == 'bdist_dumb': |
| comment = 'built for %s' % platform.platform(terse=1) |
| data['comment'] = comment |
| |
| if self.sign: |
| data['gpg_signature'] = (os.path.basename(filename) + ".asc", |
| open(filename+".asc").read()) |
| |
| # set up the authentication |
| auth = "Basic " + standard_b64encode(self.username + ":" + |
| self.password) |
| |
| # Build up the MIME payload for the POST data |
| boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254' |
| sep_boundary = '\n--' + boundary |
| end_boundary = sep_boundary + '--' |
| body = StringIO.StringIO() |
| for key, value in data.items(): |
| # handle multiple entries for the same name |
| if not isinstance(value, list): |
| value = [value] |
| for value in value: |
| if isinstance(value, tuple): |
| fn = ';filename="%s"' % value[0] |
| value = value[1] |
| else: |
| fn = "" |
| |
| body.write(sep_boundary) |
| body.write('\nContent-Disposition: form-data; name="%s"'%key) |
| body.write(fn) |
| body.write("\n\n") |
| body.write(value) |
| if value and value[-1] == '\r': |
| body.write('\n') # write an extra newline (lurve Macs) |
| body.write(end_boundary) |
| body.write("\n") |
| body = body.getvalue() |
| |
| self.announce("Submitting %s to %s" % (filename, self.repository), log.INFO) |
| |
| # build the Request |
| headers = {'Content-type': |
| 'multipart/form-data; boundary=%s' % boundary, |
| 'Content-length': str(len(body)), |
| 'Authorization': auth} |
| |
| request = Request(self.repository, data=body, |
| headers=headers) |
| # send the data |
| try: |
| result = urlopen(request) |
| status = result.getcode() |
| reason = result.msg |
| if self.show_response: |
| msg = '\n'.join(('-' * 75, r.read(), '-' * 75)) |
| self.announce(msg, log.INFO) |
| except socket.error, e: |
| self.announce(str(e), log.ERROR) |
| return |
| except HTTPError, e: |
| status = e.code |
| reason = e.msg |
| |
| if status == 200: |
| self.announce('Server response (%s): %s' % (status, reason), |
| log.INFO) |
| else: |
| self.announce('Upload failed (%s): %s' % (status, reason), |
| log.ERROR) |
