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()