def create_package(conanfile,
source_folder,
build_folder,
package_folder,
install_folder,
output,
local=False,
copy_info=False):
""" copies built artifacts, libs, headers, data, etc from build_folder to
package folder
"""
mkdir(package_folder)
# Make the copy of all the patterns
output.info("Generating the package")
output.info("Package folder %s" % (package_folder))
try:
package_output = ScopedOutput("%s package()" % output.scope, output)
output.highlight("Calling package()")
conanfile.package_folder = package_folder
conanfile.source_folder = source_folder
conanfile.install_folder = install_folder
conanfile.build_folder = build_folder
def recipe_has(conanfile, attribute):
return attribute in conanfile.__class__.__dict__
if source_folder != build_folder:
conanfile.copy = FileCopier(source_folder, package_folder,
build_folder)
with conanfile_exception_formatter(str(conanfile), "package"):
with tools.chdir(source_folder):
conanfile.package()
warn = recipe_has(conanfile, "package")
conanfile.copy.report(package_output, warn=warn)
conanfile.copy = FileCopier(build_folder, package_folder)
with tools.chdir(build_folder):
with conanfile_exception_formatter(str(conanfile), "package"):
conanfile.package()
warn = recipe_has(conanfile, "build") and recipe_has(
conanfile, "package")
conanfile.copy.report(package_output, warn=warn)
except Exception as e:
if not local:
os.chdir(build_folder)
try:
rmdir(package_folder)
except Exception as e_rm:
output.error("Unable to remove package folder %s\n%s" %
(package_folder, str(e_rm)))
output.warn("**** Please delete it manually ****")
if isinstance(e, ConanExceptionInUserConanfileMethod):
raise
raise ConanException(e)
_create_aux_files(install_folder, package_folder, conanfile, copy_info)
output.success("Package '%s' created" % os.path.basename(package_folder))
def test_ignore_case_excludes(self):
src_folder = temp_folder()
save(os.path.join(src_folder, "file.h"), "")
save(os.path.join(src_folder, "AttributeStorage.h"), "")
save(os.path.join(src_folder, "sub/file.h"), "")
save(os.path.join(src_folder, "sub/AttributeStorage.h"), "")
dst_folder = temp_folder()
copier = FileCopier([src_folder], dst_folder)
# Exclude pattern will match AttributeStorage
copier("*.h", excludes="*Test*", dst="include")
self.assertEqual(["include"], os.listdir(dst_folder))
self.assertEqual(
sorted(["file.h", "sub"]),
sorted(os.listdir(os.path.join(dst_folder, "include"))))
self.assertEqual(["file.h"],
os.listdir(os.path.join(dst_folder, "include",
"sub")))
dst_folder = temp_folder()
copier = FileCopier([src_folder], dst_folder)
# Exclude pattern will not match AttributeStorage if ignore_case=False
copier("*.h", excludes="*Test*", dst="include", ignore_case=False)
self.assertEqual(["include"], os.listdir(dst_folder))
self.assertEqual(
sorted(["AttributeStorage.h", "file.h", "sub"]),
sorted(os.listdir(os.path.join(dst_folder, "include"))))
self.assertEqual(
sorted(["AttributeStorage.h", "file.h"]),
sorted(os.listdir(os.path.join(dst_folder, "include", "sub"))))
def excludes_test(self):
folder1 = temp_folder()
sub1 = os.path.join(folder1, "subdir1")
save(os.path.join(sub1, "file1.txt"), "Hello1")
save(os.path.join(sub1, "file2.c"), "Hello2")
folder2 = temp_folder()
copier = FileCopier([folder1], folder2)
copier("*.*", "texts", excludes="*.c")
self.assertEqual(['file1.txt'],
os.listdir(os.path.join(folder2, "texts/subdir1")))
folder1 = temp_folder()
save(os.path.join(folder1, "MyLib.txt"), "")
save(os.path.join(folder1, "MyLibImpl.txt"), "")
save(os.path.join(folder1, "MyLibTests.txt"), "")
folder2 = temp_folder()
copier = FileCopier([folder1], folder2)
copier("*.txt", excludes="*Test*.txt")
self.assertEqual(set(['MyLib.txt', 'MyLibImpl.txt']),
set(os.listdir(folder2)))
folder2 = temp_folder()
copier = FileCopier([folder1], folder2)
copier("*.txt", excludes=("*Test*.txt", "*Impl*"))
self.assertEqual(['MyLib.txt'], os.listdir(folder2))
def execute_export(conanfile, origin_folder, destination_folder, output, filename=None):
def classify_patterns(patterns):
patterns = patterns or []
included, excluded = [], []
for p in patterns:
if p.startswith("!"):
excluded.append(p[1:])
else:
included.append(p)
return included, excluded
included_exports, excluded_exports = classify_patterns(conanfile.exports)
included_sources, excluded_sources = classify_patterns(conanfile.exports_sources)
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except:
pass
copier = FileCopier(origin_folder, destination_folder)
for pattern in included_exports:
copier(pattern, links=True, excludes=excluded_exports)
# create directory for sources, and import them
export_sources_dir = os.path.join(destination_folder, EXPORT_SOURCES_DIR)
mkdir(export_sources_dir)
copier = FileCopier(origin_folder, export_sources_dir)
for pattern in included_sources:
copier(pattern, links=True, excludes=excluded_sources)
package_output = ScopedOutput("%s export" % output.scope, output)
copier.report(package_output)
shutil.copy2(os.path.join(origin_folder, filename or CONANFILE),
os.path.join(destination_folder, CONANFILE))
def export_recipe(conanfile, origin_folder, destination_folder):
if isinstance(conanfile.exports, str):
conanfile.exports = (conanfile.exports, )
output = conanfile.output
package_output = ScopedOutput("%s exports" % output.scope, output)
if os.path.exists(os.path.join(origin_folder, DATA_YML)):
package_output.info(
"File '{}' found. Exporting it...".format(DATA_YML))
tmp = [DATA_YML]
if conanfile.exports:
tmp.extend(conanfile.exports
) # conanfile.exports could be a tuple (immutable)
conanfile.exports = tmp
included_exports, excluded_exports = _classify_patterns(conanfile.exports)
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except OSError:
pass
copier = FileCopier([origin_folder], destination_folder)
for pattern in included_exports:
copier(pattern, links=True, excludes=excluded_exports)
copier.report(package_output)
def basic_test(self):
folder1 = temp_folder()
sub1 = os.path.join(folder1, "subdir1")
sub2 = os.path.join(folder1, "subdir2")
save(os.path.join(sub1, "file1.txt"), "Hello1")
save(os.path.join(sub1, "file2.c"), "Hello2")
save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")
save(os.path.join(sub1, "sub1/file2.c"), "Hello2 sub")
save(os.path.join(sub2, "file1.txt"), "2 Hello1")
save(os.path.join(sub2, "file2.c"), "2 Hello2")
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.txt", "texts")
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt")))
self.assertEqual("2 Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt")))
self.assertEqual(['file1.txt'], os.listdir(os.path.join(folder2, "texts/subdir2")))
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.txt", "texts", "subdir1")
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt")))
self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
def basic_with_linked_dir_test(self):
if platform.system() == "Linux" or platform.system() == "Darwin":
folder1 = temp_folder()
sub1 = os.path.join(folder1, "subdir1")
sub2 = os.path.join(folder1, "subdir2")
os.makedirs(sub1)
os.symlink("subdir1", sub2)
save(os.path.join(sub1, "file1.txt"), "Hello1")
save(os.path.join(sub1, "file2.c"), "Hello2")
save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.txt", "texts")
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt")))
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt")))
self.assertEqual(['file1.txt', 'sub1'].sort(), os.listdir(os.path.join(folder2, "texts/subdir2")).sort())
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.txt", "texts", "subdir1")
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt")))
self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
def basic_with_linked_dir_test(self):
folder1 = temp_folder()
sub1 = os.path.join(folder1, "subdir1")
sub2 = os.path.join(folder1, "subdir2")
os.makedirs(sub1)
os.symlink("subdir1", sub2) # @UndefinedVariable
save(os.path.join(sub1, "file1.txt"), "Hello1")
save(os.path.join(sub1, "file2.c"), "Hello2")
save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")
for links in (False, True):
folder2 = temp_folder()
copier = FileCopier([folder1], folder2)
copier("*.txt", "texts", links=links)
if links:
self.assertEqual(os.readlink(os.path.join(folder2, "texts/subdir2")), "subdir1") # @UndefinedVariable
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt")))
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt")))
self.assertEqual(['file1.txt', 'sub1'].sort(), os.listdir(os.path.join(folder2, "texts/subdir2")).sort())
for links in (False, True):
folder2 = temp_folder()
copier = FileCopier([folder1], folder2)
copier("*.txt", "texts", "subdir1", links=links)
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt")))
self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
def export_pkg(conanfile, pkg_id, src_package_folder, package_folder, output,
hook_manager, conanfile_path, reference):
mkdir(package_folder)
conanfile.package_folder = src_package_folder
output.info("Exporting to cache existing package from user folder")
output.info("Package folder %s" % package_folder)
hook_manager.execute("pre_package",
conanfile=conanfile,
conanfile_path=conanfile_path,
reference=reference,
package_id=pkg_id)
copier = FileCopier(src_package_folder, package_folder)
copier("*", symlinks=True)
copy_done = copier.report(output)
if not copy_done:
output.warn("No files copied from package folder!")
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
digest = FileTreeManifest.create(package_folder)
digest.save(package_folder)
output.success("Package '%s' created" % pkg_id)
conanfile.package_folder = package_folder
hook_manager.execute("post_package",
conanfile=conanfile,
conanfile_path=conanfile_path,
reference=reference,
package_id=pkg_id)
def create_package(conanfile,
source_folder,
build_folder,
package_folder,
output,
local=False,
copy_info=False):
""" copies built artifacts, libs, headers, data, etc from build_folder to
package folder
"""
mkdir(package_folder)
# Make the copy of all the patterns
output.info("Generating the package")
output.info("Package folder %s" % (package_folder))
def wrap(dst_folder):
def new_method(pattern, src=""):
conanfile.copy(pattern, dst_folder, src)
return new_method
# FIXME: Deprecate these methods. Not documented. Confusing. Rely on LINTER
conanfile.copy_headers = wrap(DEFAULT_INCLUDE)
conanfile.copy_libs = wrap(DEFAULT_LIB)
conanfile.copy_bins = wrap(DEFAULT_BIN)
conanfile.copy_res = wrap(DEFAULT_RES)
try:
package_output = ScopedOutput("%s package()" % output.scope, output)
output.highlight("Calling package()")
if source_folder != build_folder:
conanfile.copy = FileCopier(source_folder, package_folder,
build_folder)
with conanfile_exception_formatter(str(conanfile), "package"):
conanfile.package()
conanfile.copy.report(package_output, warn=True)
conanfile.copy = FileCopier(build_folder, package_folder)
with conanfile_exception_formatter(str(conanfile), "package"):
conanfile.package()
conanfile.copy.report(package_output, warn=True)
except Exception as e:
if not local:
os.chdir(build_folder)
try:
rmdir(package_folder)
except Exception as e_rm:
output.error("Unable to remove package folder %s\n%s" %
(package_folder, str(e_rm)))
output.warn("**** Please delete it manually ****")
if isinstance(e, ConanExceptionInUserConanfileMethod):
raise
raise ConanException(e)
_create_aux_files(build_folder, package_folder, conanfile, copy_info)
output.success("Package '%s' created" % os.path.basename(package_folder))
def export_source(conanfile, origin_folder, destination_source_folder):
if isinstance(conanfile.exports_sources, str):
conanfile.exports_sources = (conanfile.exports_sources, )
included_sources, excluded_sources = _classify_patterns(conanfile.exports_sources)
copier = FileCopier([origin_folder], destination_source_folder)
for pattern in included_sources:
copier(pattern, links=True, excludes=excluded_sources)
output = conanfile.output
package_output = ScopedOutput("%s exports_sources" % output.scope, output)
copier.report(package_output)
def execute(self):
""" Execute the stored requested copies, using a FileCopier as helper
"""
root_src_folder = self._paths.store
file_copier = FileCopier(root_src_folder, self._dst_folder)
for pattern, dst_folder, src_folder, conan_name_pattern in self._copies:
real_dst_folder = os.path.normpath(os.path.join(self._dst_folder, dst_folder))
matching_paths = self._get_paths(conan_name_pattern)
for matching_path in matching_paths:
real_src_folder = os.path.join(matching_path, src_folder)
file_copier(pattern, real_dst_folder, real_src_folder)
file_copier.execute()
def create_package(conanfile, package_id, source_folder, build_folder, package_folder,
install_folder, hook_manager, conanfile_path, ref, local=False,
copy_info=False):
""" copies built artifacts, libs, headers, data, etc. from build_folder to
package folder
"""
mkdir(package_folder)
output = conanfile.output
# Make the copy of all the patterns
output.info("Generating the package")
output.info("Package folder %s" % package_folder)
try:
conanfile.package_folder = package_folder
conanfile.source_folder = source_folder
conanfile.install_folder = install_folder
conanfile.build_folder = build_folder
hook_manager.execute("pre_package", conanfile=conanfile, conanfile_path=conanfile_path,
reference=ref, package_id=package_id)
package_output = ScopedOutput("%s package()" % output.scope, output)
output.highlight("Calling package()")
if source_folder != build_folder:
conanfile.copy = FileCopier(source_folder, package_folder, build_folder)
with conanfile_exception_formatter(str(conanfile), "package"):
with tools.chdir(source_folder):
conanfile.package()
conanfile.copy = FileCopier(build_folder, package_folder)
with tools.chdir(build_folder):
with conanfile_exception_formatter(str(conanfile), "package"):
conanfile.package()
except Exception as e:
if not local:
os.chdir(build_folder)
try:
rmdir(package_folder)
except Exception as e_rm:
output.error("Unable to remove package folder %s\n%s" % (package_folder, str(e_rm)))
output.warn("**** Please delete it manually ****")
if isinstance(e, ConanExceptionInUserConanfileMethod):
raise
raise ConanException(e)
_create_aux_files(install_folder, package_folder, conanfile, copy_info)
_report_files_from_manifest(package_output, package_folder)
package_id = package_id or os.path.basename(package_folder)
output.success("Package '%s' created" % package_id)
hook_manager.execute("post_package", conanfile=conanfile, conanfile_path=conanfile_path,
reference=ref, package_id=package_id)
def execute(self):
""" Execute the stored requested copies, using a FileCopier as helper
"""
root_src_folder = self._paths.store
file_copier = FileCopier(root_src_folder, self._dst_folder)
for pattern, dst_folder, src_folder, conan_name_pattern in self._copies:
real_dst_folder = os.path.normpath(
os.path.join(self._dst_folder, dst_folder))
matching_paths = self._get_paths(conan_name_pattern)
for matching_path in matching_paths:
real_src_folder = os.path.join(matching_path, src_folder)
file_copier(pattern, real_dst_folder, real_src_folder)
file_copier.execute()
def _export(file_patterns, origin_folder, destination_folder):
file_patterns = file_patterns or []
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except:
pass
copier = FileCopier(origin_folder, destination_folder)
for pattern in file_patterns:
copier(pattern)
copier.execute()
shutil.copy2(os.path.join(origin_folder, CONANFILE), destination_folder)
def _export(file_patterns, origin_folder, destination_folder):
file_patterns = file_patterns or []
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except:
pass
copier = FileCopier(origin_folder, destination_folder)
for pattern in file_patterns:
copier(pattern)
copier.execute()
shutil.copy2(os.path.join(origin_folder, CONANFILE), destination_folder)
def _export(file_patterns, origin_folder, destination_folder, output):
file_patterns = file_patterns or []
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except:
pass
copier = FileCopier(origin_folder, destination_folder)
for pattern in file_patterns:
copier(pattern)
package_output = ScopedOutput("%s export" % output.scope, output)
copier.report(package_output)
shutil.copy2(os.path.join(origin_folder, CONANFILE), destination_folder)
def export_pkg(conanfile, src_package_folder, package_folder, output):
mkdir(package_folder)
output.info("Exporting to cache existing package from user folder")
output.info("Package folder %s" % (package_folder))
copier = FileCopier(src_package_folder, package_folder)
copier("*", symlinks=True)
copier.report(output, warn=True)
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
digest = FileTreeManifest.create(package_folder)
save(os.path.join(package_folder, CONAN_MANIFEST), str(digest))
output.success("Package '%s' created" % os.path.basename(package_folder))
def _export(file_patterns, origin_folder, destination_folder, output):
file_patterns = file_patterns or []
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except:
pass
copier = FileCopier(origin_folder, destination_folder)
for pattern in file_patterns:
copier(pattern)
package_output = ScopedOutput("%s export" % output.scope, output)
copier.report(package_output)
shutil.copy2(os.path.join(origin_folder, CONANFILE), destination_folder)
def create_package(conanfile, build_folder, package_folder, output):
""" copies built artifacts, libs, headers, data, etc from build_folder to
package folder
"""
mkdir(package_folder)
# Make the copy of all the patterns
output.info("Copying files to %s" % (package_folder))
conanfile.copy = FileCopier(build_folder, package_folder)
def wrap(dst_folder):
def new_method(pattern, src=""):
conanfile.copy(pattern, dst_folder, src)
return new_method
conanfile.copy_headers = wrap(DEFAULT_INCLUDE)
conanfile.copy_libs = wrap(DEFAULT_LIB)
conanfile.copy_bins = wrap(DEFAULT_BIN)
conanfile.copy_res = wrap(DEFAULT_RES)
try:
conanfile.package()
conanfile.copy.execute()
except Exception as e:
os.chdir(build_folder)
try:
shutil.rmtree(package_folder)
except Exception as e_rm:
output.error("Unable to remove package folder %s\n%s"
% (package_folder, str(e_rm)))
output.warn("**** Please delete it manually ****")
raise ConanException("%s: %s" % (conanfile.name, str(e)))
_create_aux_files(build_folder, package_folder)
output.success("Created '%s' package." % os.path.basename(package_folder))
def linked_folder_copy_from_linked_folder_test(self):
# https://github.com/conan-io/conan/issues/5114
folder1 = temp_folder(path_with_spaces=False)
sub_src = os.path.join(folder1, "sub/src")
src = os.path.join(folder1, "src")
src_dir = os.path.join(folder1, "src/dir")
src_dir_link = os.path.join(folder1, "src/dir_link")
src_dir_file = os.path.join(src_dir, "file.txt")
dst = os.path.join(folder1, "dst")
dst_dir = os.path.join(folder1, "dst/dir")
dst_dir_link = os.path.join(folder1, "dst/dir_link")
dst_dir_file = os.path.join(dst_dir, "file.txt")
os.makedirs(dst)
os.makedirs(sub_src)
# input src folder should be a symlink
os.symlink(sub_src, src)
# folder, file and folder link to copy
os.mkdir(src_dir)
save(src_dir_file, "file")
os.symlink(src_dir, src_dir_link)
copier = FileCopier([src], dst)
copied = copier("*", symlinks=True)
self.assertEqual(copied, [dst_dir_file])
self.assertEqual(os.listdir(dst), os.listdir(src))
self.assertTrue(os.path.islink(dst_dir_link))
def linked_folder_missing_error_test(self):
if platform.system() != "Linux" and platform.system() != "Darwin":
return
folder1 = temp_folder()
sub1 = os.path.join(folder1, "subdir1")
sub2 = os.path.join(folder1, "subdir2")
os.makedirs(sub1)
os.symlink("subdir1", sub2)
save(os.path.join(sub1, "file1.txt"), "Hello1")
save(os.path.join(sub1, "file2.c"), "Hello2")
save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.cpp", links=True)
self.assertEqual(len(os.listdir(folder2)), 0)
copier("*.txt", links=True)
self.assertEqual(sorted(os.listdir(folder2)),
sorted(["subdir1", "subdir2"]))
self.assertEqual(os.readlink(os.path.join(folder2, "subdir2")),
"subdir1")
self.assertEqual("Hello1",
load(os.path.join(folder2, "subdir1/file1.txt")))
self.assertEqual("Hello1",
load(os.path.join(folder2, "subdir2/file1.txt")))
def export_recipe(conanfile, origin_folder, destination_folder, output):
if isinstance(conanfile.exports, str):
conanfile.exports = (conanfile.exports, )
included_exports, excluded_exports = _classify_patterns(conanfile.exports)
try:
os.unlink(os.path.join(origin_folder, CONANFILE + 'c'))
except OSError:
pass
copier = FileCopier(origin_folder, destination_folder)
for pattern in included_exports:
copier(pattern, links=True, excludes=excluded_exports)
package_output = ScopedOutput("%s exports" % output.scope, output)
copier.report(package_output)
def _package_cppinfo(self, origin_name, origin_cppinfo, dest_cppinfo):
"""
@param origin_name: one from ["source", "build"]
@param origin_cppinfo: cpp_info object of an origin (can be a component cppinfo too)
@param dest_cppinfo: cpp_info object of the package or a component from package
"""
patterns_var = getattr(self.patterns, origin_name)
base_folder = getattr(self._conanfile, "{}_folder".format(origin_name))
for var in [
"include", "lib", "bin", "framework", "src", "build", "res"
]:
dirs_var_name = "{}dirs".format(var)
origin_paths = getattr(origin_cppinfo, dirs_var_name)
if not origin_paths:
continue
patterns = getattr(patterns_var, var)
destinations = getattr(dest_cppinfo, dirs_var_name)
if not destinations: # For example: Not declared "includedirs" in package.cpp_info
continue
if len(destinations) > 1:
# Check if there is only one possible destination at package, otherwise the
# copy would need to be done manually
err_msg = "The package has more than 1 cpp_info.{}, cannot package automatically"
raise ConanException(err_msg.format(dirs_var_name))
for d in origin_paths:
copier = FileCopier([os.path.join(base_folder, d)],
self._conanfile.folders.base_package)
for pattern in patterns:
copier(pattern, dst=destinations[0])
def _call_package(conanfile, package_id, source_folder, build_folder, package_folder,
install_folder, hook_manager, conanfile_path, ref, copy_info):
output = conanfile.output
hook_manager.execute("pre_package", conanfile=conanfile, conanfile_path=conanfile_path,
reference=ref, package_id=package_id)
output.highlight("Calling package()")
folders = [source_folder, build_folder] if source_folder != build_folder else [build_folder]
conanfile.copy = FileCopier(folders, package_folder)
with conanfile_exception_formatter(str(conanfile), "package"):
with chdir(build_folder):
with conan_v2_property(conanfile, 'info',
"'self.info' access in package() method is deprecated"):
conanfile.package()
hook_manager.execute("post_package", conanfile=conanfile, conanfile_path=conanfile_path,
reference=ref, package_id=package_id)
manifest = _create_aux_files(install_folder, package_folder, conanfile, copy_info)
package_output = ScopedOutput("%s package()" % output.scope, output)
report_files_from_manifest(package_output, manifest)
package_id = package_id or os.path.basename(package_folder)
output.success("Package '%s' created" % package_id)
prev = manifest.summary_hash
output.info("Created package revision %s" % prev)
return prev
def export_pkg(conanfile, package_id, src_package_folder, package_folder,
hook_manager, conanfile_path, ref):
mkdir(package_folder)
conanfile.package_folder = package_folder
output = conanfile.output
output.info("Exporting to cache existing package from user folder")
output.info("Package folder %s" % package_folder)
hook_manager.execute("pre_package",
conanfile=conanfile,
conanfile_path=conanfile_path,
reference=ref,
package_id=package_id)
copier = FileCopier([src_package_folder], package_folder)
copier("*", symlinks=True)
conanfile.package_folder = package_folder
hook_manager.execute("post_package",
conanfile=conanfile,
conanfile_path=conanfile_path,
reference=ref,
package_id=package_id)
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
manifest = FileTreeManifest.create(package_folder)
manifest.save(package_folder)
_report_files_from_manifest(output, manifest)
output.success("Package '%s' created" % package_id)
prev = manifest.summary_hash
output.info("Created package revision %s" % prev)
return prev
def __call__(self,
pattern,
dst="",
src="",
root_package=None,
folder=False,
ignore_case=False,
excludes=None):
"""
param pattern: an fnmatch file pattern of the files that should be copied. Eg. *.dll
param dst: the destination local folder, wrt to current conanfile dir, to which
the files will be copied. Eg: "bin"
param src: the source folder in which those files will be searched. This folder
will be stripped from the dst name. Eg.: lib/Debug/x86
param root_package: fnmatch pattern of the package name ("OpenCV", "Boost") from
which files will be copied. Default: all packages in deps
"""
if os.path.isabs(dst):
real_dst_folder = dst
else:
real_dst_folder = os.path.normpath(
os.path.join(self._dst_folder, dst))
matching_paths = self._get_folders(root_package)
for name, matching_path in matching_paths.items():
final_dst_path = os.path.join(real_dst_folder,
name) if folder else real_dst_folder
file_copier = FileCopier(matching_path, final_dst_path)
files = file_copier(pattern,
src=src,
links=True,
ignore_case=ignore_case,
excludes=excludes)
self.copied_files.update(files)
def export_pkg(conanfile, src_package_folder, package_folder, output):
mkdir(package_folder)
output.info("Exporting to cache existing package from user folder")
output.info("Package folder %s" % package_folder)
copier = FileCopier(src_package_folder, package_folder)
copier("*", symlinks=True)
copy_done = copier.report(output)
if not copy_done:
output.warn("No files copied from package folder!")
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
digest = FileTreeManifest.create(package_folder)
digest.save(package_folder)
output.success("Package '%s' created" % os.path.basename(package_folder))
def export_pkg(conanfile, src_package_folder, package_folder, output):
mkdir(package_folder)
output.info("Exporting to cache existing package from user folder")
output.info("Package folder %s" % package_folder)
copier = FileCopier(src_package_folder, package_folder)
copier("*", symlinks=True)
copy_done = copier.report(output)
if not copy_done:
output.warn("No files copied from package folder!")
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
digest = FileTreeManifest.create(package_folder)
digest.save(package_folder)
output.success("Package '%s' created" % os.path.basename(package_folder))
def test_ignore_case(self):
src_folder = temp_folder()
save(os.path.join(src_folder, "FooBar.txt"), "Hello")
dst_folder = temp_folder()
copier = FileCopier([src_folder], dst_folder)
copier("foobar.txt", ignore_case=False)
self.assertEqual([], os.listdir(dst_folder))
dst_folder = temp_folder()
copier = FileCopier([src_folder], dst_folder)
copier("FooBar.txt", ignore_case=False)
self.assertEqual(["FooBar.txt"], os.listdir(dst_folder))
dst_folder = temp_folder()
copier = FileCopier([src_folder], dst_folder)
copier("foobar.txt", ignore_case=True)
self.assertEqual(["FooBar.txt"], os.listdir(dst_folder))
def __call__(self,
pattern,
dst="",
src="",
root_package=None,
folder=False,
ignore_case=True,
excludes=None,
keep_path=True):
"""
param pattern: an fnmatch file pattern of the files that should be copied. Eg. *.dll
param dst: the destination local folder, wrt to current conanfile dir, to which
the files will be copied. Eg: "bin"
param src: the source folder in which those files will be searched. This folder
will be stripped from the dst name. Eg.: lib/Debug/x86
param root_package: fnmatch pattern of the package name ("OpenCV", "Boost") from
which files will be copied. Default: all packages in deps
"""
if os.path.isabs(dst):
real_dst_folder = dst
else:
real_dst_folder = os.path.normpath(
os.path.join(self._dst_folder, dst))
pkgs = (
self._conanfile.deps_cpp_info.dependencies if not root_package else
[(pkg, cpp_info)
for pkg, cpp_info in self._conanfile.deps_cpp_info.dependencies
if fnmatch.fnmatch(pkg, root_package)])
symbolic_dir_name = src[1:] if src.startswith("@") else None
src_dirs = [src] # hardcoded src="bin" origin
for pkg_name, cpp_info in pkgs:
final_dst_path = os.path.join(
real_dst_folder, pkg_name) if folder else real_dst_folder
file_copier = FileCopier([cpp_info.rootpath], final_dst_path)
if symbolic_dir_name: # Syntax for package folder symbolic names instead of hardcoded
try:
src_dirs = getattr(cpp_info, symbolic_dir_name)
if not isinstance(
src_dirs,
list): # it can return a "config" CppInfo item!
raise AttributeError
except AttributeError:
raise ConanException(
"Import from unknown package folder '@%s'" %
symbolic_dir_name)
for src_dir in src_dirs:
files = file_copier(pattern,
src=src_dir,
links=True,
ignore_case=ignore_case,
excludes=excludes,
keep_path=keep_path)
self.copied_files.update(files)
def merge_directories(src, dst, excluded=None, symlinks=True):
src = os.path.normpath(src)
dst = os.path.normpath(dst)
excluded = excluded or []
excluded = [os.path.normpath(entry) for entry in excluded]
def is_excluded(origin_path):
if origin_path == dst:
return True
rel_path = os.path.normpath(os.path.relpath(origin_path, src))
if rel_path in excluded:
return True
return False
linked_folders = []
for src_dir, dirs, files in walk(src, followlinks=True):
if is_excluded(src_dir):
dirs[:] = []
continue
if os.path.islink(src_dir):
rel_link = os.path.relpath(src_dir, src)
linked_folders.append(rel_link)
continue
# Overwriting the dirs will prevents walk to get into them
files[:] = [d for d in files if not is_excluded(os.path.join(src_dir, d))]
dst_dir = os.path.normpath(os.path.join(dst, os.path.relpath(src_dir, src)))
if not os.path.exists(dst_dir):
os.makedirs(dst_dir)
for file_ in files:
src_file = os.path.join(src_dir, file_)
dst_file = os.path.join(dst_dir, file_)
if os.path.islink(src_file) and symlinks:
linkto = os.readlink(src_file)
os.symlink(linkto, dst_file)
else:
shutil.copy2(src_file, dst_file)
FileCopier.link_folders(src, dst, linked_folders)
def multifolder_test(self):
src_folder1 = temp_folder()
src_folder2 = temp_folder()
save(os.path.join(src_folder1, "file1.txt"), "Hello1")
save(os.path.join(src_folder2, "file2.txt"), "Hello2")
dst_folder = temp_folder()
copier = FileCopier([src_folder1, src_folder2], dst_folder)
copier("*")
self.assertEqual(['file1.txt', 'file2.txt'],
sorted(os.listdir(dst_folder)))
def _run_method(conanfile, method, origin_folder, destination_folder, output):
export_method = getattr(conanfile, method, None)
if export_method:
if not callable(export_method):
raise ConanException("conanfile '%s' must be a method" % method)
output.highlight("Calling %s()" % method)
copier = FileCopier([origin_folder], destination_folder)
conanfile.copy = copier
default_options = conanfile.default_options
try:
# TODO: Poor man attribute control access. Convert to nice decorator
conanfile.default_options = None
with chdir(origin_folder):
with conanfile_exception_formatter(str(conanfile), method):
export_method()
finally:
conanfile.default_options = default_options
export_method_output = ScopedOutput(
"%s %s() method" % (output.scope, method), output)
copier.report(export_method_output)
def export_source(conanfile, origin_folder, destination_source_folder):
if callable(conanfile.exports_sources):
raise ConanException(
"conanfile 'exports_sources' shouldn't be a method, "
"use 'export_sources()' instead")
if isinstance(conanfile.exports_sources, str):
conanfile.exports_sources = (conanfile.exports_sources, )
included_sources, excluded_sources = _classify_patterns(
conanfile.exports_sources)
copier = FileCopier([origin_folder], destination_source_folder)
for pattern in included_sources:
copier(pattern, links=True, excludes=excluded_sources)
output = conanfile.output
package_output = ScopedOutput("%s exports_sources" % output.scope, output)
copier.report(package_output)
_run_method(conanfile, "export_sources", origin_folder,
destination_source_folder, output)
def basic_test(self):
folder1 = temp_folder()
sub1 = os.path.join(folder1, "subdir1")
sub2 = os.path.join(folder1, "subdir2")
save(os.path.join(sub1, "file1.txt"), "Hello1")
save(os.path.join(sub1, "file2.c"), "Hello2")
save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")
save(os.path.join(sub1, "sub1/file2.c"), "Hello2 sub")
save(os.path.join(sub2, "file1.txt"), "2 Hello1")
save(os.path.join(sub2, "file2.c"), "2 Hello2")
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.txt", "texts")
copier.execute()
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt")))
self.assertEqual("2 Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt")))
self.assertEqual(['file1.txt'], os.listdir(os.path.join(folder2, "texts/subdir2")))
folder2 = temp_folder()
copier = FileCopier(folder1, folder2)
copier("*.txt", "texts", "subdir1")
copier.execute()
self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt")))
self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt")))
self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
