def main():
builder = ConanMultiPackager(
username='******',
archs=['x86_64'],
upload='https://api.bintray.com/conan/fmorgner/conan-fmorgner',
remotes='https://api.bintray.com/conan/fmorgner/conan-fmorgner',
)
builder.add()
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)
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_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)
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
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add(settings={})
builder.run()
from conan.packager import ConanMultiPackager
# Common settings
username = "******" if "CONAN_USERNAME" not in os.environ else None
# Windows settings
visual_versions = ["15", "16"] if "CONAN_VISUAL_VERSIONS" not in os.environ else None
visual_runtimes = ["MD", "MDd"] if "CONAN_VISUAL_RUNTIMES" not in os.environ else None
dll_sign = False if "CONAN_DISABLE_DLL_SIGN" in os.environ else True
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=True)
# Adjusting build configurations
builds = builder.items
# Replace build configurations
builder.items = []
for settings, options, env_vars, build_requires, _ in builds:
builder.add(
settings=settings,
options=options,
env_vars=env_vars,
build_requires=build_requires
)
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(build_policy="missing")
builder.add({"compiler.libcxx": "libstdc++11", "build_type": "Release"})
builder.add({"compiler.libcxx": "libstdc++11", "build_type": "Debug"})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(build_policy="missing", gcc_versions=["5"], archs=["x86_64"], username="******")
builder.add({"compiler.version": 5, "compiler.libcxx": "libstdc++11", "arch": "x86_64", "build_type": "Release"},
{"zipkin-cpp-opentracing:shared": False})
builder.add({"compiler.version": 5, "compiler.libcxx": "libstdc++11", "arch": "x86_64", "build_type": "Debug"},
{"zipkin-cpp-opentracing:shared": False})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add(settings={"os": "Android", "os.api_level": "21", "arch": "armv7", "compiler": "clang", "compiler.version": "7.0", "compiler.libcxx": "libc++"},
options={"android-ndk:libcxx": "shared", "android-ndk:arm_mode": "thumb", "android-ndk:neon": "True"})
builder.add(settings={"os": "Android", "os.api_level": "28", "arch": "armv8", "compiler": "clang", "compiler.version": "7.0", "compiler.libcxx": "libc++"})
builder.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from conan.packager import ConanMultiPackager
from conans.client.tools.oss import detected_os
from conans.util.env_reader import get_env
if __name__ == "__main__":
arch_str = get_env("ARCH", "x86,x86_64")
archs = arch_str.split(",")
builder = ConanMultiPackager(
# docker_entry_script="pwd && ls",
)
for arch in archs:
builder.add(settings={
"arch_build": arch,
"os_build": detected_os(),
})
builder.run()
from conan.packager import ConanMultiPackager
from conans import tools
if __name__ == "__main__":
builder = ConanMultiPackager()
if tools.os_info.is_windows:
builder.add(settings={
"compiler": "Visual Studio",
"compiler.version": "16",
"arch": "x86",
"build_type": "Release"
},
options={},
env_vars={},
build_requires={})
elif tools.os_info.is_linux:
builder.add(settings={
"compiler": "gcc",
"compiler.version": "8",
"arch": "x86_64",
"build_type": "Release"
},
options={},
env_vars={},
build_requires={})
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()
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()
for shared in ["True", "False"]:
if build_type == "Debug" and compiler_runtime == "MT" and shared == "True":
# NB: "Debug Assertion Failed!" in protoc.exe, at C++ Runtime "debug_heap.cpp" or "dbgheap.cpp"
# "arch": ["x86", "x86_64"]
# "compiler.version": ["11", 12", "14"]
continue
settings = {}
settings["compiler"] = "Visual Studio"
settings["compiler.version"] = compiler_version
settings["build_type"] = build_type
settings["compiler.runtime"] = "%s%s" % (compiler_runtime, "d" if build_type == "Debug" else "")
settings["arch"] = arch
options = {}
options["Protobuf:shared"] = shared
builder.add(settings, options)
else:
for build_type in ["Release", "Debug"]:
for shared in ["True", "False"]:
settings = {}
settings["build_type"] = build_type
options = {}
options["Protobuf:shared"] = shared
builder.add(settings, options)
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()
import os
from conan.packager import ConanMultiPackager
# Common settings
username = "******" if "CONAN_USERNAME" not in os.environ else None
if __name__ == "__main__":
builder = ConanMultiPackager(username=username,
exclude_vcvars_precommand=True)
builder.add()
builder.run()
username, _ = reponame_a.split("/") if reponame_a else reponame_t.split("/")
channel, version = repobranch_a.split("/") 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({}, {}, {}, {})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add(settings={"os": "iOS", "os.version": "9.0", 'arch': 'x86_64'})
# builder.add(settings={"os": "watchOS", "os.version": "4.0", "arch": "armv8"})
# builder.add(settings={"os": "tvOS", "os.version": "11.0", "arch": "armv8"})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
command = "gcc --version && g++ --version"
builder = ConanMultiPackager(docker_entry_script=command)
builder.add(
settings={
'compiler.libcxx': 'libstdc++11',
'arch': 'x86_64',
'build_type': 'Release',
'compiler': 'gcc'
})
builder.run()
from conan.packager import ConanMultiPackager
import copy
if __name__ == "__main__":
builder = ConanMultiPackager()
base = {
"os": "Windows",
"compiler": "gcc",
"compiler.version": "7.1",
"compiler.exception": "seh",
"compiler.libcxx": "libstdc++",
"compiler.threads": "posix"
}
for version in ["4.9", "5.4", "6.4", "7.2"]:
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["compiler.exception"] = ex
builder.add(tmp3, {}, {}, {})
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******")
#builder.add_common_builds(pure_c=False)
builder.add(settings={
"arch": "x86_64",
"build_type": "Debug"
},
options={},
env_vars={},
build_requires={})
builder.run()
"3.11.1", "3.10.0", "3.9.0", "3.8.2",
"3.8.1", "3.8.0", "3.7.2", "3.7.1",
"3.7.0", "3.6.3", "3.6.2", "3.6.1",
"3.6.0", "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()
i386 = "CONAN_DOCKER_IMAGE" in os.environ and \
os.environ["CONAN_DOCKER_IMAGE"].endswith("i386")
# New mode, with version field
for version in available_versions:
# Unknown problem with 3.0.2 on travis
# Building from sources takes much time so build the very recent 32bit version only
if (version > "3.0.2" and not i386) or platform.system() == "Windows" or \
version == available_versions[0]:
builder.add({}, {}, {}, {}, reference="cmake_installer/%s" % version)
# Old mode, with options
for version in available_versions:
# Unknown problem with 3.0.2 on travis
# Building from sources takes much time so build the very recent 32bit version only
if (version > "3.0.2" and not i386) or platform.system() == "Windows" or \
version == available_versions[0]:
builder.add({}, {"cmake_installer:version": version}, {}, {}, "cmake_installer/1.0")
builder.run()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
libstd = ['libstdc++11', 'libstdc++']
types = ['Debug', 'Release']
configs = [[i, k] for i in libstd for k in types]
for triple in configs:
builder.add(settings={
"build_type": triple[1],
"compiler.libcxx": triple[0]
},
options={},
env_vars={},
build_requires={})
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-x86", 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-x86",
self.runner.calls[0])
self.assertIn("arch_build=x86\\", self.runner.calls[-1])
# Test the opossite
packager = ConanMultiPackager("--build missing -r conan.io",
"lasote",
"mychannel",
runner=self.runner,
use_docker=True,
docker_32_images=False,
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", self.runner.calls[0])
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)
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")
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
from conan.packager import ConanMultiPackager
from conans import __version__ as conan_version
from conans.model.version import Version
if __name__ == "__main__":
builder = ConanMultiPackager()
if conan_version < Version("0.99"):
builder.add({"os": "Windows", "arch": "x86"}, {}, {}, {})
builder.add({"os": "Windows", "arch": "x86_64"}, {}, {}, {})
else:
builder.add({"os_build": "Windows", "arch_build": "x86"}, {}, {}, {})
builder.add({
"os_build": "Windows",
"arch_build": "x86_64"
}, {}, {}, {})
builder.run()
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()
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add(settings={
"os": "Android",
"os.api_level": 21,
"arch": "armv7",
"compiler": "gcc",
"compiler.version": "4.9",
"compiler.libcxx": "libstdc++"
},
options={},
env_vars={},
build_requires={})
builder.add(settings={
"os": "Android",
"os.api_level": 21,
"arch": "armv7",
"compiler": "clang",
"compiler.version": "5.0",
"compiler.libcxx": "libc++"
},
options={},
env_vars={},
build_requires={})
builder.run()
from conan.packager import ConanMultiPackager
import copy
import platform
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="Boost:shared", pure_c=False)
builder.add({}, {"Boost:header_only": True}, {}, {})
if platform.system() == "Linux":
filtered_builds = []
for settings, options, env_vars, build_requires in builder.builds:
filtered_builds.append([settings, options])
new_options = copy.copy(options)
new_options["Boost:fPIC"] = True
filtered_builds.append(
[settings, new_options, env_vars, build_requires])
builder.builds = filtered_builds
builder.run()
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()
repobranch_a = os.getenv("APPVEYOR_REPO_BRANCH","")
reponame_t = os.getenv("TRAVIS_REPO_SLUG","")
repobranch_t = os.getenv("TRAVIS_BRANCH","")
username, _ = reponame_a.split("/") if reponame_a else reponame_t.split("/")
channel, version = repobranch_a.split("/") 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({"os" : get_os(), "arch" : "x86_64"}, {}, {}, {})
builder.run()
from conan.packager import ConanMultiPackager
import copy
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
if ((settings["compiler"] == "Visual Studio") and
(int(settings["compiler.version"]) >= 14)) and (int(
settings["compiler.version"]) <= 15):
options_use_icu = options.copy()
options_use_icu["boost:use_icu"] = True
filtered_builds.append(
[settings, options_use_icu, env_vars, build_requires])
import os
from conan.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(
build_policy="missing",
remotes="https://api.bintray.com/conan/bincrafters/public-conan")
builder.add({"compiler.libcxx": "libstdc++11"})
builder.add_common_builds(shared_option_name="dlib:shared", pure_c=False)
builder.run()
#/usr/bin/python3
from conan.packager import ConanMultiPackager
import platform
if __name__ == "__main__":
builder = ConanMultiPackager(visual_runtimes=["MT", "MD"])
if platform.system() == "Windows":
builder.add_common_builds()
if platform.system() == "Linux":
for ver in builder.gcc_versions:
for bt in [ "Release", "Debug"]:
builder.add(
{"arch": "x86_64",
"build_type": bt,
"compiler": "gcc",
"compiler.version": ver,
"compiler.libcxx": "libstdc++11"})
builder.run()
from conan.packager import ConanMultiPackager
import platform
import os
if __name__ == "__main__":
builder = ConanMultiPackager(visual_runtimes=["MT", "MD"])
if platform.system() == "Windows":
builder.add_common_builds(visual_versions=[12, 13])
if platform.system() == "Linux":
for ver in (filter(None,
os.getenv("CONAN_GCC_VERSIONS", "").split(","))
or ["4.8", "4.9", "5.2", "5.3"]):
for arch in ["x86", "x86_64"]:
builder.add({"arch": arch,
"build_type": "Release",
"compiler": "gcc",
"compiler.version": ver}, {})
if platform.system() == "Darwin":
for ver in (filter(None,
os.getenv("CONAN_APPLE_CLANG_VERSIONS_VERSIONS", "").split(","))
or ["5.0", "5.1", "6.0", "6.1", "7.0"]):
for arch in ["x86", "x86_64"]:
builder.add({"arch": arch,
"build_type": "Release",
"compiler": "apple-clang",
"compiler.version": ver}, {})
builder.run()
