def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
child = CppInfo("Boost", "F:")
child.filter_empty = False
child.includedirs.append("ChildrenPath")
child.cxxflags.append("cxxmyflag")
deps_cpp_info.add("Boost", DepCppInfo(child))
fakeconan = namedtuple(
"Conanfile",
"deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info"
)
output = TXTGenerator(
fakeconan(deps_cpp_info, None, deps_env_info, None, {},
defaultdict(dict))).content
deps_cpp_info2, _, _, _ = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cxxflags,
deps_cpp_info2["Boost"].cxxflags)
self.assertEqual(deps_cpp_info["Boost"].cxxflags, ["cxxmyflag"])
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple(
"Conanfile",
"deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info"
)
output = TXTGenerator(
fakeconan(deps_cpp_info, None, deps_env_info, None, {},
defaultdict(dict))).content
deps_cpp_info2, _ = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
def parse_test(self):
text = """[includedirs]
C:/Whenever
[includedirs_Boost]
F:/ChildrenPath
[includedirs_My_Lib]
mylib_path
[includedirs_My_Other_Lib]
otherlib_path
[includedirs_My.Component.Lib]
my_component_lib
[includedirs_My-Component-Tool]
my-component-tool
"""
deps_cpp_info, _, _ = TXTGenerator.loads(text)
def assert_cpp(deps_cpp_info_test):
self.assertEqual(deps_cpp_info_test.includedirs, ['C:/Whenever'])
self.assertEqual(deps_cpp_info_test["Boost"].includedirs,
['F:/ChildrenPath'])
self.assertEqual(deps_cpp_info_test["My_Lib"].includedirs,
['mylib_path'])
self.assertEqual(deps_cpp_info_test["My_Other_Lib"].includedirs,
['otherlib_path'])
self.assertEqual(
deps_cpp_info_test["My-Component-Tool"].includedirs,
['my-component-tool'])
assert_cpp(deps_cpp_info)
# Now adding env_info
text2 = text + """
[ENV_LIBA]
VAR2=23
"""
deps_cpp_info, _, deps_env_info = TXTGenerator.loads(text2)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_env_info["LIBA"].VAR2, "23")
# Now only with user info
text3 = text + """
[USER_LIBA]
VAR2=23
"""
deps_cpp_info, deps_user_info, _ = TXTGenerator.loads(text3)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_user_info["LIBA"].VAR2, "23")
# Now with all
text4 = text + """
[USER_LIBA]
VAR2=23
[ENV_LIBA]
VAR2=23
"""
deps_cpp_info, deps_user_info, deps_env_info = TXTGenerator.loads(
text4)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_user_info["LIBA"].VAR2, "23")
self.assertEqual(deps_env_info["LIBA"].VAR2, "23")
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.debug.includedirs.append("C:/whenever")
deps_cpp_info.libs.extend(["math"])
deps_cpp_info.debug.libs.extend(["debug_Lib"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.debug.includedirs.append("F:/ChildrenDebugPath")
child.cppflags.append("cxxmyflag")
child.debug.cppflags.append("cxxmydebugflag")
deps_cpp_info._dependencies["Boost"] = child
deps_env_info = DepsEnvInfo()
env_info_lib1 = EnvInfo()
env_info_lib1.var = "32"
env_info_lib1.othervar.append("somevalue")
deps_env_info.update(env_info_lib1, "LIB1")
deps_user_info = DepsUserInfo()
deps_user_info["LIB2"].myuservar = "23"
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, deps_user_info, {}, defaultdict(dict))).content
deps_cpp_info2, _, deps_env_info2 = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ["C:/whenever"])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
["F:/ChildrenDebugPath"])
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
deps_cpp_info2["Boost"].debug.cppflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags, ["cxxmydebugflag"])
self.assertEqual(deps_env_info["LIB1"].var, "32")
self.assertEqual(deps_env_info["LIB1"].othervar, ["somevalue"])
self.assertEqual(deps_user_info["LIB2"].myuservar, "23")
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.filter_empty = False
child = CppInfo("Boost", "F:/")
child.filter_empty = False
child.version = "<version>"
child.includedirs.append("ChildrenPath")
child.debug.includedirs.append("ChildrenDebugPath")
child.cxxflags.append("cxxmyflag")
child.debug.cxxflags.append("cxxmydebugflag")
child.libs.extend(["math"])
child.debug.libs.extend(["debug_Lib"])
deps_cpp_info.add("Boost", DepCppInfo(child))
deps_env_info = DepsEnvInfo()
env_info_lib1 = EnvInfo()
env_info_lib1.var = "32"
env_info_lib1.othervar.append("somevalue")
deps_env_info.update(env_info_lib1, "LIB1")
deps_user_info = DepsUserInfo()
deps_user_info["LIB2"].myuservar = "23"
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, deps_user_info, {}, defaultdict(dict))).content
deps_cpp_info2, _, deps_env_info2, _ = TXTGenerator.loads(output, filter_empty=False)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cxxflags,
deps_cpp_info2["Boost"].cxxflags)
self.assertEqual(deps_cpp_info["Boost"].cxxflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ['F:/include', 'F:/ChildrenDebugPath'])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs, ['include', 'ChildrenDebugPath'])
self.assertEqual(deps_cpp_info["Boost"].debug.cxxflags,
deps_cpp_info2["Boost"].debug.cxxflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cxxflags, ["cxxmydebugflag"])
self.assertEqual(deps_env_info["LIB1"].var, "32")
self.assertEqual(deps_env_info["LIB1"].othervar, ["somevalue"])
self.assertEqual(deps_user_info["LIB2"].myuservar, "23")
def parse_test(self):
text = """[includedirs]
C:/Whenever
[includedirs_Boost]
F:/ChildrenPath
[includedirs_My_Lib]
mylib_path
[includedirs_My_Other_Lib]
otherlib_path
[includedirs_My.Component.Lib]
my_component_lib
[includedirs_My-Component-Tool]
my-component-tool
"""
deps_cpp_info, _, _ = TXTGenerator.loads(text)
def assert_cpp(deps_cpp_info_test):
self.assertEqual(deps_cpp_info_test.includedirs, ['C:/Whenever'])
self.assertEqual(deps_cpp_info_test["Boost"].includedirs, ['F:/ChildrenPath'])
self.assertEqual(deps_cpp_info_test["My_Lib"].includedirs, ['mylib_path'])
self.assertEqual(deps_cpp_info_test["My_Other_Lib"].includedirs, ['otherlib_path'])
self.assertEqual(deps_cpp_info_test["My-Component-Tool"].includedirs, ['my-component-tool'])
assert_cpp(deps_cpp_info)
# Now adding env_info
text2 = text + """
[ENV_LIBA]
VAR2=23
"""
deps_cpp_info, _, deps_env_info = TXTGenerator.loads(text2)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_env_info["LIBA"].VAR2, "23")
# Now only with user info
text3 = text + """
[USER_LIBA]
VAR2=23
"""
deps_cpp_info, deps_user_info, _ = TXTGenerator.loads(text3)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_user_info["LIBA"].VAR2, "23")
# Now with all
text4 = text + """
[USER_LIBA]
VAR2=23
[ENV_LIBA]
VAR2=23
"""
deps_cpp_info, deps_user_info, deps_env_info = TXTGenerator.loads(text4)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_user_info["LIBA"].VAR2, "23")
self.assertEqual(deps_env_info["LIBA"].VAR2, "23")
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, None, {}, defaultdict(dict))).content
deps_cpp_info2, _, _ = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
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
prev = run_package_method(conanfile, package_id, source_folder, build_folder,
package_folder, install_folder, self._hook_manager,
conanfile_path, pref.ref)
update_package_metadata(prev, package_layout, package_id, 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 prev
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(self, conanfile, pref, package_layout, conanfile_path):
# 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(conanfile.folders.base_build, CONANINFO),
conanfile.info.dumps())
self._output.info("Generated %s" % CONANINFO)
save(os.path.join(conanfile.folders.base_build, 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
# While installing, the infos goes to build folder
conanfile.folders.set_base_install(conanfile.folders.base_build)
prev = run_package_method(conanfile, package_id, self._hook_manager,
conanfile_path, pref.ref)
update_package_metadata(prev, package_layout, package_id,
pref.ref.revision)
if get_env("CONAN_READ_ONLY_CACHE", False):
make_read_only(conanfile.folders.base_package)
# FIXME: Conan 2.0 Clear the registry entry (package ref)
return prev
def _handle_node_editable(self, node, graph_info):
# Get source of information
package_layout = self._cache.package_layout(node.ref)
base_path = package_layout.base_folder()
self._call_package_info(node.conanfile, package_folder=base_path, ref=node.ref)
node.conanfile.cpp_info.filter_empty = False
# Try with package-provided file
editable_cpp_info = package_layout.editable_cpp_info()
if editable_cpp_info:
editable_cpp_info.apply_to(node.ref,
node.conanfile.cpp_info,
settings=node.conanfile.settings,
options=node.conanfile.options)
build_folder = editable_cpp_info.folder(node.ref, EditableLayout.BUILD_FOLDER,
settings=node.conanfile.settings,
options=node.conanfile.options)
if build_folder is not None:
build_folder = os.path.join(base_path, build_folder)
output = node.conanfile.output
write_generators(node.conanfile, build_folder, output)
save(os.path.join(build_folder, CONANINFO), node.conanfile.info.dumps())
output.info("Generated %s" % CONANINFO)
graph_info_node = GraphInfo(graph_info.profile_host, root_ref=node.ref)
graph_info_node.options = node.conanfile.options.values
graph_info_node.graph_lock = graph_info.graph_lock
graph_info_node.save(build_folder)
output.info("Generated graphinfo")
save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(node.conanfile).content)
output.info("Generated %s" % BUILD_INFO)
# Build step might need DLLs, binaries as protoc to generate source files
# So execute imports() before build, storing the list of copied_files
copied_files = run_imports(node.conanfile, build_folder)
report_copied_files(copied_files, output)
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_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 _handle_node_workspace(self, node, workspace_package, inverse_levels,
deps_graph):
conan_ref, conan_file = node.conan_ref, node.conanfile
output = ScopedOutput("Workspace %s" % conan_ref.name, self._out)
include_dirs = workspace_package.includedirs
lib_dirs = workspace_package.libdirs
self._call_package_info(conan_file, workspace_package.package_folder)
if include_dirs:
conan_file.cpp_info.includedirs = include_dirs
if lib_dirs:
conan_file.cpp_info.libdirs = lib_dirs
# Make sure the folders exists, otherwise they will be filtered out
lib_paths = [
os.path.join(conan_file.cpp_info.rootpath, p)
if not os.path.isabs(p) else p for p in lib_dirs
]
for p in lib_paths:
mkdir(p)
self._propagate_info(node, inverse_levels, deps_graph, output)
build_folder = workspace_package.build_folder
write_generators(conan_file, build_folder, output)
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)
# Build step might need DLLs, binaries as protoc to generate source files
# So execute imports() before build, storing the list of copied_files
from conans.client.importer import run_imports
copied_files = run_imports(conan_file, build_folder, output)
report_copied_files(copied_files, 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,
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 configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.debug.includedirs.append("C:/whenever")
deps_cpp_info.libs.extend(["math"])
deps_cpp_info.debug.libs.extend(["debug_Lib"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.debug.includedirs.append("F:/ChildrenDebugPath")
child.cppflags.append("cxxmyflag")
child.debug.cppflags.append("cxxmydebugflag")
deps_cpp_info._dependencies["Boost"] = child
deps_env_info = DepsEnvInfo()
env_info_lib1 = EnvInfo()
env_info_lib1.var = "32"
env_info_lib1.othervar.append("somevalue")
deps_env_info.update(env_info_lib1, "LIB1")
deps_user_info = DepsUserInfo()
deps_user_info["LIB2"].myuservar = "23"
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, deps_user_info, {}, defaultdict(dict))).content
deps_cpp_info2, _, deps_env_info2 = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ["C:/whenever"])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
["F:/ChildrenDebugPath"])
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
deps_cpp_info2["Boost"].debug.cppflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags, ["cxxmydebugflag"])
self.assertEqual(deps_env_info["LIB1"].var, "32")
self.assertEqual(deps_env_info["LIB1"].othervar, ["somevalue"])
self.assertEqual(deps_user_info["LIB2"].myuservar, "23")
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 parse_test(self):
text = """[includedirs]
C:/Whenever
[includedirs_Boost]
F:/ChildrenPath
[includedirs_My_Lib]
mylib_path
[includedirs_My_Other_Lib]
otherlib_path
"""
deps_info, _ = TXTGenerator.loads(text)
self.assertEqual(deps_info.includedirs, ['C:/Whenever'])
self.assertEqual(deps_info["Boost"].includedirs, ['F:/ChildrenPath'])
self.assertEqual(deps_info["My_Lib"].includedirs, ['mylib_path'])
self.assertEqual(deps_info["My_Other_Lib"].includedirs,
['otherlib_path'])
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.debug.includedirs.append("C:/whenever")
deps_cpp_info.libs.extend(["math"])
deps_cpp_info.debug.libs.extend(["debug_Lib"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.debug.includedirs.append("F:/ChildrenDebugPath")
child.cppflags.append("cxxmyflag")
child.debug.cppflags.append("cxxmydebugflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple(
"Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, None,
None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs,
deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ["C:/whenever"])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
["F:/ChildrenDebugPath"])
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
deps_cpp_info2["Boost"].debug.cppflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
["cxxmydebugflag"])
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple(
"Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(
fakeconan(deps_cpp_info, None, deps_env_info, None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
self._equal(deps_cpp_info, deps_cpp_info2)
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 _handle_node_editable(self, node, profile_host, profile_build,
graph_lock):
# Get source of information
conanfile = node.conanfile
ref = node.ref
package_layout = self._cache.package_layout(ref)
base_path = package_layout.base_folder()
if hasattr(conanfile, "layout"):
conanfile.folders.set_base_folders(base_path,
package_layout.output_folder)
else:
conanfile.folders.set_base_package(base_path)
conanfile.folders.set_base_source(None)
conanfile.folders.set_base_build(None)
conanfile.folders.set_base_install(None)
self._call_package_info(conanfile,
package_folder=base_path,
ref=ref,
is_editable=True)
# New editables mechanism based on Folders
if hasattr(conanfile, "layout"):
output = conanfile.output
output.info("Rewriting files of editable package "
"'{}' at '{}'".format(conanfile.name,
conanfile.generators_folder))
self._generator_manager.write_generators(
conanfile, conanfile.install_folder,
conanfile.generators_folder, output)
write_toolchain(conanfile, conanfile.generators_folder, output)
output.info("Generated toolchain")
graph_info_node = GraphInfo(profile_host, root_ref=node.ref)
graph_info_node.options = node.conanfile.options.values
graph_info_node.graph_lock = graph_lock
graph_info_node.save(base_path)
output.info("Generated conan.lock")
copied_files = run_imports(conanfile)
report_copied_files(copied_files, output)
return
node.conanfile.cpp_info.filter_empty = False
# OLD EDITABLE LAYOUTS:
# Try with package-provided file
editable_cpp_info = package_layout.editable_cpp_info()
if editable_cpp_info:
editable_cpp_info.apply_to(ref,
conanfile.cpp_info,
settings=conanfile.settings,
options=conanfile.options)
build_folder = editable_cpp_info.folder(
ref,
EditableLayout.BUILD_FOLDER,
settings=conanfile.settings,
options=conanfile.options)
if build_folder is not None:
build_folder = os.path.join(base_path, build_folder)
output = conanfile.output
self._generator_manager.write_generators(
conanfile, build_folder, build_folder, output)
write_toolchain(conanfile, build_folder, output)
save(os.path.join(build_folder, CONANINFO),
conanfile.info.dumps())
output.info("Generated %s" % CONANINFO)
graph_info_node = GraphInfo(profile_host, root_ref=node.ref)
graph_info_node.options = node.conanfile.options.values
graph_info_node.graph_lock = graph_lock
graph_info_node.save(build_folder)
output.info("Generated graphinfo")
graph_lock_file = GraphLockFile(profile_host, profile_build,
graph_lock)
graph_lock_file.save(os.path.join(build_folder, "conan.lock"))
save(os.path.join(build_folder, BUILD_INFO),
TXTGenerator(conanfile).content)
output.info("Generated %s" % BUILD_INFO)
# Build step might need DLLs, binaries as protoc to generate source files
# So execute imports() before build, storing the list of copied_files
conanfile.folders.set_base_imports(build_folder)
copied_files = run_imports(conanfile)
report_copied_files(copied_files, output)
def __repr__(self):
return TXTGenerator(self).content
def parse_test(self):
text = """[includedirs]
F:/ChildrenPath
G:/mylib_path
H:/otherlib_path
I:/my_component_lib
J:/my-component-tool
[name_Boost]
Boost
[rootpath_Boost]
F:/
[includedirs_Boost]
F:/ChildrenPath
[name_My_Lib]
My_Lib
[rootpath_My_Lib]
G:/
[includedirs_My_Lib]
G:/mylib_path
[name_My_Other_Lib]
My_Other_Lib
[rootpath_My_Other_Lib]
H:/
[includedirs_My_Other_Lib]
H:/otherlib_path
[name_My.Component.Lib]
My.Component.Lib
[rootpath_My.Component.Lib]
I:/
[includedirs_My.Component.Lib]
I:/my_component_lib
[name_My-Component-Tool]
My-Component-Tool
[rootpath_My-Component-Tool]
J:/
[includedirs_My-Component-Tool]
J:/my-component-tool
"""
deps_cpp_info, _, _, _ = TXTGenerator.loads(text)
def assert_cpp(deps_cpp_info_test):
self.assertEqual(deps_cpp_info_test.includedirs, [
'F:/ChildrenPath', 'G:/mylib_path', 'H:/otherlib_path',
'I:/my_component_lib', 'J:/my-component-tool'
])
self.assertEqual(deps_cpp_info_test["Boost"].includedirs,
['ChildrenPath'])
self.assertEqual(deps_cpp_info_test["My_Lib"].includedirs,
['mylib_path'])
self.assertEqual(deps_cpp_info_test["My_Other_Lib"].includedirs,
['otherlib_path'])
self.assertEqual(
deps_cpp_info_test["My-Component-Tool"].includedirs,
['my-component-tool'])
assert_cpp(deps_cpp_info)
# Now adding env_info
text2 = text + """
[ENV_LIBA]
VAR2=23
"""
deps_cpp_info, _, deps_env_info, _ = TXTGenerator.loads(text2)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_env_info["LIBA"].VAR2, "23")
# Now only with user info
text3 = text + """
[USER_LIBA]
VAR2=23
"""
deps_cpp_info, deps_user_info, _, _ = TXTGenerator.loads(text3)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_user_info["LIBA"].VAR2, "23")
# Now with all
text4 = text + """
[USER_LIBA]
VAR2=23
[ENV_LIBA]
VAR2=23
"""
deps_cpp_info, deps_user_info, deps_env_info, _ = TXTGenerator.loads(
text4)
assert_cpp(deps_cpp_info)
self.assertEqual(deps_user_info["LIBA"].VAR2, "23")
self.assertEqual(deps_env_info["LIBA"].VAR2, "23")
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)
