def __init__(self, client_cache, user_io, runner, remote_manager, search_manager):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager)
def __init__(self, paths, user_io, runner, remote_manager):
assert isinstance(user_io, UserIO)
assert isinstance(paths, ConanPaths)
self._conan_paths = paths
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(paths, user_io, runner, remote_manager)
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager,
settings_preprocessor):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager,
settings_preprocessor)
# Patch the tools module with a good requester and user_io
set_global_instances(self._user_io.out, get_basic_requester(self._client_cache))
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager,
_settings_preprocessor, interactive=True):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._remote_manager = remote_manager
self.recorder = ActionRecorder()
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager,
_settings_preprocessor, self.recorder)
if not interactive:
self._user_io.disable_input()
def __init__(self, paths, user_io, runner, remote_manager):
assert isinstance(user_io, UserIO)
assert isinstance(paths, ConanPaths)
self._conan_paths = paths
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(paths, user_io, runner, remote_manager)
def get_command():
def instance_remote_manager(client_cache):
requester = requests.Session()
requester.proxies = client_cache.conan_config.proxies
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(
requester, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION), out)
# To handle remote connections
rest_api_client = RestApiClient(out,
requester=version_checker_requester)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~"))
try:
# To capture exceptions in conan.conf parsing
client_cache = ClientCache(user_folder, None, out)
# obtain a temp ConanManager instance to execute the migrations
remote_manager = instance_remote_manager(client_cache)
# Get a DiskSearchManager
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(client_cache, search_adapter)
manager = ConanManager(client_cache, user_io, ConanRunner(),
remote_manager, search_manager)
client_cache = migrate_and_get_client_cache(user_folder, out, manager)
except Exception as e:
out.error(str(e))
sys.exit(True)
# Get the new command instance after migrations have been done
remote_manager = instance_remote_manager(client_cache)
# Get a search manager
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(client_cache, search_adapter)
command = Command(client_cache, user_io, ConanRunner(), remote_manager,
search_manager)
return command
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager)
# Patch the tools module with a good requester and user_io
tools._global_requester = get_basic_requester(self._client_cache)
tools._global_output = self._user_io.out
class Command(object):
""" A single command of the conans application, with all the first level commands.
Manages the parsing of parameters and delegates functionality in
collaborators.
It can also show help of the tool
"""
def __init__(self, paths, user_io, runner, remote_manager, localdb):
assert isinstance(user_io, UserIO)
assert isinstance(paths, ConanPaths)
self._conan_paths = paths
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(paths, user_io, runner, remote_manager,
localdb)
self._localdb = localdb
def _parse_args(self, parser):
parser.add_argument("-r",
"--remote",
help='look for in the remote storage')
parser.add_argument(
"--options",
"-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1,
action=Extender)
parser.add_argument(
"--settings",
"-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1,
action=Extender)
parser.add_argument(
"--build",
"-b",
action=Extender,
nargs="*",
help='''Optional, use it to choose if you want to build from sources:
--build Build all from sources, do not use binary packages.
--build=never Default option. Never build, use binary packages or fail if a binary package is not found.
--build=missing Build from code if a binary package is not found.
--build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters.
''')
def _detect_tested_library_name(self):
conanfile_content = load(CONANFILE)
match = re.search('^\s*name\s*=\s*"(.*)"', conanfile_content,
re.MULTILINE)
if match:
return "%s*" % match.group(1)
self._user_io.out.warn(
"Cannot detect a valid conanfile in current directory")
return None
def _get_build_sources_parameter(self, build_param):
# returns True if we want to build the missing libraries
# False if building is forbidden
# A list with patterns: Will force build matching libraries,
# will look for the package for the rest
if isinstance(build_param, list):
if len(build_param) == 0: # All packages from source
return ["*"]
elif len(build_param) == 1 and build_param[0] == "never":
return False # Default
elif len(build_param) == 1 and build_param[0] == "missing":
return True
else: # A list of expressions to match (if matches, will build from source)
return ["%s*" % ref_expr for ref_expr in build_param]
else:
return False # Nothing is built
def test(self, *args):
""" build and run your package test. Must have conanfile.py with "test"
method and "test" subfolder with package consumer test project
"""
parser = argparse.ArgumentParser(description=self.test.__doc__,
prog="conan",
formatter_class=RawTextHelpFormatter)
parser.add_argument(
"path",
nargs='?',
default="",
help='path to conanfile file, '
'e.g., openssl/1.0.2@lasote/testing or ./my_project/')
self._parse_args(parser)
args = parser.parse_args(*args)
folder = os.path.normpath(os.path.join(os.getcwd(), args.path))
test_folder = os.path.join(folder, "test")
if not os.path.exists(test_folder):
raise ConanException("test folder not available")
lib_to_test = self._detect_tested_library_name()
# Get False or a list of patterns to check
if args.build is None and lib_to_test: # Not specified, force build the tested library
args.build = [lib_to_test]
else:
args.build = self._get_build_sources_parameter(args.build)
options = args.options or []
settings = args.settings or []
sha = hashlib.sha1("".join(options + settings)).hexdigest()
build_folder = os.path.join(folder, "build", sha)
rmdir(build_folder)
shutil.copytree(test_folder, build_folder)
self._manager.install(reference=build_folder,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build)
self._manager.build(build_folder, test=True)
def install(self, *args):
""" install in the local store the given requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans install opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.install.__doc__,
prog="conan",
formatter_class=RawTextHelpFormatter)
parser.add_argument(
"reference",
nargs='?',
default="",
help='reference name or path to conanfile file, '
'e.g., openssl/1.0.2@lasote/testing or ./my_project/')
self._parse_args(parser)
args = parser.parse_args(*args)
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
option_dict = args.options or []
settings_dict = args.settings or []
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(
os.path.join(os.getcwd(), args.reference))
self._manager.install(reference=reference,
remote=args.remote,
options=option_dict,
settings=settings_dict,
build_mode=args.build)
def build(self, *args):
""" calls your project conanfile.py "build" method.
EX: conans build ./my_project
Intended for package creators, requires a conanfile.py.
"""
parser = argparse.ArgumentParser(description=self.build.__doc__,
prog="conan")
parser.add_argument(
"path",
nargs="?",
help='path to user conanfile.py, e.g., conans build .',
default="")
args = parser.parse_args(*args)
root_path = os.path.normpath(os.path.join(os.getcwd(), args.path))
self._manager.build(root_path)
def export(self, *args):
""" copies a conanfile.py and associated (export) files to your local store,
where it can be shared and reused in other projects.
From that store, it can be uploaded to any remote with "upload" command.
"""
parser = argparse.ArgumentParser(description=self.export.__doc__,
prog="conan")
parser.add_argument("user",
help='user_name[/channel]. By default, channel is '
'"testing", e.g., phil or phil/stable')
parser.add_argument(
'--path',
'-p',
default=None,
help='Optional. Folder with a %s. Default current directory.' %
CONANFILE)
args = parser.parse_args(*args)
self._manager.export(args.user, args.path)
def remove(self, *args):
""" Remove any folder from your local/remote store
"""
parser = argparse.ArgumentParser(description=self.remove.__doc__,
prog="conan")
parser.add_argument('pattern', help='Pattern name, e.g., openssl/*')
parser.add_argument(
'-p',
'--packages',
const=[],
nargs='?',
help='By default, remove all the packages or select one, '
'specifying the SHA key')
parser.add_argument(
'-b',
'--builds',
const=[],
nargs='?',
help='By default, remove all the build folders or select one, '
'specifying the SHA key')
parser.add_argument('-s',
'--src',
default=False,
action="store_true",
help='Remove source folders')
parser.add_argument('-f',
'--force',
default=False,
action='store_true',
help='Remove without requesting a confirmation')
parser.add_argument('-r', '--remote', help='Remote origin')
args = parser.parse_args(*args)
if args.packages:
args.packages = args.packages.split(",")
if args.builds:
args.builds = args.builds.split(",")
self._manager.remove(args.pattern,
package_ids_filter=args.packages,
build_ids=args.builds,
src=args.src,
force=args.force,
remote=args.remote)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__,
prog="conan")
parser.add_argument(
"name",
nargs='?',
default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument("-p", "--password", help='User password')
parser.add_argument("--remote",
"-r",
help='look for in the remote storage')
args = parser.parse_args(*parameters) # To enable -h
self._manager.user(args.remote, args.name, args.password)
def search(self, *args):
""" show local/remote packages
"""
parser = argparse.ArgumentParser(description=self.search.__doc__,
prog="conan")
parser.add_argument('pattern',
nargs='?',
help='Pattern name, e.g., openssl/*')
parser.add_argument('--case-sensitive',
default=False,
action='store_true',
help='Make a case-sensitive search')
parser.add_argument('-r', '--remote', help='Remote origin')
parser.add_argument('-v',
'--verbose',
default=False,
action='store_true',
help='Show packages options and settings')
parser.add_argument('-p',
'--package',
help='Package ID pattern. EX: 23*',
default=None)
args = parser.parse_args(*args)
self._manager.search(args.pattern,
args.remote,
ignorecase=not args.case_sensitive,
verbose=args.verbose,
package_pattern=args.package)
def upload(self, *args):
""" uploads a conanfile or binary packages from the local store to any remote.
To upload something, it should be "exported" first.
"""
parser = argparse.ArgumentParser(description=self.upload.__doc__,
prog="conan")
parser.add_argument(
"reference",
help='conan reference, e.g., openssl/1.0.2@lasote/testing')
# TODO: packageparser.add_argument('package', help='user name')
parser.add_argument("--package",
"-p",
default=None,
help='package ID to upload')
parser.add_argument("--remote",
"-r",
help='upload to this specific remote')
parser.add_argument("--all",
action='store_true',
default=False,
help='Upload both conans sources and packages')
parser.add_argument(
"--force",
action='store_true',
default=False,
help='Do not check conans date, override remote with local')
args = parser.parse_args(*args)
conan_ref = ConanFileReference.loads(args.reference)
package_id = args.package
if not conan_ref and not package_id:
raise ConanException("Enter conans or package id")
self._manager.upload(conan_ref,
package_id,
args.remote,
all_packages=args.all,
force=args.force)
def _show_help(self):
""" prints a summary of all commands
"""
self._user_io.out.writeln(
'Conan commands. Type $conan "command" -h for help',
Color.BRIGHT_YELLOW)
commands = self._commands()
for name in sorted(self._commands()):
self._user_io.out.write(' %-10s' % name, Color.GREEN)
self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0])
def _commands(self):
""" returns a list of available commands
"""
result = {}
for m in inspect.getmembers(self, predicate=inspect.ismethod):
method_name = m[0]
if not method_name.startswith('_'):
method = m[1]
if method.__doc__ and not method.__doc__.startswith('HIDDEN'):
result[method_name] = method
return result
def run(self, *args):
"""HIDDEN: entry point for executing commands, dispatcher to class
methods
"""
errors = False
try:
try:
command = args[0][0]
commands = self._commands()
method = commands[command]
except KeyError as exc:
if command in ["-v", "--version"]:
self._user_io.out.success("Conan version %s" %
CLIENT_VERSION)
return False
self._show_help()
if command in ["-h", "--help"]:
return False
raise ConanException("Unknown command %s" % str(exc))
except IndexError as exc: # No parameters
self._show_help()
return False
method(args[0][1:])
except (KeyboardInterrupt, SystemExit) as exc:
logger.error(exc)
errors = True
except ConanException as exc:
logger.error(exc)
# logger.debug(traceback.format_exc())
errors = True
self._user_io.out.error(str(exc))
return errors
class ConanAPIV1(object):
@staticmethod
def instance_remote_manager(requester, client_cache, user_io, _client_version,
min_server_compatible_version):
# Verify client version against remotes
version_checker_req = VersionCheckerRequester(requester, _client_version,
min_server_compatible_version,
user_io.out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(user_io.out, requester=version_checker_req,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, user_io.out)
return localdb, rest_api_client, remote_manager
@staticmethod
def factory(interactive=None):
"""Factory"""
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
try:
user_home = get_conan_user_home()
client_cache = migrate_and_get_client_cache(user_home, out)
sys.path.append(os.path.join(user_home, "python"))
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Get the new command instance after migrations have been done
requester = get_basic_requester(client_cache)
_, _, remote_manager = ConanAPIV1.instance_remote_manager(
requester,
client_cache, user_io,
Version(client_version),
Version(MIN_SERVER_COMPATIBLE_VERSION))
# Adjust global tool variables
set_global_instances(out, requester)
# Get a search manager
search_manager = DiskSearchManager(client_cache)
# Settings preprocessor
if interactive is None:
interactive = not get_env("CONAN_NON_INTERACTIVE", False)
conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager,
settings_preprocessor, interactive=interactive)
return conan, client_cache, user_io
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager,
_settings_preprocessor, interactive=True):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._remote_manager = remote_manager
self.recorder = ActionRecorder()
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager,
_settings_preprocessor, self.recorder)
if not interactive:
self._user_io.disable_input()
@api_method
def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False,
cwd=None, visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None,
osx_clang_versions=None, shared=None, upload_url=None, gitignore=None,
gitlab_gcc_versions=None, gitlab_clang_versions=None):
from conans.client.cmd.new import cmd_new
cwd = os.path.abspath(cwd or os.getcwd())
files = cmd_new(name, header=header, pure_c=pure_c, test=test,
exports_sources=exports_sources, bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions, shared=shared,
upload_url=upload_url, gitignore=gitignore,
gitlab_gcc_versions=gitlab_gcc_versions,
gitlab_clang_versions=gitlab_clang_versions)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
@api_method
def test(self, path, reference, profile_name=None, settings=None, options=None, env=None,
remote=None, update=False, build_modes=None, cwd=None, test_build_folder=None):
settings = settings or []
options = options or []
env = env or []
conanfile_path = _get_conanfile_path(path, cwd, py=True)
cwd = cwd or os.getcwd()
profile = profile_from_args(profile_name, settings, options, env, cwd,
self._client_cache)
reference = ConanFileReference.loads(reference)
pt = PackageTester(self._manager, self._user_io)
pt.install_build_and_test(conanfile_path, reference, profile, remote,
update, build_modes=build_modes,
test_build_folder=test_build_folder)
@api_method
def create(self, conanfile_path, name=None, version=None, user=None, channel=None,
profile_name=None, settings=None,
options=None, env=None, test_folder=None, not_export=False,
build_modes=None,
keep_source=False, keep_build=False, verify=None,
manifests=None, manifests_interactive=None,
remote=None, update=False, cwd=None, test_build_folder=None):
"""
API method to create a conan package
:param test_folder: default None - looks for default 'test' or 'test_package' folder),
string - test_folder path
False - disabling tests
"""
settings = settings or []
options = options or []
env = env or []
cwd = cwd or os.getcwd()
conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
if not name or not version:
conanfile = load_conanfile_class(conanfile_path)
name, version = conanfile.name, conanfile.version
if not name or not version:
raise ConanException("conanfile.py doesn't declare package name or version")
reference = ConanFileReference(name, version, user, channel)
scoped_output = ScopedOutput(str(reference), self._user_io.out)
# Make sure keep_source is set for keep_build
if keep_build:
keep_source = True
# Forcing an export!
if not not_export:
scoped_output.highlight("Exporting package recipe")
self._manager.export(conanfile_path, name, version, user, channel, keep_source)
if build_modes is None: # Not specified, force build the tested library
build_modes = [name]
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env,
cwd, self._client_cache)
def get_test_conanfile_path(tf):
"""Searches in the declared test_folder or in the standard locations"""
if tf is False:
# Look up for testing conanfile can be disabled if tf (test folder) is False
return None
test_folders = [tf] if tf else ["test_package", "test"]
base_folder = os.path.dirname(conanfile_path)
for test_folder_name in test_folders:
test_folder = os.path.join(base_folder, test_folder_name)
test_conanfile_path = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile_path):
return test_conanfile_path
else:
if tf:
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" % tf)
test_conanfile_path = get_test_conanfile_path(test_folder)
if test_conanfile_path:
pt = PackageTester(self._manager, self._user_io)
pt.install_build_and_test(test_conanfile_path, reference, profile,
remote, update, build_modes=build_modes,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
keep_build=keep_build,
test_build_folder=test_build_folder)
else:
self._manager.install(reference=reference,
install_folder=None, # Not output anything
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build_modes,
update=update,
keep_build=keep_build)
@api_method
def export_pkg(self, conanfile_path, name, channel, source_folder=None, build_folder=None,
package_folder=None, install_folder=None, profile_name=None, settings=None,
options=None, env=None, force=False, user=None, version=None, cwd=None):
settings = settings or []
options = options or []
env = env or []
cwd = cwd or os.getcwd()
# Checks that info files exists if the install folder is specified
if install_folder and not existing_info_files(_make_abs_path(install_folder, cwd)):
raise ConanException("The specified install folder doesn't contain '%s' and '%s' "
"files" % (CONANINFO, BUILD_INFO))
conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
if package_folder:
if build_folder or source_folder:
raise ConanException("package folder definition incompatible with build and source folders")
package_folder = _make_abs_path(package_folder, cwd)
build_folder = _make_abs_path(build_folder, cwd)
install_folder = _make_abs_path(install_folder, cwd, default=build_folder)
source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path))
# Checks that no both settings and info files are specified
if install_folder and existing_info_files(install_folder) and \
(profile_name or settings or options or env):
raise ConanException("%s and %s are found, at '%s' folder, so specifying profile, "
"settings, options or env is not allowed" % (CONANINFO, BUILD_INFO,
install_folder))
infos_present = existing_info_files(install_folder)
if not infos_present:
profile = profile_from_args(profile_name, settings, options, env=env,
cwd=cwd, client_cache=self._client_cache)
else:
profile = read_conaninfo_profile(install_folder)
conanfile = load_conanfile_class(conanfile_path)
if (name and conanfile.name and conanfile.name != name) or \
(version and conanfile.version and conanfile.version != version):
raise ConanException("Specified name/version doesn't match with the "
"name/version in the conanfile")
self._manager.export(conanfile_path, name, version, user, channel)
if not (name and version):
name = conanfile.name
version = conanfile.version
reference = ConanFileReference(name, version, user, channel)
self._manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder,
package_folder=package_folder, install_folder=install_folder,
profile=profile, force=force)
@api_method
def download(self, reference, remote=None, package=None, recipe=False):
if package and recipe:
raise ConanException("recipe parameter cannot be used together with package")
# Install packages without settings (fixed ids or all)
conan_ref = ConanFileReference.loads(reference)
self._manager.download(conan_ref, package, remote=remote, recipe=recipe)
@api_method
def install_reference(self, reference, settings=None, options=None, env=None,
remote=None, verify=None, manifests=None,
manifests_interactive=None, build=None, profile_name=None,
update=False, generators=None, install_folder=None, cwd=None):
cwd = cwd or os.getcwd()
install_folder = _make_abs_path(install_folder, cwd)
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, cwd,
self._client_cache)
if not generators: # We don't want the default txt
generators = False
mkdir(install_folder)
self._manager.install(reference=reference, install_folder=install_folder, remote=remote,
profile=profile, build_modes=build, update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generators,
install_reference=True)
@api_method
def install(self, path="", settings=None, options=None, env=None,
remote=None, verify=None, manifests=None,
manifests_interactive=None, build=None, profile_name=None,
update=False, generators=None, no_imports=False, install_folder=None, cwd=None):
cwd = cwd or os.getcwd()
install_folder = _make_abs_path(install_folder, cwd)
conanfile_path = _get_conanfile_path(path, cwd, py=None)
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, cwd,
self._client_cache)
self._manager.install(reference=conanfile_path,
install_folder=install_folder,
remote=remote,
profile=profile,
build_modes=build,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generators,
no_imports=no_imports)
@api_method
def config_get(self, item):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
self._user_io.out.info(config_parser.get_item(item))
return config_parser.get_item(item)
@api_method
def config_set(self, item, value):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
config_parser.set_item(item, value)
self._client_cache.invalidate()
@api_method
def config_rm(self, item):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
config_parser.rm_item(item)
self._client_cache.invalidate()
@api_method
def config_install(self, item, verify_ssl):
from conans.client.conf.config_installer import configuration_install
return configuration_install(item, self._client_cache, self._user_io.out, verify_ssl)
def _info_get_profile(self, reference, install_folder, profile_name, settings, options, env):
cwd = os.getcwd()
try:
reference = ConanFileReference.loads(reference)
except ConanException:
reference = _get_conanfile_path(reference, cwd=None, py=None)
if install_folder or not (profile_name or settings or options or env):
# When not install folder is specified but neither any setting, we try to read the
# info from cwd
install_folder = _make_abs_path(install_folder, cwd)
if existing_info_files(install_folder):
return reference, read_conaninfo_profile(install_folder)
return reference, profile_from_args(profile_name, settings, options, env=env,
cwd=cwd, client_cache=self._client_cache)
@api_method
def info_build_order(self, reference, settings=None, options=None, env=None,
profile_name=None, remote=None, build_order=None, check_updates=None,
install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
graph = self._manager.info_build_order(reference, profile, build_order, remote, check_updates)
return graph
@api_method
def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None,
profile_name=None, remote=None, check_updates=None, install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
ret = self._manager.info_nodes_to_build(reference, profile, build_modes, remote,
check_updates)
ref_list, project_reference = ret
return ref_list, project_reference
@api_method
def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None,
profile_name=None, update=False, install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
ret = self._manager.info_get_graph(reference, remote=remote, profile=profile,
check_updates=update)
deps_graph, graph_updates_info, project_reference = ret
return deps_graph, graph_updates_info, project_reference
@api_method
def build(self, conanfile_path, source_folder=None, package_folder=None, build_folder=None,
install_folder=None, should_configure=True, should_build=True, should_install=True, cwd=None):
cwd = cwd or os.getcwd()
conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
build_folder = _make_abs_path(build_folder, cwd)
install_folder = _make_abs_path(install_folder, cwd, default=build_folder)
source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path))
default_pkg_folder = os.path.join(build_folder, "package")
package_folder = _make_abs_path(package_folder, cwd, default=default_pkg_folder)
self._manager.build(conanfile_path, source_folder, build_folder, package_folder,
install_folder, should_configure=should_configure, should_build=should_build,
should_install=should_install)
@api_method
def package(self, path, build_folder, package_folder, source_folder=None, install_folder=None, cwd=None):
cwd = cwd or os.getcwd()
conanfile_path = _get_conanfile_path(path, cwd, py=True)
build_folder = _make_abs_path(build_folder, cwd)
install_folder = _make_abs_path(install_folder, cwd, default=build_folder)
source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path))
default_pkg_folder = os.path.join(build_folder, "package")
package_folder = _make_abs_path(package_folder, cwd, default=default_pkg_folder)
self._manager.local_package(package_folder, conanfile_path, build_folder, source_folder,
install_folder)
@api_method
def source(self, path, source_folder=None, info_folder=None, cwd=None):
cwd = cwd or os.getcwd()
conanfile_path = _get_conanfile_path(path, cwd, py=True)
source_folder = _make_abs_path(source_folder, cwd)
info_folder = _make_abs_path(info_folder, cwd)
mkdir(source_folder)
if not os.path.exists(info_folder):
raise ConanException("Specified info-folder doesn't exist")
self._manager.source(conanfile_path, source_folder, info_folder)
@api_method
def imports(self, path, dest=None, info_folder=None, cwd=None):
"""
:param path: Path to the conanfile
:param dest: Dir to put the imported files. (Abs path or relative to cwd)
:param info_folder: Dir where the conaninfo.txt and conanbuildinfo.txt files are
:param cwd: Current working directory
:return: None
"""
cwd = cwd or os.getcwd()
info_folder = _make_abs_path(info_folder, cwd)
dest = _make_abs_path(dest, cwd)
mkdir(dest)
conanfile_abs_path = _get_conanfile_path(path, cwd, py=None)
self._manager.imports(conanfile_abs_path, dest, info_folder)
@api_method
def imports_undo(self, manifest_path):
cwd = os.getcwd()
manifest_path = _make_abs_path(manifest_path, cwd)
self._manager.imports_undo(manifest_path)
@api_method
def export(self, path, name, version, user, channel, keep_source=False, cwd=None):
conanfile_path = _get_conanfile_path(path, cwd, py=True)
self._manager.export(conanfile_path, name, version, user, channel, keep_source)
@api_method
def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False,
remote=None, outdated=False):
self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds,
src=src, force=force, remote=remote, packages_query=query,
outdated=outdated)
@api_method
def copy(self, reference, user_channel, force=False, packages=None):
"""
param packages: None=No binaries, True=All binaries, else list of IDs
"""
from conans.client.cmd.copy import cmd_copy
# FIXME: conan copy does not support short-paths in Windows
cmd_copy(reference, user_channel, packages, self._client_cache,
self._user_io, self._remote_manager, self.recorder, force=force)
@api_method
def authenticate(self, name, password, remote=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if not remote:
remote = registry.default_remote
else:
remote = registry.remote(remote)
if password == "":
name, password = self._user_io.request_login(remote_name=remote.name,
username=name)
self._remote_manager.authenticate(remote, name, password)
@api_method
def user_set(self, user, remote_name=None):
return user_set(self._client_cache, self._user_io.out, user, remote_name)
@api_method
def users_clean(self):
return users_clean(self._client_cache)
@api_method
def users_list(self, remote=None):
users = users_list(self._client_cache, self._user_io.out, remote)
for remote_name, username in users:
self._user_io.out.info("Current '%s' user: %s" % (remote_name, username))
@api_method
def search_recipes(self, pattern, remote=None, case_sensitive=False):
search = Search(self._client_cache, self._remote_manager, self._user_io)
return search.search_recipes(pattern, remote, case_sensitive)
@api_method
def search_packages(self, reference, query=None, remote=None, outdated=False):
search = Search(self._client_cache, self._remote_manager, self._user_io)
return search.search_packages(reference, remote, query=query,
outdated=outdated)
@api_method
def upload(self, pattern, package=None, remote=None, all_packages=False, force=False,
confirm=False, retry=2, retry_wait=5, skip_upload=False, integrity_check=False,
no_overwrite=None):
""" Uploads a package recipe and the generated binary packages to a specified remote
"""
if force and no_overwrite:
raise ConanException("'no_overwrite' argument cannot be used together with 'force'")
uploader = CmdUpload(self._client_cache, self._user_io, self._remote_manager, remote, self.recorder)
return uploader.upload(pattern, package, all_packages, force, confirm, retry, retry_wait,
skip_upload, integrity_check, no_overwrite)
@api_method
def remote_list(self):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remotes
@api_method
def remote_add(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.add(remote, url, verify_ssl, insert)
@api_method
def remote_remove(self, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remove(remote)
@api_method
def remote_update(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.update(remote, url, verify_ssl, insert)
@api_method
def remote_list_ref(self):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.refs
@api_method
def remote_add_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.add_ref(reference, remote)
@api_method
def remote_remove_ref(self, reference):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remove_ref(reference)
@api_method
def remote_update_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.update_ref(reference, remote)
@api_method
def profile_list(self):
return cmd_profile_list(self._client_cache.profiles_path, self._user_io.out)
@api_method
def create_profile(self, profile_name, detect=False):
return cmd_profile_create(profile_name, self._client_cache.profiles_path,
self._user_io.out, detect)
@api_method
def update_profile(self, profile_name, key, value):
return cmd_profile_update(profile_name, key, value, self._client_cache.profiles_path)
@api_method
def get_profile_key(self, profile_name, key):
return cmd_profile_get(profile_name, key, self._client_cache.profiles_path)
@api_method
def delete_profile_key(self, profile_name, key):
return cmd_profile_delete_key(profile_name, key, self._client_cache.profiles_path)
@api_method
def read_profile(self, profile=None):
p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path)
return p
@api_method
def get_path(self, reference, package_id=None, path=None, remote=None):
reference = ConanFileReference.loads(str(reference))
return self._manager.get_path(reference, package_id, path, remote)
@api_method
def export_alias(self, reference, target_reference):
reference = ConanFileReference.loads(str(reference))
target_reference = ConanFileReference.loads(str(target_reference))
return self._manager.export_alias(reference, target_reference)
def _init_manager(self, action_recorder):
"""Every api call gets a new recorder and new manager"""
return ConanManager(self._client_cache, self._user_io, self._runner,
self._remote_manager, self._search_manager,
self._settings_preprocessor, action_recorder, self._registry)
class Command(object):
""" A single command of the conans application, with all the first level commands.
Manages the parsing of parameters and delegates functionality in
collaborators.
It can also show help of the tool
"""
def __init__(self, paths, user_io, runner, remote_manager, localdb):
assert isinstance(user_io, UserIO)
assert isinstance(paths, ConanPaths)
self._conan_paths = paths
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(paths, user_io, runner, remote_manager, localdb)
self._localdb = localdb
def _parse_args(self, parser):
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--build", "-b", action=Extender, nargs="*",
help='''Optional, use it to choose if you want to build from sources:
--build Build all from sources, do not use binary packages.
--build=never Default option. Never build, use binary packages or fail if a binary package is not found.
--build=missing Build from code if a binary package is not found.
--build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters.
''')
def _detect_tested_library_name(self):
conanfile_content = load(CONANFILE)
match = re.search('^\s*name\s*=\s*"(.*)"', conanfile_content, re.MULTILINE)
if match:
return "%s*" % match.group(1)
self._user_io.out.warn("Cannot detect a valid conanfile in current directory")
return None
def _get_build_sources_parameter(self, build_param):
# returns True if we want to build the missing libraries
# False if building is forbidden
# A list with patterns: Will force build matching libraries,
# will look for the package for the rest
if isinstance(build_param, list):
if len(build_param) == 0: # All packages from source
return ["*"]
elif len(build_param) == 1 and build_param[0] == "never":
return False # Default
elif len(build_param) == 1 and build_param[0] == "missing":
return True
else: # A list of expressions to match (if matches, will build from source)
return ["%s*" % ref_expr for ref_expr in build_param]
else:
return False # Nothing is built
def test(self, *args):
""" build and run your package test. Must have conanfile.py with "test"
method and "test" subfolder with package consumer test project
"""
parser = argparse.ArgumentParser(description=self.test.__doc__, prog="conan test",
formatter_class=RawTextHelpFormatter)
parser.add_argument("path", nargs='?', default="",
help='path to conanfile file, '
'e.g. /my_project/')
self._parse_args(parser)
args = parser.parse_args(*args)
root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path))
test_folder = os.path.join(root_folder, "test")
if not os.path.exists(test_folder):
raise ConanException("test folder not available")
lib_to_test = self._detect_tested_library_name()
# Get False or a list of patterns to check
if args.build is None and lib_to_test: # Not specified, force build the tested library
args.build = [lib_to_test]
else:
args.build = self._get_build_sources_parameter(args.build)
options = args.options or []
settings = args.settings or []
sha = hashlib.sha1("".join(options + settings)).hexdigest()
build_folder = os.path.join(root_folder, "build", sha)
rmdir(build_folder)
shutil.copytree(test_folder, build_folder)
self._manager.install(reference=build_folder,
current_path=build_folder,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build)
self._manager.build(build_folder, build_folder, test=True)
def install(self, *args):
""" install in the local store the given requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans install opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='reference'
'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/')
parser.add_argument("--package", "-p", nargs=1, action=Extender, help='Force install specified package ID (ignore settings/options)')
parser.add_argument("--all", action='store_true',
default=False, help='Install all packages from the specified reference')
parser.add_argument("--file", "-f", help="specify conanfile filename")
self._parse_args(parser)
args = parser.parse_args(*args)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
if args.all or args.package: # Install packages without settings (fixed ids or all)
if args.all:
args.package = []
if not args.reference or not isinstance(reference, ConanFileReference):
raise ConanException("Invalid conanfile reference. e.g., OpenSSL/1.0.2e@lasote/stable")
self._manager.download(reference, args.package, remote=args.remote)
else: # Classic install, package chosen with settings and options
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
option_dict = args.options or []
settings_dict = args.settings or []
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=option_dict,
settings=settings_dict,
build_mode=args.build,
filename=args.file)
def info(self, *args):
""" Prints information about the requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans info opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='reference name or path to conanfile file, '
'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/')
parser.add_argument("--file", "-f", help="specify conanfile filename")
self._parse_args(parser)
args = parser.parse_args(*args)
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
option_dict = args.options or []
settings_dict = args.settings or []
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=option_dict,
settings=settings_dict,
build_mode=args.build,
info=True,
filename=args.file)
def build(self, *args):
""" calls your project conanfile.py "build" method.
EX: conans build ./my_project
Intended for package creators, requires a conanfile.py.
"""
parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build")
parser.add_argument("path", nargs="?",
help='path to user conanfile.py, e.g., conans build .',
default="")
parser.add_argument("--file", "-f", help="specify conanfile filename")
args = parser.parse_args(*args)
current_path = os.getcwd()
if args.path:
root_path = os.path.abspath(args.path)
else:
root_path = current_path
self._manager.build(root_path, current_path, filename=args.file)
def package(self, *args):
""" calls your conanfile.py "package" method for a specific package or regenerates the existing
package's manifest.
Intended for package creators, for regenerating a package without recompiling the source.
e.g. conan package OpenSSL/1.0.2e@lasote/stable 9cf83afd07b678d38a9c1645f605875400847ff3
"""
parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package")
parser.add_argument("reference", help='reference name. e.g., openssl/1.0.2@lasote/testing')
parser.add_argument("package", nargs="?", default="",
help='Package ID to regenerate. e.g., '
'9cf83afd07b678d38a9c1645f605875400847ff3')
parser.add_argument("-o", "--only-manifest", default=False, action='store_true',
help='Just regenerate manifest for the existing package.'
'If True conan won\'t call your conanfile\'s package method.')
parser.add_argument("--all", action='store_true',
default=False, help='Package all packages from specified reference')
args = parser.parse_args(*args)
try:
reference = ConanFileReference.loads(args.reference)
except:
raise ConanException("Invalid conanfile reference. e.g., OpenSSL/1.0.2e@lasote/stable")
if not args.all and not args.package:
raise ConanException("'conan package': Please specify --all or a package ID")
self._manager.package(reference, args.package, args.only_manifest, args.all)
def export(self, *args):
""" copies a conanfile.py and associated (export) files to your local store,
where it can be shared and reused in other projects.
From that store, it can be uploaded to any remote with "upload" command.
"""
parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export")
parser.add_argument("user", help='user_name[/channel]. By default, channel is '
'"testing", e.g., phil or phil/stable')
parser.add_argument('--path', '-p', default=None,
help='Optional. Folder with a %s. Default current directory.'
% CONANFILE)
parser.add_argument('--keep-source', '-k', default=False, action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
args = parser.parse_args(*args)
current_path = args.path or os.getcwd()
keep_source = args.keep_source
self._manager.export(args.user, current_path, keep_source)
def remove(self, *args):
""" Remove any folder from your local/remote store
"""
parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove")
parser.add_argument('pattern', help='Pattern name, e.g., openssl/*')
parser.add_argument('-p', '--packages', const=[], nargs='?',
help='By default, remove all the packages or select one, '
'specifying the SHA key')
parser.add_argument('-b', '--builds', const=[], nargs='?',
help='By default, remove all the build folders or select one, '
'specifying the SHA key')
parser.add_argument('-s', '--src', default=False, action="store_true",
help='Remove source folders')
parser.add_argument('-f', '--force', default=False,
action='store_true', help='Remove without requesting a confirmation')
parser.add_argument('-r', '--remote', help='Remote origin')
args = parser.parse_args(*args)
if args.packages:
args.packages = args.packages.split(",")
if args.builds:
args.builds = args.builds.split(",")
self._manager.remove(args.pattern, package_ids_filter=args.packages,
build_ids=args.builds,
src=args.src, force=args.force, remote=args.remote)
def copy(self, *args):
""" Copy packages to another user/channel
"""
parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy")
parser.add_argument("reference", default="",
help='reference'
'e.g., OpenSSL/1.0.2e@lasote/stable')
parser.add_argument("user_channel", default="",
help='Destination user/channel'
'e.g., lasote/testing')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='copy specified package ID')
parser.add_argument("--all", action='store_true',
default=False,
help='Copy all packages from the specified reference')
parser.add_argument("--force", action='store_true',
default=False,
help='Override destination packages and conanfile')
args = parser.parse_args(*args)
reference = ConanFileReference.loads(args.reference)
new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name,
reference.version,
args.user_channel))
if args.all:
args.package = []
self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user")
parser.add_argument("name", nargs='?', default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument("-p", "--password", help='User password')
parser.add_argument("--remote", "-r", help='look for in the remote storage')
args = parser.parse_args(*parameters) # To enable -h
self._manager.user(args.remote, args.name, args.password)
def search(self, *args):
""" show local/remote packages
"""
parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search")
parser.add_argument('pattern', nargs='?', help='Pattern name, e.g., openssl/*')
parser.add_argument('--case-sensitive', default=False,
action='store_true', help='Make a case-sensitive search')
parser.add_argument('-r', '--remote', help='Remote origin')
parser.add_argument('-v', '--verbose', default=False,
action='store_true', help='Show packages options and settings')
parser.add_argument('-p', '--package', help='Package ID pattern. EX: 23*', default=None)
args = parser.parse_args(*args)
self._manager.search(args.pattern,
args.remote,
ignorecase=not args.case_sensitive,
verbose=args.verbose,
package_pattern=args.package)
def upload(self, *args):
""" uploads a conanfile or binary packages from the local store to any remote.
To upload something, it should be "exported" first.
"""
parser = argparse.ArgumentParser(description=self.upload.__doc__,
prog="conan upload")
parser.add_argument("reference",
help='conan reference, e.g., OpenSSL/1.0.2e@lasote/stable')
# TODO: packageparser.add_argument('package', help='user name')
parser.add_argument("--package", "-p", default=None, help='package ID to upload')
parser.add_argument("--remote", "-r", help='upload to this specific remote')
parser.add_argument("--all", action='store_true',
default=False, help='Upload both conans sources and packages')
parser.add_argument("--force", action='store_true',
default=False,
help='Do not check conans date, override remote with local')
args = parser.parse_args(*args)
conan_ref = ConanFileReference.loads(args.reference)
package_id = args.package
if not conan_ref and not package_id:
raise ConanException("Enter conans or package id")
self._manager.upload(conan_ref, package_id,
args.remote, all_packages=args.all, force=args.force)
def _show_help(self):
""" prints a summary of all commands
"""
self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help',
Color.BRIGHT_YELLOW)
commands = self._commands()
for name in sorted(self._commands()):
self._user_io.out.write(' %-10s' % name, Color.GREEN)
self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0])
def _commands(self):
""" returns a list of available commands
"""
result = {}
for m in inspect.getmembers(self, predicate=inspect.ismethod):
method_name = m[0]
if not method_name.startswith('_'):
method = m[1]
if method.__doc__ and not method.__doc__.startswith('HIDDEN'):
result[method_name] = method
return result
def run(self, *args):
"""HIDDEN: entry point for executing commands, dispatcher to class
methods
"""
errors = False
try:
try:
command = args[0][0]
commands = self._commands()
method = commands[command]
except KeyError as exc:
if command in ["-v", "--version"]:
self._user_io.out.success("Conan version %s" % CLIENT_VERSION)
return False
self._show_help()
if command in ["-h", "--help"]:
return False
raise ConanException("Unknown command %s" % str(exc))
except IndexError as exc: # No parameters
self._show_help()
return False
method(args[0][1:])
except (KeyboardInterrupt, SystemExit) as exc:
logger.error(exc)
errors = True
except ConanException as exc:
logger.error(exc)
# logger.debug(traceback.format_exc())
errors = True
self._user_io.out.error(str(exc))
return errors
def _init_manager(self, action_recorder):
"""Every api call gets a new recorder and new manager"""
return ConanManager(self._client_cache, self._user_io, self._runner,
self._remote_manager, action_recorder, self._registry,
self._graph_manager)
class Command(object):
""" A single command of the conans application, with all the first level commands.
Manages the parsing of parameters and delegates functionality in
collaborators.
It can also show help of the tool
"""
def __init__(self, paths, user_io, runner, remote_manager):
assert isinstance(user_io, UserIO)
assert isinstance(paths, ConanPaths)
self._conan_paths = paths
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(paths, user_io, runner, remote_manager)
def _parse_args(self, parser):
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--build", "-b", action=Extender, nargs="*",
help='''Optional, use it to choose if you want to build from sources:
--build Build all from sources, do not use binary packages.
--build=never Default option. Never build, use binary packages or fail if a binary package is not found.
--build=missing Build from code if a binary package is not found.
--build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters.
''')
def _get_tuples_list_from_extender_arg(self, items):
if not items:
return []
# Validate the pairs
for item in items:
chunks = item.split("=")
if len(chunks) != 2:
raise ConanException("Invalid input '%s', use 'name=value'" % item)
return [(item[0], item[1]) for item in [item.split("=") for item in items]]
def _detect_tested_library_name(self):
conanfile_content = load(CONANFILE)
match = re.search('^\s*name\s*=\s*[\'"](.*)[\'"]', conanfile_content, re.MULTILINE)
if match:
return "%s*" % match.group(1)
self._user_io.out.warn("Cannot detect a valid conanfile in current directory")
return None
def _get_build_sources_parameter(self, build_param):
# returns True if we want to build the missing libraries
# False if building is forbidden
# A list with patterns: Will force build matching libraries,
# will look for the package for the rest
if isinstance(build_param, list):
if len(build_param) == 0: # All packages from source
return ["*"]
elif len(build_param) == 1 and build_param[0] == "never":
return False # Default
elif len(build_param) == 1 and build_param[0] == "missing":
return True
else: # A list of expressions to match (if matches, will build from source)
return ["%s*" % ref_expr for ref_expr in build_param]
else:
return False # Nothing is built
def _test_check(self, test_folder, test_folder_name):
""" To ensure that the 0.9 version new layout is detected and users warned
"""
# Check old tests, format
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("Test conanfile.py does not exist")
test_conanfile_content = load(test_conanfile)
if ".conanfile_directory" not in test_conanfile_content:
self._user_io.out.error("""******* conan test command layout has changed *******
In your "%s" folder 'conanfile.py' you should use the
path to the conanfile_directory, something like:
self.run('cmake %%s %%s' %% (self.conanfile_directory, cmake.command_line))
""" % (test_folder_name))
# Test the CMakeLists, if existing
test_cmake = os.path.join(test_folder, "CMakeLists.txt")
if os.path.exists(test_cmake):
test_cmake_content = load(test_cmake)
if "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake" not in test_cmake_content:
self._user_io.out.error("""******* conan test command layout has changed *******
In your "%s" folder 'CMakeLists.txt' you should use the
path to the CMake binary directory, like this:
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
""" % (test_folder_name))
def new(self, *args):
""" create a new package template conanfile.py and other optional files
"""
parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new",
formatter_class=RawTextHelpFormatter)
parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing')
parser.add_argument("-t", "--test", action='store_true', default=False,
help='Create test_package skeleton to test package')
parser.add_argument("-i", "--header", action='store_true', default=False,
help='Create a headers only package')
parser.add_argument("-c", "--pure_c", action='store_true', default=False,
help='Create a C language package only package (non-headers)')
args = parser.parse_args(*args)
root_folder = os.getcwd()
try:
name, version, user, channel = ConanFileReference.loads(args.name)
except:
raise ConanException("Bad parameter, please use full package name,"
"e.g: MyLib/1.2.3@user/testing")
from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake,
test_main)
if args.header:
files = {"conanfile.py": conanfile_header.format(name=name, version=version)}
else:
files = {"conanfile.py": conanfile.format(name=name, version=version)}
if args.pure_c:
config = "\n def config(self):\n del self.settings.compiler.libcxx"
files["conanfile.py"] = files["conanfile.py"] + config
if args.test:
files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version,
user=user, channel=channel)
files["test_package/CMakeLists.txt"] = test_cmake
files["test_package/example.cpp"] = test_main
save_files(root_folder, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def test_package(self, *args):
""" build and run your package test. Must have conanfile.py with "test"
method and "test_package" subfolder with package consumer test project
"""
parser = argparse.ArgumentParser(description=self.test_package.__doc__, prog="conan test",
formatter_class=RawTextHelpFormatter)
parser.add_argument("path", nargs='?', default="", help='path to conanfile file, '
'e.g. /my_project/')
parser.add_argument("-f", "--folder", help='alternative test folder name')
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
self._parse_args(parser)
args = parser.parse_args(*args)
root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path))
if args.folder:
test_folder_name = args.folder
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" % args.folder)
else:
for name in ["test_package", "test"]:
test_folder_name = name
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile):
break
else:
raise ConanException("test folder 'test_package' not available, "
"or it doesn't have a conanfile.py")
lib_to_test = self._detect_tested_library_name()
# Get False or a list of patterns to check
if args.build is None and lib_to_test: # Not specified, force build the tested library
args.build = [lib_to_test]
else:
args.build = self._get_build_sources_parameter(args.build)
options = args.options or []
settings = args.settings or []
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
scopes = Scopes.from_list(args.scope) if args.scope else None
self._manager.install(reference=test_folder,
current_path=build_folder,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build,
scopes=scopes)
self._test_check(test_folder, test_folder_name)
self._manager.build(test_folder, build_folder, test=True)
# Alias to test
def test(self, *args):
""" (deprecated). Alias to test_package, use it instead
"""
self.test_package(*args)
def install(self, *args):
""" install in the local store the given requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans install opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='package recipe reference'
'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='Force install specified package ID (ignore settings/options)')
parser.add_argument("--all", action='store_true', default=False,
help='Install all packages from the specified package recipe')
parser.add_argument("--integrity", "-i", action='store_true', default=False,
help='Check that the stored recipe or package manifests are correct')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("--update", "-u", action='store_true', default=False,
help="update with new upstream packages")
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
self._parse_args(parser)
args = parser.parse_args(*args)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
if args.all or args.package: # Install packages without settings (fixed ids or all)
if args.all:
args.package = []
if not args.reference or not isinstance(reference, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., OpenSSL/1.0.2e@lasote/stable")
self._manager.download(reference, args.package, remote=args.remote)
else: # Classic install, package chosen with settings and options
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
scopes = Scopes.from_list(args.scope) if args.scope else None
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build,
filename=args.file,
update=args.update,
integrity=args.integrity,
scopes=scopes)
def info(self, *args):
""" Prints information about the requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans info opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='reference name or path to conanfile file, '
'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--only", "-n",
help='show fields only')
parser.add_argument("--integrity", "-i", action='store_true', default=False,
help='Check that the stored recipe or package manifests are correct')
parser.add_argument("--update", "-u", action='store_true', default=False,
help="check updates exist from upstream remotes")
args = parser.parse_args(*args)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
build_mode=False,
info=args.only or True,
check_updates=args.update,
integrity=args.integrity,
filename=args.file)
def build(self, *args):
""" calls your project conanfile.py "build" method.
EX: conans build ./my_project
Intended for package creators, requires a conanfile.py.
"""
parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build")
parser.add_argument("path", nargs="?",
help='path to user conanfile.py, e.g., conans build .',
default="")
parser.add_argument("--file", "-f", help="specify conanfile filename")
args = parser.parse_args(*args)
current_path = os.getcwd()
if args.path:
root_path = os.path.abspath(args.path)
else:
root_path = current_path
self._manager.build(root_path, current_path, filename=args.file)
def package(self, *args):
""" calls your conanfile.py "package" method for a specific package or
regenerates the existing package's manifest.
Intended for package creators, for regenerating a package without
recompiling the source.
e.g. conan package OpenSSL/1.0.2e@lasote/stable 9cf83afd07b678da9c1645f605875400847ff3
"""
parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package")
parser.add_argument("reference", help='package recipe reference name. e.g., openssl/1.0.2@lasote/testing')
parser.add_argument("package", nargs="?", default="",
help='Package ID to regenerate. e.g., '
'9cf83afd07b678d38a9c1645f605875400847ff3')
parser.add_argument("-o", "--only-manifest", default=False, action='store_true',
help='Just regenerate manifest for the existing package.'
'If True conan won\'t call your conanfile\'s package method.')
parser.add_argument("--all", action='store_true',
default=False, help='Package all packages from specified reference')
args = parser.parse_args(*args)
try:
reference = ConanFileReference.loads(args.reference)
except:
raise ConanException("Invalid package recipe reference. e.g., OpenSSL/1.0.2e@lasote/stable")
if not args.all and not args.package:
raise ConanException("'conan package': Please specify --all or a package ID")
self._manager.package(reference, args.package, args.only_manifest, args.all)
def export(self, *args):
""" copies the package recipe (conanfile.py and associated files) to your local store,
where it can be shared and reused in other projects.
From that store, it can be uploaded to any remote with "upload" command.
"""
parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export")
parser.add_argument("user", help='user_name[/channel]. By default, channel is '
'"testing", e.g., phil or phil/stable')
parser.add_argument('--path', '-p', default=None,
help='Optional. Folder with a %s. Default current directory.'
% CONANFILE)
parser.add_argument('--keep-source', '-k', default=False, action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
args = parser.parse_args(*args)
current_path = args.path or os.getcwd()
keep_source = args.keep_source
self._manager.export(args.user, current_path, keep_source)
def remove(self, *args):
""" Remove any package recipe or package from your local/remote store
"""
parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove")
parser.add_argument('pattern', help='Pattern name, e.g., openssl/*')
parser.add_argument('-p', '--packages', const=[], nargs='?',
help='By default, remove all the packages or select one, '
'specifying the SHA key')
parser.add_argument('-b', '--builds', const=[], nargs='?',
help='By default, remove all the build folders or select one, '
'specifying the SHA key')
parser.add_argument('-s', '--src', default=False, action="store_true",
help='Remove source folders')
parser.add_argument('-f', '--force', default=False,
action='store_true', help='Remove without requesting a confirmation')
parser.add_argument('-r', '--remote', help='Remote origin')
args = parser.parse_args(*args)
if args.packages:
args.packages = args.packages.split(",")
if args.builds:
args.builds = args.builds.split(",")
self._manager.remove(args.pattern, package_ids_filter=args.packages,
build_ids=args.builds,
src=args.src, force=args.force, remote=args.remote)
def copy(self, *args):
""" Copy package recipe and packages to another user/channel
"""
parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy")
parser.add_argument("reference", default="",
help='package recipe reference'
'e.g., OpenSSL/1.0.2e@lasote/stable')
parser.add_argument("user_channel", default="",
help='Destination user/channel'
'e.g., lasote/testing')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='copy specified package ID')
parser.add_argument("--all", action='store_true',
default=False,
help='Copy all packages from the specified package recipe')
parser.add_argument("--force", action='store_true',
default=False,
help='Override destination packages and the package recipe')
args = parser.parse_args(*args)
reference = ConanFileReference.loads(args.reference)
new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name,
reference.version,
args.user_channel))
if args.all:
args.package = []
self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user")
parser.add_argument("name", nargs='?', default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument("-p", "--password", help='User password. Use double quotes '
'if password with spacing, and escape quotes if existing')
parser.add_argument("--remote", "-r", help='look for in the remote storage')
parser.add_argument('-c', '--clean', default=False,
action='store_true', help='Remove user and tokens for all remotes')
args = parser.parse_args(*parameters) # To enable -h
if args.clean:
localdb = LocalDB(self._conan_paths.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(args.remote, args.name, args.password)
def search(self, *args):
""" show local/remote packages
"""
parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search")
parser.add_argument('pattern', nargs='?', help='Pattern name, e.g., openssl/*')
parser.add_argument('--case-sensitive', default=False,
action='store_true', help='Make a case-sensitive search')
parser.add_argument('-r', '--remote', help='Remote origin')
parser.add_argument('-v', '--verbose', default=False,
action='store_true', help='Show packages')
parser.add_argument('-x', '--extra-verbose', default=False,
action='store_true', help='Show packages options and settings')
parser.add_argument('-p', '--package', help='Package ID pattern. EX: 23*', default=None)
args = parser.parse_args(*args)
self._manager.search(args.pattern,
args.remote,
ignorecase=not args.case_sensitive,
verbose=args.verbose,
extra_verbose=args.extra_verbose,
package_pattern=args.package)
def upload(self, *args):
""" uploads a conanfile or binary packages from the local store to any remote.
To upload something, it should be "exported" first.
"""
parser = argparse.ArgumentParser(description=self.upload.__doc__,
prog="conan upload")
parser.add_argument("reference",
help='package recipe reference, e.g., OpenSSL/1.0.2e@lasote/stable')
# TODO: packageparser.add_argument('package', help='user name')
parser.add_argument("--package", "-p", default=None, help='package ID to upload')
parser.add_argument("--remote", "-r", help='upload to this specific remote')
parser.add_argument("--all", action='store_true',
default=False, help='Upload both package recipe and packages')
parser.add_argument("--force", action='store_true',
default=False,
help='Do not check conans date, override remote with local')
args = parser.parse_args(*args)
conan_ref = ConanFileReference.loads(args.reference)
package_id = args.package
if not conan_ref and not package_id:
raise ConanException("Enter conans or package id")
self._manager.upload(conan_ref, package_id,
args.remote, all_packages=args.all, force=args.force)
def remote(self, *args):
""" manage remotes
"""
parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote")
subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help')
# create the parser for the "a" command
subparsers.add_parser('list', help='list current remotes')
parser_add = subparsers.add_parser('add', help='add a remote')
parser_add.add_argument('remote', help='name of the remote')
parser_add.add_argument('url', help='url of the remote')
parser_rm = subparsers.add_parser('remove', help='remove a remote')
parser_rm.add_argument('remote', help='name of the remote')
parser_upd = subparsers.add_parser('update', help='update the remote url')
parser_upd.add_argument('remote', help='name of the remote')
parser_upd.add_argument('url', help='url')
subparsers.add_parser('list_ref', help='list the package recipes and its associated remotes')
parser_padd = subparsers.add_parser('add_ref', help="associate a recipe's reference to a remote")
parser_padd.add_argument('reference', help='package recipe reference')
parser_padd.add_argument('remote', help='name of the remote')
parser_prm = subparsers.add_parser('remove_ref', help="dissociate a recipe's reference and its remote")
parser_prm.add_argument('reference', help='package recipe reference')
parser_pupd = subparsers.add_parser('update_ref', help="update the remote associated with a package recipe")
parser_pupd.add_argument('reference', help='package recipe reference')
parser_pupd.add_argument('remote', help='name of the remote')
args = parser.parse_args(*args)
registry = RemoteRegistry(self._conan_paths.registry, self._user_io.out)
if args.subcommand == "list":
for r in registry.remotes:
self._user_io.out.info("%s: %s" % (r.name, r.url))
elif args.subcommand == "add":
registry.add(args.remote, args.url)
elif args.subcommand == "remove":
registry.remove(args.remote)
elif args.subcommand == "update":
registry.update(args.remote, args.url)
elif args.subcommand == "list_ref":
for ref, remote in registry.refs.items():
self._user_io.out.info("%s: %s" % (ref, remote))
elif args.subcommand == "add_ref":
registry.add_ref(args.reference, args.remote)
elif args.subcommand == "remove_ref":
registry.remove_ref(args.reference)
elif args.subcommand == "update_ref":
registry.update_ref(args.reference, args.remote)
def _show_help(self):
""" prints a summary of all commands
"""
self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help',
Color.BRIGHT_YELLOW)
commands = self._commands()
for name in sorted(self._commands()):
self._user_io.out.write(' %-10s' % name, Color.GREEN)
self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0])
def _commands(self):
""" returns a list of available commands
"""
result = {}
for m in inspect.getmembers(self, predicate=inspect.ismethod):
method_name = m[0]
if not method_name.startswith('_'):
method = m[1]
if method.__doc__ and not method.__doc__.startswith('HIDDEN'):
result[method_name] = method
return result
def run(self, *args):
"""HIDDEN: entry point for executing commands, dispatcher to class
methods
"""
errors = False
try:
try:
command = args[0][0]
commands = self._commands()
method = commands[command]
except KeyError as exc:
if command in ["-v", "--version"]:
self._user_io.out.success("Conan version %s" % CLIENT_VERSION)
return False
self._show_help()
if command in ["-h", "--help"]:
return False
raise ConanException("Unknown command %s" % str(exc))
except IndexError as exc: # No parameters
self._show_help()
return False
method(args[0][1:])
except (KeyboardInterrupt, SystemExit) as exc:
logger.error(exc)
errors = True
except ConanException as exc:
logger.error(exc)
# import traceback
# logger.debug(traceback.format_exc())
errors = True
self._user_io.out.error(str(exc))
return errors
class Command(object):
""" A single command of the conan application, with all the first level commands.
Manages the parsing of parameters and delegates functionality in
collaborators.
It can also show help of the tool
"""
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager)
def _parse_args(self, parser):
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--build", "-b", action=Extender, nargs="*",
help='''Optional, use it to choose if you want to build from sources:
--build Build all from sources, do not use binary packages.
--build=never Default option. Never build, use binary packages or fail if a binary package is not found.
--build=missing Build from code if a binary package is not found.
--build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters.
''')
def _get_tuples_list_from_extender_arg(self, items):
if not items:
return []
# Validate the pairs
for item in items:
chunks = item.split("=")
if len(chunks) != 2:
raise ConanException("Invalid input '%s', use 'name=value'" % item)
return [(item[0], item[1]) for item in [item.split("=") for item in items]]
def _get_build_sources_parameter(self, build_param):
# returns True if we want to build the missing libraries
# False if building is forbidden
# A list with patterns: Will force build matching libraries,
# will look for the package for the rest
if isinstance(build_param, list):
if len(build_param) == 0: # All packages from source
return ["*"]
elif len(build_param) == 1 and build_param[0] == "never":
return False # Default
elif len(build_param) == 1 and build_param[0] == "missing":
return True
else: # A list of expressions to match (if matches, will build from source)
return ["%s*" % ref_expr for ref_expr in build_param]
else:
return False # Nothing is built
def _test_check(self, test_folder, test_folder_name):
""" To ensure that the 0.9 version new layout is detected and users warned
"""
# Check old tests, format
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("Test conanfile.py does not exist")
test_conanfile_content = load(test_conanfile)
if ".conanfile_directory" not in test_conanfile_content:
self._user_io.out.error("""******* conan test command layout has changed *******
In your "%s" folder 'conanfile.py' you should use the
path to the conanfile_directory, something like:
self.run('cmake %%s %%s' %% (self.conanfile_directory, cmake.command_line))
""" % (test_folder_name))
# Test the CMakeLists, if existing
test_cmake = os.path.join(test_folder, "CMakeLists.txt")
if os.path.exists(test_cmake):
test_cmake_content = load(test_cmake)
if "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake" not in test_cmake_content:
self._user_io.out.error("""******* conan test command layout has changed *******
In your "%s" folder 'CMakeLists.txt' you should use the
path to the CMake binary directory, like this:
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
""" % (test_folder_name))
def new(self, *args):
""" create a new package template conanfile.py and other optional files
"""
parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new",
formatter_class=RawTextHelpFormatter)
parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing')
parser.add_argument("-t", "--test", action='store_true', default=False,
help='Create test_package skeleton to test package')
parser.add_argument("-i", "--header", action='store_true', default=False,
help='Create a headers only package')
parser.add_argument("-c", "--pure_c", action='store_true', default=False,
help='Create a C language package only package (non-headers)')
args = parser.parse_args(*args)
root_folder = os.getcwd()
try:
name, version, user, channel = ConanFileReference.loads(args.name)
pattern = re.compile('[\W_]+')
package_name = pattern.sub('', name).capitalize()
except:
raise ConanException("Bad parameter, please use full package name,"
"e.g: MyLib/1.2.3@user/testing")
from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake,
test_main)
if args.header:
files = {"conanfile.py": conanfile_header.format(name=name, version=version,
package_name=package_name)}
else:
files = {"conanfile.py": conanfile.format(name=name, version=version,
package_name=package_name)}
if args.pure_c:
config = "\n def config(self):\n del self.settings.compiler.libcxx"
files["conanfile.py"] = files["conanfile.py"] + config
if args.test:
files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version,
user=user, channel=channel,
package_name=package_name)
files["test_package/CMakeLists.txt"] = test_cmake
files["test_package/example.cpp"] = test_main
save_files(root_folder, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def test_package(self, *args):
""" build and run your package test. Must have conanfile.py with "test"
method and "test_package" subfolder with package consumer test project
"""
parser = argparse.ArgumentParser(description=self.test_package.__doc__,
prog="conan test_package",
formatter_class=RawTextHelpFormatter)
parser.add_argument("path", nargs='?', default="", help='path to conanfile file, '
'e.g. /my_project/')
parser.add_argument("-ne", "--not-export", default=False, action='store_true',
help='Do not export the conanfile before test execution')
parser.add_argument("-f", "--folder", help='alternative test folder name')
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
parser.add_argument('--keep-source', '-k', default=False, action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
parser.add_argument("--update", "-u", action='store_true', default=False,
help="update with new upstream packages")
parser.add_argument("--profile", "-pr", default=None, help='Define a profile')
self._parse_args(parser)
args = parser.parse_args(*args)
root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path))
if args.folder:
test_folder_name = args.folder
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" % args.folder)
else:
for name in ["test_package", "test"]:
test_folder_name = name
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile):
break
else:
raise ConanException("test folder 'test_package' not available, "
"or it doesn't have a conanfile.py")
options = args.options or []
settings = args.settings or []
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
scopes = Scopes.from_list(args.scope) if args.scope else None
manager = self._manager
loader = manager._loader(None, settings, options, scopes)
conanfile = loader.load_conan(test_conanfile, self._user_io.out, consumer=True)
try:
# convert to list from ItemViews required for python3
reqs = list(conanfile.requires.items())
first_dep = reqs[0][1].conan_reference
except Exception:
raise ConanException("Unable to retrieve first requirement of test conanfile.py")
# Forcing an export!
if not args.not_export:
self._user_io.out.info("Exporting package recipe")
user_channel = "%s/%s" % (first_dep.user, first_dep.channel)
self._manager.export(user_channel, root_folder, keep_source=args.keep_source)
lib_to_test = first_dep.name + "*"
# Get False or a list of patterns to check
if args.build is None and lib_to_test: # Not specified, force build the tested library
args.build = [lib_to_test]
else:
args.build = self._get_build_sources_parameter(args.build)
self._manager.install(reference=test_folder,
current_path=build_folder,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build,
scopes=scopes,
update=args.update,
profile_name=args.profile)
self._test_check(test_folder, test_folder_name)
self._manager.build(test_folder, build_folder, test=True, profile_name=args.profile)
# Alias to test
def test(self, *args):
""" (deprecated). Alias to test_package, use it instead
"""
self.test_package(*args)
def install(self, *args):
""" install in the local store the given requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conan install opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='package recipe reference'
'e.g., MyPackage/1.2@user/channel or ./my_project/')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='Force install specified package ID (ignore settings/options)')
parser.add_argument("--all", action='store_true', default=False,
help='Install all packages from the specified package recipe')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("--update", "-u", action='store_true', default=False,
help="update with new upstream packages")
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
parser.add_argument("--profile", "-pr", default=None, help='Define a profile')
parser.add_argument("--generator", "-g", nargs=1, action=Extender,
help='Generators to use')
parser.add_argument("--werror", action='store_true', default=False,
help='Error instead of warnings for graph inconsistencies')
# Manifests arguments
default_manifest_folder = '.conan_manifests'
parser.add_argument("--manifests", "-m", const=default_manifest_folder, nargs="?",
help='Install dependencies manifests in folder for later verify.'
' Default folder is .conan_manifests, but can be changed')
parser.add_argument("--manifests-interactive", "-mi", const=default_manifest_folder,
nargs="?",
help='Install dependencies manifests in folder for later verify, '
'asking user for confirmation. '
'Default folder is .conan_manifests, but can be changed')
parser.add_argument("--verify", "-v", const=default_manifest_folder, nargs="?",
help='Verify dependencies manifests against stored ones')
self._parse_args(parser)
args = parser.parse_args(*args)
self._user_io.out.werror_active = args.werror
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
if args.all or args.package: # Install packages without settings (fixed ids or all)
if args.all:
args.package = []
if not args.reference or not isinstance(reference, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.download(reference, args.package, remote=args.remote)
else: # Classic install, package chosen with settings and options
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
scopes = Scopes.from_list(args.scope) if args.scope else None
if args.manifests and args.manifests_interactive:
raise ConanException("Do not specify both manifests and "
"manifests-interactive arguments")
if args.verify and (args.manifests or args.manifests_interactive):
raise ConanException("Do not specify both 'verify' and "
"'manifests' or 'manifests-interactive' arguments")
manifest_folder = args.verify or args.manifests or args.manifests_interactive
if manifest_folder:
if not os.path.isabs(manifest_folder):
if isinstance(reference, ConanFileReference):
manifest_folder = os.path.join(current_path, manifest_folder)
else:
manifest_folder = os.path.join(reference, manifest_folder)
manifest_verify = args.verify is not None
manifest_interactive = args.manifests_interactive is not None
else:
manifest_verify = manifest_interactive = False
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build,
filename=args.file,
update=args.update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
scopes=scopes,
generators=args.generator,
profile_name=args.profile)
def info(self, *args):
""" Prints information about the requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conan info opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='reference name or path to conanfile file, '
'e.g., MyPackage/1.2@user/channel or ./my_project/')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--only", "-n",
help='show fields only')
parser.add_argument("--update", "-u", action='store_true', default=False,
help="check updates exist from upstream remotes")
parser.add_argument("--build_order", "-bo",
help='given a modified reference, return ordered list to build (CI)',
nargs=1, action=Extender)
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
args = parser.parse_args(*args)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
scopes = Scopes.from_list(args.scope) if args.scope else None
self._manager.info(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
info=args.only or True,
check_updates=args.update,
filename=args.file,
build_order=args.build_order,
scopes=scopes)
def build(self, *args):
""" calls your project conanfile.py "build" method.
EX: conan build ./my_project
Intended for package creators, requires a conanfile.py.
"""
parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build")
parser.add_argument("path", nargs="?",
help='path to user conanfile.py, e.g., conan build .',
default="")
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("--profile", "-pr", default=None, help='Define a profile')
args = parser.parse_args(*args)
current_path = os.getcwd()
if args.path:
root_path = os.path.abspath(args.path)
else:
root_path = current_path
self._manager.build(root_path, current_path, filename=args.file, profile_name=args.profile)
def package(self, *args):
""" calls your conanfile.py "package" method for a specific package or
regenerates the existing package's manifest.
It will not create a new package, use 'install' or 'test_package' instead.
Intended for package creators, for regenerating a package without
recompiling the source, i.e. for troubleshooting,
and fixing the package() method, not normal operation. It requires
the package has been built locally, it will not re-package otherwise.
e.g. conan package MyPackage/1.2@user/channel 9cf83afd07b678da9c1645f605875400847ff3
"""
parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package")
parser.add_argument("reference", help='package recipe reference name. '
'e.g., MyPackage/1.2@user/channel')
parser.add_argument("package", nargs="?", default="",
help='Package ID to regenerate. e.g., '
'9cf83afd07b678d38a9c1645f605875400847ff3'
' If not specified, ALL binaries for this recipe are re-packaged')
args = parser.parse_args(*args)
try:
reference = ConanFileReference.loads(args.reference)
except:
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.package(reference, args.package)
def source(self, *args):
""" Calls your conanfile.py "source" method to configure the source directory.
I.e., downloads and unzip the package source.
"""
parser = argparse.ArgumentParser(description=self.source.__doc__, prog="conan source")
parser.add_argument("reference", help="package recipe reference name. e.g., zlib-ng/1.2.8@plex/stable")
parser.add_argument("-f", "--force", default=False, action="store_true", help="force remove the source directory and run again.")
args = parser.parse_args(*args)
try:
reference = ConanFileReference.loads(args.reference)
except:
raise ConanException("Invalid package recipe reference. e.g., zlib-ng/1.2.8@plex/stable")
self._manager.source(reference, args.force)
def export(self, *args):
""" copies the package recipe (conanfile.py and associated files) to your local store,
where it can be shared and reused in other projects.
From that store, it can be uploaded to any remote with "upload" command.
"""
parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export")
parser.add_argument("user", help='user_name[/channel]. By default, channel is '
'"testing", e.g., phil or phil/stable')
parser.add_argument('--path', '-p', default=None,
help='Optional. Folder with a %s. Default current directory.'
% CONANFILE)
parser.add_argument('--keep-source', '-k', default=False, action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
args = parser.parse_args(*args)
current_path = os.path.abspath(args.path or os.getcwd())
keep_source = args.keep_source
self._manager.export(args.user, current_path, keep_source)
def remove(self, *args):
""" Remove any package recipe or package from your local/remote store
"""
parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove")
parser.add_argument('pattern', help='Pattern name, e.g., openssl/*')
parser.add_argument('-p', '--packages', const=[], nargs='?',
help='By default, remove all the packages or select one, '
'specifying the SHA key')
parser.add_argument('-b', '--builds', const=[], nargs='?',
help='By default, remove all the build folders or select one, '
'specifying the SHA key')
parser.add_argument('-s', '--src', default=False, action="store_true",
help='Remove source folders')
parser.add_argument('-f', '--force', default=False,
action='store_true', help='Remove without requesting a confirmation')
parser.add_argument('-r', '--remote', help='Remote origin')
args = parser.parse_args(*args)
if args.packages:
args.packages = args.packages.split(",")
if args.builds:
args.builds = args.builds.split(",")
self._manager.remove(args.pattern, package_ids_filter=args.packages,
build_ids=args.builds,
src=args.src, force=args.force, remote=args.remote)
def copy(self, *args):
""" Copy package recipe and packages to another user/channel
"""
parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy")
parser.add_argument("reference", default="",
help='package recipe reference'
'e.g., MyPackage/1.2@user/channel')
parser.add_argument("user_channel", default="",
help='Destination user/channel'
'e.g., lasote/testing')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='copy specified package ID')
parser.add_argument("--all", action='store_true',
default=False,
help='Copy all packages from the specified package recipe')
parser.add_argument("--force", action='store_true',
default=False,
help='Override destination packages and the package recipe')
args = parser.parse_args(*args)
reference = ConanFileReference.loads(args.reference)
new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name,
reference.version,
args.user_channel))
if args.all:
args.package = []
self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user")
parser.add_argument("name", nargs='?', default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument("-p", "--password", help='User password. Use double quotes '
'if password with spacing, and escape quotes if existing')
parser.add_argument("--remote", "-r", help='look for in the remote storage')
parser.add_argument('-c', '--clean', default=False,
action='store_true', help='Remove user and tokens for all remotes')
args = parser.parse_args(*parameters) # To enable -h
if args.clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(args.remote, args.name, args.password)
def search(self, *args):
""" show local/remote packages
"""
parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search")
parser.add_argument('pattern', nargs='?', help='Pattern name, e.g. openssl/* or package recipe reference if "-q" is used. e.g. MyPackage/1.2@user/channel')
parser.add_argument('--case-sensitive', default=False,
action='store_true', help='Make a case-sensitive search')
parser.add_argument('-r', '--remote', help='Remote origin')
parser.add_argument('-q', '--query', default=None, help='Packages query: "os=Windows AND arch=x86". The "pattern" parameter has to be a package recipe reference: MyPackage/1.2@user/channel')
args = parser.parse_args(*args)
reference = None
if args.pattern:
try:
reference = ConanFileReference.loads(args.pattern)
except ConanException:
if args.query is not None:
raise ConanException("-q parameter only allowed with a valid recipe "
"reference as search pattern. e.j conan search "
"MyPackage/1.2@user/channel -q \"os=Windows\"")
self._manager.search(reference or args.pattern,
args.remote,
ignorecase=not args.case_sensitive,
packages_query=args.query)
def upload(self, *args):
""" uploads a conanfile or binary packages from the local store to any remote.
To upload something, it should be "exported" first.
"""
parser = argparse.ArgumentParser(description=self.upload.__doc__,
prog="conan upload")
parser.add_argument("reference",
help='package recipe reference, e.g., MyPackage/1.2@user/channel')
# TODO: packageparser.add_argument('package', help='user name')
parser.add_argument("--package", "-p", default=None, help='package ID to upload')
parser.add_argument("--remote", "-r", help='upload to this specific remote')
parser.add_argument("--all", action='store_true',
default=False, help='Upload both package recipe and packages')
parser.add_argument("--force", action='store_true',
default=False,
help='Do not check conan recipe date, override remote with local')
args = parser.parse_args(*args)
conan_ref = ConanFileReference.loads(args.reference)
package_id = args.package
if not conan_ref and not package_id:
raise ConanException("Enter conan reference or package id")
self._manager.upload(conan_ref, package_id,
args.remote, all_packages=args.all, force=args.force)
def remote(self, *args):
""" manage remotes
"""
parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote")
subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help')
# create the parser for the "a" command
subparsers.add_parser('list', help='list current remotes')
parser_add = subparsers.add_parser('add', help='add a remote')
parser_add.add_argument('remote', help='name of the remote')
parser_add.add_argument('url', help='url of the remote')
parser_rm = subparsers.add_parser('remove', help='remove a remote')
parser_rm.add_argument('remote', help='name of the remote')
parser_upd = subparsers.add_parser('update', help='update the remote url')
parser_upd.add_argument('remote', help='name of the remote')
parser_upd.add_argument('url', help='url')
subparsers.add_parser('list_ref',
help='list the package recipes and its associated remotes')
parser_padd = subparsers.add_parser('add_ref',
help="associate a recipe's reference to a remote")
parser_padd.add_argument('reference', help='package recipe reference')
parser_padd.add_argument('remote', help='name of the remote')
parser_prm = subparsers.add_parser('remove_ref',
help="dissociate a recipe's reference and its remote")
parser_prm.add_argument('reference', help='package recipe reference')
parser_pupd = subparsers.add_parser('update_ref', help="update the remote associated "
"with a package recipe")
parser_pupd.add_argument('reference', help='package recipe reference')
parser_pupd.add_argument('remote', help='name of the remote')
args = parser.parse_args(*args)
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if args.subcommand == "list":
for r in registry.remotes:
self._user_io.out.info("%s: %s" % (r.name, r.url))
elif args.subcommand == "add":
registry.add(args.remote, args.url)
elif args.subcommand == "remove":
registry.remove(args.remote)
elif args.subcommand == "update":
registry.update(args.remote, args.url)
elif args.subcommand == "list_ref":
for ref, remote in registry.refs.items():
self._user_io.out.info("%s: %s" % (ref, remote))
elif args.subcommand == "add_ref":
registry.add_ref(args.reference, args.remote)
elif args.subcommand == "remove_ref":
registry.remove_ref(args.reference)
elif args.subcommand == "update_ref":
registry.update_ref(args.reference, args.remote)
def _show_help(self):
""" prints a summary of all commands
"""
self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help',
Color.BRIGHT_YELLOW)
commands = self._commands()
for name in sorted(self._commands()):
self._user_io.out.write(' %-10s' % name, Color.GREEN)
self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0])
def _commands(self):
""" returns a list of available commands
"""
result = {}
for m in inspect.getmembers(self, predicate=inspect.ismethod):
method_name = m[0]
if not method_name.startswith('_'):
method = m[1]
if method.__doc__ and not method.__doc__.startswith('HIDDEN'):
result[method_name] = method
return result
def run(self, *args):
"""HIDDEN: entry point for executing commands, dispatcher to class
methods
"""
errors = False
try:
try:
command = args[0][0]
commands = self._commands()
method = commands[command]
except KeyError as exc:
if command in ["-v", "--version"]:
self._user_io.out.success("Conan version %s" % CLIENT_VERSION)
return False
self._show_help()
if command in ["-h", "--help"]:
return False
raise ConanException("Unknown command %s" % str(exc))
except IndexError as exc: # No parameters
self._show_help()
return False
method(args[0][1:])
except (KeyboardInterrupt, SystemExit) as exc:
logger.error(exc)
errors = True
except ConanException as exc:
try:
msg = unicode(exc)
except:
msg = str(exc)
# import traceback
# logger.debug(traceback.format_exc())
errors = True
self._user_io.out.error(msg)
return errors
class ConanAPIV1(object):
@staticmethod
def factory():
"""Factory"""
def instance_remote_manager(client_cache):
requester = get_basic_requester(client_cache)
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(
requester, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION), out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(
out,
requester=version_checker_requester,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io,
localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~"))
try:
client_cache = migrate_and_get_client_cache(user_folder, out)
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Get the new command instance after migrations have been done
remote_manager = instance_remote_manager(client_cache)
# Get a search manager
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(client_cache, search_adapter)
conan = Conan(client_cache, user_io, get_conan_runner(),
remote_manager, search_manager)
return conan
def __init__(self, client_cache, user_io, runner, remote_manager,
search_manager):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner,
remote_manager, search_manager)
# Patch the tools module with a good requester and user_io
tools._global_requester = get_basic_requester(self._client_cache)
tools._global_output = self._user_io.out
@api_method
def new(self,
name,
header=False,
pure_c=False,
test=False,
exports_sources=False,
bare=False,
cwd=None,
visual_versions=None,
linux_gcc_versions=None,
linux_clang_versions=None,
osx_clang_versions=None,
shared=None,
upload_url=None,
gitignore=None):
from conans.client.new import get_files
cwd = prepare_cwd(cwd)
files = get_files(name,
header=header,
pure_c=pure_c,
test=test,
exports_sources=exports_sources,
bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions,
shared=shared,
upload_url=upload_url,
gitignore=gitignore)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
@api_method
def test_package(self,
path=None,
profile_name=None,
settings=None,
options=None,
env=None,
scope=None,
test_folder=None,
not_export=False,
build=None,
keep_source=False,
verify=default_manifest_folder,
manifests=default_manifest_folder,
manifests_interactive=default_manifest_folder,
remote=None,
update=False,
cwd=None):
settings = settings or []
options = options or []
env = env or []
cwd = prepare_cwd(cwd)
root_folder = os.path.normpath(os.path.join(cwd, path))
if test_folder:
test_folder_name = test_folder
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" %
test_folder)
else:
for name in ["test_package", "test"]:
test_folder_name = name
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile):
break
else:
raise ConanException(
"test folder 'test_package' not available, "
"or it doesn't have a conanfile.py")
options = options or []
settings = settings or []
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd,
self._client_cache.profiles_path)
conanfile = load_consumer_conanfile(test_conanfile, "",
self._client_cache.settings,
self._runner, self._user_io.out)
try:
# convert to list from ItemViews required for python3
if hasattr(conanfile, "requirements"):
conanfile.requirements()
reqs = list(conanfile.requires.items())
first_dep = reqs[0][1].conan_reference
except Exception:
raise ConanException(
"Unable to retrieve first requirement of test conanfile.py")
# Forcing an export!
if not not_export:
self._user_io.out.info("Exporting package recipe")
user_channel = "%s/%s" % (first_dep.user, first_dep.channel)
self._manager.export(user_channel,
root_folder,
keep_source=keep_source)
lib_to_test = first_dep.name
# Get False or a list of patterns to check
if build is None and lib_to_test: # Not specified, force build the tested library
build = [lib_to_test]
manifests = _parse_manifests_arguments(verify, manifests,
manifests_interactive,
root_folder, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
self._manager.install(reference=test_folder,
current_path=build_folder,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build,
update=update,
generators=["txt"])
test_conanfile = os.path.join(test_folder, CONANFILE)
self._manager.build(test_conanfile,
test_folder,
build_folder,
test=True)
# Alias to test
@api_method
def test(self, *args):
self.test_package(*args)
@api_method
def package_files(self,
reference,
package_folder=None,
profile_name=None,
force=False,
settings=None,
options=None,
cwd=None):
cwd = prepare_cwd(cwd)
reference = ConanFileReference.loads(reference)
package_folder = package_folder or cwd
if not os.path.isabs(package_folder):
package_folder = os.path.join(cwd, package_folder)
profile = profile_from_args(
profile_name,
settings,
options,
env=None,
scope=None,
cwd=cwd,
default_folder=self._client_cache.profiles_path)
self._manager.package_files(reference=reference,
package_folder=package_folder,
profile=profile,
force=force)
@api_method
def install(self,
reference="",
package=None,
settings=None,
options=None,
env=None,
scope=None,
all=False,
remote=None,
werror=False,
verify=default_manifest_folder,
manifests=default_manifest_folder,
manifests_interactive=default_manifest_folder,
build=None,
profile_name=None,
update=False,
generator=None,
no_imports=False,
filename=None,
cwd=None):
self._user_io.out.werror_active = werror
cwd = prepare_cwd(cwd)
try:
ref = ConanFileReference.loads(reference)
except:
ref = os.path.normpath(os.path.join(cwd, reference))
if all or package: # Install packages without settings (fixed ids or all)
if all:
package = []
if not reference or not isinstance(ref, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.download(ref, package, remote=remote)
else: # Classic install, package chosen with settings and options
manifests = _parse_manifests_arguments(
verify, manifests, manifests_interactive, cwd,
self._client_cache.profiles_path)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd,
self._client_cache.profiles_path)
self._manager.install(reference=ref,
current_path=cwd,
remote=remote,
profile=profile,
build_modes=build,
filename=filename,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generator,
no_imports=no_imports)
@api_method
def config_get(self, item):
config_parser = ConanClientConfigParser(
self._client_cache.conan_conf_path)
self._user_io.out.info(config_parser.get_item(item))
return config_parser.get_item(item)
@api_method
def config_set(self, item, value):
config_parser = ConanClientConfigParser(
self._client_cache.conan_conf_path)
config_parser.set_item(item, value)
@api_method
def config_rm(self, item):
config_parser = ConanClientConfigParser(
self._client_cache.conan_conf_path)
config_parser.rm_item(item)
@api_method
def info_build_order(self,
reference,
settings=None,
options=None,
env=None,
scope=None,
profile_name=None,
filename=None,
remote=None,
build_order=None,
check_updates=None,
cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd,
self._client_cache.profiles_path)
graph = self._manager.info_build_order(reference,
profile,
filename,
build_order,
remote,
check_updates,
cwd=cwd)
return graph
@api_method
def info_nodes_to_build(self,
reference,
build_modes,
settings=None,
options=None,
env=None,
scope=None,
profile_name=None,
filename=None,
remote=None,
check_updates=None,
cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd,
self._client_cache.profiles_path)
ret = self._manager.info_nodes_to_build(reference, profile, filename,
build_modes, remote,
check_updates, cwd)
ref_list, project_reference = ret
return ref_list, project_reference
@api_method
def info_get_graph(self,
reference,
remote=None,
settings=None,
options=None,
env=None,
scope=None,
profile_name=None,
update=False,
filename=None,
cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env,
scope, current_path,
self._client_cache.profiles_path)
ret = self._manager.info_get_graph(reference=reference,
current_path=current_path,
remote=remote,
profile=profile,
check_updates=update,
filename=filename)
deps_graph, graph_updates_info, project_reference = ret
return deps_graph, graph_updates_info, project_reference
@api_method
def build(self, path="", source_folder=None, filename=None, cwd=None):
current_path = prepare_cwd(cwd)
if path:
root_path = os.path.abspath(path)
else:
root_path = current_path
build_folder = current_path
source_folder = source_folder or root_path
if not os.path.isabs(source_folder):
source_folder = os.path.normpath(
os.path.join(current_path, source_folder))
if filename and filename.endswith(".txt"):
raise ConanException(
"A conanfile.py is needed to call 'conan build'")
conanfile_path = os.path.join(root_path, filename or CONANFILE)
self._manager.build(conanfile_path, source_folder, build_folder)
@api_method
def package(self,
reference="",
package=None,
build_folder=None,
source_folder=None,
cwd=None):
current_path = prepare_cwd(cwd)
try:
self._manager.package(ConanFileReference.loads(reference), package)
except:
if "@" in reference:
raise
recipe_folder = reference
if not os.path.isabs(recipe_folder):
recipe_folder = os.path.normpath(
os.path.join(current_path, recipe_folder))
build_folder = build_folder or current_path
if not os.path.isabs(build_folder):
build_folder = os.path.normpath(
os.path.join(current_path, build_folder))
package_folder = current_path
source_folder = source_folder or recipe_folder
self._manager.local_package(package_folder, recipe_folder,
build_folder, source_folder)
@api_method
def source(self, reference, force=False, cwd=None):
cwd = prepare_cwd(cwd)
current_path, reference = _get_reference(reference, cwd)
self._manager.source(current_path, reference, force)
@api_method
def imports(self,
reference,
undo=False,
dest=None,
filename=None,
cwd=None):
cwd = prepare_cwd(cwd)
if undo:
if not os.path.isabs(reference):
current_path = os.path.normpath(os.path.join(cwd, reference))
else:
current_path = reference
self._manager.imports_undo(current_path)
else:
cwd = prepare_cwd(cwd)
current_path, reference = _get_reference(reference, cwd)
self._manager.imports(current_path, reference, filename, dest)
@api_method
def export(self,
user,
path=None,
keep_source=False,
filename=None,
cwd=None):
cwd = prepare_cwd(cwd)
current_path = os.path.abspath(path or cwd)
self._manager.export(user,
current_path,
keep_source,
filename=filename)
@api_method
def remove(self,
pattern,
query=None,
packages=None,
builds=None,
src=False,
force=False,
remote=None):
self._manager.remove(pattern,
package_ids_filter=packages,
build_ids=builds,
src=src,
force=force,
remote=remote,
packages_query=query)
@api_method
def copy(self,
reference="",
user_channel="",
force=False,
all=False,
package=None):
reference = ConanFileReference.loads(reference)
new_ref = ConanFileReference.loads(
"%s/%s@%s" % (reference.name, reference.version, user_channel))
if all:
package = []
self._manager.copy(reference, package, new_ref.user, new_ref.channel,
force)
@api_method
def user(self, name=None, clean=False, remote=None, password=None):
if clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(remote, name, password)
@api_method
def search_recipes(self, pattern, remote=None, case_sensitive=False):
refs = self._manager.search_recipes(pattern,
remote,
ignorecase=not case_sensitive)
return refs
@api_method
def search_packages(self, reference, query=None, remote=None):
ret = self._manager.search_packages(reference,
remote,
packages_query=query)
return ret
@api_method
def upload(self,
pattern,
package=None,
remote=None,
all=False,
force=False,
confirm=False,
retry=2,
retry_wait=5,
skip_upload=False):
""" Uploads a package recipe and the generated binary packages to a specified remote
"""
if package and not is_a_reference(pattern):
raise ConanException(
"-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
self._manager.upload(pattern,
package,
remote,
all_packages=all,
force=force,
confirm=confirm,
retry=retry,
retry_wait=retry_wait,
skip_upload=skip_upload)
@api_method
def remote_list(self):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
for r in registry.remotes:
self._user_io.out.info("%s: %s [Verify SSL: %s]" %
(r.name, r.url, r.verify_ssl))
@api_method
def remote_add(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.add(remote, url, verify_ssl, insert)
@api_method
def remote_remove(self, remote):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.remove(remote)
@api_method
def remote_update(self, remote, url, verify_ssl=True):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.update(remote, url, verify_ssl)
@api_method
def remote_list_ref(self):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
for ref, remote in registry.refs.items():
self._user_io.out.info("%s: %s" % (ref, remote))
@api_method
def remote_add_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.add_ref(reference, remote)
@api_method
def remote_remove_ref(self, reference):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.remove_ref(reference)
@api_method
def remote_update_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.update_ref(reference, remote)
@api_method
def profile(self, subcommand, profile=None, cwd=None):
cwd = prepare_cwd(cwd)
if subcommand == "list":
folder = self._client_cache.profiles_path
if os.path.exists(folder):
profiles = [
name for name in os.listdir(folder)
if not os.path.isdir(name)
]
for p in sorted(profiles):
self._user_io.out.info(p)
else:
self._user_io.out.info("No profiles defined")
elif subcommand == "show":
p, _ = read_profile(profile, os.getcwd(),
self._client_cache.profiles_path)
Printer(self._user_io.out).print_profile(profile, p)
class ConanAPIV1(object):
@staticmethod
def factory():
"""Factory"""
def instance_remote_manager(client_cache):
requester = get_basic_requester(client_cache)
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(requester, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION),
out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(out, requester=version_checker_requester, put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
try:
client_cache = migrate_and_get_client_cache(get_conan_user_home(), out)
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Get the new command instance after migrations have been done
remote_manager = instance_remote_manager(client_cache)
# Get a search manager
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(client_cache, search_adapter)
# Settings preprocessor
conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager,
settings_preprocessor)
return conan
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager,
settings_preprocessor):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager,
settings_preprocessor)
# Patch the tools module with a good requester and user_io
tools._global_requester = get_basic_requester(self._client_cache)
tools._global_output = self._user_io.out
@api_method
def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None,
visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None,
shared=None, upload_url=None, gitignore=None, gitlab_gcc_versions=None, gitlab_clang_versions=None):
from conans.client.new import get_files
cwd = prepare_cwd(cwd)
files = get_files(name, header=header, pure_c=pure_c, test=test,
exports_sources=exports_sources, bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions, shared=shared,
upload_url=upload_url, gitignore=gitignore,
gitlab_gcc_versions=gitlab_gcc_versions,
gitlab_clang_versions=gitlab_clang_versions)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
@api_method
def test_package(self, profile_name=None, settings=None, options=None, env=None,
scope=None, test_folder=None, not_export=False, build=None, keep_source=False,
verify=default_manifest_folder, manifests=default_manifest_folder,
manifests_interactive=default_manifest_folder,
remote=None, update=False, cwd=None, user=None, channel=None, name=None,
version=None):
settings = settings or []
options = options or []
env = env or []
cwd = prepare_cwd(cwd)
if name and version:
package_name = name
package_version = version
else:
conanfile_path = os.path.join(cwd, "conanfile.py")
conanfile = load_conanfile_class(conanfile_path)
package_name = getattr(conanfile, "name", None)
package_version = getattr(conanfile, "version", None)
if not package_name or not package_version:
raise ConanException("conanfile.py doesn't declare package name or version")
test_folders = [test_folder] if test_folder else ["test_package", "test"]
for test_folder_name in test_folders:
test_folder = os.path.join(cwd, test_folder_name)
test_conanfile_path = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile_path):
break
else:
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" % test_folder_name)
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
profile = profile_from_args(profile_name, settings, options, env, scope, cwd,
self._client_cache.profiles_path)
loader = self._manager.get_loader(profile)
test_conanfile = loader.load_conan(test_conanfile_path, self._user_io.out, consumer=True)
try:
if hasattr(test_conanfile, "requirements"):
test_conanfile.requirements()
except Exception as e:
raise ConanException("Error in test_package/conanfile.py requirements(). %s" % str(e))
requirement = test_conanfile.requires.get(package_name)
if requirement:
if requirement.conan_reference.version != package_version:
raise ConanException("package version is '%s', but test_package/conanfile "
"is requiring version '%s'\n"
"You can remove this requirement and use "
"'conan test_package user/channel' instead"
% (package_version, requirement.conan_reference.version))
user = user or requirement.conan_reference.user
channel = channel or requirement.conan_reference.channel
if not user or not channel:
raise ConanException("Please specify user and channel")
conanfile_reference = ConanFileReference(package_name, package_version, user, channel)
# Forcing an export!
if not not_export:
self._user_io.out.info("Exporting package recipe")
self._manager.export(user, channel, cwd, keep_source=keep_source)
if build is None: # Not specified, force build the tested library
build = [package_name]
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
self._manager.install(inject_require=conanfile_reference,
reference=test_folder,
current_path=build_folder,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build,
update=update,
generators=["txt"]
)
test_conanfile = os.path.join(test_folder, CONANFILE)
self._manager.build(test_conanfile, test_folder, build_folder, package_folder=None,
test=str(conanfile_reference))
@api_method
def create(self, profile_name=None, settings=None,
options=None, env=None, scope=None, test_folder=None, not_export=False, build=None,
keep_source=False, verify=default_manifest_folder,
manifests=default_manifest_folder, manifests_interactive=default_manifest_folder,
remote=None, update=False, cwd=None,
user=None, channel=None, name=None, version=None):
settings = settings or []
options = options or []
env = env or []
cwd = prepare_cwd(cwd)
if not name or not version:
conanfile_path = os.path.join(cwd, "conanfile.py")
conanfile = load_conanfile_class(conanfile_path)
name, version = conanfile.name, conanfile.version
if not name or not version:
raise ConanException("conanfile.py doesn't declare package name or version")
reference = ConanFileReference(name, version, user, channel)
scoped_output = ScopedOutput(str(reference), self._user_io.out)
# Forcing an export!
if not not_export:
scoped_output.highlight("Exporting package recipe")
self._manager.export(user, channel, cwd, keep_source=keep_source, name=name,
version=version)
if build is None: # Not specified, force build the tested library
build = [name]
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, scope,
cwd, self._client_cache.profiles_path)
self._manager.install(reference=reference,
current_path=cwd,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build,
update=update
)
test_folders = [test_folder] if test_folder else ["test_package", "test"]
for test_folder_name in test_folders:
test_folder = os.path.join(cwd, test_folder_name)
test_conanfile_path = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile_path):
break
else:
self._user_io.out.warn("test package folder not available, or it doesn't have "
"a conanfile.py\nIt is recommended to set a 'test_package' "
"while creating packages")
return
scoped_output.highlight("Testing with 'test_package'")
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
test_conanfile = os.path.join(test_folder, CONANFILE)
self._manager.install(inject_require=reference,
reference=test_folder,
current_path=build_folder,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
update=update,
generators=["txt"]
)
self._manager.build(test_conanfile, test_folder, build_folder, package_folder=None,
test=str(reference))
@api_method
def package_files(self, reference, source_folder=None, build_folder=None, package_folder=None,
profile_name=None, force=False, settings=None, options=None, cwd=None):
cwd = prepare_cwd(cwd)
reference = ConanFileReference.loads(reference)
profile = profile_from_args(profile_name, settings, options, env=None, scope=None, cwd=cwd,
default_folder=self._client_cache.profiles_path)
package_folder = package_folder or cwd
if not source_folder and build_folder:
source_folder = build_folder
if not os.path.isabs(package_folder):
package_folder = os.path.join(cwd, package_folder)
if source_folder and not os.path.isabs(source_folder):
source_folder = os.path.normpath(os.path.join(cwd, source_folder))
if build_folder and not os.path.isabs(build_folder):
build_folder = os.path.normpath(os.path.join(cwd, build_folder))
self._manager.package_files(reference=reference, source_folder=source_folder,
build_folder=build_folder, package_folder=package_folder,
profile=profile, force=force)
@api_method
def install(self, reference="", package=None, settings=None, options=None, env=None, scope=None, all=False,
remote=None, werror=False, verify=default_manifest_folder, manifests=default_manifest_folder,
manifests_interactive=default_manifest_folder, build=None, profile_name=None,
update=False, generator=None, no_imports=False, filename=None, cwd=None):
self._user_io.out.werror_active = werror
cwd = prepare_cwd(cwd)
try:
ref = ConanFileReference.loads(reference)
except:
ref = os.path.normpath(os.path.join(cwd, reference))
if all or package: # Install packages without settings (fixed ids or all)
if all:
package = []
if not reference or not isinstance(ref, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.download(ref, package, remote=remote)
else: # Classic install, package chosen with settings and options
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, scope, cwd,
self._client_cache.profiles_path)
self._manager.install(reference=ref,
current_path=cwd,
remote=remote,
profile=profile,
build_modes=build,
filename=filename,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generator,
no_imports=no_imports)
@api_method
def config_get(self, item):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
self._user_io.out.info(config_parser.get_item(item))
return config_parser.get_item(item)
@api_method
def config_set(self, item, value):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
config_parser.set_item(item, value)
@api_method
def config_rm(self, item):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
config_parser.rm_item(item)
@api_method
def info_build_order(self, reference, settings=None, options=None, env=None, scope=None, profile_name=None,
filename=None, remote=None, build_order=None, check_updates=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path)
graph = self._manager.info_build_order(reference, profile, filename, build_order, remote, check_updates, cwd=cwd)
return graph
@api_method
def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, scope=None,
profile_name=None, filename=None, remote=None, check_updates=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path)
ret = self._manager.info_nodes_to_build(reference, profile, filename, build_modes, remote, check_updates, cwd)
ref_list, project_reference = ret
return ref_list, project_reference
@api_method
def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, scope=None,
profile_name=None, update=False, filename=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env, scope, current_path,
self._client_cache.profiles_path)
ret = self._manager.info_get_graph(reference=reference, current_path=current_path, remote=remote,
profile=profile, check_updates=update, filename=filename)
deps_graph, graph_updates_info, project_reference = ret
return deps_graph, graph_updates_info, project_reference
@api_method
def build(self, path="", source_folder=None, package_folder=None, filename=None, cwd=None):
current_path = prepare_cwd(cwd)
if path:
root_path = os.path.abspath(path)
else:
root_path = current_path
build_folder = current_path
source_folder = source_folder or root_path
if not os.path.isabs(source_folder):
source_folder = os.path.normpath(os.path.join(current_path, source_folder))
if package_folder and not os.path.isabs(package_folder):
package_folder = os.path.normpath(os.path.join(current_path, package_folder))
if filename and filename.endswith(".txt"):
raise ConanException("A conanfile.py is needed to call 'conan build'")
conanfile_path = os.path.join(root_path, filename or CONANFILE)
self._manager.build(conanfile_path, source_folder, build_folder, package_folder)
@api_method
def package(self, reference="", package_id=None, build_folder=None, source_folder=None,
cwd=None):
try:
ref = ConanFileReference.loads(reference)
except:
if "@" in reference:
raise
ref = None
if ref: # cache packaging
# TODO: other args are unused. Either raise, or split API in two methods
self._manager.package(ref, package_id)
else: # local packaging
current_path = prepare_cwd(cwd)
recipe_folder = reference
if not os.path.isabs(recipe_folder):
recipe_folder = os.path.join(current_path, recipe_folder)
recipe_folder = os.path.normpath(recipe_folder)
build_folder = build_folder or recipe_folder
if not os.path.isabs(build_folder):
build_folder = os.path.join(current_path, build_folder)
build_folder = os.path.normpath(build_folder)
package_folder = current_path
source_folder = source_folder or recipe_folder
self._manager.local_package(package_folder, recipe_folder, build_folder, source_folder)
@api_method
def source(self, reference, force=False, cwd=None):
cwd = prepare_cwd(cwd)
current_path, reference = _get_reference(reference, cwd)
self._manager.source(current_path, reference, force)
@api_method
def imports(self, reference, undo=False, dest=None, filename=None, cwd=None):
cwd = prepare_cwd(cwd)
if undo:
if not os.path.isabs(reference):
current_path = os.path.normpath(os.path.join(cwd, reference))
else:
current_path = reference
self._manager.imports_undo(current_path)
else:
cwd = prepare_cwd(cwd)
current_path, reference = _get_reference(reference, cwd)
self._manager.imports(current_path, reference, filename, dest)
@api_method
def export(self, user, channel, path=None, keep_source=False, filename=None, cwd=None,
name=None, version=None):
cwd = prepare_cwd(cwd)
current_path = os.path.abspath(path or cwd)
self._manager.export(user, channel, current_path, keep_source, filename=filename, name=name,
version=version)
@api_method
def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False,
remote=None, outdated=False):
self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds,
src=src, force=force, remote=remote, packages_query=query,
outdated=outdated)
@api_method
def copy(self, reference="", user_channel="", force=False, all=False, package=None):
reference = ConanFileReference.loads(reference)
new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name,
reference.version,
user_channel))
if all:
package = []
self._manager.copy(reference, package, new_ref.user, new_ref.channel, force)
@api_method
def user(self, name=None, clean=False, remote=None, password=None):
if clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(remote, name, password)
@api_method
def search_recipes(self, pattern, remote=None, case_sensitive=False):
refs = self._manager.search_recipes(pattern, remote, ignorecase=not case_sensitive)
return refs
@api_method
def search_packages(self, reference, query=None, remote=None, outdated=False):
ret = self._manager.search_packages(reference, remote, packages_query=query,
outdated=outdated)
return ret
@api_method
def upload(self, pattern, package=None, remote=None, all=False, force=False, confirm=False,
retry=2, retry_wait=5, skip_upload=False, integrity_check=False):
""" Uploads a package recipe and the generated binary packages to a specified remote
"""
if package and not is_a_reference(pattern):
raise ConanException("-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
self._manager.upload(pattern, package, remote, all_packages=all, force=force,
confirm=confirm, retry=retry, retry_wait=retry_wait,
skip_upload=skip_upload, integrity_check=integrity_check)
@api_method
def remote_list(self):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remotes
@api_method
def remote_add(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.add(remote, url, verify_ssl, insert)
@api_method
def remote_remove(self, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remove(remote)
@api_method
def remote_update(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.update(remote, url, verify_ssl, insert)
@api_method
def remote_list_ref(self):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.refs
@api_method
def remote_add_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.add_ref(reference, remote)
@api_method
def remote_remove_ref(self, reference):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remove_ref(reference)
@api_method
def remote_update_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.update_ref(reference, remote)
@api_method
def profile_list(self):
folder = self._client_cache.profiles_path
if os.path.exists(folder):
return [name for name in os.listdir(folder) if not os.path.isdir(name)]
else:
self._user_io.out.info("No profiles defined")
return []
@api_method
def create_profile(self, profile_name, detect=False):
profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd())
if os.path.exists(profile_path):
raise ConanException("Profile already exists")
profile = Profile()
if detect:
settings = detect_defaults_settings(self._user_io.out)
for name, value in settings:
profile.settings[name] = value
contents = profile.dumps()
save(profile_path, contents)
self._user_io.out.info("Empty profile created: %s" % profile_path)
return profile_path
@staticmethod
def _get_profile_keys(key):
# settings.compiler.version => settings, compiler.version
tmp = key.split(".")
first_key = tmp[0]
rest_key = ".".join(tmp[1:]) if len(tmp) > 1 else None
if first_key not in ("build_requires", "settings", "options", "scopes", "env"):
raise ConanException("Invalid specified key: %s" % key)
return first_key, rest_key
@api_method
def update_profile(self, profile_name, key, value):
first_key, rest_key = self._get_profile_keys(key)
profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path)
if first_key == "settings":
profile.settings[rest_key] = value
elif first_key == "options":
tmp = OptionsValues([(rest_key, value)])
profile.options.update(tmp)
elif first_key == "env":
profile.env_values.update(EnvValues.loads("%s=%s" % (rest_key, value)))
elif first_key == "scopes":
profile.update_scopes(Scopes.from_list(["%s=%s" % (rest_key, value)]))
elif first_key == "build_requires":
raise ConanException("Edit the profile manually to change the build_requires")
contents = profile.dumps()
profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd())
save(profile_path, contents)
@api_method
def delete_profile_key(self, profile_name, key):
first_key, rest_key = self._get_profile_keys(key)
profile, _ = read_profile(profile_name, os.getcwd(), self._client_cache.profiles_path)
# For options, scopes, env vars
try:
package, name = rest_key.split(":")
except ValueError:
package = None
name = rest_key
try:
if first_key == "settings":
del profile.settings[rest_key]
elif first_key == "options":
profile.options.remove(name, package)
elif first_key == "env":
profile.env_values.remove(name, package)
elif first_key == "scopes":
profile.scopes.remove(name, package)
elif first_key == "build_requires":
raise ConanException("Edit the profile manually to delete a build_require")
except KeyError:
raise ConanException("Profile key '%s' doesn't exist" % key)
contents = profile.dumps()
profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd())
save(profile_path, contents)
@api_method
def read_profile(self, profile=None):
p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path)
return p
@api_method
def get_path(self, reference, package_id=None, path=None, remote=None):
reference = ConanFileReference.loads(str(reference))
return self._manager.get_path(reference, package_id, path, remote)
@api_method
def export_alias(self, reference, target_reference):
reference = ConanFileReference.loads(str(reference))
target_reference = ConanFileReference.loads(str(target_reference))
return self._manager.export_alias(reference, target_reference)
class Command(object):
""" A single command of the conan application, with all the first level commands.
Manages the parsing of parameters and delegates functionality in
collaborators.
It can also show help of the tool
"""
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager)
def _parse_args(self, parser):
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--env", "-e",
help='set environment variables to build the package, -e CXX=/usr/bin/clang++',
nargs=1, action=Extender)
parser.add_argument("--build", "-b", action=Extender, nargs="*",
help='''Optional, use it to choose if you want to build from sources:
--build Build all from sources, do not use binary packages.
--build=never Default option. Never build, use binary packages or fail if a binary package is not found.
--build=missing Build from code if a binary package is not found.
--build=outdated Build from code if the binary is not built with the current recipe or when missing binary package.
--build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters.
''')
def _get_tuples_list_from_extender_arg(self, items):
if not items:
return []
# Validate the pairs
for item in items:
chunks = item.split("=")
if len(chunks) != 2:
raise ConanException("Invalid input '%s', use 'name=value'" % item)
return [(item[0], item[1]) for item in [item.split("=") for item in items]]
def _get_simple_and_package_tuples(self, items):
''' Parse items like "thing:item=value or item2=value2 and returns a tuple list for
the simple items (name, value) and a dict for the package items
{package: [(item, value)...)], ...}
'''
simple_items = []
package_items = defaultdict(list)
tuples = self._get_tuples_list_from_extender_arg(items)
for name, value in tuples:
if ":" in name: # Scoped items
tmp = name.split(":", 1)
ref_name = tmp[0]
name = tmp[1]
package_items[ref_name].append((name, value))
else:
simple_items.append((name, value))
return simple_items, package_items
def _get_build_sources_parameter(self, build_param):
# returns True if we want to build the missing libraries
# False if building is forbidden
# A list with patterns: Will force build matching libraries,
# will look for the package for the rest
# "outdated" if will build when the package is not generated with
# the current exported recipe
if isinstance(build_param, list):
if len(build_param) == 0: # All packages from source
return ["*"]
elif len(build_param) == 1 and build_param[0] == "never":
return False # Default
elif len(build_param) == 1 and build_param[0] == "missing":
return True
elif len(build_param) == 1 and build_param[0] == "outdated":
return "outdated"
else: # A list of expressions to match (if matches, will build from source)
return ["%s*" % ref_expr for ref_expr in build_param]
else:
return False # Nothing is built
def _test_check(self, test_folder, test_folder_name):
""" To ensure that the 0.9 version new layout is detected and users warned
"""
# Check old tests, format
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("Test conanfile.py does not exist")
test_conanfile_content = load(test_conanfile)
if ".conanfile_directory" not in test_conanfile_content:
self._user_io.out.error("""******* conan test command layout has changed *******
In your "%s" folder 'conanfile.py' you should use the
path to the conanfile_directory, something like:
self.run('cmake %%s %%s' %% (self.conanfile_directory, cmake.command_line))
""" % (test_folder_name))
# Test the CMakeLists, if existing
test_cmake = os.path.join(test_folder, "CMakeLists.txt")
if os.path.exists(test_cmake):
test_cmake_content = load(test_cmake)
if "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake" not in test_cmake_content:
self._user_io.out.error("""******* conan test command layout has changed *******
In your "%s" folder 'CMakeLists.txt' you should use the
path to the CMake binary directory, like this:
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
""" % (test_folder_name))
def new(self, *args):
""" create a new package template conanfile.py and other optional files
"""
parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new",
formatter_class=RawTextHelpFormatter)
parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing')
parser.add_argument("-t", "--test", action='store_true', default=False,
help='Create test_package skeleton to test package')
parser.add_argument("-i", "--header", action='store_true', default=False,
help='Create a headers only package')
parser.add_argument("-c", "--pure_c", action='store_true', default=False,
help='Create a C language package only package (non-headers)')
args = parser.parse_args(*args)
root_folder = os.getcwd()
try:
name, version, user, channel = ConanFileReference.loads(args.name)
pattern = re.compile('[\W_]+')
package_name = pattern.sub('', name).capitalize()
except:
raise ConanException("Bad parameter, please use full package name,"
"e.g: MyLib/1.2.3@user/testing")
from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake,
test_main)
if args.header:
files = {"conanfile.py": conanfile_header.format(name=name, version=version,
package_name=package_name)}
else:
files = {"conanfile.py": conanfile.format(name=name, version=version,
package_name=package_name)}
if args.pure_c:
config = "\n def config(self):\n del self.settings.compiler.libcxx"
files["conanfile.py"] = files["conanfile.py"] + config
if args.test:
files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version,
user=user, channel=channel,
package_name=package_name)
files["test_package/CMakeLists.txt"] = test_cmake
files["test_package/example.cpp"] = test_main
save_files(root_folder, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def test_package(self, *args):
""" build and run your package test. Must have conanfile.py with "test"
method and "test_package" subfolder with package consumer test project
"""
parser = argparse.ArgumentParser(description=self.test_package.__doc__,
prog="conan test_package",
formatter_class=RawTextHelpFormatter)
parser.add_argument("path", nargs='?', default="", help='path to conanfile file, '
'e.g. /my_project/')
parser.add_argument("-ne", "--not-export", default=False, action='store_true',
help='Do not export the conanfile before test execution')
parser.add_argument("-f", "--folder", help='alternative test folder name')
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
parser.add_argument('--keep-source', '-k', default=False, action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
parser.add_argument("--update", "-u", action='store_true', default=False,
help="update with new upstream packages")
parser.add_argument("--profile", "-pr", default=None, help='Define a profile')
self._parse_args(parser)
args = parser.parse_args(*args)
current_path = os.getcwd()
root_folder = os.path.normpath(os.path.join(current_path, args.path))
if args.folder:
test_folder_name = args.folder
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" % args.folder)
else:
for name in ["test_package", "test"]:
test_folder_name = name
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile):
break
else:
raise ConanException("test folder 'test_package' not available, "
"or it doesn't have a conanfile.py")
options = args.options or []
settings = args.settings or []
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
options = self._get_tuples_list_from_extender_arg(args.options)
env, package_env = self._get_simple_and_package_tuples(args.env)
settings, package_settings = self._get_simple_and_package_tuples(args.settings)
scopes = Scopes.from_list(args.scope) if args.scope else None
manager = self._manager
# Read profile environment and mix with the command line parameters
if args.profile:
try:
profile = manager.read_profile(args.profile, current_path)
except ConanException as exc:
raise ConanException("Error reading '%s' profile: %s" % (args.profile, exc))
else:
profile.update_env(env)
profile.update_packages_env(package_env)
env = profile.env
package_env = profile.package_env
loader = manager._loader(current_path=None, user_settings_values=settings, user_options_values=options,
scopes=scopes, package_settings=package_settings, env=env, package_env=package_env)
conanfile = loader.load_conan(test_conanfile, self._user_io.out, consumer=True)
try:
# convert to list from ItemViews required for python3
conanfile.requirements()
reqs = list(conanfile.requires.items())
first_dep = reqs[0][1].conan_reference
except Exception:
raise ConanException("Unable to retrieve first requirement of test conanfile.py")
# Forcing an export!
if not args.not_export:
self._user_io.out.info("Exporting package recipe")
user_channel = "%s/%s" % (first_dep.user, first_dep.channel)
self._manager.export(user_channel, root_folder, keep_source=args.keep_source)
lib_to_test = first_dep.name + "*"
# Get False or a list of patterns to check
if args.build is None and lib_to_test: # Not specified, force build the tested library
args.build = [lib_to_test]
else:
args.build = self._get_build_sources_parameter(args.build)
self._manager.install(reference=test_folder,
current_path=build_folder,
remote=args.remote,
options=options,
settings=settings,
package_settings=package_settings,
build_mode=args.build,
scopes=scopes,
update=args.update,
generators=["env", "txt"],
profile_name=args.profile,
env=env,
package_env=package_env
)
self._test_check(test_folder, test_folder_name)
self._manager.build(test_folder, build_folder, test=True, profile_name=args.profile,
env=env, package_env=package_env)
# Alias to test
def test(self, *args):
""" (deprecated). Alias to test_package, use it instead
"""
self.test_package(*args)
def install(self, *args):
""" install in the local store the given requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conan install opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.install.__doc__, prog="conan install",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='package recipe reference'
'e.g., MyPackage/1.2@user/channel or ./my_project/')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='Force install specified package ID (ignore settings/options)')
parser.add_argument("--all", action='store_true', default=False,
help='Install all packages from the specified package recipe')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("--update", "-u", action='store_true', default=False,
help="update with new upstream packages")
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
parser.add_argument("--profile", "-pr", default=None, help='Define a profile')
parser.add_argument("--generator", "-g", nargs=1, action=Extender,
help='Generators to use')
parser.add_argument("--werror", action='store_true', default=False,
help='Error instead of warnings for graph inconsistencies')
# Manifests arguments
default_manifest_folder = '.conan_manifests'
parser.add_argument("--manifests", "-m", const=default_manifest_folder, nargs="?",
help='Install dependencies manifests in folder for later verify.'
' Default folder is .conan_manifests, but can be changed')
parser.add_argument("--manifests-interactive", "-mi", const=default_manifest_folder,
nargs="?",
help='Install dependencies manifests in folder for later verify, '
'asking user for confirmation. '
'Default folder is .conan_manifests, but can be changed')
parser.add_argument("--verify", "-v", const=default_manifest_folder, nargs="?",
help='Verify dependencies manifests against stored ones')
parser.add_argument("--no-imports", action='store_true', default=False,
help='Install specified packages but avoid running imports')
self._parse_args(parser)
args = parser.parse_args(*args)
self._user_io.out.werror_active = args.werror
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
if args.all or args.package: # Install packages without settings (fixed ids or all)
if args.all:
args.package = []
if not args.reference or not isinstance(reference, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.download(reference, args.package, remote=args.remote)
else: # Classic install, package chosen with settings and options
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
options = self._get_tuples_list_from_extender_arg(args.options)
settings, package_settings = self._get_simple_and_package_tuples(args.settings)
env, package_env = self._get_simple_and_package_tuples(args.env)
scopes = Scopes.from_list(args.scope) if args.scope else None
if args.manifests and args.manifests_interactive:
raise ConanException("Do not specify both manifests and "
"manifests-interactive arguments")
if args.verify and (args.manifests or args.manifests_interactive):
raise ConanException("Do not specify both 'verify' and "
"'manifests' or 'manifests-interactive' arguments")
manifest_folder = args.verify or args.manifests or args.manifests_interactive
if manifest_folder:
if not os.path.isabs(manifest_folder):
if isinstance(reference, ConanFileReference):
manifest_folder = os.path.join(current_path, manifest_folder)
else:
manifest_folder = os.path.join(reference, manifest_folder)
manifest_verify = args.verify is not None
manifest_interactive = args.manifests_interactive is not None
else:
manifest_verify = manifest_interactive = False
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build,
filename=args.file,
update=args.update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
scopes=scopes,
generators=args.generator,
profile_name=args.profile,
package_settings=package_settings,
env=env,
package_env=package_env,
no_imports=args.no_imports)
def info(self, *args):
""" Prints information about the requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conan info opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.info.__doc__, prog="conan info",
formatter_class=RawTextHelpFormatter)
parser.add_argument("reference", nargs='?', default="",
help='reference name or path to conanfile file, '
'e.g., MyPackage/1.2@user/channel or ./my_project/')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("-r", "--remote", help='look for in the remote storage')
parser.add_argument("--options", "-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1, action=Extender)
parser.add_argument("--settings", "-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1, action=Extender)
parser.add_argument("--only", "-n",
help='show fields only')
parser.add_argument("--update", "-u", action='store_true', default=False,
help="check updates exist from upstream remotes")
parser.add_argument("--build_order", "-bo",
help='given a modified reference, return ordered list to build (CI)',
nargs=1, action=Extender)
parser.add_argument("--scope", "-sc", nargs=1, action=Extender,
help='Define scopes for packages')
args = parser.parse_args(*args)
options = self._get_tuples_list_from_extender_arg(args.options)
settings, package_settings = self._get_simple_and_package_tuples(args.settings)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(os.path.join(current_path, args.reference))
scopes = Scopes.from_list(args.scope) if args.scope else None
self._manager.info(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
package_settings=package_settings,
info=args.only or True,
check_updates=args.update,
filename=args.file,
build_order=args.build_order,
scopes=scopes)
def build(self, *args):
""" Calls your project conanfile.py "build" method.
E.g. conan build ./my_project
Intended for package creators, requires a conanfile.py.
"""
parser = argparse.ArgumentParser(description=self.build.__doc__, prog="conan build")
parser.add_argument("path", nargs="?",
help='path to user conanfile.py, e.g., conan build .',
default="")
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("--profile", "-pr", default=None, help='Define a profile')
args = parser.parse_args(*args)
current_path = os.getcwd()
if args.path:
root_path = os.path.abspath(args.path)
else:
root_path = current_path
self._manager.build(root_path, current_path, filename=args.file, profile_name=args.profile)
def package(self, *args):
""" Calls your conanfile.py "package" method for a specific package recipe.
It will not create a new package, use 'install' or 'test_package' instead for
packages in the conan local cache, or `build' for conanfile.py in user space.
Intended for package creators, for regenerating a package without
recompiling the source, i.e. for troubleshooting,
and fixing the package() method, not normal operation. It requires
the package has been built locally, it will not re-package otherwise.
E.g. conan package MyPackage/1.2@user/channel 9cf83afd07b678da9c1645f605875400847ff3
When used in a user space project, it will execute from the build folder specified
as parameter, and the current directory. This is useful while creating package recipes
or just for extracting artifacts from the current project, without even being a package
"""
parser = argparse.ArgumentParser(description=self.package.__doc__, prog="conan package")
parser.add_argument("reference", help='package recipe reference '
'e.g. MyPkg/0.1@user/channel, or local path to the build folder'
' (relative or absolute)')
parser.add_argument("package", nargs="?", default="",
help='Package ID to regenerate. e.g., '
'9cf83afd07b678d38a9c1645f605875400847ff3'
' If not specified, ALL binaries for this recipe are re-packaged')
args = parser.parse_args(*args)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
self._manager.package(reference, args.package)
except:
if "@" in args.reference:
raise
build_folder = args.reference
if not os.path.isabs(build_folder):
build_folder = os.path.normpath(os.path.join(current_path, build_folder))
self._manager.local_package(current_path, build_folder)
def _get_reference(self, args):
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
if "@" in args.reference:
raise
if not os.path.isabs(args.reference):
reference = os.path.normpath(os.path.join(current_path, args.reference))
else:
reference = args.reference
return current_path, reference
def source(self, *args):
""" Calls your conanfile.py "source" method to configure the source directory.
I.e., downloads and unzip the package source.
"""
parser = argparse.ArgumentParser(description=self.source.__doc__, prog="conan source")
parser.add_argument("reference", nargs='?', default="", help="package recipe reference. e.g., MyPackage/1.2@user/channel or ./my_project/")
parser.add_argument("-f", "--force", default=False, action="store_true", help="force remove the source directory and run again.")
args = parser.parse_args(*args)
current_path, reference = self._get_reference(args)
self._manager.source(current_path, reference, args.force)
def imports(self, *args):
""" Executes only the import functionality of the conanfile (txt or py). It requires
to have been previously installed and have a conanbuildinfo.txt generated file
"""
parser = argparse.ArgumentParser(description=self.imports.__doc__, prog="conan imports")
parser.add_argument("reference", nargs='?', default="",
help="package recipe reference. e.g., MyPackage/1.2@user/channel or ./my_project/")
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("-d", "--dest",
help="optional destination base directory, current dir by default")
parser.add_argument("-u", "--undo", default=False, action="store_true",
help="Undo the imports, remove files copied to project or user space")
args = parser.parse_args(*args)
if args.undo:
if not os.path.isabs(args.reference):
current_path = os.path.normpath(os.path.join(os.getcwd(), args.reference))
else:
current_path = args.reference
self._manager.imports_undo(current_path)
else:
dest_folder = args.dest
current_path, reference = self._get_reference(args)
self._manager.imports(current_path, reference, args.file, dest_folder)
def export(self, *args):
""" Copies the package recipe (conanfile.py and associated files) to your local store,
where it can be shared and reused in other projects.
From that store, it can be uploaded to any remote with "upload" command.
"""
parser = argparse.ArgumentParser(description=self.export.__doc__, prog="conan export")
parser.add_argument("user", help='user_name[/channel]. By default, channel is '
'"testing", e.g., phil or phil/stable')
parser.add_argument('--path', '-p', default=None,
help='Optional. Folder with a %s. Default current directory.'
% CONANFILE)
parser.add_argument('--keep-source', '-k', default=False, action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
args = parser.parse_args(*args)
current_path = os.path.abspath(args.path or os.getcwd())
keep_source = args.keep_source
self._manager.export(args.user, current_path, keep_source)
def remove(self, *args):
""" Remove any package recipe or package from your local/remote store
"""
parser = argparse.ArgumentParser(description=self.remove.__doc__, prog="conan remove")
parser.add_argument('pattern', help='Pattern name, e.g., openssl/*')
parser.add_argument('-p', '--packages', const=[], nargs='?',
help='By default, remove all the packages or select one, '
'specifying the SHA key')
parser.add_argument('-b', '--builds', const=[], nargs='?',
help='By default, remove all the build folders or select one, '
'specifying the SHA key')
parser.add_argument('-s', '--src', default=False, action="store_true",
help='Remove source folders')
parser.add_argument('-f', '--force', default=False,
action='store_true', help='Remove without requesting a confirmation')
parser.add_argument('-r', '--remote', help='Remote origin')
args = parser.parse_args(*args)
if args.packages:
args.packages = args.packages.split(",")
if args.builds:
args.builds = args.builds.split(",")
self._manager.remove(args.pattern, package_ids_filter=args.packages,
build_ids=args.builds,
src=args.src, force=args.force, remote=args.remote)
def copy(self, *args):
""" Copy package recipe and packages to another user/channel
"""
parser = argparse.ArgumentParser(description=self.copy.__doc__, prog="conan copy")
parser.add_argument("reference", default="",
help='package recipe reference'
'e.g., MyPackage/1.2@user/channel')
parser.add_argument("user_channel", default="",
help='Destination user/channel'
'e.g., lasote/testing')
parser.add_argument("--package", "-p", nargs=1, action=Extender,
help='copy specified package ID')
parser.add_argument("--all", action='store_true',
default=False,
help='Copy all packages from the specified package recipe')
parser.add_argument("--force", action='store_true',
default=False,
help='Override destination packages and the package recipe')
args = parser.parse_args(*args)
reference = ConanFileReference.loads(args.reference)
new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name,
reference.version,
args.user_channel))
if args.all:
args.package = []
self._manager.copy(reference, args.package, new_ref.user, new_ref.channel, args.force)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user")
parser.add_argument("name", nargs='?', default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument("-p", "--password", help='User password. Use double quotes '
'if password with spacing, and escape quotes if existing')
parser.add_argument("--remote", "-r", help='look for in the remote storage')
parser.add_argument('-c', '--clean', default=False,
action='store_true', help='Remove user and tokens for all remotes')
args = parser.parse_args(*parameters) # To enable -h
if args.clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(args.remote, args.name, args.password)
def search(self, *args):
""" show local/remote packages
"""
parser = argparse.ArgumentParser(description=self.search.__doc__, prog="conan search")
parser.add_argument('pattern', nargs='?', help='Pattern name, e.g. openssl/* or package recipe reference if "-q" is used. e.g. MyPackage/1.2@user/channel')
parser.add_argument('--case-sensitive', default=False,
action='store_true', help='Make a case-sensitive search')
parser.add_argument('-r', '--remote', help='Remote origin')
parser.add_argument('-q', '--query', default=None, help='Packages query: "os=Windows AND arch=x86". The "pattern" parameter has to be a package recipe reference: MyPackage/1.2@user/channel')
args = parser.parse_args(*args)
reference = None
if args.pattern:
try:
reference = ConanFileReference.loads(args.pattern)
except ConanException:
if args.query is not None:
raise ConanException("-q parameter only allowed with a valid recipe "
"reference as search pattern. e.j conan search "
"MyPackage/1.2@user/channel -q \"os=Windows\"")
self._manager.search(reference or args.pattern,
args.remote,
ignorecase=not args.case_sensitive,
packages_query=args.query)
def upload(self, *args):
""" uploads a conanfile or binary packages from the local store to any remote.
To upload something, it should be "exported" first.
"""
parser = argparse.ArgumentParser(description=self.upload.__doc__,
prog="conan upload")
parser.add_argument("reference",
help='package recipe reference, e.g., MyPackage/1.2@user/channel')
# TODO: packageparser.add_argument('package', help='user name')
parser.add_argument("--package", "-p", default=None, help='package ID to upload')
parser.add_argument("--remote", "-r", help='upload to this specific remote')
parser.add_argument("--all", action='store_true',
default=False, help='Upload both package recipe and packages')
parser.add_argument("--force", action='store_true',
default=False,
help='Do not check conan recipe date, override remote with local')
args = parser.parse_args(*args)
conan_ref = ConanFileReference.loads(args.reference)
package_id = args.package
if not conan_ref and not package_id:
raise ConanException("Enter conan reference or package id")
self._manager.upload(conan_ref, package_id,
args.remote, all_packages=args.all, force=args.force)
def remote(self, *args):
""" manage remotes
"""
parser = argparse.ArgumentParser(description=self.remote.__doc__, prog="conan remote")
subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help')
# create the parser for the "a" command
subparsers.add_parser('list', help='list current remotes')
parser_add = subparsers.add_parser('add', help='add a remote')
parser_add.add_argument('remote', help='name of the remote')
parser_add.add_argument('url', help='url of the remote')
parser_add.add_argument('verify_ssl', help='Verify SSL certificated. Default True',
default="True", nargs="?")
parser_rm = subparsers.add_parser('remove', help='remove a remote')
parser_rm.add_argument('remote', help='name of the remote')
parser_upd = subparsers.add_parser('update', help='update the remote url')
parser_upd.add_argument('remote', help='name of the remote')
parser_upd.add_argument('url', help='url')
parser_upd.add_argument('verify_ssl', help='Verify SSL certificated. Default True',
default="True", nargs="?")
subparsers.add_parser('list_ref',
help='list the package recipes and its associated remotes')
parser_padd = subparsers.add_parser('add_ref',
help="associate a recipe's reference to a remote")
parser_padd.add_argument('reference', help='package recipe reference')
parser_padd.add_argument('remote', help='name of the remote')
parser_prm = subparsers.add_parser('remove_ref',
help="dissociate a recipe's reference and its remote")
parser_prm.add_argument('reference', help='package recipe reference')
parser_pupd = subparsers.add_parser('update_ref', help="update the remote associated "
"with a package recipe")
parser_pupd.add_argument('reference', help='package recipe reference')
parser_pupd.add_argument('remote', help='name of the remote')
args = parser.parse_args(*args)
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if args.subcommand == "list":
for r in registry.remotes:
self._user_io.out.info("%s: %s [Verify SSL: %s]" % (r.name, r.url, r.verify_ssl))
elif args.subcommand == "add":
verify = get_bool_from_text_value(args.verify_ssl)
registry.add(args.remote, args.url, args.verify_ssl)
elif args.subcommand == "remove":
registry.remove(args.remote)
elif args.subcommand == "update":
verify = get_bool_from_text_value(args.verify_ssl)
registry.update(args.remote, args.url, verify)
elif args.subcommand == "list_ref":
for ref, remote in registry.refs.items():
self._user_io.out.info("%s: %s" % (ref, remote))
elif args.subcommand == "add_ref":
registry.add_ref(args.reference, args.remote)
elif args.subcommand == "remove_ref":
registry.remove_ref(args.reference)
elif args.subcommand == "update_ref":
registry.update_ref(args.reference, args.remote)
def profile(self, *args):
""" manage profiles
"""
parser = argparse.ArgumentParser(description=self.profile.__doc__, prog="conan profile")
subparsers = parser.add_subparsers(dest='subcommand', help='sub-command help')
# create the parser for the "profile" command
subparsers.add_parser('list', help='list current profiles')
parser_show = subparsers.add_parser('show', help='show the values defined for a profile')
parser_show.add_argument('profile', help='name of the profile')
args = parser.parse_args(*args)
if args.subcommand == "list":
folder = self._client_cache.profiles_path
if os.path.exists(folder):
profiles = [name for name in os.listdir(folder) if not os.path.isdir(name)]
for p in profiles:
self._user_io.out.info(p)
else:
self._user_io.out.info("No profiles defined")
elif args.subcommand == "show":
p = self._manager.read_profile(args.profile, os.getcwd())
Printer(self._user_io.out).print_profile(args.profile, p)
def _show_help(self):
""" prints a summary of all commands
"""
self._user_io.out.writeln('Conan commands. Type $conan "command" -h for help',
Color.BRIGHT_YELLOW)
commands = self._commands()
for name in sorted(self._commands()):
self._user_io.out.write(' %-10s' % name, Color.GREEN)
self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0])
def _commands(self):
""" returns a list of available commands
"""
result = {}
for m in inspect.getmembers(self, predicate=inspect.ismethod):
method_name = m[0]
if not method_name.startswith('_'):
method = m[1]
if method.__doc__ and not method.__doc__.startswith('HIDDEN'):
result[method_name] = method
return result
def run(self, *args):
"""HIDDEN: entry point for executing commands, dispatcher to class
methods
"""
errors = False
try:
try:
command = args[0][0]
commands = self._commands()
method = commands[command]
except KeyError as exc:
if command in ["-v", "--version"]:
self._user_io.out.success("Conan version %s" % CLIENT_VERSION)
return False
self._show_help()
if command in ["-h", "--help"]:
return False
raise ConanException("Unknown command %s" % str(exc))
except IndexError as exc: # No parameters
self._show_help()
return False
method(args[0][1:])
except (KeyboardInterrupt, SystemExit) as exc:
logger.error(exc)
errors = True
except ConanException as exc:
msg = str(exc)
# import traceback
# logger.debug(traceback.format_exc())
errors = True
self._user_io.out.error(msg)
return errors
class ConanAPIV1(object):
@staticmethod
def factory():
"""Factory"""
def instance_remote_manager(client_cache):
requester = get_basic_requester(client_cache)
# Verify client version against remotes
version_checker_req = VersionCheckerRequester(
requester, Version(client_version),
Version(MIN_SERVER_COMPATIBLE_VERSION), out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(out,
requester=version_checker_req,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io,
localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
try:
client_cache = migrate_and_get_client_cache(
get_conan_user_home(), out)
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Get the new command instance after migrations have been done
remote_manager = instance_remote_manager(client_cache)
# Get a search manager
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(client_cache, search_adapter)
# Settings preprocessor
conan = Conan(client_cache, user_io, get_conan_runner(),
remote_manager, search_manager,
settings_preprocessor)
return conan, client_cache, user_io
def __init__(self, client_cache, user_io, runner, remote_manager,
search_manager, settings_preprocessor):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner,
remote_manager, search_manager,
settings_preprocessor)
# Patch the tools module with a good requester and user_io
set_global_instances(self._user_io.out,
get_basic_requester(self._client_cache))
@api_method
def new(self,
name,
header=False,
pure_c=False,
test=False,
exports_sources=False,
bare=False,
cwd=None,
visual_versions=None,
linux_gcc_versions=None,
linux_clang_versions=None,
osx_clang_versions=None,
shared=None,
upload_url=None,
gitignore=None,
gitlab_gcc_versions=None,
gitlab_clang_versions=None):
from conans.client.new import get_files
cwd = prepare_cwd(cwd)
files = get_files(name,
header=header,
pure_c=pure_c,
test=test,
exports_sources=exports_sources,
bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions,
shared=shared,
upload_url=upload_url,
gitignore=gitignore,
gitlab_gcc_versions=gitlab_gcc_versions,
gitlab_clang_versions=gitlab_clang_versions)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
@api_method
def test(self,
path,
profile_name=None,
settings=None,
options=None,
env=None,
remote=None,
update=False,
user=None,
channel=None,
name=None,
version=None,
build_modes=None):
settings = settings or []
options = options or []
env = env or []
cwd = os.getcwd()
base_folder = self._abs_relative_to(path, cwd, default=cwd)
conanfile_abs_path = self._get_conanfile_path(base_folder,
"conanfile.py")
profile = profile_from_args(profile_name, settings, options, env, None,
cwd, self._client_cache)
pt = PackageTester(self._manager, self._user_io)
pt.install_build_and_test(conanfile_abs_path,
profile,
name,
version,
user,
channel,
remote,
update,
build_modes=build_modes)
@api_method
def test_package(self,
profile_name=None,
settings=None,
options=None,
env=None,
scope=None,
test_folder=None,
not_export=False,
build=None,
keep_source=False,
verify=None,
manifests=None,
manifests_interactive=None,
remote=None,
update=False,
cwd=None,
user=None,
channel=None,
name=None,
version=None):
self._user_io.out.warn(
"THIS METHOD IS DEPRECATED and will be removed. "
"Use 'conan create' to generate binary packages for a "
"recipe. If you want to test a package you can use 'conan test' "
"command.")
settings = settings or []
options = options or []
env = env or []
cwd = prepare_cwd(cwd)
if name and version:
package_name = name
package_version = version
else:
conanfile_path = os.path.join(cwd, "conanfile.py")
conanfile = load_conanfile_class(conanfile_path)
package_name = getattr(conanfile, "name", None)
package_version = getattr(conanfile, "version", None)
if not package_name or not package_version:
raise ConanException(
"conanfile.py doesn't declare package name or version")
test_folders = [test_folder
] if test_folder else ["test_package", "test"]
for test_folder_name in test_folders:
test_folder = os.path.join(cwd, test_folder_name)
test_conanfile_path = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile_path):
break
else:
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" %
test_folder_name)
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd, self._client_cache)
loader = self._manager.get_loader(profile)
test_conanfile = loader.load_conan(test_conanfile_path,
self._user_io.out,
consumer=True)
try:
if hasattr(test_conanfile, "requirements"):
test_conanfile.requirements()
except Exception as e:
raise ConanException(
"Error in test_package/conanfile.py requirements(). %s" %
str(e))
requirement = test_conanfile.requires.get(package_name)
if requirement:
if requirement.conan_reference.version != package_version:
raise ConanException(
"package version is '%s', but test_package/conanfile "
"is requiring version '%s'\n"
"You can remove this requirement and use "
"'conan test_package user/channel' instead" %
(package_version, requirement.conan_reference.version))
user = user or requirement.conan_reference.user
channel = channel or requirement.conan_reference.channel
if not user or not channel:
raise ConanException("Please specify user and channel")
conanfile_reference = ConanFileReference(package_name, package_version,
user, channel)
# Forcing an export!
if not not_export:
self._user_io.out.info("Exporting package recipe")
self._manager.export(user, channel, cwd, keep_source=keep_source)
if build is None: # Not specified, force build the tested library
build = [package_name]
manifests = _parse_manifests_arguments(verify, manifests,
manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
self._manager.install(inject_require=conanfile_reference,
reference=test_folder,
install_folder=build_folder,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build,
update=update,
generators=["txt"])
test_conanfile = os.path.join(test_folder, CONANFILE)
self._manager.build(test_conanfile,
test_folder,
build_folder,
package_folder=None,
install_folder=build_folder,
test=str(conanfile_reference))
@api_method
def create(self,
profile_name=None,
settings=None,
options=None,
env=None,
scope=None,
test_folder=None,
not_export=False,
build_modes=None,
keep_source=False,
verify=None,
manifests=None,
manifests_interactive=None,
remote=None,
update=False,
conan_file_path=None,
filename=None,
user=None,
channel=None,
name=None,
version=None,
werror=False):
settings = settings or []
options = options or []
env = env or []
self._user_io.out.werror_active = werror
cwd = os.getcwd()
conanfile_folder = self._abs_relative_to(conan_file_path,
cwd,
default=cwd)
if not name or not version:
conanfile_abs_path = self._get_conanfile_path(
conanfile_folder, filename or CONANFILE)
conanfile = load_conanfile_class(conanfile_abs_path)
name, version = conanfile.name, conanfile.version
if not name or not version:
raise ConanException(
"conanfile.py doesn't declare package name or version")
reference = ConanFileReference(name, version, user, channel)
scoped_output = ScopedOutput(str(reference), self._user_io.out)
# Forcing an export!
if not not_export:
scoped_output.highlight("Exporting package recipe")
self._manager.export(user,
channel,
conanfile_folder,
keep_source=keep_source,
name=name,
version=version,
filename=filename)
if build_modes is None: # Not specified, force build the tested library
build_modes = [name]
manifests = _parse_manifests_arguments(verify, manifests,
manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd, self._client_cache)
self._manager.install(
reference=reference,
install_folder=None, # Not output anything
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build_modes,
update=update,
filename=filename)
base_folder = self._abs_relative_to(conan_file_path, cwd, default=cwd)
def get_test_conanfile_path(tf):
"""Searchs in the declared test_folder or in the standard locations"""
test_folders = [tf] if tf else ["test_package", "test"]
for test_folder_name in test_folders:
test_folder = os.path.join(base_folder, test_folder_name)
test_conanfile_path = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile_path):
return test_conanfile_path
else:
if tf:
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" %
tf)
test_conanfile_path = get_test_conanfile_path(test_folder)
if test_conanfile_path:
pt = PackageTester(self._manager, self._user_io)
scoped_output.highlight("Testing with 'test_package'")
pt.install_build_and_test(test_conanfile_path, profile, name,
version, user, channel, remote, update)
def _get_profile(self, profile_name, settings, options, env, cwd,
install_folder):
infos_present = existing_info_files(install_folder)
if not infos_present:
profile = profile_from_args(profile_name,
settings,
options,
env=env,
scope=None,
cwd=cwd,
client_cache=self._client_cache)
else:
profile = read_conaninfo_profile(install_folder)
return profile
def _validate_can_read_infos(self, install_folder, cwd):
if install_folder and not existing_info_files(
self._abs_relative_to(install_folder, cwd)):
raise ConanException(
"The specified --install-folder doesn't contain '%s' and '%s' "
"files" % (CONANINFO, BUILD_INFO))
@staticmethod
def _validate_one_settings_source(install_folder, profile_name, settings,
options, env):
if install_folder and existing_info_files(install_folder) and \
(profile_name or settings or options or env):
raise ConanException(
"%s and %s are found, at '%s' folder, so specifying profile, "
"settings, options or env is not allowed" %
(CONANINFO, BUILD_INFO, install_folder))
@api_method
def export_pkg(self,
path,
name,
channel,
source_folder=None,
build_folder=None,
install_folder=None,
profile_name=None,
settings=None,
options=None,
env=None,
force=False,
user=None,
version=None):
settings = settings or []
options = options or []
env = env or []
cwd = os.getcwd()
# Checks that info files exists if the install folder is specified
self._validate_can_read_infos(install_folder, cwd)
path = self._abs_relative_to(path, cwd)
build_folder = self._abs_relative_to(build_folder, cwd, default=cwd)
install_folder = self._abs_relative_to(install_folder,
cwd,
default=build_folder)
source_folder = self._abs_relative_to(source_folder,
cwd,
default=build_folder)
# Checks that no both settings and info files are specified
self._validate_one_settings_source(install_folder, profile_name,
settings, options, env)
profile = self._get_profile(profile_name, settings, options, env, cwd,
install_folder)
conanfile_abs_path = self._get_conanfile_path(path, "conanfile.py")
conanfile = load_conanfile_class(conanfile_abs_path)
if (name and conanfile.name and conanfile.name != name) or \
(version and conanfile.version and conanfile.version != version):
raise ConanException(
"Specified name/version doesn't match with the "
"name/version in the conanfile")
self._manager.export(user, channel, path, name=name, version=version)
if not (name and version):
name = conanfile.name
version = conanfile.version
reference = ConanFileReference(name, version, user, channel)
self._manager.export_pkg(reference,
source_folder=source_folder,
build_folder=build_folder,
install_folder=install_folder,
profile=profile,
force=force)
@api_method
def download(self, reference, remote=None, package=None):
# Install packages without settings (fixed ids or all)
if not reference or not isinstance(reference, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.download(reference, package, remote=remote)
@api_method
def install_reference(self,
reference,
settings=None,
options=None,
env=None,
scope=None,
remote=None,
werror=False,
verify=None,
manifests=None,
manifests_interactive=None,
build=None,
profile_name=None,
update=False,
generators=None,
install_folder=None):
self._user_io.out.werror_active = werror
cwd = os.getcwd()
install_folder = self._abs_relative_to(install_folder,
cwd,
default=cwd)
manifests = _parse_manifests_arguments(verify, manifests,
manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd, self._client_cache)
if not generators: # We don't want the default txt
generators = False
self._manager.install(reference=reference,
install_folder=install_folder,
remote=remote,
profile=profile,
build_modes=build,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generators,
cwd=cwd,
deploy=True)
@api_method
def install(self,
path="",
settings=None,
options=None,
env=None,
scope=None,
remote=None,
werror=False,
verify=None,
manifests=None,
manifests_interactive=None,
build=None,
profile_name=None,
update=False,
generators=None,
no_imports=False,
filename=None,
install_folder=None):
self._user_io.out.werror_active = werror
cwd = os.getcwd()
install_folder = self._abs_relative_to(install_folder,
cwd,
default=cwd)
conanfile_folder = self._abs_relative_to(path, cwd, default=cwd)
manifests = _parse_manifests_arguments(verify, manifests,
manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env,
scope, cwd, self._client_cache)
self._manager.install(reference=conanfile_folder,
install_folder=install_folder,
remote=remote,
profile=profile,
build_modes=build,
filename=filename,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generators,
no_imports=no_imports)
@api_method
def config_get(self, item):
config_parser = ConanClientConfigParser(
self._client_cache.conan_conf_path)
self._user_io.out.info(config_parser.get_item(item))
return config_parser.get_item(item)
@api_method
def config_set(self, item, value):
config_parser = ConanClientConfigParser(
self._client_cache.conan_conf_path)
config_parser.set_item(item, value)
@api_method
def config_rm(self, item):
config_parser = ConanClientConfigParser(
self._client_cache.conan_conf_path)
config_parser.rm_item(item)
@api_method
def config_install(self, item):
from conans.client.conf.config_installer import configuration_install
return configuration_install(item, self._client_cache,
self._user_io.out, self._runner)
@api_method
def info_build_order(self,
reference,
settings=None,
options=None,
env=None,
scope=None,
profile_name=None,
filename=None,
remote=None,
build_order=None,
check_updates=None,
build_folder=None):
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env,
scope, build_folder, self._client_cache)
graph = self._manager.info_build_order(reference, profile, filename,
build_order, remote,
check_updates)
return graph
@api_method
def info_nodes_to_build(self,
reference,
build_modes,
settings=None,
options=None,
env=None,
scope=None,
profile_name=None,
filename=None,
remote=None,
check_updates=None,
build_folder=None):
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env,
scope, build_folder, self._client_cache)
ret = self._manager.info_nodes_to_build(reference, profile, filename,
build_modes, remote,
check_updates)
ref_list, project_reference = ret
return ref_list, project_reference
@api_method
def info_get_graph(self,
reference,
remote=None,
settings=None,
options=None,
env=None,
scope=None,
profile_name=None,
update=False,
filename=None,
build_folder=None):
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env,
scope, build_folder, self._client_cache)
ret = self._manager.info_get_graph(reference=reference,
remote=remote,
profile=profile,
check_updates=update,
filename=filename)
deps_graph, graph_updates_info, project_reference = ret
return deps_graph, graph_updates_info, project_reference
@api_method
def build(self,
path,
source_folder=None,
package_folder=None,
filename=None,
build_folder=None,
install_folder=None):
cwd = os.getcwd()
conanfile_folder = self._abs_relative_to(path, cwd)
build_folder = self._abs_relative_to(build_folder, cwd, default=cwd)
install_folder = self._abs_relative_to(install_folder,
cwd,
default=build_folder)
source_folder = self._abs_relative_to(source_folder,
cwd,
default=conanfile_folder)
default_pkg_folder = os.path.join(build_folder, "package")
package_folder = self._abs_relative_to(package_folder,
cwd,
default=default_pkg_folder)
conanfile_abs_path = self._get_conanfile_path(conanfile_folder,
filename)
if conanfile_abs_path.endswith(".txt"):
raise ConanException(
"A conanfile.py is needed to call 'conan build' "
"(not valid conanfile.txt)")
self._manager.build(conanfile_abs_path, source_folder, build_folder,
package_folder, install_folder)
@api_method
def package(self,
path,
build_folder,
package_folder,
source_folder=None,
install_folder=None):
cwd = os.getcwd()
conanfile_folder = self._abs_relative_to(path, cwd)
build_folder = self._abs_relative_to(build_folder, cwd, default=cwd)
install_folder = self._abs_relative_to(install_folder,
cwd,
default=build_folder)
source_folder = self._abs_relative_to(source_folder,
cwd,
default=conanfile_folder)
default_pkg = os.path.join(build_folder, "package")
package_folder = self._abs_relative_to(package_folder,
cwd,
default=default_pkg)
self._manager.local_package(package_folder, conanfile_folder,
build_folder, source_folder,
install_folder)
@api_method
def source(self, path, source_folder=None, info_folder=None):
cwd = os.getcwd()
path = self._abs_relative_to(path, cwd)
source_folder = self._abs_relative_to(source_folder, cwd, default=cwd)
info_folder = self._abs_relative_to(info_folder, cwd, default=cwd)
mkdir(source_folder)
if not os.path.exists(info_folder):
raise ConanException("Specified info-folder doesn't exist")
conanfile_abs_path = self._get_conanfile_path(path, CONANFILE)
self._manager.source(conanfile_abs_path, source_folder, info_folder)
@staticmethod
def _abs_relative_to(path, base_relative, default=None):
"""Gets an absolute path from "path" parameter, prepending base_relative if not abs yet.
If path is none, will return the 'default'"""
if not path:
return default
if not os.path.isabs(path):
return os.path.normpath(os.path.join(base_relative, path))
else:
return path
@staticmethod
def _get_conanfile_path(conanfile_folder, the_filename=None):
def raise_if_not_exists(some_path):
if not os.path.exists(some_path):
raise ConanException("Conanfile not found: %s" % some_path)
if the_filename:
conanfile_path = os.path.join(conanfile_folder, the_filename)
raise_if_not_exists(conanfile_path)
else:
conanfile_path = os.path.join(conanfile_folder, CONANFILE)
if not os.path.exists(conanfile_path):
conanfile_path = os.path.join(conanfile_folder, CONANFILE_TXT)
raise_if_not_exists(conanfile_path)
return conanfile_path
@api_method
def imports(self, path, dest=None, filename=None, info_folder=None):
"""
:param path: Path to the conanfile
:param dest: Dir to put the imported files. (Abs path or relative to cwd)
:param filename: Alternative name of the conanfile. Default: conanfile.py or conanfile.txt
:param build_folder: Dir where the conaninfo.txt and conanbuildinfo.txt files are
:return: None
"""
cwd = os.getcwd()
conanfile_folder = self._abs_relative_to(path, cwd)
info_folder = self._abs_relative_to(info_folder, cwd, default=cwd)
dest = self._abs_relative_to(dest, cwd, default=cwd)
mkdir(dest)
conanfile_abs_path = self._get_conanfile_path(conanfile_folder,
filename)
self._manager.imports(conanfile_abs_path, dest, info_folder)
@api_method
def imports_undo(self, manifest_path):
manifest_path = self._abs_relative_to(manifest_path, os.getcwd())
self._manager.imports_undo(manifest_path)
@api_method
def export(self,
user,
channel,
path=None,
keep_source=False,
filename=None,
cwd=None,
name=None,
version=None):
cwd = prepare_cwd(cwd)
current_path = os.path.abspath(path or cwd)
self._manager.export(user,
channel,
current_path,
keep_source,
filename=filename,
name=name,
version=version)
@api_method
def remove(self,
pattern,
query=None,
packages=None,
builds=None,
src=False,
force=False,
remote=None,
outdated=False):
self._manager.remove(pattern,
package_ids_filter=packages,
build_ids=builds,
src=src,
force=force,
remote=remote,
packages_query=query,
outdated=outdated)
@api_method
def copy(self,
reference="",
user_channel="",
force=False,
all=False,
package=None):
reference = ConanFileReference.loads(reference)
new_ref = ConanFileReference.loads(
"%s/%s@%s" % (reference.name, reference.version, user_channel))
if all:
package = []
self._manager.copy(reference, package, new_ref.user, new_ref.channel,
force)
@api_method
def user(self, name=None, clean=False, remote=None, password=None):
if clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(remote, name, password)
@api_method
def search_recipes(self, pattern, remote=None, case_sensitive=False):
refs = self._manager.search_recipes(pattern,
remote,
ignorecase=not case_sensitive)
return refs
@api_method
def search_packages(self,
reference,
query=None,
remote=None,
outdated=False):
ret = self._manager.search_packages(reference,
remote,
packages_query=query,
outdated=outdated)
return ret
@api_method
def upload(self,
pattern,
package=None,
remote=None,
all=False,
force=False,
confirm=False,
retry=2,
retry_wait=5,
skip_upload=False,
integrity_check=False):
""" Uploads a package recipe and the generated binary packages to a specified remote
"""
if package and not is_a_reference(pattern):
raise ConanException(
"-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
self._manager.upload(pattern,
package,
remote,
all_packages=all,
force=force,
confirm=confirm,
retry=retry,
retry_wait=retry_wait,
skip_upload=skip_upload,
integrity_check=integrity_check)
@api_method
def remote_list(self):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.remotes
@api_method
def remote_add(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.add(remote, url, verify_ssl, insert)
@api_method
def remote_remove(self, remote):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.remove(remote)
@api_method
def remote_update(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.update(remote, url, verify_ssl, insert)
@api_method
def remote_list_ref(self):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.refs
@api_method
def remote_add_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.add_ref(reference, remote)
@api_method
def remote_remove_ref(self, reference):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.remove_ref(reference)
@api_method
def remote_update_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return registry.update_ref(reference, remote)
@api_method
def profile_list(self):
folder = self._client_cache.profiles_path
if os.path.exists(folder):
return [
name for name in os.listdir(folder)
if not os.path.isdir(os.path.join(folder, name))
]
else:
self._user_io.out.info("No profiles defined")
return []
@api_method
def create_profile(self, profile_name, detect=False):
profile_path = get_profile_path(profile_name,
self._client_cache.profiles_path,
os.getcwd())
if os.path.exists(profile_path):
raise ConanException("Profile already exists")
profile = Profile()
if detect:
settings = detect_defaults_settings(self._user_io.out)
for name, value in settings:
profile.settings[name] = value
contents = profile.dumps()
save(profile_path, contents)
self._user_io.out.info("Empty profile created: %s" % profile_path)
return profile_path
@staticmethod
def _get_profile_keys(key):
# settings.compiler.version => settings, compiler.version
tmp = key.split(".")
first_key = tmp[0]
rest_key = ".".join(tmp[1:]) if len(tmp) > 1 else None
if first_key not in ("build_requires", "settings", "options", "scopes",
"env"):
raise ConanException("Invalid specified key: %s" % key)
return first_key, rest_key
@api_method
def update_profile(self, profile_name, key, value):
first_key, rest_key = self._get_profile_keys(key)
profile, _ = read_profile(profile_name, os.getcwd(),
self._client_cache.profiles_path)
if first_key == "settings":
profile.settings[rest_key] = value
elif first_key == "options":
tmp = OptionsValues([(rest_key, value)])
profile.options.update(tmp)
elif first_key == "env":
profile.env_values.update(
EnvValues.loads("%s=%s" % (rest_key, value)))
elif first_key == "scopes":
profile.update_scopes(
Scopes.from_list(["%s=%s" % (rest_key, value)]))
elif first_key == "build_requires":
raise ConanException(
"Edit the profile manually to change the build_requires")
contents = profile.dumps()
profile_path = get_profile_path(profile_name,
self._client_cache.profiles_path,
os.getcwd())
save(profile_path, contents)
@api_method
def get_profile_key(self, profile_name, key):
first_key, rest_key = self._get_profile_keys(key)
profile, _ = read_profile(profile_name, os.getcwd(),
self._client_cache.profiles_path)
try:
if first_key == "settings":
return profile.settings[rest_key]
elif first_key == "options":
return dict(profile.options.as_list())[rest_key]
elif first_key == "env":
package = None
var = rest_key
if ":" in rest_key:
package, var = rest_key.split(":")
return profile.env_values.data[package][var]
elif first_key == "build_requires":
raise ConanException(
"List the profile manually to see the build_requires")
except KeyError:
raise ConanException("Key not found: '%s'" % key)
@api_method
def delete_profile_key(self, profile_name, key):
first_key, rest_key = self._get_profile_keys(key)
profile, _ = read_profile(profile_name, os.getcwd(),
self._client_cache.profiles_path)
# For options, scopes, env vars
try:
package, name = rest_key.split(":")
except ValueError:
package = None
name = rest_key
try:
if first_key == "settings":
del profile.settings[rest_key]
elif first_key == "options":
profile.options.remove(name, package)
elif first_key == "env":
profile.env_values.remove(name, package)
elif first_key == "scopes":
profile.scopes.remove(name, package)
elif first_key == "build_requires":
raise ConanException(
"Edit the profile manually to delete a build_require")
except KeyError:
raise ConanException("Profile key '%s' doesn't exist" % key)
contents = profile.dumps()
profile_path = get_profile_path(profile_name,
self._client_cache.profiles_path,
os.getcwd())
save(profile_path, contents)
@api_method
def read_profile(self, profile=None):
p, _ = read_profile(profile, os.getcwd(),
self._client_cache.profiles_path)
return p
@api_method
def get_path(self, reference, package_id=None, path=None, remote=None):
reference = ConanFileReference.loads(str(reference))
return self._manager.get_path(reference, package_id, path, remote)
@api_method
def export_alias(self, reference, target_reference):
reference = ConanFileReference.loads(str(reference))
target_reference = ConanFileReference.loads(str(target_reference))
return self._manager.export_alias(reference, target_reference)
class Command(object):
""" A single command of the conans application, with all the first level commands.
Manages the parsing of parameters and delegates functionality in
collaborators.
It can also show help of the tool
"""
def __init__(self, paths, user_io, runner, remote_manager):
assert isinstance(user_io, UserIO)
assert isinstance(paths, ConanPaths)
self._conan_paths = paths
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(paths, user_io, runner, remote_manager)
def _parse_args(self, parser):
parser.add_argument("-r",
"--remote",
help='look for in the remote storage')
parser.add_argument(
"--options",
"-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1,
action=Extender)
parser.add_argument(
"--settings",
"-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1,
action=Extender)
parser.add_argument(
"--build",
"-b",
action=Extender,
nargs="*",
help='''Optional, use it to choose if you want to build from sources:
--build Build all from sources, do not use binary packages.
--build=never Default option. Never build, use binary packages or fail if a binary package is not found.
--build=missing Build from code if a binary package is not found.
--build=[pattern] Build always these packages from source, but never build the others. Allows multiple --build parameters.
''')
def _get_tuples_list_from_extender_arg(self, items):
if not items:
return []
# Validate the pairs
for item in items:
chunks = item.split("=")
if len(chunks) != 2:
raise ConanException("Invalid input '%s', use 'name=value'" %
item)
return [(item[0], item[1])
for item in [item.split("=") for item in items]]
def _detect_tested_library_name(self):
conanfile_content = load(CONANFILE)
match = re.search('^\s*name\s*=\s*"(.*)"', conanfile_content,
re.MULTILINE)
if match:
return "%s*" % match.group(1)
self._user_io.out.warn(
"Cannot detect a valid conanfile in current directory")
return None
def _get_build_sources_parameter(self, build_param):
# returns True if we want to build the missing libraries
# False if building is forbidden
# A list with patterns: Will force build matching libraries,
# will look for the package for the rest
if isinstance(build_param, list):
if len(build_param) == 0: # All packages from source
return ["*"]
elif len(build_param) == 1 and build_param[0] == "never":
return False # Default
elif len(build_param) == 1 and build_param[0] == "missing":
return True
else: # A list of expressions to match (if matches, will build from source)
return ["%s*" % ref_expr for ref_expr in build_param]
else:
return False # Nothing is built
def test(self, *args):
""" build and run your package test. Must have conanfile.py with "test"
method and "test" subfolder with package consumer test project
"""
parser = argparse.ArgumentParser(description=self.test.__doc__,
prog="conan test",
formatter_class=RawTextHelpFormatter)
parser.add_argument("path",
nargs='?',
default="",
help='path to conanfile file, '
'e.g. /my_project/')
self._parse_args(parser)
args = parser.parse_args(*args)
root_folder = os.path.normpath(os.path.join(os.getcwd(), args.path))
test_folder = os.path.join(root_folder, "test")
if not os.path.exists(test_folder):
raise ConanException("test folder not available")
lib_to_test = self._detect_tested_library_name()
# Get False or a list of patterns to check
if args.build is None and lib_to_test: # Not specified, force build the tested library
args.build = [lib_to_test]
else:
args.build = self._get_build_sources_parameter(args.build)
options = args.options or []
settings = args.settings or []
sha = hashlib.sha1("".join(options + settings)).hexdigest()
build_folder = os.path.join(root_folder, "build", sha)
rmdir(build_folder)
shutil.copytree(test_folder, build_folder)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
self._manager.install(reference=build_folder,
current_path=build_folder,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build)
self._manager.build(build_folder, build_folder, test=True)
def install(self, *args):
""" install in the local store the given requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans install opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.install.__doc__,
prog="conan install",
formatter_class=RawTextHelpFormatter)
parser.add_argument(
"reference",
nargs='?',
default="",
help='package recipe reference'
'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/')
parser.add_argument(
"--package",
"-p",
nargs=1,
action=Extender,
help='Force install specified package ID (ignore settings/options)'
)
parser.add_argument(
"--all",
action='store_true',
default=False,
help='Install all packages from the specified package recipe')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("--update",
"-u",
action='store_true',
default=False,
help="update with new upstream packages")
self._parse_args(parser)
args = parser.parse_args(*args)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(
os.path.join(current_path, args.reference))
if args.all or args.package: # Install packages without settings (fixed ids or all)
if args.all:
args.package = []
if not args.reference or not isinstance(reference,
ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., OpenSSL/1.0.2e@lasote/stable")
self._manager.download(reference, args.package, remote=args.remote)
else: # Classic install, package chosen with settings and options
# Get False or a list of patterns to check
args.build = self._get_build_sources_parameter(args.build)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
build_mode=args.build,
filename=args.file,
update=args.update)
def info(self, *args):
""" Prints information about the requirements.
Requirements can be defined in the command line or in a conanfile.
EX: conans info opencv/2.4.10@lasote/testing
"""
parser = argparse.ArgumentParser(description=self.info.__doc__,
prog="conan info",
formatter_class=RawTextHelpFormatter)
parser.add_argument(
"reference",
nargs='?',
default="",
help='reference name or path to conanfile file, '
'e.g., OpenSSL/1.0.2e@lasote/stable or ./my_project/')
parser.add_argument("--file", "-f", help="specify conanfile filename")
parser.add_argument("-r",
"--remote",
help='look for in the remote storage')
parser.add_argument(
"--options",
"-o",
help='load options to build the package, e.g., -o with_qt=true',
nargs=1,
action=Extender)
parser.add_argument(
"--settings",
"-s",
help='load settings to build the package, -s compiler:gcc',
nargs=1,
action=Extender)
args = parser.parse_args(*args)
options = self._get_tuples_list_from_extender_arg(args.options)
settings = self._get_tuples_list_from_extender_arg(args.settings)
current_path = os.getcwd()
try:
reference = ConanFileReference.loads(args.reference)
except:
reference = os.path.normpath(
os.path.join(current_path, args.reference))
self._manager.install(reference=reference,
current_path=current_path,
remote=args.remote,
options=options,
settings=settings,
build_mode=False,
info=True,
filename=args.file)
def build(self, *args):
""" calls your project conanfile.py "build" method.
EX: conans build ./my_project
Intended for package creators, requires a conanfile.py.
"""
parser = argparse.ArgumentParser(description=self.build.__doc__,
prog="conan build")
parser.add_argument(
"path",
nargs="?",
help='path to user conanfile.py, e.g., conans build .',
default="")
parser.add_argument("--file", "-f", help="specify conanfile filename")
args = parser.parse_args(*args)
current_path = os.getcwd()
if args.path:
root_path = os.path.abspath(args.path)
else:
root_path = current_path
self._manager.build(root_path, current_path, filename=args.file)
def package(self, *args):
""" calls your conanfile.py "package" method for a specific package or
regenerates the existing package's manifest.
Intended for package creators, for regenerating a package without
recompiling the source.
e.g. conan package OpenSSL/1.0.2e@lasote/stable 9cf83afd07b678da9c1645f605875400847ff3
"""
parser = argparse.ArgumentParser(description=self.package.__doc__,
prog="conan package")
parser.add_argument(
"reference",
help=
'package recipe reference name. e.g., openssl/1.0.2@lasote/testing'
)
parser.add_argument("package",
nargs="?",
default="",
help='Package ID to regenerate. e.g., '
'9cf83afd07b678d38a9c1645f605875400847ff3')
parser.add_argument(
"-o",
"--only-manifest",
default=False,
action='store_true',
help='Just regenerate manifest for the existing package.'
'If True conan won\'t call your conanfile\'s package method.')
parser.add_argument(
"--all",
action='store_true',
default=False,
help='Package all packages from specified reference')
args = parser.parse_args(*args)
try:
reference = ConanFileReference.loads(args.reference)
except:
raise ConanException(
"Invalid package recipe reference. e.g., OpenSSL/1.0.2e@lasote/stable"
)
if not args.all and not args.package:
raise ConanException(
"'conan package': Please specify --all or a package ID")
self._manager.package(reference, args.package, args.only_manifest,
args.all)
def export(self, *args):
""" copies the package recipe (conanfile.py and associated files) to your local store,
where it can be shared and reused in other projects.
From that store, it can be uploaded to any remote with "upload" command.
"""
parser = argparse.ArgumentParser(description=self.export.__doc__,
prog="conan export")
parser.add_argument("user",
help='user_name[/channel]. By default, channel is '
'"testing", e.g., phil or phil/stable')
parser.add_argument(
'--path',
'-p',
default=None,
help='Optional. Folder with a %s. Default current directory.' %
CONANFILE)
parser.add_argument(
'--keep-source',
'-k',
default=False,
action='store_true',
help='Optional. Do not remove the source folder in local store. '
'Use for testing purposes only')
args = parser.parse_args(*args)
current_path = args.path or os.getcwd()
keep_source = args.keep_source
self._manager.export(args.user, current_path, keep_source)
def remove(self, *args):
""" Remove any package recipe or package from your local/remote store
"""
parser = argparse.ArgumentParser(description=self.remove.__doc__,
prog="conan remove")
parser.add_argument('pattern', help='Pattern name, e.g., openssl/*')
parser.add_argument(
'-p',
'--packages',
const=[],
nargs='?',
help='By default, remove all the packages or select one, '
'specifying the SHA key')
parser.add_argument(
'-b',
'--builds',
const=[],
nargs='?',
help='By default, remove all the build folders or select one, '
'specifying the SHA key')
parser.add_argument('-s',
'--src',
default=False,
action="store_true",
help='Remove source folders')
parser.add_argument('-f',
'--force',
default=False,
action='store_true',
help='Remove without requesting a confirmation')
parser.add_argument('-r', '--remote', help='Remote origin')
args = parser.parse_args(*args)
if args.packages:
args.packages = args.packages.split(",")
if args.builds:
args.builds = args.builds.split(",")
self._manager.remove(args.pattern,
package_ids_filter=args.packages,
build_ids=args.builds,
src=args.src,
force=args.force,
remote=args.remote)
def copy(self, *args):
""" Copy package recipe and packages to another user/channel
"""
parser = argparse.ArgumentParser(description=self.copy.__doc__,
prog="conan copy")
parser.add_argument("reference",
default="",
help='package recipe reference'
'e.g., OpenSSL/1.0.2e@lasote/stable')
parser.add_argument("user_channel",
default="",
help='Destination user/channel'
'e.g., lasote/testing')
parser.add_argument("--package",
"-p",
nargs=1,
action=Extender,
help='copy specified package ID')
parser.add_argument(
"--all",
action='store_true',
default=False,
help='Copy all packages from the specified package recipe')
parser.add_argument(
"--force",
action='store_true',
default=False,
help='Override destination packages and the package recipe')
args = parser.parse_args(*args)
reference = ConanFileReference.loads(args.reference)
new_ref = ConanFileReference.loads(
"%s/%s@%s" %
(reference.name, reference.version, args.user_channel))
if args.all:
args.package = []
self._manager.copy(reference, args.package, new_ref.user,
new_ref.channel, args.force)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__,
prog="conan user")
parser.add_argument(
"name",
nargs='?',
default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument(
"-p",
"--password",
help='User password. Use double quotes '
'if password with spacing, and escape quotes if existing')
parser.add_argument("--remote",
"-r",
help='look for in the remote storage')
args = parser.parse_args(*parameters) # To enable -h
self._manager.user(args.remote, args.name, args.password)
def search(self, *args):
""" show local/remote packages
"""
parser = argparse.ArgumentParser(description=self.search.__doc__,
prog="conan search")
parser.add_argument('pattern',
nargs='?',
help='Pattern name, e.g., openssl/*')
parser.add_argument('--case-sensitive',
default=False,
action='store_true',
help='Make a case-sensitive search')
parser.add_argument('-r', '--remote', help='Remote origin')
parser.add_argument('-v',
'--verbose',
default=False,
action='store_true',
help='Show packages options and settings')
parser.add_argument('-p',
'--package',
help='Package ID pattern. EX: 23*',
default=None)
args = parser.parse_args(*args)
self._manager.search(args.pattern,
args.remote,
ignorecase=not args.case_sensitive,
verbose=args.verbose,
package_pattern=args.package)
def upload(self, *args):
""" uploads a conanfile or binary packages from the local store to any remote.
To upload something, it should be "exported" first.
"""
parser = argparse.ArgumentParser(description=self.upload.__doc__,
prog="conan upload")
parser.add_argument(
"reference",
help='package recipe reference, e.g., OpenSSL/1.0.2e@lasote/stable'
)
# TODO: packageparser.add_argument('package', help='user name')
parser.add_argument("--package",
"-p",
default=None,
help='package ID to upload')
parser.add_argument("--remote",
"-r",
help='upload to this specific remote')
parser.add_argument("--all",
action='store_true',
default=False,
help='Upload both package recipe and packages')
parser.add_argument(
"--force",
action='store_true',
default=False,
help='Do not check conans date, override remote with local')
args = parser.parse_args(*args)
conan_ref = ConanFileReference.loads(args.reference)
package_id = args.package
if not conan_ref and not package_id:
raise ConanException("Enter conans or package id")
self._manager.upload(conan_ref,
package_id,
args.remote,
all_packages=args.all,
force=args.force)
def remote(self, *args):
""" manage remotes
"""
parser = argparse.ArgumentParser(description=self.remote.__doc__,
prog="conan remote")
subparsers = parser.add_subparsers(dest='subcommand',
help='sub-command help')
# create the parser for the "a" command
subparsers.add_parser('list', help='list current remotes')
parser_add = subparsers.add_parser('add', help='add a remote')
parser_add.add_argument('remote', help='name of the remote')
parser_add.add_argument('url', help='url of the remote')
parser_rm = subparsers.add_parser('remove', help='remove a remote')
parser_rm.add_argument('remote', help='name of the remote')
parser_upd = subparsers.add_parser('update',
help='update the remote url')
parser_upd.add_argument('remote', help='name of the remote')
parser_upd.add_argument('url', help='url')
subparsers.add_parser(
'list_ref',
help='list the package recipes and its associated remotes')
parser_padd = subparsers.add_parser(
'add_ref', help="associate a recipe's reference to a remote")
parser_padd.add_argument('reference', help='package recipe reference')
parser_padd.add_argument('remote', help='name of the remote')
parser_prm = subparsers.add_parser(
'remove_ref',
help="dissociate a recipe's reference and its remote")
parser_prm.add_argument('reference', help='package recipe reference')
parser_pupd = subparsers.add_parser(
'update_ref',
help="update the remote associated with a package recipe")
parser_pupd.add_argument('reference', help='package recipe reference')
parser_pupd.add_argument('remote', help='name of the remote')
args = parser.parse_args(*args)
registry = RemoteRegistry(self._conan_paths.registry,
self._user_io.out)
if args.subcommand == "list":
for r in registry.remotes:
self._user_io.out.info("%s: %s" % (r.name, r.url))
elif args.subcommand == "add":
registry.add(args.remote, args.url)
elif args.subcommand == "remove":
registry.remove(args.remote)
elif args.subcommand == "update":
registry.update(args.remote, args.url)
elif args.subcommand == "list_ref":
for ref, remote in registry.refs.iteritems():
self._user_io.out.info("%s: %s" % (ref, remote))
elif args.subcommand == "add_ref":
registry.add_ref(args.reference, args.remote)
elif args.subcommand == "remove_ref":
registry.remove_ref(args.reference)
elif args.subcommand == "update_ref":
registry.update_ref(args.reference, args.remote)
def _show_help(self):
""" prints a summary of all commands
"""
self._user_io.out.writeln(
'Conan commands. Type $conan "command" -h for help',
Color.BRIGHT_YELLOW)
commands = self._commands()
for name in sorted(self._commands()):
self._user_io.out.write(' %-10s' % name, Color.GREEN)
self._user_io.out.writeln(commands[name].__doc__.split('\n', 1)[0])
def _commands(self):
""" returns a list of available commands
"""
result = {}
for m in inspect.getmembers(self, predicate=inspect.ismethod):
method_name = m[0]
if not method_name.startswith('_'):
method = m[1]
if method.__doc__ and not method.__doc__.startswith('HIDDEN'):
result[method_name] = method
return result
def run(self, *args):
"""HIDDEN: entry point for executing commands, dispatcher to class
methods
"""
errors = False
try:
try:
command = args[0][0]
commands = self._commands()
method = commands[command]
except KeyError as exc:
if command in ["-v", "--version"]:
self._user_io.out.success("Conan version %s" %
CLIENT_VERSION)
return False
self._show_help()
if command in ["-h", "--help"]:
return False
raise ConanException("Unknown command %s" % str(exc))
except IndexError as exc: # No parameters
self._show_help()
return False
method(args[0][1:])
except (KeyboardInterrupt, SystemExit) as exc:
logger.error(exc)
errors = True
except ConanException as exc:
logger.error(exc)
# logger.debug(traceback.format_exc())
errors = True
self._user_io.out.error(str(exc))
return errors
class ConanAPIV1(object):
@staticmethod
def factory():
"""Factory"""
def instance_remote_manager(client_cache):
requester = get_basic_requester(client_cache)
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(requester, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION),
out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(out, requester=version_checker_requester, put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~"))
try:
client_cache = migrate_and_get_client_cache(user_folder, out)
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Get the new command instance after migrations have been done
remote_manager = instance_remote_manager(client_cache)
# Get a search manager
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(client_cache, search_adapter)
conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager)
return conan
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager)
# Patch the tools module with a good requester and user_io
tools._global_requester = get_basic_requester(self._client_cache)
tools._global_output = self._user_io.out
@api_method
def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None,
visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None,
shared=None, upload_url=None, gitignore=None):
from conans.client.new import get_files
cwd = prepare_cwd(cwd)
files = get_files(name, header=header, pure_c=pure_c, test=test,
exports_sources=exports_sources, bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions, shared=shared,
upload_url=upload_url, gitignore=gitignore)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
@api_method
def test_package(self, path=None, profile_name=None, settings=None, options=None, env=None, scope=None,
test_folder=None, not_export=False, build=None, keep_source=False,
verify=default_manifest_folder, manifests=default_manifest_folder,
manifests_interactive=default_manifest_folder,
remote=None, update=False, cwd=None):
settings = settings or []
options = options or []
env = env or []
cwd = prepare_cwd(cwd)
root_folder = os.path.normpath(os.path.join(cwd, path))
if test_folder:
test_folder_name = test_folder
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if not os.path.exists(test_conanfile):
raise ConanException("test folder '%s' not available, "
"or it doesn't have a conanfile.py" % test_folder)
else:
for name in ["test_package", "test"]:
test_folder_name = name
test_folder = os.path.join(root_folder, test_folder_name)
test_conanfile = os.path.join(test_folder, "conanfile.py")
if os.path.exists(test_conanfile):
break
else:
raise ConanException("test folder 'test_package' not available, "
"or it doesn't have a conanfile.py")
options = options or []
settings = settings or []
sha = hashlib.sha1("".join(options + settings).encode()).hexdigest()
build_folder = os.path.join(test_folder, "build", sha)
rmdir(build_folder)
# shutil.copytree(test_folder, build_folder)
profile = profile_from_args(profile_name, settings, options, env, scope, cwd,
self._client_cache.profiles_path)
conanfile = load_consumer_conanfile(test_conanfile, "",
self._client_cache.settings, self._runner,
self._user_io.out)
try:
# convert to list from ItemViews required for python3
if hasattr(conanfile, "requirements"):
conanfile.requirements()
reqs = list(conanfile.requires.items())
first_dep = reqs[0][1].conan_reference
except Exception:
raise ConanException("Unable to retrieve first requirement of test conanfile.py")
# Forcing an export!
if not not_export:
self._user_io.out.info("Exporting package recipe")
user_channel = "%s/%s" % (first_dep.user, first_dep.channel)
self._manager.export(user_channel, root_folder, keep_source=keep_source)
lib_to_test = first_dep.name
# Get False or a list of patterns to check
if build is None and lib_to_test: # Not specified, force build the tested library
build = [lib_to_test]
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive,
root_folder, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
self._manager.install(reference=test_folder,
current_path=build_folder,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
remote=remote,
profile=profile,
build_modes=build,
update=update,
generators=["txt"]
)
test_conanfile = os.path.join(test_folder, CONANFILE)
self._manager.build(test_conanfile, test_folder, build_folder, test=True)
# Alias to test
@api_method
def test(self, *args):
self.test_package(*args)
@api_method
def package_files(self, reference, package_folder=None, profile_name=None,
force=False, settings=None, options=None, cwd=None):
cwd = prepare_cwd(cwd)
reference = ConanFileReference.loads(reference)
package_folder = package_folder or cwd
if not os.path.isabs(package_folder):
package_folder = os.path.join(cwd, package_folder)
profile = profile_from_args(profile_name, settings, options, env=None,
scope=None, cwd=cwd, default_folder=self._client_cache.profiles_path)
self._manager.package_files(reference=reference, package_folder=package_folder,
profile=profile, force=force)
@api_method
def install(self, reference="", package=None, settings=None, options=None, env=None, scope=None, all=False,
remote=None, werror=False, verify=default_manifest_folder, manifests=default_manifest_folder,
manifests_interactive=default_manifest_folder, build=None, profile_name=None,
update=False, generator=None, no_imports=False, filename=None, cwd=None):
self._user_io.out.werror_active = werror
cwd = prepare_cwd(cwd)
try:
ref = ConanFileReference.loads(reference)
except:
ref = os.path.normpath(os.path.join(cwd, reference))
if all or package: # Install packages without settings (fixed ids or all)
if all:
package = []
if not reference or not isinstance(ref, ConanFileReference):
raise ConanException("Invalid package recipe reference. "
"e.g., MyPackage/1.2@user/channel")
self._manager.download(ref, package, remote=remote)
else: # Classic install, package chosen with settings and options
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd,
self._client_cache.profiles_path)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, scope, cwd,
self._client_cache.profiles_path)
self._manager.install(reference=ref,
current_path=cwd,
remote=remote,
profile=profile,
build_modes=build,
filename=filename,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generator,
no_imports=no_imports)
@api_method
def config_get(self, item):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
self._user_io.out.info(config_parser.get_item(item))
return config_parser.get_item(item)
@api_method
def config_set(self, item, value):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
config_parser.set_item(item, value)
@api_method
def config_rm(self, item):
config_parser = ConanClientConfigParser(self._client_cache.conan_conf_path)
config_parser.rm_item(item)
@api_method
def info_build_order(self, reference, settings=None, options=None, env=None, scope=None, profile_name=None,
filename=None, remote=None, build_order=None, check_updates=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path)
graph = self._manager.info_build_order(reference, profile, filename, build_order, remote, check_updates, cwd=cwd)
return graph
@api_method
def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None, scope=None,
profile_name=None, filename=None, remote=None, check_updates=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path)
ret = self._manager.info_nodes_to_build(reference, profile, filename, build_modes, remote, check_updates, cwd)
ref_list, project_reference = ret
return ref_list, project_reference
@api_method
def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None, scope=None,
profile_name=None, update=False, filename=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
reference = ConanFileReference.loads(reference)
except:
reference = os.path.normpath(os.path.join(current_path, reference))
profile = profile_from_args(profile_name, settings, options, env, scope, current_path,
self._client_cache.profiles_path)
ret = self._manager.info_get_graph(reference=reference, current_path=current_path, remote=remote,
profile=profile, check_updates=update, filename=filename)
deps_graph, graph_updates_info, project_reference = ret
return deps_graph, graph_updates_info, project_reference
@api_method
def build(self, path="", source_folder=None, filename=None, cwd=None):
current_path = prepare_cwd(cwd)
if path:
root_path = os.path.abspath(path)
else:
root_path = current_path
build_folder = current_path
source_folder = source_folder or root_path
if not os.path.isabs(source_folder):
source_folder = os.path.normpath(os.path.join(current_path, source_folder))
if filename and filename.endswith(".txt"):
raise ConanException("A conanfile.py is needed to call 'conan build'")
conanfile_path = os.path.join(root_path, filename or CONANFILE)
self._manager.build(conanfile_path, source_folder, build_folder)
@api_method
def package(self, reference="", package=None, build_folder=None, source_folder=None, cwd=None):
current_path = prepare_cwd(cwd)
try:
self._manager.package(ConanFileReference.loads(reference), package)
except:
if "@" in reference:
raise
recipe_folder = reference
if not os.path.isabs(recipe_folder):
recipe_folder = os.path.normpath(os.path.join(current_path, recipe_folder))
build_folder = build_folder or current_path
if not os.path.isabs(build_folder):
build_folder = os.path.normpath(os.path.join(current_path, build_folder))
package_folder = current_path
source_folder = source_folder or recipe_folder
self._manager.local_package(package_folder, recipe_folder, build_folder, source_folder)
@api_method
def source(self, reference, force=False, cwd=None):
cwd = prepare_cwd(cwd)
current_path, reference = _get_reference(reference, cwd)
self._manager.source(current_path, reference, force)
@api_method
def imports(self, reference, undo=False, dest=None, filename=None, cwd=None):
cwd = prepare_cwd(cwd)
if undo:
if not os.path.isabs(reference):
current_path = os.path.normpath(os.path.join(cwd, reference))
else:
current_path = reference
self._manager.imports_undo(current_path)
else:
cwd = prepare_cwd(cwd)
current_path, reference = _get_reference(reference, cwd)
self._manager.imports(current_path, reference, filename, dest)
@api_method
def export(self, user, path=None, keep_source=False, filename=None, cwd=None):
cwd = prepare_cwd(cwd)
current_path = os.path.abspath(path or cwd)
self._manager.export(user, current_path, keep_source, filename=filename)
@api_method
def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False,
remote=None):
self._manager.remove(pattern, package_ids_filter=packages, build_ids=builds,
src=src, force=force, remote=remote, packages_query=query)
@api_method
def copy(self, reference="", user_channel="", force=False, all=False, package=None):
reference = ConanFileReference.loads(reference)
new_ref = ConanFileReference.loads("%s/%s@%s" % (reference.name,
reference.version,
user_channel))
if all:
package = []
self._manager.copy(reference, package, new_ref.user, new_ref.channel, force)
@api_method
def user(self, name=None, clean=False, remote=None, password=None):
if clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(remote, name, password)
@api_method
def search_recipes(self, pattern, remote=None, case_sensitive=False):
refs = self._manager.search_recipes(pattern, remote, ignorecase=not case_sensitive)
return refs
@api_method
def search_packages(self, reference, query=None, remote=None):
ret = self._manager.search_packages(reference, remote, packages_query=query)
return ret
@api_method
def upload(self, pattern, package=None, remote=None, all=False, force=False, confirm=False,
retry=2, retry_wait=5,
skip_upload=False):
""" Uploads a package recipe and the generated binary packages to a specified remote
"""
if package and not is_a_reference(pattern):
raise ConanException("-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
self._manager.upload(pattern, package,
remote, all_packages=all,
force=force, confirm=confirm, retry=retry,
retry_wait=retry_wait, skip_upload=skip_upload)
@api_method
def remote_list(self):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
for r in registry.remotes:
self._user_io.out.info("%s: %s [Verify SSL: %s]" % (r.name, r.url, r.verify_ssl))
@api_method
def remote_add(self, remote, url, verify_ssl=True, insert=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.add(remote, url, verify_ssl, insert)
@api_method
def remote_remove(self, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remove(remote)
@api_method
def remote_update(self, remote, url, verify_ssl=True):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.update(remote, url, verify_ssl)
@api_method
def remote_list_ref(self):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
for ref, remote in registry.refs.items():
self._user_io.out.info("%s: %s" % (ref, remote))
@api_method
def remote_add_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.add_ref(reference, remote)
@api_method
def remote_remove_ref(self, reference):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.remove_ref(reference)
@api_method
def remote_update_ref(self, reference, remote):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return registry.update_ref(reference, remote)
@api_method
def profile(self, subcommand, profile=None, cwd=None):
cwd = prepare_cwd(cwd)
if subcommand == "list":
folder = self._client_cache.profiles_path
if os.path.exists(folder):
profiles = [name for name in os.listdir(folder) if not os.path.isdir(name)]
for p in sorted(profiles):
self._user_io.out.info(p)
else:
self._user_io.out.info("No profiles defined")
elif subcommand == "show":
p, _ = read_profile(profile, os.getcwd(), self._client_cache.profiles_path)
Printer(self._user_io.out).print_profile(profile, p)
