def testSerialize(self):
self.packager.add({"os": "Windows", "compiler": "Visual Studio"},
{"option1": "value1", "option2": "value2"})
serial = self.packager.serialize()
self.assertEquals(serial, '{"username": "******", "conan_pip_package": null, "args": "--build missing -r conan.io", '\
'"builds": [[{"os": "Windows", "compiler": "Visual Studio"}, '\
'{"option2": "value2", "option1": "value1"}]], "channel": "mychannel"}')
mp = ConanMultiPackager.deserialize(serial, username="******")
self.assertEqual(mp.conan_pip_package, None)
self.packager.conan_pip_package = "conan==0.0.1rc7"
serial = self.packager.serialize()
mp = ConanMultiPackager.deserialize(serial, username="******")
self.assertEqual(mp.conan_pip_package, "conan==0.0.1rc7")
def run():
"""Reads environment json to create a ConanMultiPackager,
It can run packages with pagination with
CONAN_TOTAL_PAGES and CONAN_CURRENT_PAGE"""
the_json = os.getenv("CONAN_BUILDER_ENCODED", None)
current_page = int(os.getenv("CONAN_CURRENT_PAGE", "1"))
total_pages = int(os.getenv("CONAN_TOTAL_PAGES", "1"))
builder = ConanMultiPackager.deserialize(the_json)
builder.pack(current_page, total_pages)
def main():
"""
Main function.
"""
builder = ConanMultiPackager(username="******", channel="testing")
builder.add_common_builds()
filtered_builds = []
for settings, options, env_vars, build_requires in builder.builds:
if settings["compiler"] == "Visual Studio":
if settings["compiler.runtime"] == "MT" or settings["compiler.runtime"] == "MTd":
# Ignore MT runtime
continue
if settings["arch"] != "x86_64":
continue
filtered_builds.append([settings, options, env_vars, build_requires])
builder.builds = filtered_builds
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(stable_branch_pattern=r"release/")
builder.add_common_builds(shared_option_name="wxWidgets_custom:shared", pure_c=False)
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(pure_c=True, shared_option_name="libcurl:shared")
accepted_builds = []
if platform.system() == "Linux":
for build in builder.builds:
if build[0]["arch"] != "x86":
accepted_builds.append([build[0], build[1]])
builder.builds = accepted_builds
if platform.system() == "Darwin":
for build in builder.builds:
if not build[0]["arch"] == "x86":
accepted_builds.append([build[0], build[1]])
builder.builds = accepted_builds
for compiler in builder.apple_clang_versions:
builder.add({"compiler": "apple-clang", "compiler.version": compiler,
"arch": "x86_64", "build_type": "Release"}, {"libcurl:shared": False,
"libcurl:darwin_ssl": False,
"libcurl:custom_cacert": True})
builder.add({"compiler": "apple-clang", "compiler.version": compiler,
"arch": "x86_64", "build_type": "Debug"}, {"libcurl:shared": False,
"libcurl:darwin_ssl": False,
"libcurl:custom_cacert": True})
builder.run()
class AppTest(unittest.TestCase):
def setUp(self):
self.runner = MockRunner()
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner)
def testSerialize(self):
self.packager.add({"os": "Windows", "compiler": "Visual Studio"},
{"option1": "value1", "option2": "value2"})
serial = self.packager.serialize()
self.assertEquals(serial, '{"username": "******", "conan_pip_package": null, "args": "--build missing -r conan.io", '\
'"builds": [[{"os": "Windows", "compiler": "Visual Studio"}, '\
'{"option2": "value2", "option1": "value1"}]], "channel": "mychannel"}')
mp = ConanMultiPackager.deserialize(serial, username="******")
self.assertEqual(mp.conan_pip_package, None)
self.packager.conan_pip_package = "conan==0.0.1rc7"
serial = self.packager.serialize()
mp = ConanMultiPackager.deserialize(serial, username="******")
self.assertEqual(mp.conan_pip_package, "conan==0.0.1rc7")
def _add_build(self, number):
self.packager.add({"os": "os%d" % number, "compiler": "os%d" % number},
{"option%d" % number: "value%d" % number,
"option%d" % number: "value%d" % number})
def testPages(self):
for number in xrange(10):
self._add_build(number)
# 10 pages, 1 per build
self.packager.pack(1, 10)
self.assertTrue(self.runner.tests_for([0]))
# 2 pages, 5 per build
self.runner.reset()
self.packager.pack(1, 2)
self.assertTrue(self.runner.tests_for([0, 2, 4, 6, 8]))
self.runner.reset()
self.packager.pack(2, 2)
self.assertTrue(self.runner.tests_for([1, 3, 5, 7, 9]))
# 3 pages, 4 builds in page 1 and 3 in the rest of pages
self.runner.reset()
self.packager.pack(1, 3)
self.assertTrue(self.runner.tests_for([0, 3, 6, 9]))
self.runner.reset()
self.packager.pack(2, 3)
self.assertTrue(self.runner.tests_for([1, 4, 7]))
self.runner.reset()
self.packager.pack(3, 3)
self.assertTrue(self.runner.tests_for([2, 5, 8]))
def testDocker(self):
self.packager.docker_pack(1, 2, ["4.3", "5.2"])
self.assertIn("sudo docker pull lasote/conangcc43", self.runner.calls[0])
self.assertIn("-e CONAN_CURRENT_PAGE=1 -e CONAN_TOTAL_PAGES=2 ", self.runner.calls[1])
self.assertIn('-e CONAN_BUILDER_ENCODED=\'{"username": "******"', self.runner.calls[1])
self.assertIn('-e CONAN_USERNAME=lasote -e CONAN_CHANNEL=mychannel', self.runner.calls[1])
from conan.packager import ConanMultiPackager
import os
if __name__ == "__main__":
if os.getenv("CXX") == "g++-7":
version = os.getenv("TRAVIS_TAG")
if not version:
version = "dev"
reference = "functionalplus/%s" % version
username = "******"
channel = "stable"
upload_remote = "https://api.bintray.com/conan/Dobiasd/public-conan" if version is not "dev" else None
print("Conan package metadata:", reference, username, channel,
upload_remote)
builder = ConanMultiPackager(reference=reference,
username=username,
channel=channel,
upload=upload_remote)
builder.add(
settings={
'os': 'Linux',
'compiler.version': '7',
'compiler.libcxx': 'libstdc++11',
'arch': 'x86_64',
'build_type': 'Release',
'compiler': 'gcc'
})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="Poco:shared", pure_c=False)
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="electric-fence:shared", pure_c=True)
builder.run()
import platform
from conan.packager import ConanMultiPackager
if __name__ == '__main__':
builder = ConanMultiPackager()
builder.add_common_builds(pure_c=True, shared_option_name='curl:shared')
accepted_builds = []
if platform.system() == 'Linux':
for build in builder.builds:
if build[0]['arch'] != 'x86':
accepted_builds.append([build[0], build[1]])
builder.builds = accepted_builds
if platform.system() == 'Darwin':
for build in builder.builds:
if not build[0]['arch'] == 'x86':
accepted_builds.append([build[0], build[1]])
builder.builds = accepted_builds
for compiler in builder.apple_clang_versions:
builder.add(
{
'compiler': 'apple-clang',
'compiler.version': compiler,
'arch': 'x86_64',
'build_type': 'Release'
}, {
'curl:shared': False,
'curl:darwin_ssl': False,
'curl:custom_cacert': True
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(pure_c=True)
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add(settings={"arch": "armv7", "os.api_level": "16"})
builder.add(settings={"arch": "armv8", "os.api_level": "21"})
builder.add(settings={"arch": "x86", "os.api_level": "16"})
builder.add(settings={"arch": "x86_64", "os.api_level": "21"})
builder.run()
"/") if repobranch_a else repobranch_t.split("/")
return username, channel, version
def get_env_vars():
return get_ci_vars() if is_ci_running() else get_default_vars()
def get_os():
return platform.system().replace("Darwin", "Macos")
if __name__ == "__main__":
name = get_name_from_recipe()
username, channel, version = get_env_vars()
reference = "{0}/{1}".format(name, version)
upload = "https://api.bintray.com/conan/{0}/public-conan".format(username)
builder = ConanMultiPackager(
username=username,
channel=channel,
reference=reference,
upload=upload,
remotes=
upload, #while redundant, this moves bincrafters remote to position 0
upload_only_when_stable=True,
stable_branch_pattern="stable/*")
builder.add_common_builds()
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******", channel="testing")
builder.add_common_builds(shared_option_name="libzmq:shared")
builder.run()
import platform
from conan.packager import ConanMultiPackager
available_versions = ["3.9.0", "3.8.2", "3.7.2", "3.6.3",
"3.5.2", "3.4.3", "3.3.2", "3.2.3", "3.1.3", "3.0.2",
"2.8.12"]
if __name__ == "__main__":
builder = ConanMultiPackager()
for version in available_versions:
# Unknown problem with 3.0.2 on travis
if version > "3.0.2" or platform.system() == "Windows":
builder.add({}, {"cmake_installer:version": version}, {}, {})
builder.run()
def handle_microarchs(microarchs, filtered_builds, settings, options, env_vars,
build_requires):
print(microarchs)
microarchs = list(set(microarchs))
print(microarchs)
for ma in microarchs:
opts_copy = copy.deepcopy(options)
opts_copy["mpir:microarchitecture"] = ma
filtered_builds.append([settings, opts_copy, env_vars, build_requires])
if __name__ == "__main__":
builder = ConanMultiPackager(
username="******",
channel="stable",
remotes="https://api.bintray.com/conan/bitprim/bitprim")
builder.add_common_builds(shared_option_name="mpir:shared", pure_c=True)
builder.password = os.getenv("CONAN_PASSWORD")
filtered_builds = []
for settings, options, env_vars, build_requires in builder.builds:
if settings["build_type"] == "Release" \
and settings["arch"] == "x86_64" \
and not ("mpir:shared" in options and options["mpir:shared"]):
marchs = [
"x86_64", ''.join(cpuid.cpu_microarchitecture()), "haswell",
"skylake"
]
handle_microarchs(marchs, filtered_builds, settings, options,
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="libjpeg-turbo:shared", pure_c=True)
builder.run()
if __name__ == "__main__":
header_only = False
name = get_name_from_recipe()
version = get_version_from_recipe()
reference = "{0}/{1}".format(name, version)
username = "******"
login_username = "******"
upload_remote = "https://api.bintray.com/conan/conan-community/{0}".format(
username)
builder = ConanMultiPackager(stable_branch_pattern="stable/*",
upload_only_when_stable=True,
username=username,
login_username=login_username,
reference=reference,
upload=upload_remote,
remotes=upload_remote)
if header_only:
filtered_builds = []
for settings, options, env_vars, build_requires, reference in builder.items:
if settings["compiler"] == "gcc":
filtered_builds.append(
[settings, options, env_vars, build_requires])
break
builder.builds = filtered_builds
builder.add_common_builds(shared_option_name="wiringpi:shared",
pure_c=True)
def test_only_mingw(self):
mingw_configurations = [("4.9", "x86_64", "seh", "posix")]
builder = ConanMultiPackager(
mingw_configurations=mingw_configurations,
visual_versions=[],
username="******",
platform_info=platform_mock_for("Windows"),
reference="lib/1.0")
builder.add_common_builds(shared_option_name="zlib:shared",
pure_c=True)
expected = [
({
'compiler.exception': 'seh',
'compiler.libcxx': "libstdc++",
'compiler.threads': 'posix',
'compiler.version': '4.9',
'arch': 'x86_64',
'build_type': 'Release',
'compiler': 'gcc'
}, {
'zlib:shared': True
}, {}, {
'*':
[ConanFileReference.loads("mingw_installer/1.0@conan/stable")]
}),
({
'compiler.exception': 'seh',
'compiler.libcxx': "libstdc++",
'arch': 'x86_64',
'compiler.threads': 'posix',
'compiler.version': '4.9',
'build_type': 'Debug',
'compiler': 'gcc'
}, {
'zlib:shared': True
}, {}, {
'*':
[ConanFileReference.loads("mingw_installer/1.0@conan/stable")]
}),
({
'compiler.exception': 'seh',
'compiler.libcxx': "libstdc++",
'compiler.threads': 'posix',
'compiler.version': '4.9',
'arch': 'x86_64',
'build_type': 'Release',
'compiler': 'gcc'
}, {
'zlib:shared': False
}, {}, {
'*':
[ConanFileReference.loads("mingw_installer/1.0@conan/stable")]
}),
({
'compiler.exception': 'seh',
'compiler.libcxx': "libstdc++",
'arch': 'x86_64',
'compiler.threads': 'posix',
'compiler.version': '4.9',
'build_type': 'Debug',
'compiler': 'gcc'
}, {
'zlib:shared': False
}, {}, {
'*':
[ConanFileReference.loads("mingw_installer/1.0@conan/stable")]
})
]
self.assertEquals([tuple(a) for a in builder.builds], expected)
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(reference="llvm/9.0.0")
# builder.add_common_builds(reference="llvm/9.0.0")
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(build_policy="outdated")
builder.add_common_builds(shared_option_name=None)
builder.run()
result.append([settings, options, env_vars, build_requires, reference])
return result
def filter_libcxx(builds):
result = []
for settings, options, env_vars, build_requires, reference in builds:
if settings["compiler.libcxx"] == "libstdc++11":
result.append(
[settings, options, env_vars, build_requires, reference])
return result
if __name__ == "__main__":
builder = ConanMultiPackager(username=username,
visual_versions=visual_versions,
visual_runtimes=visual_runtimes,
exclude_vcvars_precommand=True)
builder.add_common_builds(pure_c=False)
# Adjusting build configurations
builds = builder.items
if platform.system() == "Windows":
builds = add_dll_sign(builds)
builds = filter_shared_MT(builds)
if platform.system() == "Linux":
builds = filter_libcxx(builds)
builds = add_with_unit_tests(builds)
# Replace build configurations
builder.items = []
for settings, options, env_vars, build_requires, _ in builds:
builder.add(settings=settings,
options=options,
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="BeagleBoneBlackGPIO:shared", pure_c=False)
builder.run()
from conan.packager import ConanMultiPackager
from conans import __version__ as conan_version
from conans.model.version import Version
if __name__ == "__main__":
builder = ConanMultiPackager()
os_name = "os" if conan_version < Version("0.99") else "os_build"
builder.add({os_name: "Windows"}, {}, {}, {})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="jansson:shared", pure_c=True)
builder.run()
#!/usr/bin/env python3
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******")
cxxstds = ['11','14']
libstdcxx = ['libstdc++', 'libstdc++11']
shared = [True, False]
for triple in [[c,l] for c in cxxstds for l in libstdcxx]:
builder.add(
settings={"compiler.libcxx":triple[1]},
options={"stdcxx" : triple[0], "fPIC":True},
env_vars={},
build_requires={})
builder.run()
from conan.packager import ConanMultiPackager
import os
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
if os.getenv("HEADER_ONLY"):
builder.add({}, {"boost:header_only": True})
else:
builder.add_common_builds(shared_option_name="boost:shared",
pure_c=False)
if platform.system() == "Windows":
filtered_builds = []
for settings, options, env_vars, build_requires in builder.builds:
# MinGW shared with linker errors. I don't have a clue
if settings["compiler"] == "gcc" and options[
"boost:shared"] is True:
continue
filtered_builds.append(
[settings, options, env_vars, build_requires])
builder.builds = filtered_builds
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
# It always use the default compiler version on each platform
if platform.system() == "Windows":
for arch in builder.archs:
builder.add(
settings={
"arch": arch,
"compiler": "Visual Studio",
"compiler.runtime": "MT"
})
elif platform.system() == "Linux" or builder.use_docker == True:
for arch in builder.archs:
builder.add(settings={"arch": arch, "compiler": "gcc"})
elif platform.system() == "Darwin":
for arch in builder.archs:
builder.add(settings={"arch": arch, "compiler": "apple-clang"})
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
# builder.add_common_builds(shared_option_name="SDL2:shared", pure_c=True)
# if platform.system() == "Darwin":
# # Remove static builds in OSx
# static_builds = []
# for build in builder.builds:
# if build[1]["SDL2:shared"]:
# static_builds.append([build[0], {}])
#
# builder.builds = static_builds
#
builder.run() # Will upload just the recipe
import os
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(
username="******",
channel="stable",
remotes="https://api.bintray.com/conan/bitprim/bitprim",
archs=["x86_64"])
builder.add_common_builds(shared_option_name="bitprim-node-cint:shared")
filtered_builds = []
for settings, options, env_vars, build_requires in builder.builds:
if settings["build_type"] == "Release" \
and not options["bitprim-node-cint:shared"] \
and (not "compiler.runtime" in settings or not settings["compiler.runtime"] == "MT"):
env_vars["BITPRIM_BUILD_NUMBER"] = os.getenv(
'BITPRIM_BUILD_NUMBER', '-')
filtered_builds.append(
[settings, options, env_vars, build_requires])
builder.builds = filtered_builds
builder.run()
from conan.packager import ConanMultiPackager
import copy
if __name__ == "__main__":
builder = ConanMultiPackager()
base = {"os": "Windows", "compiler": "gcc", "compiler.version": "7",
"compiler.exception": "seh", "compiler.libcxx": "libstdc++",
"compiler.threads": "posix"}
for version in ["4.9", "5", "6", "7", "8"]:
tmp = copy.copy(base)
tmp["compiler.version"] = version
for th in ["posix", "win32"]:
tmp2 = copy.copy(tmp)
tmp2["compiler.threads"] = th
for ex in ["seh", "sjlj"]:
tmp3 = copy.copy(tmp2)
tmp3["arch"] = "x86_64"
tmp3["compiler.exception"] = ex
builder.add(tmp3, {}, {}, {})
for ex in ["dwarf2", "sjlj"]:
tmp3 = copy.copy(tmp2)
tmp3["arch"] = "x86"
tmp3["compiler.exception"] = ex
builder.add(tmp3, {}, {}, {})
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager(build_policy="missing")
shared_option = False if platform.system() == "Windows" else None
builder.add_common_builds(shared_option_name=shared_option, pure_c=False)
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(pure_c=True)
x86_64_builds = []
for build in builder.builds: # Problems installing native GL libs for x86
if not build[0]["arch"] == "x86":
x86_64_builds.append([build[0], build[1]])
builder.builds = x86_64_builds
builder.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
from bincrafters import build_template_installer
from bincrafters import build_shared
from bincrafters import build_template_default
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="apache-apr-util:shared")
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="cyrus-sasl:shared")
builder.run()
from conan.packager import ConanMultiPackager
import os, platform
if __name__ == "__main__":
builder = ConanMultiPackager(args="--build missing")
builder.add_common_builds()
filtered_builds = []
for settings, options, env_vars, build_requires in builder.builds:
if not (settings["arch"] == "x86"):
filtered_builds.append(
[settings, options, env_vars, build_requires])
builder.builds = filtered_builds
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager(visual_runtimes=["MT", "MD"])
builder.add_common_builds()
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="libnghttp2:shared",
pure_c=True)
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="imageflow:shared", pure_c=True)
x64_builds = []
for build in builder.builds:
if build[0]["arch"] != "x86":
x64_builds.append([build[0], build[1]])
builder.builds = x64_builds
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager(username="******", channel="testing")
builder.add_common_builds(pure_c=False)
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******", channel="testing")
builder.add_common_builds(shared_option_name="ZMQ:shared")
builder.run()
def test_32bits_images(self):
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True,
docker_32_images=True,
reference="zlib/1.2.11")
packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"})
packager.run_builds(1, 1)
self.assertIn("docker pull lasote/conangcc6-i386", self.runner.calls[0])
self.runner.reset()
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True,
docker_32_images=False)
packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"})
packager.run_builds(1, 1)
self.assertNotIn("docker pull lasote/conangcc6-i386", self.runner.calls[0])
self.runner.reset()
with tools.environment_append({"CONAN_DOCKER_32_IMAGES": "1"}):
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True)
packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"})
packager.run_builds(1, 1)
self.assertIn("docker pull lasote/conangcc6-i386", self.runner.calls[0])
self.assertIn("arch_build=x86\\", self.runner.calls[-1])
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******", channel="testing")
builder.add_common_builds(shared_option_name="Protobuf:shared")
filtered_builds = []
for settings, options in builder.builds:
if settings["compiler.version"] in (12, 14):
filtered_builds.append([settings, options])
builder.builds = filtered_builds
builder.run()
def test_upload_false(self):
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel", upload=False)
self.assertFalse(packager._upload_enabled())
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager(visual_runtimes=["MT", "MD"])
if platform.system() == "Windows":
builder.add_common_builds(visual_versions=[12])
if platform.system() == "Linux":
for ver in ["4.8", "4.9", "5.2", "5.3"]:
for arch in ["x86", "x86_64"]:
for libcxx in ["libstdc++", "libstdc++11"]:
builder.add({"arch": arch,
"build_type": "Release",
"compiler": "gcc",
"compiler.version": ver,
"compiler.libcxx": libcxx},
{})
if platform.system() == "Darwin":
for compiler_version in ["5.0", "5.1", "6.0", "6.1", "7.0"]:
for arch in ["x86", "x86_64"]:
for build_type in ["Release"]:
builder.add({"arch": arch,
"build_type": build_type,
"compiler": "apple-clang",
"compiler.version": compiler_version}, {})
builder.run()
def test_url_handling(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes=["URL1", "URL2"],
upload="URL",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
print(runner.calls)
self.assertIn('conan remote add remote0 url2 --insert', runner.calls)
self.assertIn('conan remote add remote1 url1 --insert', runner.calls)
self.assertIn('conan remote add upload_repo url', runner.calls)
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes="URL1, URL2",
upload="URL",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 url2 --insert', runner.calls)
self.assertIn('conan remote add remote1 url1 --insert', runner.calls)
self.assertIn('conan remote add upload_repo url', runner.calls)
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes="URL1",
upload="URL",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 url1 --insert', runner.calls)
self.assertIn('conan remote add upload_repo url', runner.calls)
import os
from conan.packager import ConanMultiPackager
from conans import tools
if __name__ == "__main__":
runtimes = ["MD", "MDd"]
for subdir in ["sasl2", "sasldb", "gssapiv2"]:
ref = os.environ.get("CONAN_REFERENCE", "")
if ref:
name, ver = ref.split("/", 1)
os.environ["CONAN_REFERENCE"] = "cyrus-sasl-" + subdir + "/" + ver
with tools.chdir(os.path.join("win32", "conan", subdir)):
builder = ConanMultiPackager(visual_runtimes=runtimes)
builder.add_common_builds(shared_option_name=False, pure_c=True)
builder.run()
def test_remotes(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes=["url1", "url2"],
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 url2 --insert', runner.calls)
self.assertIn('conan remote add remote1 url1 --insert', runner.calls)
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes="myurl1",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 myurl1 --insert', runner.calls)
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="freetype:shared", pure_c=True)
builder.run()
def test_upload(self):
runner = MockRunner()
runner.output = "arepo: myurl"
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="myurl, otherurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# Duplicated upload remote puts upload repo first (in the remotes order)
self.assertEqual(runner.calls[0:3], ['conan remote add remote0 otherurl --insert',
'conan remote add upload_repo myurl --insert',
'conan remote list'])
# Now check that the upload remote order is preserved if we specify it in the remotes
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl, myurl, moreurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# Duplicated upload remote puts upload repo first (in the remotes order)
self.assertEqual(runner.calls[0:3], ['conan remote add remote0 moreurl --insert',
'conan remote add upload_repo myurl --insert',
'conan remote add remote2 otherurl --insert'])
self.assertEqual(runner.calls[-1],
'conan upload Hello/0.1@pepe/testing --retry 3 --all --force '
'--confirm -r=upload_repo')
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
self.assertEqual(runner.calls[0:3],
['conan remote add remote0 otherurl --insert',
'conan remote list',
'conan remote add upload_repo myurl'])
self.assertEqual(runner.calls[-1],
'conan upload Hello/0.1@pepe/testing --retry 3 --all '
'--force --confirm -r=upload_repo')
from conan.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager(username="******") builder.add_common_builds(pure_c=False) builder.run()
def test_build_policy(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"),
build_policy="outdated")
builder.add_common_builds()
builder.run()
self.assertIn(" --build=outdated", runner.calls[-1])
with tools.environment_append({"CONAN_BUILD_POLICY": "missing"}):
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"),
build_policy="missing")
builder.add_common_builds()
builder.run()
self.assertIn(" --build=missing", runner.calls[-1])
def setUp(self):
self.runner = MockRunner()
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner)
def test_check_credentials(self):
runner = MockRunner()
runner.output = "arepo: myurl"
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# When activated, check credentials before to create the profiles
self.assertEqual(runner.calls[0], 'conan remote add upload_repo myurl')
self.assertEqual(runner.calls[2], 'conan user pepe -p="password" -r=upload_repo')
self.assertIn("conan create", runner.calls[-2]) # Not login again before upload its cached
self.assertEqual(runner.calls[-1],
"conan upload Hello/0.1@pepe/testing --retry 3 --all --force --confirm "
"-r=upload_repo")
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# When upload is not required, credentials verification must be avoided
self.assertFalse('conan user pepe -p="password" -r=upload_repo' in runner.calls)
self.assertFalse('conan upload Hello/0.1@pepe/testing --retry 3 '
'--all --force --confirm -r=upload_repo' in runner.calls)
# If we skip the credentials check, the login will be performed just before the upload
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
platform_info=platform_mock_for("Darwin"),
skip_check_credentials=True)
builder.add_common_builds()
builder.run()
self.assertEqual(runner.calls[-2],
'conan user pepe -p="password" -r=upload_repo')
self.assertEqual(runner.calls[-1],
"conan upload Hello/0.1@pepe/testing --retry 3 --all --force --confirm "
"-r=upload_repo")
from conan.packager import ConanMultiPackager
import os
if __name__ == "__main__":
if os.getenv("CXX") == "g++-7":
version = os.getenv("TRAVIS_TAG")
if not version:
version = "dev"
reference = "functionalplus/%s" % version
username = "******"
channel = "stable"
upload_remote = "https://api.bintray.com/conan/dobiasd/public-conan" if version is not "dev" else None
print("Conan package metadata:", reference, username, channel, upload_remote)
builder = ConanMultiPackager(reference=reference,
username=username,
channel=channel,
upload=upload_remote)
builder.add(settings={
'os': 'Linux',
'compiler.version': '7',
'compiler.libcxx': 'libstdc++11',
'arch': 'x86_64',
'build_type': 'Release',
'compiler': 'gcc'
})
builder.run()
class AppTest(unittest.TestCase):
def setUp(self):
self.runner = MockRunner()
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner)
if "APPVEYOR" in os.environ:
del os.environ["APPVEYOR"]
if "TRAVIS" in os.environ:
del os.environ["TRAVIS"]
def _add_build(self, number, compiler=None, version=None):
self.packager.add({"os": "os%d" % number, "compiler": compiler or "compiler%d" % number,
"compiler.version": version or "4.3"},
{"option%d" % number: "value%d" % number,
"option%d" % number: "value%d" % number})
def test_full_profile(self):
self.packager.add({"os": "Windows", "compiler": "gcc"},
{"option1": "One"},
{"VAR_1": "ONE",
"VAR_2": "TWO"},
{"*": ["myreference/1.0@lasote/testing"]})
self.packager.run_builds(1, 1)
profile = self.runner.get_profile_from_trace(0)
self.assertEquals(profile.settings["os"], "Windows")
self.assertEquals(profile.settings["compiler"], "gcc")
self.assertEquals(profile.options.as_list(), [("option1", "One")])
self.assertEquals(profile.env_values.data[None]["VAR_1"], "ONE")
self.assertEquals(profile.env_values.data[None]["VAR_2"], "TWO")
self.assertEquals(profile.build_requires["*"],
[ConanFileReference.loads("myreference/1.0@lasote/testing")])
def test_profile_environ(self):
self.packager.add({"os": "Windows", "compiler": "gcc"},
{"option1": "One"},
{"VAR_1": "ONE",
"VAR_2": "TWO"},
{"*": ["myreference/1.0@lasote/testing"]})
with tools.environment_append({"CONAN_BUILD_REQUIRES": "br1/1.0@conan/testing"}):
self.packager.run_builds(1, 1)
profile = self.runner.get_profile_from_trace(0)
self.assertEquals(profile.build_requires["*"],
[ConanFileReference.loads("myreference/1.0@lasote/testing"),
ConanFileReference.loads("br1/1.0@conan/testing")])
def test_pages(self):
for number in range(10):
self._add_build(number)
# 10 pages, 1 per build
self.packager.run_builds(1, 10)
self.runner.assert_tests_for([0])
# 2 pages, 5 per build
self.runner.reset()
self.packager.run_builds(1, 2)
self.runner.assert_tests_for([0, 2, 4, 6, 8])
self.runner.reset()
self.packager.run_builds(2, 2)
self.runner.assert_tests_for([1, 3, 5, 7, 9])
# 3 pages, 4 builds in page 1 and 3 in the rest of pages
self.runner.reset()
self.packager.run_builds(1, 3)
self.runner.assert_tests_for([0, 3, 6, 9])
self.runner.reset()
self.packager.run_builds(2, 3)
self.runner.assert_tests_for([1, 4, 7])
self.runner.reset()
self.packager.run_builds(3, 3)
self.runner.assert_tests_for([2, 5, 8])
def test_deprecation_gcc(self):
with self.assertRaisesRegexp(Exception, "DEPRECATED GCC MINOR VERSIONS!"):
ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
gcc_versions=["4.3", "5.4"],
use_docker=True)
def test_32bits_images(self):
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True,
docker_32_images=True,
reference="zlib/1.2.11")
packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"})
packager.run_builds(1, 1)
self.assertIn("docker pull lasote/conangcc6-i386", self.runner.calls[0])
self.runner.reset()
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True,
docker_32_images=False)
packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"})
packager.run_builds(1, 1)
self.assertNotIn("docker pull lasote/conangcc6-i386", self.runner.calls[0])
self.runner.reset()
with tools.environment_append({"CONAN_DOCKER_32_IMAGES": "1"}):
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True)
packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"})
packager.run_builds(1, 1)
self.assertIn("docker pull lasote/conangcc6-i386", self.runner.calls[0])
self.assertIn("arch_build=x86\\", self.runner.calls[-1])
def test_docker_gcc(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
gcc_versions=["4.3", "5"],
use_docker=True)
self._add_build(1, "gcc", "4.3")
self._add_build(2, "gcc", "4.3")
self._add_build(3, "gcc", "4.3")
self.packager.run_builds(1, 2)
self.assertIn("docker pull lasote/conangcc43", self.runner.calls[0])
self.assertIn('docker run ', self.runner.calls[1])
self.assertIn('os=os1', self.runner.calls[4])
self.packager.run_builds(1, 2)
self.assertIn("docker pull lasote/conangcc43", self.runner.calls[0])
with tools.environment_append({"CONAN_DOCKER_USE_SUDO": "1"}):
self.packager.run_builds(1, 2)
self.assertIn("sudo docker run", self.runner.calls[-1])
# Next build from 4.3 is cached, not pulls are performed
self.assertIn('os=os3', self.runner.calls[5])
def test_docker_clang(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
clang_versions=["3.8", "4.0"],
use_docker=True)
self._add_build(1, "clang", "3.8")
self._add_build(2, "clang", "3.8")
self._add_build(3, "clang", "3.8")
self.packager.run_builds(1, 2)
self.assertIn("docker pull lasote/conanclang38", self.runner.calls[0])
self.assertIn('docker run ', self.runner.calls[1])
self.assertIn('os=os1', self.runner.calls[4])
# Next build from 3.8 is cached, not pulls are performed
self.assertIn('os=os3', self.runner.calls[5])
def test_docker_gcc_and_clang(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
gcc_versions=["5", "6"],
clang_versions=["3.9", "4.0"],
use_docker=True)
self._add_build(1, "gcc", "5")
self._add_build(2, "gcc", "5")
self._add_build(3, "gcc", "5")
self._add_build(4, "clang", "3.9")
self._add_build(5, "clang", "3.9")
self._add_build(6, "clang", "3.9")
self.packager.run_builds(1, 2)
self.assertIn("docker pull lasote/conangcc5", self.runner.calls[0])
self.assertIn('docker run ', self.runner.calls[1])
self.assertIn('os=os1', self.runner.calls[4])
self.assertIn('os=os3', self.runner.calls[5])
self.packager.run_builds(2, 2)
self.assertIn("docker pull lasote/conanclang39", self.runner.calls[16])
self.assertIn('docker run ', self.runner.calls[17])
self.assertIn('os=os4', self.runner.calls[20])
self.assertIn('os=os6', self.runner.calls[21])
def test_upload_false(self):
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel", upload=False)
self.assertFalse(packager._upload_enabled())
def test_docker_env_propagated(self):
# test env
with tools.environment_append({"CONAN_FAKE_VAR": "32"}):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
gcc_versions=["5", "6"],
clang_versions=["3.9", "4.0"],
use_docker=True)
self._add_build(1, "gcc", "5")
self.packager.run_builds(1, 1)
self.assertIn('-e CONAN_FAKE_VAR="32"', self.runner.calls[-1])
@unittest.skipUnless(sys.platform.startswith("win"), "Requires Windows")
def test_msvc(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
visual_versions=[15])
self.packager.add_common_builds()
with tools.environment_append({"VisualStudioVersion": "15.0"}):
self.packager.run_builds(1, 1)
self.assertIn("vcvars", self.runner.calls[1])
@unittest.skipUnless(sys.platform.startswith("win"), "Requires Windows")
def test_msvc_no_precommand(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
visual_versions=[15],
exclude_vcvars_precommand=True)
self.packager.add_common_builds()
self.packager.run_builds(1, 1)
self.assertNotIn("vcvars", self.runner.calls[1])
def test_docker_invalid(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
use_docker=True)
self._add_build(1, "msvc", "10")
# Only clang and gcc have docker images
self.assertRaises(Exception, self.packager.run_builds)
def test_assign_builds_retrocompatibility(self):
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote", "mychannel",
runner=self.runner,
gcc_versions=["4.3", "5"],
use_docker=True)
self.packager.add_common_builds()
self.packager.builds = [({"os": "Windows"}, {"option": "value"})]
self.assertEquals(self.packager.items, [BuildConf(settings={'os': 'Windows'},
options={'option': 'value'},
env_vars={}, build_requires={},
reference=None)])
def test_only_mingw(self):
mingw_configurations = [("4.9", "x86_64", "seh", "posix")]
builder = ConanMultiPackager(mingw_configurations=mingw_configurations, visual_versions=[],
username="******", platform_info=platform_mock_for("Windows"),
reference="lib/1.0")
builder.add_common_builds(shared_option_name="zlib:shared", pure_c=True)
expected = [({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++",
'compiler.threads': 'posix', 'compiler.version': '4.9', 'arch': 'x86_64',
'build_type': 'Release', 'compiler': 'gcc'},
{'zlib:shared': True},
{},
{'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]}),
({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++", 'arch': 'x86_64',
'compiler.threads': 'posix', 'compiler.version': '4.9', 'build_type': 'Debug',
'compiler': 'gcc'},
{'zlib:shared': True},
{},
{'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]}),
({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++",
'compiler.threads': 'posix', 'compiler.version': '4.9', 'arch': 'x86_64',
'build_type': 'Release', 'compiler': 'gcc'},
{'zlib:shared': False},
{},
{'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]}),
({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++", 'arch': 'x86_64',
'compiler.threads': 'posix', 'compiler.version': '4.9', 'build_type': 'Debug',
'compiler': 'gcc'},
{'zlib:shared': False},
{},
{'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]})]
self.assertEquals([tuple(a) for a in builder.builds], expected)
def test_named_pages(self):
builder = ConanMultiPackager(username="******")
named_builds = defaultdict(list)
builder.add_common_builds(shared_option_name="zlib:shared", pure_c=True)
for settings, options, env_vars, build_requires in builder.builds:
named_builds[settings['arch']].append([settings, options, env_vars, build_requires])
builder.named_builds = named_builds
self.assertEquals(builder.builds, [])
if platform.system() == "Darwin": # Not default x86 in Macos
self.assertEquals(len(builder.named_builds), 1)
self.assertFalse("x86" in builder.named_builds)
self.assertTrue("x86_64" in builder.named_builds)
else:
self.assertEquals(len(builder.named_builds), 2)
self.assertTrue("x86" in builder.named_builds)
self.assertTrue("x86_64" in builder.named_builds)
# Conan remote URLs require the username the be in all lowercase
def test_url_handling(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes=["URL1", "URL2"],
upload="URL",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
print(runner.calls)
self.assertIn('conan remote add remote0 url2 --insert', runner.calls)
self.assertIn('conan remote add remote1 url1 --insert', runner.calls)
self.assertIn('conan remote add upload_repo url', runner.calls)
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes="URL1, URL2",
upload="URL",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 url2 --insert', runner.calls)
self.assertIn('conan remote add remote1 url1 --insert', runner.calls)
self.assertIn('conan remote add upload_repo url', runner.calls)
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes="URL1",
upload="URL",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 url1 --insert', runner.calls)
self.assertIn('conan remote add upload_repo url', runner.calls)
def test_remotes(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes=["url1", "url2"],
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 url2 --insert', runner.calls)
self.assertIn('conan remote add remote1 url1 --insert', runner.calls)
runner = MockRunner()
builder = ConanMultiPackager(username="******",
remotes="myurl1",
runner=runner)
builder.add({}, {}, {}, {})
builder.run_builds()
self.assertIn('conan remote add remote0 myurl1 --insert', runner.calls)
def test_visual_defaults(self):
with tools.environment_append({"CONAN_VISUAL_VERSIONS": "10"}):
builder = ConanMultiPackager(username="******",
platform_info=platform_mock_for("Windows"))
builder.add_common_builds()
for settings, _, _, _ in builder.builds:
self.assertEquals(settings["compiler"], "Visual Studio")
self.assertEquals(settings["compiler.version"], "10")
with tools.environment_append({"CONAN_VISUAL_VERSIONS": "10",
"MINGW_CONFIGURATIONS": "4.9@x86_64@seh@posix"}):
builder = ConanMultiPackager(username="******",
platform_info=platform_mock_for("Windows"))
builder.add_common_builds()
for settings, _, _, _ in builder.builds:
self.assertEquals(settings["compiler"], "gcc")
self.assertEquals(settings["compiler.version"], "4.9")
def select_defaults_test(self):
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
gcc_versions=["4.8", "5"],
username="******")
self.assertEquals(builder.clang_versions, [])
with tools.environment_append({"CONAN_GCC_VERSIONS": "4.8, 5"}):
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
username="******")
self.assertEquals(builder.clang_versions, [])
self.assertEquals(builder.gcc_versions, ["4.8", "5"])
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
clang_versions=["4.8", "5"],
username="******")
self.assertEquals(builder.gcc_versions, [])
with tools.environment_append({"CONAN_CLANG_VERSIONS": "4.8, 5"}):
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
username="******")
self.assertEquals(builder.gcc_versions, [])
self.assertEquals(builder.clang_versions, ["4.8", "5"])
def test_upload(self):
runner = MockRunner()
runner.output = "arepo: myurl"
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="myurl, otherurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# Duplicated upload remote puts upload repo first (in the remotes order)
self.assertEqual(runner.calls[0:3], ['conan remote add remote0 otherurl --insert',
'conan remote add upload_repo myurl --insert',
'conan remote list'])
# Now check that the upload remote order is preserved if we specify it in the remotes
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl, myurl, moreurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# Duplicated upload remote puts upload repo first (in the remotes order)
self.assertEqual(runner.calls[0:3], ['conan remote add remote0 moreurl --insert',
'conan remote add upload_repo myurl --insert',
'conan remote add remote2 otherurl --insert'])
self.assertEqual(runner.calls[-1],
'conan upload Hello/0.1@pepe/testing --retry 3 --all --force '
'--confirm -r=upload_repo')
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
self.assertEqual(runner.calls[0:3],
['conan remote add remote0 otherurl --insert',
'conan remote list',
'conan remote add upload_repo myurl'])
self.assertEqual(runner.calls[-1],
'conan upload Hello/0.1@pepe/testing --retry 3 --all '
'--force --confirm -r=upload_repo')
def test_login(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner)
builder.login("Myremote", "myuser", "mypass", force=False)
self.assertIn('conan user myuser -p="mypass" -r=Myremote', runner.calls[-1])
runner.calls = []
# Already logged, not call conan user again
builder.login("Myremote", "myuser", "mypass", force=False)
self.assertEquals(len(runner.calls), 0)
# Already logged, but forced
runner.calls = []
builder.login("Myremote", "myuser", "mypass", force=True)
self.assertEquals(len(runner.calls), 1)
# Default users/pass
runner.calls = []
builder.login("Myremote2")
self.assertIn('conan user pepe -p="password" -r=Myremote2', runner.calls[-1])
def test_build_policy(self):
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"),
build_policy="outdated")
builder.add_common_builds()
builder.run()
self.assertIn(" --build=outdated", runner.calls[-1])
with tools.environment_append({"CONAN_BUILD_POLICY": "missing"}):
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"),
build_policy="missing")
builder.add_common_builds()
builder.run()
self.assertIn(" --build=missing", runner.calls[-1])
def test_check_credentials(self):
runner = MockRunner()
runner.output = "arepo: myurl"
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# When activated, check credentials before to create the profiles
self.assertEqual(runner.calls[0], 'conan remote add upload_repo myurl')
self.assertEqual(runner.calls[2], 'conan user pepe -p="password" -r=upload_repo')
self.assertIn("conan create", runner.calls[-2]) # Not login again before upload its cached
self.assertEqual(runner.calls[-1],
"conan upload Hello/0.1@pepe/testing --retry 3 --all --force --confirm "
"-r=upload_repo")
runner = MockRunner()
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
remotes="otherurl",
platform_info=platform_mock_for("Darwin"))
builder.add_common_builds()
builder.run()
# When upload is not required, credentials verification must be avoided
self.assertFalse('conan user pepe -p="password" -r=upload_repo' in runner.calls)
self.assertFalse('conan upload Hello/0.1@pepe/testing --retry 3 '
'--all --force --confirm -r=upload_repo' in runner.calls)
# If we skip the credentials check, the login will be performed just before the upload
builder = ConanMultiPackager(username="******", channel="testing",
reference="Hello/0.1", password="******",
upload="myurl", visual_versions=[], gcc_versions=[],
apple_clang_versions=[],
runner=runner,
platform_info=platform_mock_for("Darwin"),
skip_check_credentials=True)
builder.add_common_builds()
builder.run()
self.assertEqual(runner.calls[-2],
'conan user pepe -p="password" -r=upload_repo')
self.assertEqual(runner.calls[-1],
"conan upload Hello/0.1@pepe/testing --retry 3 --all --force --confirm "
"-r=upload_repo")
from conan.packager import ConanMultiPackager
def efence_options(options, no_electric_fence):
new_option_items = [
('OpenSSL:no_electric_fence', True),
('OpenSSL:zlib_dynamic', options['OpenSSL:shared'])
]
return dict(options.items() + new_option_items)
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="OpenSSL:shared", pure_c=True)
efence_builds = []
for settings, options in builder.builds:
efence_builds.append([settings, efence_options(options, True)])
efence_builds.append([settings, efence_options(options, False)])
builder.builds = efence_builds
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="Hello:shared")
builder.run()
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="littlecms:shared", pure_c=True)
builder.run()
def get_env_vars():
return get_ci_vars() if is_ci_running() else get_default_vars()
def get_os():
return platform.system().replace("Darwin", "Macos")
if __name__ == "__main__":
name = get_name_from_recipe()
username, channel, version = get_env_vars()
reference = "{0}/{1}".format(name, version)
upload = "https://api.bintray.com/conan/{0}/opensource".format(
username.lower())
bincrafters = "https://api.bintray.com/conan/bincrafters/public-conan"
builder = ConanMultiPackager(
username=username,
channel=channel,
reference=reference,
upload=upload,
remotes=[upload, bincrafters],
upload_only_when_stable=True,
docker_entry_script=
'sudo apt-get -qq update && sudo apt-get -qq install -y pkg-config',
stable_branch_pattern="stable/*")
builder.add_common_builds(shared_option_name=name + ":shared")
builder.run()
