def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
conan_ref = package_reference.conan
package_folder = self._paths.package(package_reference)
build_folder = self._paths.build(package_reference)
src_folder = self._paths.source(conan_ref)
export_folder = self._paths.export(conan_ref)
self._handle_system_requirements(conan_ref, package_reference, conan_file)
# Check if package is corrupted
valid_package_digest = self._paths.valid_package_digest(package_reference)
if os.path.exists(package_folder) and not valid_package_digest:
# If not valid package, ensure empty folder
self._user_io.out.warn("Bad package '%s' detected! Removing "
"package directory... " % str(package_reference))
rmdir(package_folder)
# Check if any only_source pattern matches with package
force_build = self._force_build(conan_ref, build_mode)
if not force_build:
local_package = os.path.exists(package_folder)
if local_package:
self._user_io.out.info('Package for %s in %s' % (str(conan_ref), package_folder))
return
self._user_io.out.info('Package for %s does not exist' % str(conan_ref))
remote_package = self._retrieve_remote_package(package_reference)
if remote_package:
return
# Can we build? Only if we are forced or build_mode missing and package not exists
build_allowed = force_build or build_mode is True
if build_allowed:
rmdir(build_folder)
rmdir(package_folder)
if force_build:
self._user_io.out.warn('Forced build from source: "%s"' % str(conan_ref))
self._build_package(export_folder, src_folder, build_folder, conan_file)
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps())
self._user_io.out.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file.deps_cpp_info,
conan_file.cpp_info).content)
self._user_io.out.info("Generated %s" % BUILD_INFO)
self._user_io.out.info("Generating the package")
os.chdir(build_folder)
create_package(conan_file, build_folder, package_folder, self._user_io.out)
self._user_io.out.success('Package for "%s" installed in %s'
% (conan_ref, package_folder))
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def package(self):
"""Generate the info txt files and calls the conanfile package method.
"""
# FIXME: Is weak to assign here the recipe_hash
manifest = self._client_cache.load_manifest(self._conan_ref)
self._conan_file.info.recipe_hash = manifest.summary_hash
# Creating ***info.txt files
save(os.path.join(self.build_folder, CONANINFO), self._conan_file.info.dumps())
self._out.info("Generated %s" % CONANINFO)
save(os.path.join(self.build_folder, BUILD_INFO), TXTGenerator(self._conan_file).content)
self._out.info("Generated %s" % BUILD_INFO)
os.chdir(self.build_folder)
if getattr(self._conan_file, 'no_copy_source', False):
source_folder = self.source_folder
else:
source_folder = self.build_folder
with get_env_context_manager(self._conan_file):
install_folder = self.build_folder # While installing, the infos goes to build folder
create_package(self._conan_file, source_folder, self.build_folder, self.package_folder,
install_folder, self._out)
if get_env("CONAN_READ_ONLY_CACHE", False):
make_read_only(self.package_folder)
def package(self):
"""Generate the info txt files and calls the conanfile package method.
Receives que build_folder because it can change if build_id() method exists"""
# FIXME: Is weak to assign here the recipe_hash
manifest = self._client_cache.load_manifest(self._conan_ref)
self._conan_file.info.recipe_hash = manifest.summary_hash
# Creating ***info.txt files
save(os.path.join(self.build_folder, CONANINFO),
self._conan_file.info.dumps())
self._out.info("Generated %s" % CONANINFO)
save(os.path.join(self.build_folder, BUILD_INFO),
TXTGenerator(self._conan_file).content)
self._out.info("Generated %s" % BUILD_INFO)
os.chdir(self.build_folder)
if getattr(self._conan_file, 'no_copy_source', False):
source_folder = self._client_cache.source(
self._conan_ref, self._conan_file.short_paths)
else:
source_folder = self.build_folder
with environment_append(self._conan_file.env):
package_folder = self._client_cache.package(
self._package_reference, self._conan_file.short_paths)
install_folder = self.build_folder # While installing, the infos goes to build folder
create_package(self._conan_file, source_folder, self.build_folder,
package_folder, install_folder, self._out)
if get_env("CONAN_READ_ONLY_CACHE", False):
make_read_only(package_folder)
def package(self):
"""Generate the info txt files and calls the conanfile package method.
"""
# FIXME: Is weak to assign here the recipe_hash
manifest = self._client_cache.load_manifest(self._conan_ref)
self._conan_file.info.recipe_hash = manifest.summary_hash
# Creating ***info.txt files
save(os.path.join(self.build_folder, CONANINFO),
self._conan_file.info.dumps())
self._out.info("Generated %s" % CONANINFO)
save(os.path.join(self.build_folder, BUILD_INFO),
TXTGenerator(self._conan_file).content)
self._out.info("Generated %s" % BUILD_INFO)
os.chdir(self.build_folder)
if getattr(self._conan_file, 'no_copy_source', False):
source_folder = self.source_folder
else:
source_folder = self.build_folder
with get_env_context_manager(self._conan_file):
install_folder = self.build_folder # While installing, the infos goes to build folder
pkg_id = self._conan_file.info.package_id()
create_package(self._conan_file, pkg_id, source_folder,
self.build_folder, self.package_folder,
install_folder, self._out)
if get_env("CONAN_READ_ONLY_CACHE", False):
make_read_only(self.package_folder)
def package_files(self, reference, source_folder, build_folder,
package_folder, profile, force):
""" Bundle pre-existing binaries
@param reference: ConanFileReference
"""
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" %
str(reference))
current_path = package_folder
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote_name=None,
update=False,
check_updates=False,
manifest_manager=None)
loader = self.get_loader(profile)
conanfile = loader.load_virtual([reference], current_path)
graph_builder = self._get_graph_builder(loader, False, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# this is a bit tricky, but works. The loading of a cache package makes the referenced
# one, the first of the first level, always existing
nodes = deps_graph.direct_requires()
_, conanfile = nodes[0]
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = self._client_cache.package(
pkg_reference, short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException(
"Package already exists. Please use --force, -f to overwrite it"
)
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
if source_folder or build_folder:
package_output = ScopedOutput(str(reference), self._user_io.out)
packager.create_package(conanfile,
source_folder,
build_folder,
dest_package_folder,
package_output,
local=True)
else: # we are specifying a final package
shutil.copytree(package_folder, dest_package_folder, symlinks=True)
save(os.path.join(dest_package_folder, CONANINFO),
conanfile.info.dumps())
# Create the digest for the package
digest = FileTreeManifest.create(dest_package_folder)
save(os.path.join(dest_package_folder, CONAN_MANIFEST),
str(digest))
def _package_conanfile(self, conan_ref, conan_file, package_reference,
build_folder, package_folder, output):
"""Generate the info txt files and calls the conanfile package method"""
# FIXME: Is weak to assign here the recipe_hash
conan_file.info.recipe_hash = self._client_cache.load_manifest(
conan_ref).summary_hash
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO),
TXTGenerator(conan_file).content)
output.info("Generated %s" % BUILD_INFO)
save(os.path.join(build_folder, CONANENV),
ConanEnvGenerator(conan_file).content)
output.info("Generated %s" % CONANENV)
os.chdir(build_folder)
if getattr(conan_file, 'no_copy_source', False):
source_folder = self._client_cache.source(package_reference.conan,
conan_file.short_paths)
else:
source_folder = build_folder
with environment_append(conan_file.env):
create_package(conan_file, source_folder, build_folder,
package_folder, output, False)
self._remote_proxy.handle_package_manifest(package_reference,
installed=True)
def package(self, reference, package_id, only_manifest, package_all):
assert(isinstance(reference, ConanFileReference))
# Package paths
conan_file_path = self._paths.conanfile(reference)
if package_all:
if only_manifest:
packages_dir = self._paths.packages(reference)
else:
packages_dir = self._paths.builds(reference)
if not os.path.exists(packages_dir):
raise NotFoundException('%s does not exist' % str(reference))
packages = [PackageReference(reference, packid)
for packid in os.listdir(packages_dir)]
else:
packages = [PackageReference(reference, package_id)]
for package_reference in packages:
package_folder = self._paths.package(package_reference)
# Will read current conaninfo with specified options and load conanfile with them
if not only_manifest:
self._user_io.out.info("Packaging %s" % package_reference.package_id)
build_folder = self._paths.build(package_reference)
loader = self._loader(build_folder)
conanfile = loader.load_conan(conan_file_path, self._user_io.out)
rmdir(package_folder)
output = ScopedOutput(str(reference), self._user_io.out)
packager.create_package(conanfile, build_folder, package_folder, output)
else:
self._user_io.out.info("Creating manifest for %s" % package_reference.package_id)
if not os.path.exists(package_folder):
raise NotFoundException('Package %s does not exist' % str(package_reference))
packager.generate_manifest(package_folder)
def package(self, reference, package_id):
# Package paths
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" % str(reference))
if not package_id:
packages = [PackageReference(reference, packid)
for packid in self._client_cache.conan_builds(reference)]
if not packages:
raise NotFoundException("%s: Package recipe has not been built locally\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries" % str(reference))
else:
packages = [PackageReference(reference, package_id)]
for package_reference in packages:
build_folder = self._client_cache.build(package_reference, short_paths=None)
if not os.path.exists(build_folder):
raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries"
% (str(reference), package_reference.package_id))
# The package already exist, we can use short_paths if they were defined
package_folder = self._client_cache.package(package_reference, short_paths=None)
# Will read current conaninfo with specified options and load conanfile with them
output = ScopedOutput(str(reference), self._user_io.out)
output.info("Re-packaging %s" % package_reference.package_id)
loader = self._loader(build_folder)
conanfile = loader.load_conan(conan_file_path, self._user_io.out)
self._load_deps_info(build_folder, conanfile, output)
rmdir(package_folder)
packager.create_package(conanfile, build_folder, package_folder, output)
def _package(self, conanfile, pref, package_layout, conanfile_path,
build_folder, package_folder):
# FIXME: Is weak to assign here the recipe_hash
manifest = package_layout.recipe_manifest()
conanfile.info.recipe_hash = manifest.summary_hash
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO), conanfile.info.dumps())
self._output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO),
TXTGenerator(conanfile).content)
self._output.info("Generated %s" % BUILD_INFO)
package_id = pref.id
# Do the actual copy, call the conanfile.package() method
with get_env_context_manager(conanfile):
# Could be source or build depends no_copy_source
source_folder = conanfile.source_folder
install_folder = build_folder # While installing, the infos goes to build folder
create_package(conanfile, package_id, source_folder, build_folder,
package_folder, install_folder, self._hook_manager,
conanfile_path, pref.ref)
# Update package metadata
package_hash = package_layout.package_summary_hash(pref)
self._output.info("Created package revision %s" % package_hash)
with package_layout.update_metadata() as metadata:
metadata.packages[package_id].revision = package_hash
metadata.packages[package_id].recipe_revision = pref.ref.revision
if get_env("CONAN_READ_ONLY_CACHE", False):
make_read_only(package_folder)
# FIXME: Conan 2.0 Clear the registry entry (package ref)
return package_hash
def _package_conanfile(self, conan_ref, conan_file, package_reference, build_folder,
package_folder, output):
"""Generate the info txt files and calls the conanfile package method"""
# FIXME: Is weak to assign here the recipe_hash
conan_file.info.recipe_hash = self._client_cache.load_manifest(conan_ref).summary_hash
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file).content)
output.info("Generated %s" % BUILD_INFO)
save(os.path.join(build_folder, CONANENV), ConanEnvGenerator(conan_file).content)
output.info("Generated %s" % CONANENV)
os.chdir(build_folder)
if getattr(conan_file, 'no_copy_source', False):
source_folder = self._client_cache.source(package_reference.conan,
conan_file.short_paths)
else:
source_folder = build_folder
with environment_append(conan_file.env):
create_package(conan_file, source_folder, build_folder, package_folder, output, False)
self._remote_proxy.handle_package_manifest(package_reference, installed=True)
def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
output = ScopedOutput(str(conan_ref), self._out)
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
conan_ref = package_reference.conan
package_folder = self._paths.package(package_reference)
build_folder = self._paths.build(package_reference,
conan_file.short_paths)
src_folder = self._paths.source(conan_ref, conan_file.short_paths)
export_folder = self._paths.export(conan_ref)
# If already exists do not dirt the output, the common situation
# is that package is already installed and OK. If don't, the proxy
# will print some other message about it
if not os.path.exists(package_folder):
output.info("Installing package %s" % package_id)
self._handle_system_requirements(conan_ref, package_reference,
conan_file, output)
force_build = self._build_forced(conan_ref, build_mode, conan_file)
if self._remote_proxy.get_package(package_reference, force_build):
return
# we need and can build? Only if we are forced or build_mode missing and package not exists
build = force_build or build_mode is True or conan_file.build_policy_missing
if build:
if not force_build and not build_mode:
output.info(
"Building package from source as defined by build_policy='missing'"
)
try:
rmdir(build_folder, conan_file.short_paths)
rmdir(package_folder)
except Exception as e:
raise ConanException(
"%s\n\nCouldn't remove folder, might be busy or open\n"
"Close any app using it, and retry" % str(e))
if force_build:
output.warn('Forced build from source')
self._build_package(export_folder, src_folder, build_folder,
package_folder, conan_file, output)
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO),
conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO),
TXTGenerator(conan_file).content)
output.info("Generated %s" % BUILD_INFO)
os.chdir(build_folder)
create_package(conan_file, build_folder, package_folder, output)
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def package(self, reference, package_id):
# Package paths
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" %
str(reference))
conanfile = load_conanfile_class(conan_file_path)
if hasattr(conanfile, "build_id"):
raise ConanException(
"package command does not support recipes with 'build_id'\n"
"To repackage them use 'conan install'")
if not package_id:
packages = [
PackageReference(reference, packid)
for packid in self._client_cache.conan_builds(reference)
]
if not packages:
raise NotFoundException(
"%s: Package recipe has not been built locally\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries" % str(reference))
else:
packages = [PackageReference(reference, package_id)]
package_source_folder = self._client_cache.source(
reference, conanfile.short_paths)
for package_reference in packages:
build_folder = self._client_cache.build(package_reference,
short_paths=None)
if not os.path.exists(build_folder):
raise NotFoundException(
"%s: Package binary '%s' folder doesn't exist\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries" %
(str(reference), package_reference.package_id))
# The package already exist, we can use short_paths if they were defined
package_folder = self._client_cache.package(package_reference,
short_paths=None)
# Will read current conaninfo with specified options and load conanfile with them
output = ScopedOutput(str(reference), self._user_io.out)
output.info("Re-packaging %s" % package_reference.package_id)
conanfile = load_consumer_conanfile(conan_file_path,
build_folder,
self._client_cache.settings,
self._runner,
output,
reference=reference)
rmdir(package_folder)
if getattr(conanfile, 'no_copy_source', False):
source_folder = package_source_folder
else:
source_folder = build_folder
with environment_append(conanfile.env):
packager.create_package(conanfile, source_folder, build_folder,
package_folder, output)
def export_pkg(self, reference, source_folder, build_folder,
package_folder, install_folder, profile, force):
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" %
str(reference))
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote_name=None,
update=False,
check_updates=False,
manifest_manager=None,
recorder=self._recorder)
loader = self.get_loader(profile)
conanfile = loader.load_virtual([reference], scope_options=True)
if install_folder and existing_info_files(install_folder):
_load_deps_info(install_folder, conanfile, required=True)
graph_builder = self._get_graph_builder(loader, False, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# this is a bit tricky, but works. The loading of a cache package makes the referenced
# one, the first of the first level, always existing
nodes = deps_graph.direct_requires()
_, conanfile = nodes[0]
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = self._client_cache.package(
pkg_reference, short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException(
"Package already exists. Please use --force, -f to "
"overwrite it")
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
conanfile.develop = True
package_output = ScopedOutput(str(reference), self._user_io.out)
if package_folder:
packager.export_pkg(conanfile, package_folder, dest_package_folder,
package_output)
else:
packager.create_package(conanfile,
source_folder,
build_folder,
dest_package_folder,
install_folder,
package_output,
local=True)
def local_package(self, current_path, build_folder):
if current_path == build_folder:
raise ConanException("Cannot 'conan package' to the build folder. "
"Please move to another folder and try again")
output = ScopedOutput("PROJECT", self._user_io.out)
conan_file_path = os.path.join(build_folder, CONANFILE)
conanfile = self._loader().load_conan(conan_file_path, output, consumer=True)
_load_info_file(build_folder, conanfile, output)
packager.create_package(conanfile, build_folder, current_path, output, local=True)
def local_package(self, current_path, build_folder):
if current_path == build_folder:
raise ConanException("Cannot 'conan package' to the build folder. "
"Please move to another folder and try again")
output = ScopedOutput("PROJECT", self._user_io.out)
conan_file_path = os.path.join(build_folder, CONANFILE)
conanfile = self._loader().load_conan(conan_file_path, output, consumer=True)
self._load_deps_info(build_folder, conanfile, output)
packager.create_package(conanfile, build_folder, current_path, output, local=True)
def local_package(self, package_folder, recipe_folder, build_folder, source_folder):
if package_folder == build_folder:
raise ConanException("Cannot 'conan package' to the build folder. "
"--build_folder and package folder can't be the same")
output = ScopedOutput("PROJECT", self._user_io.out)
conan_file_path = os.path.join(recipe_folder, CONANFILE)
conanfile = self.load_consumer_conanfile(conan_file_path, build_folder, output)
packager.create_package(conanfile, source_folder, build_folder, package_folder, output,
local=True, copy_info=True)
def local_package(self, package_folder, conanfile_path, build_folder, source_folder,
install_folder):
if package_folder == build_folder:
raise ConanException("Cannot 'conan package' to the build folder. "
"--build-folder and package folder can't be the same")
output = ScopedOutput("PROJECT", self._user_io.out)
conanfile = self._load_consumer_conanfile(conanfile_path, install_folder, output,
deps_info_required=True)
packager.create_package(conanfile, source_folder, build_folder, package_folder,
install_folder, output, local=True, copy_info=True)
def local_package(self, package_folder, conanfile_path, build_folder, source_folder,
install_folder):
if package_folder == build_folder:
raise ConanException("Cannot 'conan package' to the build folder. "
"--build-folder and package folder can't be the same")
output = ScopedOutput("PROJECT", self._user_io.out)
conanfile = self._load_consumer_conanfile(conanfile_path, install_folder, output,
deps_info_required=True)
packager.create_package(conanfile, None, source_folder, build_folder, package_folder,
install_folder, output, local=True, copy_info=True)
def export_pkg(self, reference, source_folder, build_folder,
package_folder, install_folder, profile, force):
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" %
str(reference))
deps_graph, _, _ = self._graph_manager.load_graph(
reference,
None,
profile,
build_mode=None,
check_updates=False,
update=False,
remote_name=None,
recorder=self._recorder,
workspace=None)
# this is a bit tricky, but works. The root (virtual), has only 1 neighbor,
# which is the exported pkg
nodes = deps_graph.root.neighbors()
conanfile = nodes[0].conanfile
if install_folder and existing_info_files(install_folder):
load_deps_info(install_folder, conanfile, required=True)
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = self._client_cache.package(
pkg_reference, short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException(
"Package already exists. Please use --force, -f to "
"overwrite it")
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
conanfile.develop = True
package_output = ScopedOutput(str(reference), self._user_io.out)
if package_folder:
packager.export_pkg(conanfile, pkg_id, package_folder,
dest_package_folder, package_output)
else:
packager.create_package(conanfile,
pkg_id,
source_folder,
build_folder,
dest_package_folder,
install_folder,
package_output,
local=True)
def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
output = ScopedOutput(str(conan_ref), self._out)
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
conan_ref = package_reference.conan
package_folder = self._paths.package(package_reference, conan_file.short_paths)
build_folder = self._paths.build(package_reference, conan_file.short_paths)
src_folder = self._paths.source(conan_ref, conan_file.short_paths)
export_folder = self._paths.export(conan_ref)
# If already exists do not dirt the output, the common situation
# is that package is already installed and OK. If don't, the proxy
# will print some other message about it
if not package_exists(package_folder):
output.info("Installing package %s" % package_id)
self._handle_system_requirements(conan_ref, package_reference, conan_file, output)
force_build = self._build_forced(conan_ref, build_mode, conan_file)
if self._remote_proxy.get_package(package_reference, force_build,
short_paths=conan_file.short_paths):
return
# we need and can build? Only if we are forced or build_mode missing and package not exists
build = force_build or build_mode is True or conan_file.build_policy_missing
if build:
if not force_build and not build_mode:
output.info("Building package from source as defined by build_policy='missing'")
try:
rmdir(build_folder, conan_file.short_paths)
rmdir(package_folder)
except Exception as e:
raise ConanException("%s\n\nCouldn't remove folder, might be busy or open\n"
"Close any app using it, and retry" % str(e))
if force_build:
output.warn('Forced build from source')
self._build_package(export_folder, src_folder, build_folder, package_folder,
conan_file, output)
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file).content)
output.info("Generated %s" % BUILD_INFO)
os.chdir(build_folder)
create_package(conan_file, build_folder, package_folder, output)
self._remote_proxy.handle_package_manifest(package_reference, installed=True)
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def export_pkg(cache, graph_manager, hook_manager, recorder, output,
ref, source_folder, build_folder, package_folder, install_folder,
graph_info, force, remotes):
conan_file_path = cache.package_layout(ref).conanfile()
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" % str(ref))
# The graph has to be loaded with build_mode=[ref.name], so that node is not tried
# to be downloaded from remotes
deps_graph, _ = graph_manager.load_graph(ref, None, graph_info=graph_info, build_mode=[ref.name],
check_updates=False, update=False,
remotes=remotes, recorder=recorder,
apply_build_requires=False)
# this is a bit tricky, but works. The root (virtual), has only 1 neighbor,
# which is the exported pkg
nodes = deps_graph.root.neighbors()
conanfile = nodes[0].conanfile
from conans.client.conan_api import existing_info_files
if install_folder and existing_info_files(install_folder):
load_deps_info(install_folder, conanfile, required=True)
package_id = nodes[0].package_id
output.info("Packaging to %s" % package_id)
pref = PackageReference(ref, package_id)
layout = cache.package_layout(ref, short_paths=conanfile.short_paths)
dest_package_folder = layout.package(pref)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException("Package already exists. Please use --force, -f to "
"overwrite it")
recipe_hash = layout.recipe_manifest().summary_hash
conanfile.info.recipe_hash = recipe_hash
conanfile.develop = True
if package_folder:
packager.export_pkg(conanfile, package_id, package_folder, dest_package_folder,
hook_manager, conan_file_path, ref)
else:
with get_env_context_manager(conanfile):
packager.create_package(conanfile, package_id, source_folder, build_folder,
dest_package_folder, install_folder, hook_manager,
conan_file_path, ref, local=True)
readed_manifest = FileTreeManifest.load(dest_package_folder)
pref = PackageReference(pref.ref, pref.id, readed_manifest.summary_hash)
output.info("Package revision %s" % pref.revision)
with layout.update_metadata() as metadata:
metadata.packages[package_id].revision = pref.revision
metadata.packages[package_id].recipe_revision = metadata.recipe.revision
recorder.package_exported(pref)
def export_pkg(client_cache, graph_manager, hook_manager, recorder, output,
reference, source_folder, build_folder, package_folder,
install_folder, graph_info, force):
conan_file_path = client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" %
str(reference))
deps_graph = graph_manager.load_simple_graph(reference, graph_info.profile,
recorder)
# this is a bit tricky, but works. The root (virtual), has only 1 neighbor,
# which is the exported pkg
nodes = deps_graph.root.neighbors()
conanfile = nodes[0].conanfile
from conans.client.conan_api import existing_info_files
if install_folder and existing_info_files(install_folder):
load_deps_info(install_folder, conanfile, required=True)
pkg_id = conanfile.info.package_id()
output.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = client_cache.package(
pkg_reference, short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException(
"Package already exists. Please use --force, -f to "
"overwrite it")
recipe_hash = client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
conanfile.develop = True
package_output = ScopedOutput(str(reference), output)
if package_folder:
packager.export_pkg(conanfile, pkg_id, package_folder,
dest_package_folder, package_output, hook_manager,
conan_file_path, reference)
else:
packager.create_package(conanfile,
pkg_id,
source_folder,
build_folder,
dest_package_folder,
install_folder,
package_output,
hook_manager,
conan_file_path,
reference,
local=True)
recorder.package_exported(pkg_reference)
def local_package(self, package_folder, recipe_folder, build_folder, source_folder):
if package_folder == build_folder:
raise ConanException("Cannot 'conan package' to the build folder. "
"--build_folder and package folder can't be the same")
output = ScopedOutput("PROJECT", self._user_io.out)
conan_file_path = os.path.join(recipe_folder, CONANFILE)
conanfile = load_consumer_conanfile(conan_file_path, build_folder,
self._client_cache.settings,
self._runner, output)
packager.create_package(conanfile, source_folder, build_folder, package_folder, output,
local=True)
def package(self, package_reference):
assert(isinstance(package_reference, PackageReference))
# Package paths
conan_file_path = self._paths.conanfile(package_reference.conan)
build_folder = self._paths.build(package_reference)
package_folder = self._paths.package(package_reference)
# Will read current conaninfo with specified options and load conanfile with them
loader = self._loader(build_folder)
conanfile = loader.load_conan(conan_file_path)
rmdir(package_folder)
packager.create_package(conanfile, build_folder, package_folder, self._user_io.out)
def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
output = ScopedOutput(str(conan_ref), self._out)
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
conan_ref = package_reference.conan
package_folder = self._paths.package(package_reference)
build_folder = self._paths.build(package_reference)
src_folder = self._paths.source(conan_ref)
export_folder = self._paths.export(conan_ref)
# If already exists do not dirt the output, the common situation
# is that package is already installed and OK. If don't, the proxy
# will print some other message about it
if not os.path.exists(package_folder):
output.info("Installing package %s" % package_id)
self._handle_system_requirements(conan_ref, package_reference,
conan_file, output)
force_build = self._force_build(conan_ref, build_mode)
if self._remote_proxy.get_package(package_reference, force_build):
return
# Can we build? Only if we are forced or build_mode missing and package not exists
build_allowed = force_build or build_mode is True
if build_allowed:
rmdir(build_folder)
rmdir(package_folder)
if force_build:
output.warn('Forced build from source')
self._build_package(export_folder, src_folder, build_folder,
conan_file, output)
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO),
conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(
os.path.join(build_folder, BUILD_INFO),
TXTGenerator(conan_file.deps_cpp_info,
conan_file.cpp_info).content)
output.info("Generated %s" % BUILD_INFO)
os.chdir(build_folder)
create_package(conan_file, build_folder, package_folder, output)
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def package(self, reference, package_id):
# Package paths
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" % str(reference))
conanfile = load_conanfile_class(conan_file_path)
if hasattr(conanfile, "build_id"):
raise ConanException("package command does not support recipes with 'build_id'\n"
"To repackage them use 'conan install'")
if not package_id:
packages = [PackageReference(reference, packid)
for packid in self._client_cache.conan_builds(reference)]
if not packages:
raise NotFoundException("%s: Package recipe has not been built locally\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries" % str(reference))
else:
packages = [PackageReference(reference, package_id)]
package_source_folder = self._client_cache.source(reference, conanfile.short_paths)
for package_reference in packages:
build_folder = self._client_cache.build(package_reference, short_paths=None)
if not os.path.exists(build_folder):
raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries"
% (str(reference), package_reference.package_id))
# The package already exist, we can use short_paths if they were defined
package_folder = self._client_cache.package(package_reference, short_paths=None)
# Will read current conaninfo with specified options and load conanfile with them
output = ScopedOutput(str(reference), self._user_io.out)
output.info("Re-packaging %s" % package_reference.package_id)
conanfile = load_consumer_conanfile(conan_file_path, build_folder,
self._client_cache.settings,
self._runner, output, reference)
rmdir(package_folder)
if getattr(conanfile, 'no_copy_source', False):
source_folder = package_source_folder
else:
source_folder = build_folder
with environment_append(conanfile.env):
packager.create_package(conanfile, source_folder, build_folder, package_folder,
output)
def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
output = ScopedOutput(str(conan_ref), self._out)
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
conan_ref = package_reference.conan
package_folder = self._paths.package(package_reference)
build_folder = self._paths.build(package_reference)
src_folder = self._paths.source(conan_ref)
export_folder = self._paths.export(conan_ref)
# If already exists do not dirt the output, the common situation
# is that package is already installed and OK. If don't, the proxy
# will print some other message about it
if not os.path.exists(package_folder):
output.info("Installing package %s" % package_id)
self._handle_system_requirements(conan_ref, package_reference, conan_file, output)
force_build = self._force_build(conan_ref, build_mode)
if self._remote_proxy.get_package(package_reference, force_build):
return
# Can we build? Only if we are forced or build_mode missing and package not exists
build_allowed = force_build or build_mode is True
if build_allowed:
rmdir(build_folder)
rmdir(package_folder)
if force_build:
output.warn('Forced build from source')
self._build_package(export_folder, src_folder, build_folder, conan_file, output)
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file.deps_cpp_info,
conan_file.cpp_info).content)
output.info("Generated %s" % BUILD_INFO)
os.chdir(build_folder)
create_package(conan_file, build_folder, package_folder, output)
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def package(self, reference, package_id, only_manifest, package_all):
assert (isinstance(reference, ConanFileReference))
# Package paths
conan_file_path = self._paths.conanfile(reference)
if package_all:
if only_manifest:
packages_dir = self._paths.packages(reference)
else:
packages_dir = self._paths.builds(reference)
if not os.path.exists(packages_dir):
raise NotFoundException('%s does not exist' % str(reference))
packages = [
PackageReference(reference, packid)
for packid in os.listdir(packages_dir)
]
else:
packages = [PackageReference(reference, package_id)]
for package_reference in packages:
package_folder = self._paths.package(package_reference)
# Will read current conaninfo with specified options and load conanfile with them
if not only_manifest:
self._user_io.out.info("Packaging %s" %
package_reference.package_id)
build_folder = self._paths.build(package_reference)
# Small fix to package for short paths, without messing with the whole thing
link = os.path.join(build_folder, ".conan_link")
if os.path.exists(link):
build_folder = load(link)
loader = self._loader(build_folder)
conanfile = loader.load_conan(conan_file_path,
self._user_io.out)
rmdir(package_folder)
output = ScopedOutput(str(reference), self._user_io.out)
packager.create_package(conanfile, build_folder,
package_folder, output)
else:
self._user_io.out.info("Creating manifest for %s" %
package_reference.package_id)
if not os.path.exists(package_folder):
raise NotFoundException('Package %s does not exist' %
str(package_reference))
packager.generate_manifest(package_folder)
def export_pkg(self, reference, source_folder, build_folder, package_folder, install_folder, profile, force):
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" % str(reference))
remote_proxy = self.get_proxy()
loader = self.get_loader(profile)
conanfile = loader.load_virtual([reference], scope_options=True)
if install_folder and existing_info_files(install_folder):
_load_deps_info(install_folder, conanfile, required=True)
graph_builder = self._get_graph_builder(loader, remote_proxy)
deps_graph = graph_builder.load_graph(conanfile, check_updates=False, update=False)
# this is a bit tricky, but works. The loading of a cache package makes the referenced
# one, the first of the first level, always existing
nodes = deps_graph.direct_requires()
conanfile = nodes[0].conanfile
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = self._client_cache.package(pkg_reference,
short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException("Package already exists. Please use --force, -f to "
"overwrite it")
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
conanfile.develop = True
package_output = ScopedOutput(str(reference), self._user_io.out)
if package_folder:
packager.export_pkg(conanfile, package_folder, dest_package_folder, package_output)
else:
packager.create_package(conanfile, source_folder, build_folder, dest_package_folder,
install_folder, package_output, local=True)
def package(self):
"""Generate the info txt files and calls the conanfile package method.
"""
# FIXME: Is weak to assign here the recipe_hash
manifest = self._cache.package_layout(self._ref).recipe_manifest()
self._conan_file.info.recipe_hash = manifest.summary_hash
# Creating ***info.txt files
save(os.path.join(self.build_folder, CONANINFO), self._conan_file.info.dumps())
self._out.info("Generated %s" % CONANINFO)
save(os.path.join(self.build_folder, BUILD_INFO), TXTGenerator(self._conan_file).content)
self._out.info("Generated %s" % BUILD_INFO)
os.chdir(self.build_folder)
if getattr(self._conan_file, 'no_copy_source', False):
source_folder = self.source_folder
else:
source_folder = self.build_folder
with get_env_context_manager(self._conan_file):
install_folder = self.build_folder # While installing, the infos goes to build folder
pkg_id = self._pref.id
conanfile_path = self._cache.conanfile(self._ref)
create_package(self._conan_file, pkg_id, source_folder, self.build_folder,
self.package_folder, install_folder, self._hook_manager,
conanfile_path, self._ref)
layout = self._cache.package_layout(self._pref.ref, self._conan_file.short_paths)
package_hash = layout.package_summary_hash(self._pref)
package_id = self._pref.id
with self._cache.package_layout(self._ref).update_metadata() as metadata:
if metadata.packages[package_id].revision != package_hash:
metadata.packages[package_id].revision = package_hash
metadata.packages[package_id].recipe_revision = self._ref.revision
if get_env("CONAN_READ_ONLY_CACHE", False):
make_read_only(self.package_folder)
def package(self, reference, package_id):
assert(isinstance(reference, ConanFileReference))
# Package paths
conan_file_path = self._client_cache.conanfile(reference)
if not os.path.exists(conan_file_path):
raise ConanException("Package recipe '%s' does not exist" % str(reference))
if not package_id:
packages = [PackageReference(reference, packid)
for packid in self._client_cache.conan_builds(reference)]
if not packages:
raise NotFoundException("%s: Package recipe has not been built locally\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries" % str(reference))
else:
packages = [PackageReference(reference, package_id)]
for package_reference in packages:
build_folder = self._client_cache.build(package_reference, short_paths=None)
if not build_exists(build_folder):
raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n"
"Please read the 'conan package' command help\n"
"Use 'conan install' or 'conan test_package' to build and "
"create binaries"
% (str(reference), package_reference.package_id))
# The package already exist, we can use short_paths if they were defined
package_folder = self._client_cache.package(package_reference, short_paths=None)
# Will read current conaninfo with specified options and load conanfile with them
output = ScopedOutput(str(reference), self._user_io.out)
output.info("Re-packaging %s" % package_reference.package_id)
loader = self._loader(build_folder)
conanfile = loader.load_conan(conan_file_path, self._user_io.out)
rmdir(package_folder)
packager.create_package(conanfile, build_folder, package_folder, output)
def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
conan_ref = package_reference.conan
package_folder = self._paths.package(package_reference)
build_folder = self._paths.build(package_reference)
src_folder = self._paths.source(conan_ref)
export_folder = self._paths.export(conan_ref)
self._handle_system_requirements(conan_ref, package_reference,
conan_file)
# Check if package is corrupted
valid_package_digest = self._paths.valid_package_digest(
package_reference)
if os.path.exists(package_folder) and not valid_package_digest:
# If not valid package, ensure empty folder
self._user_io.out.warn("Bad package '%s' detected! Removing "
"package directory... " %
str(package_reference))
rmdir(package_folder)
# Check if any only_source pattern matches with package
force_build = self._force_build(conan_ref, build_mode)
if not force_build:
local_package = os.path.exists(package_folder)
if local_package:
self._user_io.out.info('Package for %s in %s' %
(str(conan_ref), package_folder))
return
self._user_io.out.info('Package for %s does not exist' %
str(conan_ref))
remote_package = self._retrieve_remote_package(package_reference)
if remote_package:
return
# Can we build? Only if we are forced or build_mode missing and package not exists
build_allowed = force_build or build_mode is True
if build_allowed:
rmdir(build_folder)
rmdir(package_folder)
if force_build:
self._user_io.out.warn('Forced build from source: "%s"' %
str(conan_ref))
self._build_package(export_folder, src_folder, build_folder,
conan_file)
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO),
conan_file.info.dumps())
self._user_io.out.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO),
repr(conan_file.deps_cpp_info))
self._user_io.out.info("Generated %s" % BUILD_INFO)
self._user_io.out.info("Generating the package")
os.chdir(build_folder)
create_package(conan_file, build_folder, package_folder,
self._user_io.out)
self._user_io.out.success('Package for "%s" installed in %s' %
(conan_ref, package_folder))
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
client.init_dynamic_vars()
files = hello_source_files()
conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
reg_folder = client.paths.export(conan_ref)
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"
},
path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
package_ref = PackageReference(conan_ref, "myfakeid")
build_folder = client.paths.build(package_ref)
package_folder = client.paths.package(package_ref)
shutil.copytree(reg_folder, build_folder)
output = ScopedOutput("", TestBufferConanOutput())
loader = ConanFileLoader(None, Settings(), Profile())
conanfile = loader.load_conan(conanfile_path, None)
create_package(conanfile,
build_folder,
build_folder,
package_folder,
output,
copy_info=True)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder,
CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
def complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
files = hello_source_files()
ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.cache.package_layout(ref).export()
client.save(files, path=reg_folder)
client.save({CONANFILE: myconan1,
"infos/%s" % CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"}, path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
pref = PackageReference(ref, "myfakeid")
build_folder = client.cache.package_layout(pref.ref).build(pref)
package_folder = client.cache.package_layout(pref.ref).package(pref)
install_folder = os.path.join(build_folder, "infos")
shutil.copytree(reg_folder, build_folder)
loader = ConanFileLoader(None, TestBufferConanOutput(), ConanPythonRequire(None, None))
conanfile = loader.load_consumer(conanfile_path, test_processed_profile())
create_package(conanfile, None, build_folder, build_folder, package_folder, install_folder,
client.hook_manager, conanfile_path, ref, copy_info=True)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder, CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
def _build_node(self, conan_ref, conan_file, build_mode):
# Compute conan_file package from local (already compiled) or from remote
output = ScopedOutput(str(conan_ref), self._out)
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
check_outdated = build_mode == "outdated"
conan_ref = package_reference.conan
package_folder = self._client_cache.package(package_reference,
conan_file.short_paths)
build_folder = self._client_cache.build(package_reference,
conan_file.short_paths)
src_folder = self._client_cache.source(conan_ref,
conan_file.short_paths)
export_folder = self._client_cache.export(conan_ref)
# If already exists do not dirt the output, the common situation
# is that package is already installed and OK. If don't, the proxy
# will print some other message about it
if not os.path.exists(package_folder):
output.info("Installing package %s" % package_id)
self._handle_system_requirements(conan_ref, package_reference,
conan_file, output)
force_build = self._build_forced(conan_ref, build_mode, conan_file)
if self._remote_proxy.get_package(package_reference,
force_build,
short_paths=conan_file.short_paths,
check_outdated=check_outdated):
return
# we need and can build? Only if we are forced or build_mode missing and package not exists
# Option "--build outdated" means: missing or outdated, so don't care if it's really oudated
# just build it.
build = force_build or build_mode is True or check_outdated or conan_file.build_policy_missing
if build:
if not force_build and not build_mode:
output.info(
"Building package from source as defined by build_policy='missing'"
)
try:
rmdir(build_folder)
rmdir(package_folder)
except Exception as e:
raise ConanException(
"%s\n\nCouldn't remove folder, might be busy or open\n"
"Close any app using it, and retry" % str(e))
if force_build:
output.warn('Forced build from source')
with environment_append(conan_file.env):
self._build_package(export_folder, src_folder, build_folder,
conan_file, output)
# FIXME: Is weak to assign here the recipe_hash
conan_file.info.recipe_hash = self._client_cache.load_manifest(
conan_ref).summary_hash
# Creating ***info.txt files
save(os.path.join(build_folder, CONANINFO),
conan_file.info.dumps())
output.info("Generated %s" % CONANINFO)
save(os.path.join(build_folder, BUILD_INFO),
TXTGenerator(conan_file).content)
output.info("Generated %s" % BUILD_INFO)
save(os.path.join(build_folder, CONANENV),
ConanEnvGenerator(conan_file).content)
output.info("Generated %s" % CONANENV)
os.chdir(build_folder)
with environment_append(conan_file.env):
create_package(conan_file, build_folder, package_folder,
output)
self._remote_proxy.handle_package_manifest(package_reference,
installed=True)
else:
self._raise_package_not_found_error(conan_ref, conan_file)
def complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
client.init_dynamic_vars()
files = hello_source_files()
conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
reg_folder = client.paths.export(conan_ref)
client.save(files, path=reg_folder)
client.save({CONANFILE: myconan1,
CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"}, path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
package_ref = PackageReference(conan_ref, "myfakeid")
build_folder = client.paths.build(package_ref)
package_folder = client.paths.package(package_ref)
shutil.copytree(reg_folder, build_folder)
loader = ConanFileLoader(None, Settings(), OptionsValues.loads(""))
conanfile = loader.load_conan(conanfile_path, None)
output = ScopedOutput("", TestBufferConanOutput())
create_package(conanfile, build_folder, package_folder, output)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder, CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
