#!/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()
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
remotes = [("https://api.bintray.com/conan/bincrafters/public-conan", "yes", "bincrafters"),
("https://api.bintray.com/conan/conan-community/conan", "yes", "conan-community"),
("https://api.bintray.com/conan/appimage-conan-community/public-conan", "yes", "appimage")]
command = "sudo apt-get -qq update && sudo apt-get -qq install -y gtk-doc-tools"
builder = ConanMultiPackager(build_policy="outdated", remotes=remotes, docker_entry_script=command)
builder.add_common_builds(shared_option_name="pango:shared")
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()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager(username="******")
builder.add_common_builds(pure_c=False)
builder.run()
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name=False)
builder.run()
# -*- coding: utf-8 -*-
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(pure_c=True)
builder.run()
class SimpleTest(BaseTest):
def test_missing_full_reference(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
pass
"""
self.save_conanfile(conanfile)
mp = ConanMultiPackager(username="******")
with self.assertRaisesRegexp(Exception, "Specify a CONAN_REFERENCE or name and version"):
mp.add_common_builds()
@unittest.skipUnless(sys.platform.startswith("win"), "Requires Windows")
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_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(username="******",
channel="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 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_auto_managed_subdirectory(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.0"
settings = "os", "compiler", "build_type", "arch"
options = {"shared": [True, False]}
"""
cwd = os.path.join(self.tmp_folder, "subdirectory")
tools.save(os.path.join(cwd, "conanfile.py"), conanfile)
self.packager = ConanMultiPackager(username="******", cwd=cwd)
self.packager.add_common_builds()
self.assertGreater(len(self.packager.items), 0)
self.assertIn("lib:shared", self.packager.items[0].options)
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_build_policy(self):
ci_manager = MockCIManager()
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"],
build_policy="outdated",
ci_manager=ci_manager)
self.packager.add_common_builds()
self.packager.run()
with tools.environment_append({"CONAN_USERNAME": "******",
"CONAN_BUILD_POLICY": "outdated"}):
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_multiple_build_policy(self):
ci_manager = MockCIManager()
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"],
build_policy=["cascade", "outdated"],
ci_manager=ci_manager)
self.packager.add_common_builds()
self.packager.run()
with tools.environment_append({"CONAN_USERNAME": "******",
"CONAN_BUILD_POLICY": "outdated, lib"}):
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_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_partial_reference(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "foobar"
version = "0.1.0"
def configure(self):
self.output.info("hello all")
"""
tools.save(os.path.join(self.tmp_folder, "conanfile.py"), conanfile)
with tools.environment_append({"CONAN_REFERENCE": "foobar/0.1.0@"}):
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run()
self.assertIn("partial_reference | foobar/0.1.0@", self.output)
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run()
self.assertIn("partial_reference | foobar/0.1.0@", self.output)
def test_save_packages_summary(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "foobar"
version = "0.1.0"
def configure(self):
self.output.info("hello all")
"""
json_file = 'cpt_summary_file.json'
tools.save(os.path.join(self.tmp_folder, "conanfile.py"), conanfile)
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run(summary_file=json_file)
self.assertTrue(os.path.isfile(json_file))
with open(json_file) as json_content:
json_data = json.load(json_content)
self.assertFalse(json_data[0]["package"]["error"])
json_file = "_" + json_file
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run()
self.packager.save_packages_summary(json_file)
self.assertTrue(os.path.isfile(json_file))
with open(json_file) as json_content:
json_data = json.load(json_content)
self.assertFalse(json_data[0]["package"]["error"])
json_file = "__" + json_file
with tools.environment_append({"CPT_SUMMARY_FILE": json_file}):
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add({}, {}, {}, {})
self.packager.run()
self.assertTrue(os.path.isfile(json_file))
with open(json_file) as json_content:
json_data = json.load(json_content)
self.assertFalse(json_data[0]["package"]["error"])
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_invalid_test_folder(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "lib"
version = "1.0"
"""
self.save_conanfile(conanfile)
for test_folder in ["True", "foobar"]:
with tools.environment_append({"CPT_TEST_FOLDER": test_folder}):
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add_common_builds()
with self.assertRaises(ConanException) as raised:
self.packager.run()
self.assertIn("test folder '{}' not available, or it doesn't have a conanfile.py"
.format(test_folder),
str(raised.exception))
def test_custom_name_version(self):
conanfile = """from conans import ConanFile
from datetime import date
class Pkg(ConanFile):
def configure(self):
self.output.info("hello all")
def set_name(self):
self.name = "foobar"
def set_version(self):
today = date.today()
self.version = today.strftime("%Y%B%d")
"""
tools.save(os.path.join(self.tmp_folder, "conanfile.py"), conanfile)
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add_common_builds(pure_c=False)
self.packager.run()
def test_header_only_option_true(self):
header_only = self._test_header_only(False)
self.assertEqual(header_only, 1)
self.packager.run()
def test_header_only_option_false(self):
header_only = self._test_header_only(True)
self.assertEqual(header_only, int(len(self.packager.builds) / 2))
self.packager.run()
def _test_header_only(self, default_value):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "qux"
version = "0.1.0"
settings = "os"
options = {"header_only": [True, False], "shared": [True, False], "fPIC": [True, False]}
default_options = {"header_only": %s, "shared": False, "fPIC": True}
def configure(self):
if self.options.header_only:
del self.options.shared
del self.options.fPIC
def package_id(self):
if self.options.header_only:
self.info.header_only()
""" % default_value
tools.save(os.path.join(self.tmp_folder, "conanfile.py"), conanfile)
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add_common_builds(pure_c=False)
header_only = 0
for build in self.packager.builds:
_, options, _, _ = build
if options.get("qux:header_only") == (not default_value):
header_only += 1
return header_only
def test_build_all_option_values(self):
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "qux"
version = "0.1.0"
options = {"shared": [True, False], "fPIC": [True, False],
"header_only": [True, False], "foo": [True, False],
"bar": ["baz", "qux", "foobar"], "blah": "ANY"}
default_options = {"shared": False, "fPIC": True, "header_only": False,
"foo": False, "bar": "baz", "blah": 42}
def configure(self):
self.output.info("hello all")
"""
tools.save(os.path.join(self.tmp_folder, "conanfile.py"), conanfile)
self.packager = ConanMultiPackager(out=self.output.write)
self.packager.add_common_builds(pure_c=False, build_all_options_values=["qux:foo", "qux:bar", "qux:blah"])
self.packager.run()
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
remotes = [("https://api.bintray.com/conan/appimage-conan-community/public-conan", "true", "appimage"),
("https://api.bintray.com/conan/bincrafters/public-conan", "true", "bincrafters")]
builder = ConanMultiPackager(remotes=remotes, build_policy="outdated", build_types=["Release"])
builder.add_common_builds()
builder.run()
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
builder = ConanMultiPackager()
builder.add_common_builds(shared_option_name="sshfs:shared")
builder.run()
except:
pass
os.chdir(cwd)
return result
def get_repo_branch_from_githubaction():
def _clean_branch(branch):
return branch[11:] if branch.startswith("refs/heads/") else branch
repobranch = _clean_branch(os.getenv("GITHUB_REF", ""))
if os.getenv("GITHUB_EVENT_NAME", "") == "pull_request":
repobranch = os.getenv("GITHUB_BASE_REF", "")
return repobranch
def has_shared_option(recipe_path):
options = inspect_value_from_recipe(attribute="options", recipe_path=recipe_path)
return options and "shared" in options
if __name__ == "__main__":
username = "******"
recipe_path = os.path.abspath("conanfile.py")
recipe_name = inspect_value_from_recipe(attribute="name", recipe_path=recipe_path)
channel, recipe_version = get_repo_branch_from_githubaction().split("/")
reference = "{}/{}@{}/{}".format(recipe_name, recipe_version, username, channel)
shared_option_name = "{}:shared".format(recipe_name) if has_shared_option(recipe_path) else None
builder = ConanMultiPackager(username=username, channel=channel,
build_policy="missing", skip_check_credentials=True)
builder.add_common_builds(shared_option_name=shared_option_name, pure_c=False, dll_with_static_runtime=True,
reference=reference, build_all_options_values=None)
builder.run()
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
remotes = [
("https://api.bintray.com/conan/bincrafters/public-conan", "yes",
"bincrafters"),
("https://api.bintray.com/conan/conan-community/conan", "yes",
"conan-community"),
("https://api.bintray.com/conan/appimage-conan-community/public-conan",
"yes", "appimage")
]
builder = ConanMultiPackager(build_policy="missing", remotes=remotes)
builder.add_common_builds(shared_option_name="libappimage:shared")
builder.run()
package_nam = os.getenv('CONAN_PACKAGE_NAME')
reference = f'{package_nam}/{package_ver}'
channel = os.getenv('CONAN_CHANNEL', 'dev')
upload = os.getenv('CONAN_UPLOAD')
branch_pat = os.getenv('CONAN_STABLE_BRANCH_PATTERN',
r'release/\d+\.\d+\.\d+.*')
conanfile = os.getenv('CONAN_CONANFILE',
os.path.join('conan', 'conanfile.py'))
test_folder = os.getenv('CONAN_TEST_FOLDER',
os.path.join('conan', 'test_package'))
only_stable = os.getenv('CONAN_UPLOAD_ONLY_WHEN_STABLE', True)
header_only = os.getenv('CONAN_HEADER_ONLY', False)
pure_c = os.getenv('CONAN_PURE_C', False)
builder = ConanMultiPackager(username=uname,
login_username=login_uname,
reference=reference,
channel=channel,
upload=upload,
stable_branch_pattern=branch_pat,
upload_only_when_stable=only_stable,
conanfile=conanfile,
test_folder=test_folder)
if header_only == "False":
builder.add_common_builds(pure_c=pure_c)
else:
builder.add()
builder.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from cpt.packager import ConanMultiPackager
if __name__ == "__main__":
remotes = [
("https://api.bintray.com/conan/appimage-conan-community/public-conan",
"yes", "appimage"),
("https://api.bintray.com/conan/bincrafters/public-conan", "yes",
"bincrafters"),
("https://api.bintray.com/conan/conan-community/conan", "yes",
"conan-community")
]
builder = ConanMultiPackager(build_policy="outdated",
remotes=remotes,
build_types=["Release"],
archs=["x86_64"])
builder.add_common_builds(
shared_option_name="AppImageUpdaterBridge:shared")
builder.run()
class DockerTest(BaseTest):
@unittest.skipUnless(sys.platform.startswith("linux"), "Requires Linux")
def test_docker(self):
if not os.getenv("PYPI_PASSWORD", None):
return
self.deploy_pip()
ci_manager = MockCIManager()
unique_ref = "zlib/%s" % str(time.time())
conanfile = """from conans import ConanFile
import os
class Pkg(ConanFile):
settings = "os", "compiler", "build_type", "arch"
"""
self.save_conanfile(conanfile)
the_version = version.replace(
"-", ".") # Canonical name for artifactory repo
pip = "--extra-index-url %s/simple conan-package-tools==%s " % (
PYPI_TESTING_REPO, the_version)
with tools.environment_append({
"CONAN_USE_DOCKER": "1",
"CONAN_DOCKER_USE_SUDO": "1",
"CONAN_PIP_PACKAGE": pip,
"CONAN_LOGIN_USERNAME": CONAN_LOGIN_UPLOAD,
"CONAN_USERNAME": "******",
"CONAN_UPLOAD": CONAN_UPLOAD_URL,
"CONAN_PASSWORD": CONAN_UPLOAD_PASSWORD
}):
self.packager = ConanMultiPackager(
["--build missing", "-r conan.io"],
channel="mychannel",
gcc_versions=["6"],
archs=["x86", "x86_64"],
build_types=["Release"],
reference=unique_ref,
ci_manager=ci_manager)
self.packager.add_common_builds()
self.packager.run()
search_pattern = "%s*" % unique_ref
ref = ConanFileReference.loads("%s@lasote/mychannel" % unique_ref)
# Remove from remote
results = self.api.search_recipes(
search_pattern, remote="upload_repo")["results"][0]["items"]
self.assertEquals(len(results), 1)
packages = self.api.search_packages(
ref, remote="upload_repo")["results"][0]["items"][0]["packages"]
self.assertEquals(len(packages), 2)
self.api.authenticate(name=CONAN_LOGIN_UPLOAD,
password=CONAN_UPLOAD_PASSWORD,
remote="upload_repo")
self.api.remove(search_pattern, remote="upload_repo", force=True)
self.assertEquals(
self.api.search_recipes(search_pattern)["results"], [])
# Try upload only when stable, shouldn't upload anything
with tools.environment_append({
"CONAN_USE_DOCKER": "1",
"CONAN_DOCKER_USE_SUDO": "1",
"CONAN_PIP_PACKAGE": pip,
"CONAN_LOGIN_USERNAME": CONAN_LOGIN_UPLOAD,
"CONAN_USERNAME": "******",
"CONAN_PASSWORD": CONAN_UPLOAD_PASSWORD,
"CONAN_UPLOAD_ONLY_WHEN_STABLE": "1"
}):
self.packager = ConanMultiPackager(
["--build missing", "-r conan.io"],
channel="mychannel",
gcc_versions=["6"],
archs=["x86", "x86_64"],
build_types=["Release"],
reference=unique_ref,
upload=CONAN_UPLOAD_URL,
ci_manager=ci_manager)
self.packager.add_common_builds()
self.packager.run()
results = self.api.search_recipes(search_pattern,
remote="upload_repo")["results"]
self.assertEquals(len(results), 0)
self.api.remove(search_pattern, remote="upload_repo", force=True)
