mirror of
https://github.com/saymrwulf/cryptography.git
synced 2026-05-14 20:37:55 +00:00
c62a78c015
Due to differences in how py.test determines which module to ``import`` the test suite actually runs against the cryptography which is in the *current* directory instead of the cryptography which is installed. The problem essentially boils down to when there is a tests/__init__.py then py.test adds the current directory to the front of the sys.path, causing it to take precedence over the installed location. This means that running the tests relies on the implicit compile that CFFI does instead of testing against what people will actually be runnning, which is the module compiled by setup.py.
346 lines
11 KiB
Python
346 lines
11 KiB
Python
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
from __future__ import absolute_import, division, print_function
|
|
|
|
import os
|
|
import platform
|
|
import subprocess
|
|
import sys
|
|
from distutils.command.build import build
|
|
|
|
import pkg_resources
|
|
|
|
from setuptools import find_packages, setup
|
|
from setuptools.command.install import install
|
|
from setuptools.command.test import test
|
|
|
|
|
|
base_dir = os.path.dirname(__file__)
|
|
src_dir = os.path.join(base_dir, "src")
|
|
|
|
# When executing the setup.py, we need to be able to import ourselves, this
|
|
# means that we need to add the src/ directory to the sys.path.
|
|
sys.path.insert(0, src_dir)
|
|
|
|
about = {}
|
|
with open(os.path.join(src_dir, "cryptography", "__about__.py")) as f:
|
|
exec(f.read(), about)
|
|
|
|
|
|
SETUPTOOLS_DEPENDENCY = "setuptools"
|
|
CFFI_DEPENDENCY = "cffi>=0.8"
|
|
SIX_DEPENDENCY = "six>=1.4.1"
|
|
VECTORS_DEPENDENCY = "cryptography_vectors=={0}".format(about['__version__'])
|
|
|
|
requirements = [
|
|
CFFI_DEPENDENCY,
|
|
SIX_DEPENDENCY,
|
|
SETUPTOOLS_DEPENDENCY
|
|
]
|
|
|
|
# If you add a new dep here you probably need to add it in the tox.ini as well
|
|
test_requirements = [
|
|
"pytest",
|
|
"pyasn1",
|
|
"pretend",
|
|
"iso8601",
|
|
]
|
|
|
|
# If there's no vectors locally that probably means we are in a tarball and
|
|
# need to go and get the matching vectors package from PyPi
|
|
if not os.path.exists(os.path.join(base_dir, "vectors/setup.py")):
|
|
test_requirements.append(VECTORS_DEPENDENCY)
|
|
|
|
|
|
def cc_is_available():
|
|
return sys.platform == "darwin" and list(map(
|
|
int, platform.mac_ver()[0].split("."))) >= [10, 8, 0]
|
|
|
|
|
|
backends = [
|
|
"openssl = cryptography.hazmat.backends.openssl:backend"
|
|
]
|
|
|
|
if cc_is_available():
|
|
backends.append(
|
|
"commoncrypto = cryptography.hazmat.backends.commoncrypto:backend",
|
|
)
|
|
|
|
|
|
def get_ext_modules():
|
|
from cryptography.hazmat.bindings.commoncrypto.binding import (
|
|
Binding as CommonCryptoBinding
|
|
)
|
|
from cryptography.hazmat.bindings.openssl.binding import (
|
|
Binding as OpenSSLBinding
|
|
)
|
|
from cryptography.hazmat.primitives import constant_time, padding
|
|
|
|
ext_modules = [
|
|
OpenSSLBinding.ffi.verifier.get_extension(),
|
|
constant_time._ffi.verifier.get_extension(),
|
|
padding._ffi.verifier.get_extension()
|
|
]
|
|
if cc_is_available():
|
|
ext_modules.append(CommonCryptoBinding.ffi.verifier.get_extension())
|
|
return ext_modules
|
|
|
|
|
|
class CFFIBuild(build):
|
|
"""
|
|
This class exists, instead of just providing ``ext_modules=[...]`` directly
|
|
in ``setup()`` because importing cryptography requires we have several
|
|
packages installed first.
|
|
|
|
By doing the imports here we ensure that packages listed in
|
|
``setup_requires`` are already installed.
|
|
"""
|
|
|
|
def finalize_options(self):
|
|
self.distribution.ext_modules = get_ext_modules()
|
|
build.finalize_options(self)
|
|
|
|
|
|
class CFFIInstall(install):
|
|
"""
|
|
As a consequence of CFFIBuild and it's late addition of ext_modules, we
|
|
need the equivalent for the ``install`` command to install into platlib
|
|
install-dir rather than purelib.
|
|
"""
|
|
|
|
def finalize_options(self):
|
|
self.distribution.ext_modules = get_ext_modules()
|
|
install.finalize_options(self)
|
|
|
|
|
|
class PyTest(test):
|
|
def finalize_options(self):
|
|
test.finalize_options(self)
|
|
self.test_args = []
|
|
self.test_suite = True
|
|
|
|
# This means there's a vectors/ folder with the package in here.
|
|
# cd into it, install the vectors package and then refresh sys.path
|
|
if VECTORS_DEPENDENCY not in test_requirements:
|
|
subprocess.check_call(
|
|
[sys.executable, "setup.py", "install"], cwd="vectors"
|
|
)
|
|
pkg_resources.get_distribution("cryptography_vectors").activate()
|
|
|
|
def run_tests(self):
|
|
# Import here because in module scope the eggs are not loaded.
|
|
import pytest
|
|
errno = pytest.main(self.test_args)
|
|
sys.exit(errno)
|
|
|
|
|
|
def keywords_with_side_effects(argv):
|
|
"""
|
|
Get a dictionary with setup keywords that (can) have side effects.
|
|
|
|
:param argv: A list of strings with command line arguments.
|
|
:returns: A dictionary with keyword arguments for the ``setup()`` function.
|
|
|
|
This setup.py script uses the setuptools 'setup_requires' feature because
|
|
this is required by the cffi package to compile extension modules. The
|
|
purpose of ``keywords_with_side_effects()`` is to avoid triggering the cffi
|
|
build process as a result of setup.py invocations that don't need the cffi
|
|
module to be built (setup.py serves the dual purpose of exposing package
|
|
metadata).
|
|
|
|
All of the options listed by ``python setup.py --help`` that print
|
|
information should be recognized here. The commands ``clean``,
|
|
``egg_info``, ``register``, ``sdist`` and ``upload`` are also recognized.
|
|
Any combination of these options and commands is also supported.
|
|
|
|
This function was originally based on the `setup.py script`_ of SciPy (see
|
|
also the discussion in `pip issue #25`_).
|
|
|
|
.. _pip issue #25: https://github.com/pypa/pip/issues/25
|
|
.. _setup.py script: https://github.com/scipy/scipy/blob/master/setup.py
|
|
"""
|
|
no_setup_requires_arguments = (
|
|
'-h', '--help',
|
|
'-n', '--dry-run',
|
|
'-q', '--quiet',
|
|
'-v', '--verbose',
|
|
'-V', '--version',
|
|
'--author',
|
|
'--author-email',
|
|
'--classifiers',
|
|
'--contact',
|
|
'--contact-email',
|
|
'--description',
|
|
'--egg-base',
|
|
'--fullname',
|
|
'--help-commands',
|
|
'--keywords',
|
|
'--licence',
|
|
'--license',
|
|
'--long-description',
|
|
'--maintainer',
|
|
'--maintainer-email',
|
|
'--name',
|
|
'--no-user-cfg',
|
|
'--obsoletes',
|
|
'--platforms',
|
|
'--provides',
|
|
'--requires',
|
|
'--url',
|
|
'clean',
|
|
'egg_info',
|
|
'register',
|
|
'sdist',
|
|
'upload',
|
|
)
|
|
|
|
def is_short_option(argument):
|
|
"""Check whether a command line argument is a short option."""
|
|
return len(argument) >= 2 and argument[0] == '-' and argument[1] != '-'
|
|
|
|
def expand_short_options(argument):
|
|
"""Expand combined short options into canonical short options."""
|
|
return ('-' + char for char in argument[1:])
|
|
|
|
def argument_without_setup_requirements(argv, i):
|
|
"""Check whether a command line argument needs setup requirements."""
|
|
if argv[i] in no_setup_requires_arguments:
|
|
# Simple case: An argument which is either an option or a command
|
|
# which doesn't need setup requirements.
|
|
return True
|
|
elif (is_short_option(argv[i]) and
|
|
all(option in no_setup_requires_arguments
|
|
for option in expand_short_options(argv[i]))):
|
|
# Not so simple case: Combined short options none of which need
|
|
# setup requirements.
|
|
return True
|
|
elif argv[i - 1:i] == ['--egg-base']:
|
|
# Tricky case: --egg-info takes an argument which should not make
|
|
# us use setup_requires (defeating the purpose of this code).
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
if all(argument_without_setup_requirements(argv, i)
|
|
for i in range(1, len(argv))):
|
|
return {
|
|
"cmdclass": {
|
|
"build": DummyCFFIBuild,
|
|
"install": DummyCFFIInstall,
|
|
"test": DummyPyTest,
|
|
}
|
|
}
|
|
else:
|
|
return {
|
|
"setup_requires": requirements,
|
|
"cmdclass": {
|
|
"build": CFFIBuild,
|
|
"install": CFFIInstall,
|
|
"test": PyTest,
|
|
}
|
|
}
|
|
|
|
|
|
setup_requires_error = ("Requested setup command that needs 'setup_requires' "
|
|
"while command line arguments implied a side effect "
|
|
"free command or option.")
|
|
|
|
|
|
class DummyCFFIBuild(build):
|
|
"""
|
|
This class makes it very obvious when ``keywords_with_side_effects()`` has
|
|
incorrectly interpreted the command line arguments to ``setup.py build`` as
|
|
one of the 'side effect free' commands or options.
|
|
"""
|
|
|
|
def run(self):
|
|
raise RuntimeError(setup_requires_error)
|
|
|
|
|
|
class DummyCFFIInstall(install):
|
|
"""
|
|
This class makes it very obvious when ``keywords_with_side_effects()`` has
|
|
incorrectly interpreted the command line arguments to ``setup.py install``
|
|
as one of the 'side effect free' commands or options.
|
|
"""
|
|
|
|
def run(self):
|
|
raise RuntimeError(setup_requires_error)
|
|
|
|
|
|
class DummyPyTest(test):
|
|
"""
|
|
This class makes it very obvious when ``keywords_with_side_effects()`` has
|
|
incorrectly interpreted the command line arguments to ``setup.py test`` as
|
|
one of the 'side effect free' commands or options.
|
|
"""
|
|
|
|
def run_tests(self):
|
|
raise RuntimeError(setup_requires_error)
|
|
|
|
|
|
with open(os.path.join(base_dir, "README.rst")) as f:
|
|
long_description = f.read()
|
|
|
|
|
|
setup(
|
|
name=about["__title__"],
|
|
version=about["__version__"],
|
|
|
|
description=about["__summary__"],
|
|
long_description=long_description,
|
|
license=about["__license__"],
|
|
url=about["__uri__"],
|
|
|
|
author=about["__author__"],
|
|
author_email=about["__email__"],
|
|
|
|
classifiers=[
|
|
"Intended Audience :: Developers",
|
|
"License :: OSI Approved :: Apache Software License",
|
|
"License :: OSI Approved :: BSD License",
|
|
"Natural Language :: English",
|
|
"Operating System :: MacOS :: MacOS X",
|
|
"Operating System :: POSIX",
|
|
"Operating System :: POSIX :: BSD",
|
|
"Operating System :: POSIX :: Linux",
|
|
"Operating System :: Microsoft :: Windows",
|
|
"Programming Language :: Python",
|
|
"Programming Language :: Python :: 2",
|
|
"Programming Language :: Python :: 2.6",
|
|
"Programming Language :: Python :: 2.7",
|
|
"Programming Language :: Python :: 3",
|
|
"Programming Language :: Python :: 3.2",
|
|
"Programming Language :: Python :: 3.3",
|
|
"Programming Language :: Python :: 3.4",
|
|
"Programming Language :: Python :: Implementation :: CPython",
|
|
"Programming Language :: Python :: Implementation :: PyPy",
|
|
"Topic :: Security :: Cryptography",
|
|
],
|
|
|
|
package_dir={"": "src"},
|
|
packages=find_packages(where="src", exclude=["tests", "tests.*"]),
|
|
include_package_data=True,
|
|
|
|
install_requires=requirements,
|
|
tests_require=test_requirements,
|
|
|
|
# for cffi
|
|
zip_safe=False,
|
|
ext_package="cryptography",
|
|
entry_points={
|
|
"cryptography.backends": backends,
|
|
},
|
|
**keywords_with_side_effects(sys.argv)
|
|
)
|