def run():
conan_version = get_client_version()
if conan_version < Version("1.18.0"):
conan_api, client_cache, _ = Conan.factory()
else:
conan_api, _, _ = Conan.factory()
conan_api.create_app()
client_cache = conan_api.app.cache
printer = Printer()
remotes_manager = RemotesManager(conan_api, printer)
remotes_manager.add_remotes_to_conan()
default_username = os.getenv("CONAN_USERNAME")
auth_manager = AuthManager(conan_api,
printer,
default_username=default_username)
upload_retry = os.getenv("CPT_UPLOAD_RETRY")
upload_only_recipe = os.getenv("CPT_UPLOAD_ONLY_RECIPE")
upload_force = os.getenv("CPT_UPLOAD_FORCE")
uploader = Uploader(conan_api, remotes_manager, auth_manager, printer,
upload_retry, upload_force)
build_policy = unscape_env(os.getenv("CPT_BUILD_POLICY"))
test_folder = unscape_env(os.getenv("CPT_TEST_FOLDER"))
reference = ConanFileReference.loads(os.getenv("CONAN_REFERENCE"))
profile_text = unscape_env(os.getenv("CPT_PROFILE"))
abs_profile_path = save_profile_to_tmp(profile_text)
base_profile_text = unscape_env(os.getenv("CPT_BASE_PROFILE"))
config_url = unscape_env(os.getenv("CPT_CONFIG_URL"))
config_args = unscape_env(os.getenv("CPT_CONFIG_ARGS"))
upload_dependencies = unscape_env(os.getenv("CPT_UPLOAD_DEPENDENCIES"))
update_dependencies = unscape_env(os.getenv("CPT_UPDATE_DEPENDENCIES"))
conanfile = unscape_env(os.getenv("CPT_CONANFILE"))
lockfile = unscape_env(os.getenv("CPT_LOCKFILE"))
skip_recipe_export = unscape_env(os.getenv("CPT_SKIP_RECIPE_EXPORT"))
if base_profile_text:
base_profile_name = unscape_env(os.getenv("CPT_BASE_PROFILE_NAME"))
tools.save(os.path.join(client_cache.profiles_path, base_profile_name),
base_profile_text)
upload = os.getenv("CPT_UPLOAD_ENABLED")
runner = CreateRunner(abs_profile_path,
reference,
conan_api,
uploader,
build_policy=build_policy,
printer=printer,
upload=upload,
upload_only_recipe=upload_only_recipe,
test_folder=test_folder,
config_url=config_url,
config_args=config_args,
upload_dependencies=upload_dependencies,
conanfile=conanfile,
skip_recipe_export=skip_recipe_export,
update_dependencies=update_dependencies,
lockfile=lockfile)
runner.run()
def deploy_release(packages, config):
if global_config["upload"]:
conan_api, client_cache, user_io = Conan.factory()
conan_repo = {
v['name']: v['conanuser']
for v in config['dependencies']
}
for package in packages:
reference = ConanFileReference.loads(package['reference'])
if reference.name not in conan_repo:
print("skip uploading due to missing remote: %s" %
str(reference))
continue
remote = conan_repo[reference.name]
all_success = True
for pid in package['package_ids']:
try:
result = conan_api.upload(package['reference'],
package=pid,
confirm=True,
remote_name=remote,
policy="force-upload")
except Exception as e:
print(e)
all_success = False
return all_success
else:
print("Upload of binary artifacts is disabled")
return True
def upload_package(name, version, user, channel, package_commit_rev, config):
if global_config["upload"]:
conan_api, client_cache, user_io = Conan.factory()
conan_repo = {
v['name']: v['conanuser']
for v in config['dependencies']
}
ref = "%s/%s@%s/%s" % (name, version, user, channel)
remote = conan_repo[name]
if remote is not None:
result = conan_api.upload(ref,
confirm=True,
remote_name=remote,
policy="force-upload")
else:
print("Upload of packages sources is disabled: %s" % name)
return {
"commit_rev": package_commit_rev,
"name": name,
"version": version,
"user": user,
"channel": channel,
}
def run():
# Get all from environ
conan_api, client_cache, _ = Conan.factory()
printer = Printer()
remotes_manager = RemotesManager(conan_api, printer)
remotes_manager.add_remotes_to_conan()
default_username = os.getenv("CONAN_USERNAME")
auth_manager = AuthManager(conan_api, printer, default_username=default_username)
upload_retry = os.getenv("CPT_UPLOAD_RETRY")
upload_only_recipe = os.getenv("CPT_UPLOAD_ONLY_RECIPE")
uploader = Uploader(conan_api, remotes_manager, auth_manager, printer, upload_retry)
build_policy = unscape_env(os.getenv("CPT_BUILD_POLICY"))
test_folder = unscape_env(os.getenv("CPT_TEST_FOLDER"))
reference = ConanFileReference.loads(os.getenv("CONAN_REFERENCE"))
profile_text = unscape_env(os.getenv("CPT_PROFILE"))
abs_profile_path = save_profile_to_tmp(profile_text)
base_profile_text = unscape_env(os.getenv("CPT_BASE_PROFILE"))
config_url = unscape_env(os.getenv("CPT_CONFIG_URL"))
upload_dependencies = unscape_env(os.getenv("CPT_UPLOAD_DEPENDENCIES"))
conanfile = unscape_env(os.getenv("CPT_CONANFILE"))
if base_profile_text:
base_profile_name = unscape_env(os.getenv("CPT_BASE_PROFILE_NAME"))
tools.save(os.path.join(client_cache.profiles_path, base_profile_name),
base_profile_text)
upload = os.getenv("CPT_UPLOAD_ENABLED")
runner = CreateRunner(abs_profile_path, reference, conan_api, uploader,
build_policy=build_policy, printer=printer, upload=upload,
upload_only_recipe=upload_only_recipe,
test_folder=test_folder, config_url=config_url,
upload_dependencies=upload_dependencies, conanfile=conanfile)
runner.run()
def export_package(user, channel, name, package_repo_folder,
package_commit_rev):
conan_api, client_cache, user_io = Conan.factory()
try:
_, project_reference = conan_api.info(package_repo_folder)
version = project_reference.version
except:
raise ValueError("missing conan version for: %s" % name)
conan_api.export(package_repo_folder,
name=name,
channel=channel,
version=version,
user=user)
try:
conan_file_loc = os.path.join(package_repo_folder, "conanfile.py")
version = conan_api.inspect(conan_file_loc,
attributes=['version'])['version']
except ConanException as e:
print("error retrieving version from package: %s" % str(e))
return {
"commit_rev": package_commit_rev,
"package_repo_folder": package_repo_folder,
"name": name,
"version": version,
"user": user,
"channel": channel,
}
def export_meta_package(meta_repo_folder, meta_commit_rev, config):
name = config['meta_package']['name']
version = config['meta_package']['version']
user = config['meta_package']['user']
channel = config['meta_package']['channel']
conan_api, client_cache, user_io = Conan.factory()
conan_api.export(meta_repo_folder,
name=name,
channel=channel,
version=version,
user=user)
try:
conan_file_loc = os.path.join(meta_repo_folder, "conanfile.py")
version = conan_api.inspect(conan_file_loc,
attributes=['version'])['version']
except ConanException as e:
print("error retrieving version from package: %s" % str(e))
return {
"commit_rev": meta_commit_rev,
"meta_repo_folder": meta_repo_folder,
"name": name,
"version": version,
"user": user,
"channel": channel,
}
def run():
# Get all from environ
conan_api, client_cache, _ = Conan.factory()
printer = Printer()
if os.path.exists(client_cache.default_profile_path):
os.remove(client_cache.default_profile_path)
remotes_manager = RemotesManager(conan_api, printer)
default_username = os.getenv("CONAN_USERNAME", None)
auth_manager = AuthManager(conan_api, printer, default_username=default_username)
uploader = Uploader(conan_api, remotes_manager, auth_manager, printer)
args = os.getenv("CPT_ARGS", "")
build_policy = unscape_env(os.getenv("CPT_BUILD_POLICY"))
reference = ConanFileReference.loads(os.getenv("CONAN_REFERENCE"))
profile_text = unscape_env(os.getenv("CPT_PROFILE"))
abs_profile_path = save_profile_to_tmp(profile_text)
base_profile_text = unscape_env(os.getenv("CPT_BASE_PROFILE"))
if base_profile_text:
base_profile_name = unscape_env(os.getenv("CPT_BASE_PROFILE_NAME"))
tools.save(os.path.join(client_cache.profiles_path, base_profile_name),
base_profile_text)
upload = os.getenv("CPT_UPLOAD_ENABLED", None)
runner = CreateRunner(abs_profile_path, reference, conan_api, uploader,
args=args,
build_policy=build_policy, printer=printer, upload=upload)
runner.run()
def _create_requesters(conan_user_home=temp_folder()):
with environment_append({'CONAN_USER_HOME': conan_user_home}):
conan_api, cache, _ = Conan.factory()
requester = conan_api._requester
mock_requester = MockRequesterGet()
requester._requester = mock_requester
return requester, mock_requester, cache
def _register_using_native_keyring(output, remote):
conan, _, _ = Conan.factory()
user_list = conan.users_list(remote.name)
authenticated, user_name = _get_default_remote_user(user_list)
if user_name is None:
output.info(
"Anonymous login for remote '{}'. Set a user with 'conan user' command."
.format(str(remote.name)))
return
if authenticated:
return # Already authenticated
_check_keyring_backend_availability()
passwd = keyring.get_password(remote.name, user_name)
if passwd is None:
passwd = unicode(
getpass.getpass("Password for {} at {}:".format(
user_name, remote.name)), 'utf8')
valid = False
while not valid:
try:
conan.authenticate(user_name, passwd, remote.name)
keyring.set_password(remote.name, user_name, passwd)
valid = True
except AuthenticationException:
output.info(
"Credentials are invalid. Please, type credentials for {}.".
format(remote.name))
user_name = raw_input("Username: "******"Password for {} at {}:".format(
user_name, remote.name)), 'utf8')
def run_conan(reference, reference_fallback):
# New API in Conan 0.28
c, _, _ = Conan.factory()
print(reference)
print(reference_fallback)
try:
# c.remote_add(remote, url, verify_ssl, args.insert)
c.remote_add('bitprim',
'https://api.bintray.com/conan/bitprim/bitprim')
except:
print("Conan Remote exists, ignoring exception")
try:
# c.install(reference, verify=None, manifests=None)
c.install(reference,
verify=None,
manifests_interactive=None,
manifests=None)
print(
'11 876128376128371263876128376128371263876128376128371263876128376128371263876128376128371263'
)
pepe = find('nodecint.h', os.getcwd())
print(pepe)
print(
'11 876128376128371263876128376128371263876128376128371263876128376128371263876128376128371263'
)
except:
print('EXCEPTION --------------------------')
c.install(reference_fallback,
verify=None,
manifests_interactive=None,
manifests=None)
print(
'22 876128376128371263876128376128371263876128376128371263876128376128371263876128376128371263'
)
pepe = find('nodecint.h', os.getcwd())
print(pepe)
shutil.move('./deps/', '..')
pepe = find('nodecint.h', os.getcwd())
print(pepe)
print(
'22 876128376128371263876128376128371263876128376128371263876128376128371263876128376128371263'
)
print('run_conan - END')
replace_boost_lib_names_on_windows('../deps/lib')
def __init__(self,
profile_text,
username,
channel,
reference,
mingw_installer_reference=None,
runner=None,
args=None,
conan_pip_package=None,
exclude_vcvars_precommand=False,
conan_vars=None,
build_policy=None):
self._conan_vars = conan_vars or {}
self._profile_text = profile_text
self._mingw_installer_reference = mingw_installer_reference
self._args = args
self._args += " --build=%s" % build_policy if build_policy else ""
self._username = username
self._channel = channel
self._reference = reference
self._conan_pip_package = conan_pip_package
self._runner = runner or os.system
self.runner = runner
self.conan_api, self.client_cache, self.user_io = Conan.factory()
self.conan_home = os.path.realpath(self.client_cache.conan_folder)
self.data_home = os.path.realpath(self.client_cache.store)
self._exclude_vcvars_precommand = exclude_vcvars_precommand
if "default" in self._profile_text: # User didn't specified a custom profile
default_profile_name = os.path.basename(
self.client_cache.default_profile_path)
if not os.path.exists(self.client_cache.default_profile_path):
self.conan_api.create_profile(default_profile_name,
detect=True)
if default_profile_name != "default": # User have a different default profile name
# https://github.com/conan-io/conan-package-tools/issues/121
self._profile_text = self._profile_text.replace(
"include(default)", "include(%s)" % default_profile_name)
# Save the profile in a tmp file
tmp = os.path.join(
tempfile.mkdtemp(suffix='conan_package_tools_profiles'), "profile")
self.abs_profile_path = os.path.abspath(tmp)
save(self.abs_profile_path, self._profile_text)
self.profile, _ = _load_profile(self._profile_text,
os.path.dirname(self.abs_profile_path),
self.client_cache.profiles_path)
def main(args):
""" main entry point of the conan application, using a Command to
parse parameters
"""
conan_api = Conan.factory()
command = Command(conan_api, conan_api._client_cache, conan_api._user_io)
current_dir = os.getcwd()
try:
import signal
def sigint_handler(signal, frame): # @UnusedVariable
print('You pressed Ctrl+C!')
sys.exit(0)
signal.signal(signal.SIGINT, sigint_handler)
error = command.run(args)
finally:
os.chdir(current_dir)
sys.exit(error)
def do_conan_stuff(microarch=None, currency=None):
# if not microarch:
# microarch = 'x86_64'
print('do_conan_stuff microarch currency')
print(microarch)
# New API in Conan 0.28
c, _, _ = Conan.factory()
try:
# c.remote_add(remote, url, verify_ssl, args.insert)
c.remote_add('bitprim',
'https://api.bintray.com/conan/bitprim/bitprim')
except:
print("Conan Remote exists, ignoring exception")
refe = "."
opts = None
# if microarch:
# # c.install(refe, verify=None, manifests=None)
# opts = ['*:microarchitecture=%s' % (microarch,)]
# c.install(refe, verify=None, manifests_interactive=None, manifests=None, options=opts)
# else:
# c.install(refe, verify=None, manifests_interactive=None, manifests=None)
if microarch:
opts = ['*:microarchitecture=%s' % (microarch, )]
if currency:
if opts:
opts.append('*:currency=%s' % (currency, ))
else:
opts = ['*:currency=%s' % (currency, )]
c.install(refe,
verify=None,
manifests_interactive=None,
manifests=None,
options=opts)
def build_release(deps, build_folder, config):
name = config['meta_package']['name']
version = config['meta_package']['version']
user = config['meta_package']['user']
channel = config['meta_package']['channel']
profile_name = global_config['profile_name']
package_repo_folder = os.path.join(build_folder, "meta")
deps_build_filter = global_config.get('deps_build_filter', '*')
build_modes = [
name,
] + [d for d in deps if fnmatch(d, deps_build_filter)]
options = config.get('options', [])
conan_api, client_cache, user_io = Conan.factory()
kw = {
"name": name,
"version": version,
"user": user,
"channel": channel,
"build_modes": build_modes,
"options": options
}
kw["profile_names"] = [
profile_name,
] if profile_name is not None else []
result = conan_api.create(package_repo_folder, **kw)
packages = []
for info in result['installed']:
packages.append({
"reference": info['recipe']['id'],
"timestamp": info['recipe']['time'].isoformat(),
"package_ids": [p['id'] for p in info['packages']],
})
return {'packages': packages}
# dest_file = os.path.join(self.install_dir, 'bitprim', filename)
# log.info("dest_file: %s" % (dest_file, ))
# log.debug("dest_file: %s" % (dest_file, ))
# print("dest_file: %s" % (dest_file, ))
# # file_util.copy_file(lib_file, bitprim_install_dir)
# file_util.copy_file(lib_file, dest_file)
# class MyDist(Distribution):
# def has_ext_modules(self):
# return True
# ------------------------------------------------
c = Conan.factory()
try:
# c.remote_add(remote, url, verify_ssl, args.insert)
c.remote_add('bitprim', 'https://api.bintray.com/conan/bitprim/bitprim')
except:
print("Conan Remote exists, ignoring exception")
refe = "."
# c.install(refe, verify=None, manifests=None)
c.install(refe, verify=None, manifests_interactive=None, manifests=None)
print(
'-----------------------------------------------------------------------------------'
)
def __init__(self,
args=None,
username=None,
channel=None,
runner=None,
gcc_versions=None,
visual_versions=None,
visual_runtimes=None,
apple_clang_versions=None,
archs=None,
use_docker=None,
curpage=None,
total_pages=None,
docker_image=None,
reference=None,
password=None,
remotes=None,
upload=None,
stable_branch_pattern=None,
vs10_x86_64_enabled=False,
mingw_configurations=None,
stable_channel=None,
platform_info=None,
upload_retry=None,
clang_versions=None,
login_username=None,
upload_only_when_stable=None,
build_types=None,
skip_check_credentials=False,
allow_gcc_minors=False,
exclude_vcvars_precommand=False,
docker_image_skip_update=False,
docker_image_skip_pull=False,
docker_entry_script=None,
docker_32_images=None,
build_policy=None,
always_update_conan_in_docker=False,
conan_api=None,
client_cache=None,
ci_manager=None,
out=None,
test_folder=None):
self.printer = Printer(out)
self.printer.print_rule()
self.printer.print_ascci_art()
if not conan_api:
self.conan_api, self.client_cache, _ = Conan.factory()
else:
self.conan_api = conan_api
self.client_cache = client_cache
self.ci_manager = ci_manager or CIManager(self.printer)
self.remotes_manager = RemotesManager(self.conan_api, self.printer,
remotes, upload)
self.username = username or os.getenv("CONAN_USERNAME", None)
if not self.username:
raise Exception(
"Instance ConanMultiPackage with 'username' parameter or use "
"CONAN_USERNAME env variable")
self.skip_check_credentials = skip_check_credentials or \
os.getenv("CONAN_SKIP_CHECK_CREDENTIALS", False)
self.auth_manager = AuthManager(
self.conan_api,
self.printer,
login_username,
password,
default_username=self.username,
skip_check_credentials=self.skip_check_credentials)
self.uploader = Uploader(self.conan_api, self.remotes_manager,
self.auth_manager, self.printer)
self._builds = []
self._named_builds = {}
self._update_conan_in_docker = (
always_update_conan_in_docker
or os.getenv("CONAN_ALWAYS_UPDATE_CONAN_DOCKER", False))
self._platform_info = platform_info or PlatformInfo()
self.stable_branch_pattern = stable_branch_pattern or \
os.getenv("CONAN_STABLE_BRANCH_PATTERN", None)
self.specified_channel = channel or os.getenv("CONAN_CHANNEL",
"testing")
self.specified_channel = self.specified_channel.rstrip()
self.stable_channel = stable_channel or os.getenv(
"CONAN_STABLE_CHANNEL", "stable")
self.stable_channel = self.stable_channel.rstrip()
self.channel = self._get_channel(self.specified_channel,
self.stable_channel)
self.partial_reference = reference or os.getenv(
"CONAN_REFERENCE", None)
if self.partial_reference:
if "@" in self.partial_reference:
self.reference = ConanFileReference.loads(
self.partial_reference)
else:
name, version = self.partial_reference.split("/")
self.reference = ConanFileReference(name, version,
self.username,
self.channel)
else:
if not os.path.exists("conanfile.py"):
raise Exception(
"Conanfile not found, specify a 'reference' parameter with name and version"
)
conanfile = load_conanfile_class("./conanfile.py")
name, version = conanfile.name, conanfile.version
if name and version:
self.reference = ConanFileReference(name, version,
self.username,
self.channel)
else:
self.reference = None
# If CONAN_DOCKER_IMAGE is speified, then use docker is True
self.use_docker = (use_docker or os.getenv("CONAN_USE_DOCKER", False)
or os.getenv("CONAN_DOCKER_IMAGE",
None) is not None)
os_name = self._platform_info.system(
) if not self.use_docker else "Linux"
self.build_generator = BuildGenerator(
reference, os_name, gcc_versions, apple_clang_versions,
clang_versions, visual_versions, visual_runtimes,
vs10_x86_64_enabled, mingw_configurations, archs, allow_gcc_minors,
build_types)
build_policy = (build_policy
or self.ci_manager.get_commit_build_policy()
or os.getenv("CONAN_BUILD_POLICY", None))
if build_policy:
if build_policy.lower() not in ("never", "outdated", "missing"):
raise Exception(
"Invalid build policy, valid values: never, outdated, missing"
)
self.build_policy = build_policy
self.sudo_docker_command = ""
if "CONAN_DOCKER_USE_SUDO" in os.environ:
self.sudo_docker_command = "sudo -E" if get_bool_from_env(
"CONAN_DOCKER_USE_SUDO") else ""
elif platform.system() != "Windows":
self.sudo_docker_command = "sudo -E"
self.sudo_pip_command = ""
if "CONAN_PIP_USE_SUDO" in os.environ:
self.sudo_pip_command = "sudo -E" if get_bool_from_env(
"CONAN_PIP_USE_SUDO") else ""
elif platform.system() != "Windows":
self.sudo_pip_command = "sudo -E"
self.docker_shell = ""
self.docker_conan_home = ""
if self.is_wcow:
self.docker_conan_home = "C:/Users/ContainerAdministrator"
self.docker_shell = "cmd /C"
else:
self.docker_conan_home = "/home/conan"
self.docker_shell = "/bin/sh -c"
self.docker_platform_param = ""
self.lcow_user_workaround = ""
if self.is_lcow:
self.docker_platform_param = "--platform=linux"
# With LCOW, Docker doesn't respect USER directive in dockerfile yet
self.lcow_user_workaround = "sudo su conan && "
self.exclude_vcvars_precommand = (
exclude_vcvars_precommand
or os.getenv("CONAN_EXCLUDE_VCVARS_PRECOMMAND", False))
self._docker_image_skip_update = (
docker_image_skip_update
or os.getenv("CONAN_DOCKER_IMAGE_SKIP_UPDATE", False))
self._docker_image_skip_pull = (docker_image_skip_pull or os.getenv(
"CONAN_DOCKER_IMAGE_SKIP_PULL", False))
self.runner = runner or os.system
self.output_runner = ConanOutputRunner()
self.args = " ".join(args) if args else " ".join(sys.argv[1:])
# Upload related variables
self.upload_retry = upload_retry or os.getenv("CONAN_UPLOAD_RETRY", 3)
if upload_only_when_stable is not None:
self.upload_only_when_stable = upload_only_when_stable
else:
self.upload_only_when_stable = get_bool_from_env(
"CONAN_UPLOAD_ONLY_WHEN_STABLE")
self.docker_entry_script = docker_entry_script or os.getenv(
"CONAN_DOCKER_ENTRY_SCRIPT")
os.environ["CONAN_CHANNEL"] = self.channel
# If CONAN_DOCKER_IMAGE is speified, then use docker is True
self.use_docker = use_docker or os.getenv("CONAN_USE_DOCKER", False) or \
(os.getenv("CONAN_DOCKER_IMAGE", None) is not None)
if docker_32_images is not None:
self.docker_32_images = docker_32_images
else:
self.docker_32_images = os.getenv("CONAN_DOCKER_32_IMAGES", False)
self.curpage = curpage or os.getenv("CONAN_CURRENT_PAGE", 1)
self.total_pages = total_pages or os.getenv("CONAN_TOTAL_PAGES", 1)
self._docker_image = docker_image or os.getenv("CONAN_DOCKER_IMAGE",
None)
self.conan_pip_package = os.getenv("CONAN_PIP_PACKAGE",
"conan==%s" % client_version)
if self.conan_pip_package in ("0", "False"):
self.conan_pip_package = False
self.vs10_x86_64_enabled = vs10_x86_64_enabled
self.builds_in_current_page = []
self.test_folder = test_folder or os.getenv("CPT_TEST_FOLDER", None)
def valid_pair(var, value):
return (isinstance(value, six.string_types)
or isinstance(value, bool) or isinstance(value, list)
) and not var.startswith("_") and "password" not in var
with self.printer.foldable_output("local_vars"):
self.printer.print_dict({
var: value
for var, value in self.__dict__.items()
if valid_pair(var, value)
})
def main(args):
""" main entry point of the conan application, using a Command to
parse parameters
Exit codes for conan command:
0: Success (done)
1: General ConanException error (done)
2: Migration error
3: Ctrl+C
4: Ctrl+Break
5: SIGTERM
6: Invalid configuration (done)
"""
try:
conan_api, _, _ = Conan.factory() # FIXME: Conan factory will be removed in Conan 2.0
except ConanMigrationError: # Error migrating
sys.exit(ERROR_MIGRATION)
except ConanException as e:
sys.stderr.write("Error in Conan initialization: {}".format(e))
sys.exit(ERROR_GENERAL)
def ctrl_c_handler(_, __):
print('You pressed Ctrl+C!')
sys.exit(USER_CTRL_C)
def sigterm_handler(_, __):
print('Received SIGTERM!')
sys.exit(ERROR_SIGTERM)
def ctrl_break_handler(_, __):
print('You pressed Ctrl+Break!')
sys.exit(USER_CTRL_BREAK)
signal.signal(signal.SIGINT, ctrl_c_handler)
signal.signal(signal.SIGTERM, sigterm_handler)
if sys.platform == 'win32':
signal.signal(signal.SIGBREAK, ctrl_break_handler)
try:
cli = Cli(conan_api)
exit_error = cli.run(args)
except SystemExit as exc:
if exc.code != 0:
logger.error(exc)
conan_api.out.error("Exiting with code: %d" % exc.code)
exit_error = exc.code
except ConanInvalidConfiguration as exc:
exit_error = ERROR_INVALID_CONFIGURATION
conan_api.out.error(exc)
except ConanException as exc:
exit_error = ERROR_GENERAL
conan_api.out.error(exc)
except Exception as exc:
import traceback
print(traceback.format_exc())
exit_error = ERROR_GENERAL
msg = exception_message_safe(exc)
conan_api.out.error(msg)
sys.exit(exit_error)
for compiler_version in get_compiler_versions():
conan_api.create(
"./conanfile.py",
user="******",
channel=channel,
build_modes=["missing"],
settings=[
"arch={}".format(arch),
"compiler={}".format(compiler),
"compiler.version={}".format(compiler_version),
],
options=options)
# Upload package
def upload(conan_api):
remote, user, password = get_remote(conan_api)
conan_api.authenticate(user, password, remote)
(_, conanfile) = parse_conanfile('./conanfile.py',
ConanPythonRequire(None, None))
conan_api.upload(pattern="{}/{}@arobasmusic/{}".format(
conanfile.name, conanfile.version, get_channel()),
remote_name=remote)
if __name__ == "__main__":
(CONAN_API, _, _) = Conan.factory()
build(CONAN_API)
upload(CONAN_API)
def __init__(self, args=None, username=None, channel=None, runner=None,
gcc_versions=None, visual_versions=None, visual_runtimes=None,
apple_clang_versions=None, archs=None,
use_docker=None, curpage=None, total_pages=None,
docker_image=None, reference=None, password=None, remote=None,
remotes=None,
upload=None, stable_branch_pattern=None,
vs10_x86_64_enabled=False,
mingw_configurations=None,
stable_channel=None,
platform_info=None,
upload_retry=None,
clang_versions=None,
login_username=None,
upload_only_when_stable=False,
build_types=None,
skip_check_credentials=False,
allow_gcc_minors=False,
exclude_vcvars_precommand=False,
docker_image_skip_update=False,
docker_entry_script=None,
docker_32_images=None):
self.sudo_command = ""
if "CONAN_DOCKER_USE_SUDO" in os.environ:
if get_bool_from_env("CONAN_DOCKER_USE_SUDO"):
self.sudo_command = "sudo"
elif platform.system() == "Linux":
self.sudo_command = "sudo"
self.exclude_vcvars_precommand = exclude_vcvars_precommand or os.getenv("CONAN_EXCLUDE_VCVARS_PRECOMMAND", False)
self.docker_image_skip_update = docker_image_skip_update or os.getenv("CONAN_DOCKER_IMAGE_SKIP_UPDATE", False)
self.allow_gcc_minors = allow_gcc_minors or os.getenv("CONAN_ALLOW_GCC_MINORS", False)
self._builds = []
self._named_builds = {}
self._platform_info = platform_info or PlatformInfo()
self.runner = runner or os.system
self.output_runner = ConanOutputRunner()
self.args = args or " ".join(sys.argv[1:])
self.username = username or os.getenv("CONAN_USERNAME", None)
self.login_username = login_username or os.getenv("CONAN_LOGIN_USERNAME",
None) or self.username
if not self.username:
raise Exception("Instance ConanMultiPackage with 'username' "
"parameter or use CONAN_USERNAME env variable")
# Upload related variables
self.upload_retry = upload_retry or os.getenv("CONAN_UPLOAD_RETRY", 3)
self.reference = reference or os.getenv("CONAN_REFERENCE", None)
self.password = password or os.getenv("CONAN_PASSWORD", None)
self.remote = remote or os.getenv("CONAN_REMOTE", None)
# User is already logged
self._logged_user_in_remote = defaultdict(lambda: False)
if self.remote:
raise Exception('''
'remote' argument is deprecated. Use:
- 'upload' argument to specify the remote URL to upload your packages (or None to disable
upload)
- 'remotes' argument to specify additional remote URLs, for example, different user
repositories.
''')
self.remotes = remotes or os.getenv("CONAN_REMOTES", [])
self.upload = upload if upload is not None else os.getenv("CONAN_UPLOAD", None)
# The username portion of the remote URLs must be all lowercase to work
if self.remotes:
if isinstance(self.remotes,list):
self.remotes = [remote.lower() for remote in self.remotes]
else:
self.remotes = self.remotes.lower()
if self.upload:
self.upload = self.upload.lower()
self.stable_branch_pattern = stable_branch_pattern or \
os.getenv("CONAN_STABLE_BRANCH_PATTERN", None)
default_channel = channel or os.getenv("CONAN_CHANNEL", "testing")
self.stable_channel = stable_channel or os.getenv("CONAN_STABLE_CHANNEL", "stable")
self.channel = self._get_channel(default_channel, self.stable_channel)
if self.reference:
self.reference = ConanFileReference.loads("%s@%s/%s" % (self.reference,
self.username, self.channel))
self.upload_only_when_stable = upload_only_when_stable or \
os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", False)
self.skip_check_credentials = skip_check_credentials or \
os.getenv("CONAN_SKIP_CHECK_CREDENTIALS", False)
self.docker_entry_script = docker_entry_script or \
os.getenv("CONAN_DOCKER_ENTRY_SCRIPT", None)
if self.upload:
if self.upload in ("0", "None", "False"):
self.upload = None
elif self.upload == "1":
raise Exception("WARNING! 'upload' argument has changed. Use 'upload' argument or "
"CONAN_UPLOAD environment variable to specify a remote URL to "
"upload your packages. e.j: "
"upload='https://api.bintray.com/conan/myuser/myconanrepo'")
os.environ["CONAN_CHANNEL"] = self.channel
self.clang_versions = clang_versions or split_colon_env("CONAN_CLANG_VERSIONS")
self.gcc_versions = gcc_versions or split_colon_env("CONAN_GCC_VERSIONS")
# If there are some GCC versions declared then we don't default the clang
# versions
if not self.clang_versions and not self.gcc_versions:
self.clang_versions = self.default_clang_versions
# If there are some CLANG versions declared then we don't default the gcc
# versions
if not self.gcc_versions and self.clang_versions == self.default_clang_versions:
self.gcc_versions = self.default_gcc_versions
if self.gcc_versions and not self.allow_gcc_minors:
for a_version in self.gcc_versions:
if Version(a_version) >= Version("5") and "." in a_version:
raise Exception("""
******************* DEPRECATED GCC MINOR VERSIONS! ***************************************
- The use of gcc versions >= 5 and specifying the minor version (e.j "5.4") is deprecated.
- The ABI of gcc >= 5 (5, 6, and 7) is compatible between minor versions (e.j 5.3 is compatible with 5.4)
- Specify only the major in your script:
- CONAN_GCC_VERSIONS="5,6,7" if you are using environment variables.
- gcc_versions=["5", "6", "7"] if you are using the constructor parameter.
You can still keep using the same docker images, or use the new "lasote/conangcc5", "lasote/conangcc6", "lasote/conangcc7"
If you still want to keep the old behavior, set the environment var CONAN_ALLOW_GCC_MINORS or pass the
"allow_gcc_minors=True" parameter. But it is not recommended, if your packages are public most users
won't be able to use them.
******************************************************************************************
""")
if visual_versions is not None:
self.visual_versions = visual_versions
else:
self.visual_versions = split_colon_env("CONAN_VISUAL_VERSIONS")
if not self.visual_versions and not mingw_configurations and not get_mingw_config_from_env():
self.visual_versions = self.default_visual_versions
elif mingw_configurations or get_mingw_config_from_env():
self.visual_versions = []
self.visual_runtimes = visual_runtimes or split_colon_env("CONAN_VISUAL_RUNTIMES") or \
self.default_visual_runtimes
self.apple_clang_versions = apple_clang_versions or \
split_colon_env("CONAN_APPLE_CLANG_VERSIONS") or \
self.default_apple_clang_versions
self.mingw_configurations = mingw_configurations or get_mingw_config_from_env()
env_ref = os.getenv("CONAN_MINGW_INSTALLER_REFERENCE")
self.mingw_installer_reference = ConanFileReference.loads(env_ref or
"mingw_installer/1.0"
"@conan/stable")
if not archs and not os.getenv("CONAN_ARCHS") and platform.system() == "Darwin":
self.default_archs = ["x86_64"] # No longer supported (by default) x86 macos
self.archs = archs or split_colon_env("CONAN_ARCHS") or self.default_archs
self.build_types = build_types or split_colon_env("CONAN_BUILD_TYPES") or \
self.default_build_types
# If CONAN_DOCKER_IMAGE is speified, then use docker is True
self.use_docker = use_docker or os.getenv("CONAN_USE_DOCKER", False) or \
(os.getenv("CONAN_DOCKER_IMAGE", None) is not None)
if docker_32_images is not None:
self.docker_32_images = docker_32_images
else:
self.docker_32_images = os.getenv("CONAN_DOCKER_32_IMAGES", False)
self.curpage = curpage or os.getenv("CONAN_CURRENT_PAGE", 1)
self.total_pages = total_pages or os.getenv("CONAN_TOTAL_PAGES", 1)
self.docker_image = docker_image or os.getenv("CONAN_DOCKER_IMAGE", None)
if self.password:
self.password = self.password.replace('"', '\\"')
self.conan_pip_package = os.getenv("CONAN_PIP_PACKAGE", "conan==%s" % client_version)
self.vs10_x86_64_enabled = vs10_x86_64_enabled
# Set the remotes
if self.remotes:
if not isinstance(self.remotes, list):
self.remotes = [r.strip() for r in self.remotes.split(",") if r.strip()]
for counter, remote in enumerate(reversed(self.remotes)):
remote_name = "remote%s" % counter if remote != self.upload else "upload_repo"
self.add_remote_safe(remote_name, remote, insert=True)
self.runner("conan remote list")
else:
logger.info("Not additional remotes declared...")
if self.upload and self.upload not in self.remotes:
# If you specify the upload as a remote, put it first
# this way we can cover all the possibilities
self.add_remote_safe("upload_repo", self.upload, insert=False)
_, client_cache, _ = Conan.factory()
self.data_home = client_cache.store
self.builds_in_current_page = []
def build_workspace(deps, build_folder, config):
name = config['meta_package']['name']
version = config['meta_package']['version']
user = config['meta_package']['user']
channel = config['meta_package']['channel']
workspace_filename = os.path.join(os.curdir, build_folder, "conanws.yml")
installFolder = os.path.join(os.curdir, "install")
installFolder = os.path.abspath(installFolder)
# create install folder
# should the folder be cleared before installing? cases like renaming a pattern file
if not os.path.exists(installFolder):
os.mkdir(installFolder)
#shutil.rmtree(installFolder)
# Format of workspace config file: conanws.yml
#editables:
# ubitrack_core/1.3.0@user/dev:
# path: utcore
# ubitrack_vision/1.3.0@user/dev:
# path: utvision
# ubitrack/1.3.0@user/dev:
# path: ubitrack
# layout: layout_gcc_ubitrack
#layout: layout_gcc
#workspace_generator: cmake
#root: ubitrack/1.3.0@user/dev
editables = {}
for dep in deps:
key = "{0}/{1}@{2}/{3}".format(dep, version, "local", "dev")
edit = {"path": dep}
if dep.startswith("ubitrack"):
editables[key] = edit
key = "{0}/{1}@{2}/{3}".format("ubitrack", version, "local", "dev")
edit = {"path": "meta", "layout": "../workspace/layout_gcc_ubitrack"}
editables[key] = edit
workspace_config = {
"editables": editables,
"layout": "../workspace/layout_gcc",
"workspace_generator": "cmake",
"root": key,
}
yaml.dump(workspace_config, open(workspace_filename, "w"))
conan_api, client_cache, user_io = Conan.factory()
conan_api.create_app()
build_parameter = ["*:workspaceBuild=True"]
profile_name = global_config['profile_name'].split(",")
result = conan_api.workspace_install(build_folder,
options=build_parameter,
install_folder=installFolder,
profile_name=profile_name)
return {}
from conans.client.conan_api import Conan
import platform
import os
conan_api, _, _ = Conan.factory()
conan_api.config_set("general.cmake_generator", "Xcode")
conan_api.update_profile("./profile/ios", "settings.os", "iOS")
conan_api.update_profile("./profile/ios", "settings.compiler", "apple-clang")
conan_api.update_profile("./profile/ios", "settings.compiler.version", "11.0")
conan_api.update_profile("./profile/ios", "settings.compiler.libcxx", "libc++")
conan_api.update_profile("./profile/ios", "settings.os.version", "9.0")
### just install pip every time?
CONAN_LOGIN_USERNAME = os.getenv('CONAN_LOGIN_USERNAME')
CONAN_PASSWORD = os.getenv('CONAN_PASSWORD')
conan_api.remote_add(
"bintray", f"https://api.bintray.com/conan/{CONAN_LOGIN_USERNAME}/test")
conan_api.authenticate(CONAN_LOGIN_USERNAME, CONAN_PASSWORD, "bintray")
conan_api.export("./ios_recipe", "dlib", "19.21", CONAN_LOGIN_USERNAME,
"github_action")
conan_api.install("./build",
build=["outdated"],
profile_names=["./profile/ios"])
conan_api.upload("dlib",
all_packages=True,
confirm=True,
remote_name="bintray")
#!/usr/bin/env python
from conans.client.conan_api import Conan
if __name__ == "__main__":
user = "******"
channel = "testing"
conan, _, _ = Conan.factory()
conan.create(".", user=user, channel=channel)
def __init__(self,
username=None,
channel=None,
runner=None,
gcc_versions=None,
visual_versions=None,
visual_runtimes=None,
visual_toolsets=None,
apple_clang_versions=None,
archs=None,
options=None,
use_docker=None,
curpage=None,
total_pages=None,
docker_image=None,
reference=None,
password=None,
remotes=None,
upload=None,
stable_branch_pattern=None,
vs10_x86_64_enabled=False,
mingw_configurations=None,
stable_channel=None,
platform_info=None,
upload_retry=None,
clang_versions=None,
login_username=None,
upload_only_when_stable=None,
upload_only_when_tag=None,
upload_only_recipe=None,
build_types=None,
cppstds=None,
skip_check_credentials=False,
allow_gcc_minors=False,
exclude_vcvars_precommand=False,
docker_run_options=None,
docker_image_skip_update=False,
docker_image_skip_pull=False,
docker_entry_script=None,
docker_32_images=None,
docker_conan_home=None,
docker_shell=None,
pip_install=None,
build_policy=None,
always_update_conan_in_docker=False,
conan_api=None,
client_cache=None,
conanfile=None,
ci_manager=None,
out=None,
test_folder=None,
cwd=None,
config_url=None,
config_args=None,
upload_dependencies=None,
force_selinux=None,
skip_recipe_export=False,
update_dependencies=None,
lockfile=None):
conan_version = get_client_version()
self.printer = Printer(out)
self.printer.print_rule()
self.printer.print_ascci_art()
self.cwd = cwd or os.getcwd()
if not conan_api:
self.conan_api, _, _ = Conan.factory()
self.conan_api.create_app()
self.client_cache = self.conan_api.app.cache
else:
self.conan_api = conan_api
self.client_cache = client_cache
self.ci_manager = ci_manager or CIManager(self.printer)
self.remotes_manager = RemotesManager(self.conan_api, self.printer,
remotes, upload)
self.username = username or os.getenv("CONAN_USERNAME", None)
self.skip_check_credentials = skip_check_credentials or get_bool_from_env(
"CONAN_SKIP_CHECK_CREDENTIALS")
self.auth_manager = AuthManager(
self.conan_api,
self.printer,
login_username,
password,
default_username=self.username,
skip_check_credentials=self.skip_check_credentials)
# Upload related variables
self.upload_retry = upload_retry or os.getenv("CONAN_UPLOAD_RETRY", 3)
if upload_only_when_stable is not None:
self.upload_only_when_stable = upload_only_when_stable
else:
self.upload_only_when_stable = get_bool_from_env(
"CONAN_UPLOAD_ONLY_WHEN_STABLE")
if upload_only_when_tag is not None:
self.upload_only_when_tag = upload_only_when_tag
else:
self.upload_only_when_tag = get_bool_from_env(
"CONAN_UPLOAD_ONLY_WHEN_TAG")
self.upload_only_recipe = upload_only_recipe or get_bool_from_env(
"CONAN_UPLOAD_ONLY_RECIPE")
self.remotes_manager.add_remotes_to_conan()
self.uploader = Uploader(self.conan_api, self.remotes_manager,
self.auth_manager, self.printer,
self.upload_retry)
self._builds = []
self._named_builds = {}
self._packages_summary = []
self._update_conan_in_docker = always_update_conan_in_docker or get_bool_from_env(
"CONAN_ALWAYS_UPDATE_CONAN_DOCKER")
self._platform_info = platform_info or PlatformInfo()
self.stable_branch_pattern = stable_branch_pattern or \
os.getenv("CONAN_STABLE_BRANCH_PATTERN", None)
self.stable_channel = stable_channel or os.getenv(
"CONAN_STABLE_CHANNEL", "stable")
self.stable_channel = self.stable_channel.rstrip()
self.partial_reference = reference or os.getenv(
"CONAN_REFERENCE", None)
self.channel = self._get_specified_channel(channel, reference)
self.conanfile = conanfile or os.getenv("CONAN_CONANFILE",
"conanfile.py")
if self.partial_reference:
if "@" in self.partial_reference:
self.reference = ConanFileReference.loads(
self.partial_reference)
else:
name, version = self.partial_reference.split("/")
self.reference = ConanFileReference(name, version,
self.username,
self.channel)
else:
if not os.path.exists(os.path.join(self.cwd, self.conanfile)):
raise Exception("Conanfile not found, specify a 'reference' "
"parameter with name and version")
conanfile = load_cf_class(os.path.join(self.cwd, self.conanfile),
self.conan_api)
name, version = conanfile.name, conanfile.version
if name and version:
self.reference = ConanFileReference(name, version,
self.username,
self.channel)
else:
self.reference = None
self._docker_image = docker_image or os.getenv("CONAN_DOCKER_IMAGE",
None)
# If CONAN_DOCKER_IMAGE is specified, then use docker is True
self.use_docker = (use_docker or os.getenv("CONAN_USE_DOCKER", False)
or self._docker_image is not None)
self.docker_conan_home = docker_conan_home or os.getenv(
"CONAN_DOCKER_HOME", None)
os_name = self._platform_info.system(
) if not self.use_docker else "Linux"
self.build_generator = BuildGenerator(
reference, os_name, gcc_versions, apple_clang_versions,
clang_versions, visual_versions, visual_runtimes, visual_toolsets,
vs10_x86_64_enabled, mingw_configurations, archs, allow_gcc_minors,
build_types, options, cppstds)
self.build_policy = (build_policy
or self.ci_manager.get_commit_build_policy()
or split_colon_env("CONAN_BUILD_POLICY"))
if isinstance(self.build_policy, list):
self.build_policy = ",".join(self.build_policy)
self.sudo_docker_command = ""
if "CONAN_DOCKER_USE_SUDO" in os.environ:
self.sudo_docker_command = "sudo -E" if get_bool_from_env(
"CONAN_DOCKER_USE_SUDO") else ""
elif platform.system() != "Windows":
self.sudo_docker_command = "sudo -E"
self.sudo_pip_command = ""
if "CONAN_PIP_USE_SUDO" in os.environ:
self.sudo_pip_command = "sudo -E" if get_bool_from_env(
"CONAN_PIP_USE_SUDO") else ""
elif platform.system(
) != "Windows" and self._docker_image and 'conanio/' not in str(
self._docker_image):
self.sudo_pip_command = "sudo -E"
self.pip_command = os.getenv("CONAN_PIP_COMMAND", "pip")
pip_found = True if tools.os_info.is_windows else tools.which(
self.pip_command)
if not pip_found or not "pip" in self.pip_command:
raise Exception(
"CONAN_PIP_COMMAND: '{}' is not a valid pip command.".format(
self.pip_command))
self.docker_pip_command = os.getenv("CONAN_DOCKER_PIP_COMMAND", "pip")
self.docker_shell = docker_shell or os.getenv("CONAN_DOCKER_SHELL")
if self.is_wcow:
if self.docker_conan_home is None:
self.docker_conan_home = "C:/Users/ContainerAdministrator"
self.docker_shell = docker_shell or "cmd /C"
else:
if self.docker_conan_home is None:
self.docker_conan_home = "/home/conan"
self.docker_shell = docker_shell or "/bin/sh -c"
self.docker_platform_param = ""
self.lcow_user_workaround = ""
if self.is_lcow:
self.docker_platform_param = "--platform=linux"
# With LCOW, Docker doesn't respect USER directive in dockerfile yet
self.lcow_user_workaround = "sudo su conan && "
self.exclude_vcvars_precommand = exclude_vcvars_precommand or \
get_bool_from_env("CONAN_EXCLUDE_VCVARS_PRECOMMAND")
self._docker_image_skip_update = docker_image_skip_update or \
get_bool_from_env("CONAN_DOCKER_IMAGE_SKIP_UPDATE")
self._docker_image_skip_pull = docker_image_skip_pull or \
get_bool_from_env("CONAN_DOCKER_IMAGE_SKIP_PULL")
self.runner = runner or os.system
self.output_runner = ConanOutputRunner()
self.docker_run_options = docker_run_options or split_colon_env(
"CONAN_DOCKER_RUN_OPTIONS")
if isinstance(self.docker_run_options, list):
self.docker_run_options = " ".join(self.docker_run_options)
self.docker_entry_script = docker_entry_script or os.getenv(
"CONAN_DOCKER_ENTRY_SCRIPT")
self.pip_install = pip_install or split_colon_env("CONAN_PIP_INSTALL")
self.upload_dependencies = upload_dependencies or split_colon_env(
"CONAN_UPLOAD_DEPENDENCIES") or ""
if isinstance(self.upload_dependencies, list):
self.upload_dependencies = ",".join(self.upload_dependencies)
if "all" in self.upload_dependencies and self.upload_dependencies != "all":
raise Exception(
"Upload dependencies only accepts or 'all' or package references. Do not mix both!"
)
self.update_dependencies = update_dependencies or get_bool_from_env(
"CONAN_UPDATE_DEPENDENCIES")
if self.channel:
os.environ["CONAN_CHANNEL"] = self.channel
if docker_32_images is not None:
self.docker_32_images = docker_32_images
else:
self.docker_32_images = os.getenv("CONAN_DOCKER_32_IMAGES", False)
self.force_selinux = force_selinux or get_bool_from_env(
"CONAN_FORCE_SELINUX")
self.curpage = curpage or os.getenv("CONAN_CURRENT_PAGE", 1)
self.total_pages = total_pages or os.getenv("CONAN_TOTAL_PAGES", 1)
self.conan_pip_package = os.getenv("CONAN_PIP_PACKAGE",
"conan==%s" % conan_version)
if self.conan_pip_package in ("0", "False"):
self.conan_pip_package = ""
self.vs10_x86_64_enabled = vs10_x86_64_enabled
self.builds_in_current_page = []
self.test_folder = test_folder or os.getenv("CPT_TEST_FOLDER")
self.config_url = config_url or os.getenv("CONAN_CONFIG_URL")
self.skip_recipe_export = skip_recipe_export or \
get_bool_from_env("CONAN_SKIP_RECIPE_EXPORT")
self.config_args = config_args or os.getenv("CONAN_CONFIG_ARGS")
self.lockfile = lockfile or os.getenv("CONAN_LOCKFILE")
def valid_pair(var, value):
return (isinstance(value, six.string_types)
or isinstance(value, bool) or isinstance(value, list)
) and not var.startswith("_") and "password" not in var
with self.printer.foldable_output("local_vars"):
self.printer.print_dict({
var: value
for var, value in self.__dict__.items()
if valid_pair(var, value)
})
self._newest_supported_conan_version = Version(
NEWEST_CONAN_SUPPORTED).minor(fill=False)
self._client_conan_version = conan_version
def conan():
"""Conan API fixture"""
conan, _, _ = Conan.factory(False)
return conan