def test_disable_test_folder(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.0"
"""
self.save_conanfile(conanfile)
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
def test(self):
raise Exception("Should not run")
"""
tools.save(
os.path.join(self.tmp_folder, "test_package", "conanfile.py"),
conanfile)
with tools.environment_append({"CPT_TEST_FOLDER": "False"}):
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add_common_builds()
self.packager.run()
def test_deprecation_gcc(self):
with self.assertRaisesRegexp(Exception,
"DEPRECATED GCC MINOR VERSIONS!"):
ConanMultiPackager(username="******",
channel="mychannel",
runner=self.runner,
conan_api=self.conan_api,
gcc_versions=["4.3", "5.4"],
use_docker=True,
reference="zlib/1.2.11",
ci_manager=self.ci_manager)
def test_invalid_pip_command(self):
""" CPT should not accept invalid `pip` command when CONAN_PIP_COMMAND is declared.
"""
with tools.environment_append({"CONAN_USERNAME": "******",
"CONAN_PIP_PACKAGE": "conan==0.1.0",
"CONAN_PIP_COMMAND": "/bin/bash"}):
output = TestBufferConanOutput()
with self.assertRaises(Exception) as context:
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
reference="lib/1.0",
ci_manager=self.ci_manager,
out=output.write,
conan_api=self.conan_api,
runner=self.runner,
exclude_vcvars_precommand=True)
self.packager.add_common_builds()
self.packager.run()
self.assertTrue("CONAN_PIP_COMMAND: '/bin/bash' is not a valid pip command" in context.exception)
self.assertNotIn("[pip_update]", output)
def test_msvc(self):
conanfile = """from conans import ConanFile
import os
class Pkg(ConanFile):
settings = "os", "compiler", "build_type", "arch"
def build(self):
assert("WindowsLibPath" in os.environ)
"""
self.save_conanfile(conanfile)
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
visual_versions=[15],
archs=["x86"],
build_types=["Release"],
visual_runtimes=["MD"],
reference="zlib/1.2.2")
self.packager.add_common_builds()
self.packager.run_builds(1, 1)
def test_named_pages(self):
builder = ConanMultiPackager(username="******",
reference="zlib/1.2.11",
ci_manager=self.ci_manager)
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.items:
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_build_policy(self):
ci_manager = MockCIManager(build_policy="outdated")
conanfile = """from conans import ConanFile
import os
class Pkg(ConanFile):
name = "lib"
version = "1.2"
settings = "os", "compiler", "build_type", "arch"
"""
self.save_conanfile(conanfile)
with tools.environment_append({"CONAN_USERNAME": "******"}):
self.packager = ConanMultiPackager(channel="mychannel",
gcc_versions=["6"],
visual_versions=["12"],
archs=["x86", "x86_64"],
build_types=["Release"],
ci_manager=ci_manager)
self.packager.add_common_builds()
self.packager.run()
def test_docker_clang(self):
self.packager = ConanMultiPackager(["--build missing", "-r conan.io"],
"lasote", "mychannel",
runner=self.runner,
conan_api=self.conan_api,
clang_versions=["3.8", "4.0"],
use_docker=True,
reference="zlib/1.2.11",
ci_manager=self.ci_manager)
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(self):
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
runner=self.runner,
conan_api=self.conan_api,
gcc_versions=["4.3", "5"],
use_docker=True,
reference="zlib/1.2.11",
ci_manager=self.ci_manager)
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 conanio/gcc43", self.runner.calls[0])
self.assertIn('docker run ', self.runner.calls[1])
self.assertNotIn('sudo pip', self.runner.calls[1])
self.assertIn('pip install', self.runner.calls[1])
self.assertIn('os=os1', self.runner.calls[4])
self.packager.run_builds(1, 2)
self.assertIn("docker pull conanio/gcc43", self.runner.calls[0])
# Next build from 4.3 is cached, not pulls are performed
self.assertIn('os=os3', self.runner.calls[5])
for the_bool in ["True", "False"]:
self.runner.reset()
with tools.environment_append({"CONAN_DOCKER_USE_SUDO": the_bool}):
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
runner=self.runner,
conan_api=self.conan_api,
gcc_versions=["4.3", "5"],
use_docker=True,
reference="zlib/1.2.11",
ci_manager=self.ci_manager)
self._add_build(1, "gcc", "4.3")
self.packager.run_builds(1, 2)
if the_bool == "True":
self.assertIn("sudo -E docker run", self.runner.calls[-1])
else:
self.assertNotIn("sudo -E docker run", self.runner.calls[-1])
self.assertIn("docker run", self.runner.calls[-1])
self.runner.reset()
with tools.environment_append({"CONAN_PIP_USE_SUDO": the_bool}):
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
runner=self.runner,
conan_api=self.conan_api,
gcc_versions=["4.3", "5"],
use_docker=True,
reference="zlib/1.2.11",
ci_manager=self.ci_manager)
self._add_build(1, "gcc", "4.3")
self.packager.run_builds(1, 2)
if the_bool == "True":
self.assertIn("sudo -E pip", self.runner.calls[1])
else:
self.assertNotIn("sudo -E pip", self.runner.calls[1])
self.assertIn("pip", self.runner.calls[1])
def test_no_upload_remote(self):
self.save_conanfile(self.conanfile)
mp = ConanMultiPackager(username="******", out=self.output.write)
mp.add({}, {}, {})
mp.run()
self.assertIn("Upload skipped, not upload remote available", self.output)
def test_shared_option_auto_managed(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.0"
settings = "os", "compiler", "build_type", "arch"
options = {"shared": [True, False]}
"""
self.save_conanfile(conanfile)
self.packager = ConanMultiPackager(username="******")
self.packager.add_common_builds()
self.assertIn("lib:shared", self.packager.items[0].options)
# Even without name and version but reference
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
settings = "os", "compiler", "build_type", "arch"
options = {"shared": [True, False]}
"""
self.save_conanfile(conanfile)
self.packager = ConanMultiPackager(username="******",
reference="lib2/1.0")
self.packager.add_common_builds()
self.assertIn("lib2:shared", self.packager.items[0].options)
self.packager = ConanMultiPackager(username="******",
reference="lib2/1.0")
self.packager.add_common_builds(shared_option_name=False)
self.assertNotIn("lib2:shared", self.packager.items[0].options)
def test_existing_upload_repo_by_name(self):
self.api.remote_add(
"upload_repo",
"https://api.bintray.com/different/conan-community/conan")
self.save_conanfile(self.conanfile)
with tools.environment_append({
"CONAN_PASSWORD":
"******",
"CONAN_UPLOAD":
"https://api.bintray.com/conan/"
"conan-community/conan"
}):
mp = ConanMultiPackager(username="******",
out=self.output.write,
ci_manager=self.ci_manager)
mp.add({}, {}, {})
with self.assertRaisesRegexp(ConanException,
"Wrong user or password"):
mp.run()
self.assertNotIn(
"already exist, keeping the current remote and its name",
self.output)
repo = self.api.get_remote_by_name("upload_repo")
self.assertEquals(
repo.url,
"https://api.bintray.com/conan/conan-community/conan")
def test_custom_pip_command(self):
""" CPT should run custom `pip` path when CONAN_PIP_COMMAND is declared.
"""
pip = "pip3" if tools.which("pip3") else "pip2"
with tools.environment_append({"CONAN_USERNAME": "******",
"CONAN_PIP_PACKAGE": "conan==0.1.0",
"CONAN_PIP_INSTALL": "foobar==0.1.0",
"CONAN_PIP_COMMAND": pip}):
output = TestBufferConanOutput()
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
reference="lib/1.0",
ci_manager=self.ci_manager,
out=output.write,
conan_api=self.conan_api,
runner=self.runner,
exclude_vcvars_precommand=True)
self.packager.add_common_builds()
self.packager.run()
self.assertIn("[pip_update]", output)
self.assertIn(" {} install -q conan==0.1.0".format(pip), self.runner.calls)
self.assertIn(" {} install -q foobar==0.1.0".format(pip), self.runner.calls)
def select_defaults_test(self):
with tools.environment_append({"CONAN_REFERENCE": "zlib/1.2.8"}):
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
gcc_versions=["4.8", "5"],
username="******",
reference="lib/1.0@lasote/mychannel",
ci_manager=self.ci_manager)
self.assertEquals(builder.build_generator._clang_versions, [])
with tools.environment_append({"CONAN_GCC_VERSIONS": "4.8, 5",
"CONAN_REFERENCE": "zlib/1.2.8"}):
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
username="******",
reference="lib/1.0@lasote/mychannel",
ci_manager=self.ci_manager)
self.assertEquals(builder.build_generator._clang_versions, [])
self.assertEquals(builder.build_generator._gcc_versions, ["4.8", "5"])
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
clang_versions=["4.8", "5"],
username="******",
reference="lib/1.0",
ci_manager=self.ci_manager)
self.assertEquals(builder.build_generator._gcc_versions, [])
with tools.environment_append({"CONAN_CLANG_VERSIONS": "4.8, 5",
"CONAN_APPLE_CLANG_VERSIONS": " "}):
builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"),
username="******",
reference="lib/1.0",
ci_manager=self.ci_manager)
self.assertEquals(builder.build_generator._gcc_versions, [])
self.assertEquals(builder.build_generator._clang_versions, ["4.8", "5"])
self.assertEquals(builder.build_generator._clang_versions, ["4.8", "5"])
self.assertEquals(builder.build_generator._apple_clang_versions, [])
def build_conf(multi_options, **kw):
items = []
for options in multi_options:
builder = ConanMultiPackager()
builder.add_common_builds(pure_c=False, shared_option_name=False)
builder.update_build_if(lambda x: True, new_options=options)
items.extend(builder.items)
return items
def Main(name, pure_c=True):
sch = os.environ.get("CONANOS_SCHEME")
if not sch:
tools.out.error('''Warning !!!!!!!!!!
Use the conanos to build package, but you didn't set sdk name.
Please set CONANOS_SCHEME to right name which you want build the package for.
!!!!!!!!!!
''')
else:
tools.out.info('''
======================================
package : %s
scheme : %s
======================================
''' % (name, sch))
scheme = loadScheme_(sch)
if hasattr(scheme, 'pre_build'):
scheme.pre_build()
if platform.system() == 'Windows':
os.environ['CONAN_VISUAL_VERSIONS'] = os.environ.get(
'CONAN_VISUAL_VERSIONS', '15')
os.environ['CONAN_USERNAME'] = os.environ.get('CONAN_USERNAME', 'conanos')
PATTERN = re.compile(
r'conan(io|os)/(?P<compiler>gcc|clang|emcc)(?P<version>\d+)(-(?P<arch>\w+(-\w+)*))?'
)
m = PATTERN.match(os.environ.get('CONAN_DOCKER_IMAGE', ''))
docker_entry_script = ''
if m:
compiler = m.group('compiler')
version = m.group('version')
arch = 'x86_64' if not m.group('arch') else m.group('arch')
CONANOS_SCHEME = os.environ.get("CONANOS_SCHEME")
CONANOS_SCHEME_REPO = os.environ.get("CONANOS_SCHEME_REPO")
docker_entry_script += "pip install conan --upgrade"
docker_entry_script += " && pip install conan_package_tools"
docker_entry_script += " && pip install conanos --upgrade"
if CONANOS_SCHEME:
docker_entry_script += " && export CONANOS_SCHEME=%s" % CONANOS_SCHEME
if CONANOS_SCHEME_REPO:
docker_entry_script += " && export CONANOS_SCHEME_REPO=%s" % CONANOS_SCHEME_REPO
if os.path.exists('docker_entry_script.sh'):
docker_entry_script += ' && /bin/bash docker_entry_script.sh %s %s %s' % (
compiler, version, arch)
builder = ConanMultiPackager(docker_entry_script=docker_entry_script)
builder.add_common_builds(pure_c=pure_c)
_filter(name, builder)
builder.run()
def build():
n = get_build_number()
conanfile = load_conanfile_class(os.path.join(__dir__, 'conanfile.py'))
version = conanfile.version
CONAN_STABLE_CHANNEL = None
if n == 0:
CONAN_CHANNEL = 'stable'
CONAN_UPLOAD_ONLY_WHEN_STABLE = True
else:
version = '%s.%d' % (version, n)
CONAN_CHANNEL = 'testing'
CONAN_UPLOAD_ONLY_WHEN_STABLE = False
CONAN_STABLE_CHANNEL = 'testing'
update_version(version)
CONAN_UPLOAD = 'https://api.bintray.com/conan/%s/%s' % (CONAN_USERNAME,
CONAN_CHANNEL)
builder = ConanMultiPackager(
channel=CONAN_CHANNEL,
upload_only_when_stable=CONAN_UPLOAD_ONLY_WHEN_STABLE,
upload=CONAN_UPLOAD,
username=CONAN_USERNAME,
stable_channel=CONAN_STABLE_CHANNEL)
builder.add_common_builds()
builds = []
for settings, options, env_vars, build_requires, reference in builder.items:
# dynamic only
if not options["libwebstreamer:shared"]:
continue
# release only
if settings["build_type"] == "Debug":
continue
# Visual Sutido 2017 only
if platform.system() == "Windows":
if settings["compiler"] == "Visual Studio":
if settings["compiler.version"] == '14':
builds.append(
[settings, options, env_vars, build_requires])
elif platform.system() == "Linux":
if settings["compiler"] == "gcc":
if settings["compiler.version"] == '4.9' and settings[
"arch"] == 'x86_64':
builds.append([
settings, options, {
'DEPENDENT_BINTRAY_REPO': DEPENDENT_BINTRAY_REPO
}, build_requires
])
builder.builds = builds
builder.run()
def test_msvc_exclude_precommand(self):
conanfile = """from conans import ConanFile
import os
class Pkg(ConanFile):
settings = "os", "compiler", "build_type", "arch"
def build(self):
assert("WindowsLibPath" not in os.environ)
"""
self.save_conanfile(conanfile)
self.packager = ConanMultiPackager("--build missing -r conan.io",
"lasote",
"mychannel",
visual_versions=[15],
archs=["x86"],
build_types=["Release"],
visual_runtimes=["MD"],
exclude_vcvars_precommand=True,
reference="zlib/1.2.2")
self.packager.add_common_builds()
self.packager.run_builds(1, 1)
def get_builder(build_policy=None, cwd=None, **kwargs):
recipe = get_recipe_path(cwd)
name = get_name_from_recipe(recipe=recipe)
username, version, kwargs = get_conan_vars(recipe=recipe, kwargs=kwargs)
kwargs = get_reference(name, version, kwargs)
kwargs = get_conan_upload_param(username, kwargs)
kwargs = get_conan_remotes(username, kwargs)
kwargs = get_upload_when_stable(kwargs)
kwargs = get_stable_branch_pattern(kwargs)
kwargs = get_archs(kwargs)
build_policy = os.getenv('CONAN_BUILD_POLICY', build_policy)
builder = ConanMultiPackager(build_policy=build_policy, cwd=cwd, **kwargs)
return builder
def test_exported_files(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.0"
settings = "os"
exports = "*"
exports_sources = "source*"
"""
ci_manager = MockCIManager()
self.save_conanfile(conanfile)
tools.save(os.path.join(self.tmp_folder, "other_file"), "Dummy contents")
tools.save(os.path.join(self.tmp_folder, "source.cpp"), "Dummy contents")
self.packager = ConanMultiPackager(username="******", reference="lib/1.0", ci_manager=ci_manager)
self.packager.add({}, {}, {}, {})
self.packager.run()
ref = ConanFileReference.loads("lib/1.0@lasote/testing")
pf = self.client_cache.package_layout(ref).export()
found_in_export = False
for exported in os.listdir(pf):
if "other_file" == exported:
found_in_export = True
break
self.assertTrue(found_in_export)
pf = self.client_cache.package_layout(ref).export_sources()
found_in_export_sources = False
for exported in os.listdir(pf):
if "source.cpp" == exported:
found_in_export_sources = True
break
self.assertTrue(found_in_export_sources)
def test_custom_conanfile(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.2"
settings = "os", "compiler", "build_type", "arch"
"""
tools.save(os.path.join(self.tmp_folder, "foobar.py"), conanfile)
with tools.environment_append({"CONAN_CONANFILE": "foobar.py"}):
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run()
self.assertIn("conanfile | foobar.py", self.output)
tools.save(os.path.join(self.tmp_folder, "custom_recipe.py"), conanfile)
self.packager = ConanMultiPackager(username="******",
channel="mychannel",
conanfile="custom_recipe.py",
out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run()
self.assertIn("conanfile | custom_recipe.py", self.output)
def test_missing_username(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.0"
options = {"shared": [True, False]}
default_options = "shared=False"
"""
self.save_conanfile(conanfile)
with self.assertRaisesRegexp(
Exception, "Instance ConanMultiPackage with 'username' "
"parameter or use CONAN_USERNAME env variable"):
ConanMultiPackager()
def test_no_credentials_only_url(self):
self.save_conanfile(self.conanfile)
mp = ConanMultiPackager(username="******", out=self.output.write,
ci_manager=self.ci_manager,
upload="https://api.bintray.com/conan/conan-community/conan")
mp.add({}, {}, {})
mp.run()
self.assertIn("Upload skipped, credentials for remote 'my_upload_remote' "
"not available", self.output)
self.assertNotIn("Uploading packages", self.output)
def test_no_credentials_only_url(self):
self.save_conanfile(self.conanfile)
mp = ConanMultiPackager(username="******", out=self.output.write,
ci_manager=self.ci_manager,
upload="https://uilianr.jfrog.io/artifactory/api/conan/public-conan")
mp.add({}, {}, {})
mp.run()
self.assertIn("Upload skipped, credentials for remote 'my_upload_remote' "
"not available", self.output)
self.assertNotIn("Uploading packages", self.output)
def channel_detector_test(self):
for branch, expected_channel in [("testing", "a_channel"),
("dummy", "a_channel"),
("stable", "stable"),
("stable/something", "stable"),
("release", "stable"),
("release/something", "stable"),
("master", "stable"),
("master/something", "a_channel")]:
builder = ConanMultiPackager(username="******",
channel="a_channel",
reference="lib/1.0",
ci_manager=MockCIManager(current_branch=branch))
self.assertEquals(builder.channel, expected_channel, "Not match for branch %s" % branch)
def test_no_credentials_only_url_skip_check(self):
self.save_conanfile(self.conanfile)
with tools.environment_append({"CONAN_PASSWORD": "******",
"CONAN_UPLOAD_ONLY_WHEN_STABLE": "1"}):
mp = ConanMultiPackager(username="******", out=self.output.write,
channel="my_channel",
ci_manager=self.ci_manager,
upload="https://api.bintray.com/conan/conan-community/conan",)
mp.add({}, {}, {})
mp.run()
self.assertIn("Skipping upload, not stable channel", self.output)
def test_remove_build_if(self):
self.packager.add({
"arch": "x86",
"build_type": "Release",
"compiler": "gcc",
"compiler.version": "6"
})
self.packager.add({
"arch": "x86",
"build_type": "Debug",
"compiler": "gcc",
"compiler.version": "6"
})
self.packager.add({
"arch": "x86",
"build_type": "Release",
"compiler": "gcc",
"compiler.version": "7"
})
self.packager.add({
"arch": "x86",
"build_type": "Debug",
"compiler": "gcc",
"compiler.version": "7"
})
self.packager.remove_build_if(
lambda build: build.settings["compiler.version"] == "6")
packager_expected = ConanMultiPackager("lasote",
"mychannel",
runner=self.runner,
conan_api=self.conan_api,
reference="lib/1.0",
ci_manager=self.ci_manager)
packager_expected.add({
"arch": "x86",
"build_type": "Release",
"compiler": "gcc",
"compiler.version": "7"
})
packager_expected.add({
"arch": "x86",
"build_type": "Debug",
"compiler": "gcc",
"compiler.version": "7"
})
self.assertEqual([tuple(a) for a in self.packager.items],
packager_expected.items)
def test_no_credentials_but_skip(self):
with tools.environment_append({"CONAN_NON_INTERACTIVE": "1"}):
self.save_conanfile(self.conanfile)
mp = ConanMultiPackager(username="******", out=self.output.write,
ci_manager=self.ci_manager,
upload=("https://uilianr.jfrog.io/artifactory/api/conan/public-conan",
True, "my_upload_remote"),
skip_check_credentials=True)
mp.add({}, {}, {})
with self.assertRaisesRegexp(ConanException, "Errors uploading some packages"):
mp.run()
self.assertIn("Uploading packages for", self.output)
self.assertIn("Credentials not specified but 'skip_check_credentials' activated",
self.output)
def test_no_credentials_but_skip(self):
with tools.environment_append({"CONAN_NON_INTERACTIVE": "1"}):
self.save_conanfile(self.conanfile)
mp = ConanMultiPackager(username="******", out=self.output.write,
ci_manager=self.ci_manager,
upload=("https://api.bintray.com/conan/conan-community/conan",
True, "my_upload_remote"),
skip_check_credentials=True)
mp.add({}, {}, {})
with self.assertRaisesRegexp(ConanException, "Conan interactive mode disabled"):
mp.run()
self.assertIn("Uploading packages for", self.output)
self.assertIn("Credentials not specified but 'skip_check_credentials' activated",
self.output)
def test_existing_upload_repo(self):
self.api.remote_add("my_upload_repo", "https://api.bintray.com/conan/conan-community/conan")
self.save_conanfile(self.conanfile)
with tools.environment_append({"CONAN_PASSWORD": "******"}):
mp = ConanMultiPackager(username="******", out=self.output.write,
ci_manager=self.ci_manager,
upload=["https://api.bintray.com/conan/conan-community/conan",
False, "othername"])
mp.add({}, {}, {})
with self.assertRaisesRegexp(ConanException, "Wrong user or password"):
mp.run()
# The upload repo is kept because there is already an url
# FIXME: Probaby we should rename if name is different (Conan 1.3)
self.assertIn("Remote for URL 'https://api.bintray.com/conan/conan-community/conan' "
"already exist, keeping the current remote and its name", self.output)
def main():
with open(os.path.join(HERE, "requirements.txt")) as f:
requirement_str = f.read().replace("\\\n", " ").replace("\\\r\n", " ")
reqs = [
str(req) for req in pkg_resources.parse_requirements(requirement_str)
]
builder = ConanMultiPackager(pip_install=reqs)
builder.add_common_builds(pure_c=False)
configs = list(builder.items)
configs = _add_cpp_stds(configs)
if sys.platform == "darwin":
configs = _add_macos_versions(configs)
builder.items = configs
builder.run()
""" Only upload the package the branch name is like a tag
"""
return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"\d+\.\d+\.\d+")
@property
def reference(self):
""" Read project version from CMake file to create Conan referece
"""
pattern = re.compile(r"project\(taocpp-operators VERSION (\d+\.\d+\.\d+) LANGUAGES CXX\)")
version = None
with open('CMakeLists.txt') as file:
for line in file:
result = pattern.match(line)
if result:
version = result.group(1)
if not version:
raise Exception("Could not find version in CMakeLists.txt")
return os.getenv("CONAN_REFERENCE", "operators/{}@taocpp/stable".format(version))
if __name__ == "__main__":
settings = BuilderSettings()
builder = ConanMultiPackager(
reference=settings.reference,
username=settings.username,
upload=settings.upload,
upload_only_when_stable=settings.upload_only_when_stable,
stable_branch_pattern=settings.stable_branch_pattern,
test_folder=os.path.join(".conan", "test_package"))
builder.add()
builder.run()
def stable_branch_pattern(self):
""" Only upload the package the branch name is like a tag
"""
return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v(\d+\.\d+)")
@property
def version(self):
regex = re.compile(self.stable_branch_pattern)
match = regex.match(self.branch)
if match:
return match.group(1)
return "latest"
@property
def reference(self):
""" Read project version from branch name to create Conan referece
"""
return os.getenv("CONAN_REFERENCE", "civetweb/{}".format(self.version))
if __name__ == "__main__":
settings = BuilderSettings()
builder = ConanMultiPackager(
reference=settings.reference,
username=settings.username,
upload=settings.upload,
upload_only_when_stable=settings.upload_only_when_stable,
stable_branch_pattern=settings.stable_branch_pattern,
test_folder=os.path.join("conan", "test_package"))
builder.add_common_builds(pure_c=False)
builder.run()
def get_reference():
version = get_version()
username = get_username()
return "uvw/{}@{}/stable".format(version, username)
def get_upload():
username = get_username()
url = "https://api.bintray.com/conan/{}/conan".format(username)
default_upload = url if os.getenv("TRAVIS_TAG") else False
return os.getenv("CONAN_UPLOAD", default_upload)
def upload_when_stable():
return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "1").lower() not in ["0", "false", "no"]
if __name__ == "__main__":
test_folder = os.path.join(".conan", "test_package")
builder = ConanMultiPackager(reference=get_reference(),
username=get_username(),
upload=get_upload(),
test_folder=test_folder,
stable_branch_pattern=r'v?\d+\.\d+\.\d+.*',
upload_only_when_stable=upload_when_stable())
if platform.system() == "Linux":
builder.add(settings={"compiler": "gcc", "compiler.version": "8",
"arch": "x86_64", "build_type": "Release"},
options={}, env_vars={}, build_requires={})
builder.run()
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
from cpt.packager import ConanMultiPackager
def get_travis_branch():
return os.getenv("TRAVIS_BRANCH")
def get_reference():
return "CTRE/{}".format(get_travis_branch())
if __name__ == "__main__":
builder = ConanMultiPackager(
reference=get_reference(),
username="******",
upload="https://api.bintray.com/conan/hanickadot/ctre",
upload_only_when_stable=True,
stable_branch_pattern="v?\d+\.\d+.*",
test_folder=os.path.join(".conan", "test_package"))
builder.add_common_builds()
builder.run()
#!/usr/bin/python
import platform
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******", channel="testing")
builder.add(settings={"arch": "x86_64", "build_type": "Release"},
options={}, env_vars={}, build_requires={})
builder.run()
