def setUp(self):
self.client = self._get_client()
self.conan_ref = ConanFileReference.loads(
"Hello/1.2.1@frodo/stable#%s" % DEFAULT_REVISION_V1)
reg_folder = self.client.client_cache.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), assert_error=True)
self.assertIn(
"There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save(
{
CONANFILE: myconan1,
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"
},
path=reg_folder)
mkdir(self.client.client_cache.export_sources(self.conan_ref))
manifest = FileTreeManifest.create(reg_folder)
manifest.time = '123123123'
manifest.save(reg_folder)
self.test_server.server_store.update_last_revision(self.conan_ref)
self.package_ref = PackageReference(self.conan_ref, "myfakeid",
DEFAULT_REVISION_V1)
self.server_pack_folder = self.test_server.server_store.package(
self.package_ref)
package_folder = self.client.client_cache.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"),
"//bin")
save(os.path.join(package_folder, CONANINFO),
"""[recipe_hash]\n%s""" % manifest.summary_hash)
FileTreeManifest.create(package_folder).save(package_folder)
self.test_server.server_store.update_last_package_revision(
self.package_ref)
os.chmod(
os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin",
"executable")).st_mode | stat.S_IRWXU)
package_path = self.client.client_cache.package(self.package_ref)
expected_manifest = FileTreeManifest.create(package_path)
expected_manifest.save(package_folder)
self.server_reg_folder = self.test_server.server_store.export(
self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def setUp(self):
self.client = self._get_client()
self.ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable#%s" % DEFAULT_REVISION_V1)
self.pref = PackageReference(self.ref, "myfakeid", DEFAULT_REVISION_V1)
reg_folder = self.client.cache.package_layout(self.ref).export()
self.client.run('upload %s' % str(self.ref), assert_error=True)
self.assertIn("ERROR: Recipe not found: '%s'" % str(self.ref), self.client.out)
files = cpp_hello_source_files(0)
fake_metadata = PackageMetadata()
fake_metadata.recipe.revision = DEFAULT_REVISION_V1
fake_metadata.packages[self.pref.id].revision = DEFAULT_REVISION_V1
self.client.save({"metadata.json": fake_metadata.dumps()},
path=self.client.cache.package_layout(self.ref).base_folder())
self.client.save(files, path=reg_folder)
self.client.save({CONANFILE: GenConanfile().with_name("Hello").with_version("1.2.1"),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"}, path=reg_folder)
mkdir(self.client.cache.package_layout(self.ref).export_sources())
manifest = FileTreeManifest.create(reg_folder)
manifest.time = '123123123'
manifest.save(reg_folder)
self.test_server.server_store.update_last_revision(self.ref)
self.server_pack_folder = self.test_server.server_store.package(self.pref)
package_folder = self.client.cache.package_layout(self.ref).package(self.pref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"), "//bin")
save(os.path.join(package_folder, CONANINFO),
"""[recipe_hash]\n%s""" % manifest.summary_hash)
FileTreeManifest.create(package_folder).save(package_folder)
self.test_server.server_store.update_last_package_revision(self.pref)
os.chmod(os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin", "executable")).st_mode |
stat.S_IRWXU)
expected_manifest = FileTreeManifest.create(package_folder)
expected_manifest.save(package_folder)
self.server_reg_folder = self.test_server.server_store.export(self.ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def setUp(self):
self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
self.package_reference = PackageReference(self.conan_reference, "123123123")
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret",
timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.paths = SimplePaths(self.tmp_dir)
self.file_manager = FileManager(self.paths, adapter)
search_adapter = DiskSearchAdapter()
self.search_manager = DiskSearchManager(self.paths, search_adapter)
self.service = ConanService(authorizer, self.file_manager, "lasote")
self.search_service = SearchService(authorizer, self.search_manager, "lasote")
files = hello_source_files("test")
save_files(self.paths.export(self.conan_reference), files)
self.conan_digest = FileTreeManifest.create(self.paths.export(self.conan_reference))
conan_digest_path = os.path.join(self.paths.export(self.conan_reference), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.paths.package(self.package_reference), files)
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 test_tree_manifest(self):
tmp_dir = temp_folder()
files = {
"one.ext": "aalakjshdlkjahsdlkjahsdljkhsadljkhasljkdhlkjashd",
"path/to/two.txt": "asdas13123",
"two.txt": "asdasdasdasdasdasd",
"folder/damn.pyc": "binarythings",
"folder/damn.pyo": "binarythings2",
"pythonfile.pyc": "binarythings3"
}
for filename, content in files.items():
save(os.path.join(tmp_dir, filename), content)
manifest = FileTreeManifest.create(tmp_dir)
manifest.save(tmp_dir)
readed_manifest = FileTreeManifest.load(tmp_dir)
self.assertEqual(readed_manifest.time, manifest.time)
self.assertEqual(readed_manifest, manifest)
# Not included the pycs or pyo
self.assertEqual(set(manifest.file_sums.keys()),
set(["one.ext", "path/to/two.txt", "two.txt"]))
for filepath, md5readed in manifest.file_sums.items():
content = files[filepath]
self.assertEqual(md5(content), md5readed)
def setUp(self):
servers = {}
# All can write (for avoid authentication until we mock user_io)
self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers["default"] = self.test_server
conan_digest = FileTreeManifest('123123123', {})
self.client = TestClient(servers=servers,
users={"default": [("lasote", "mypass")]})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn(
"There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"
},
path=reg_folder)
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(
self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"),
"//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(
os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin",
"executable")).st_mode | stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(
self.package_ref)
expected_manifest = FileTreeManifest.create(
os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST),
str(expected_manifest))
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def setUp(self):
self.conan_reference = ConanFileReference.loads(
"openssl/2.0.3@lasote/testing")
self.package_reference = PackageReference(self.conan_reference,
"123123123")
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret",
timedelta(seconds=200))
adapter = DiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.paths = SimplePaths(self.tmp_dir)
self.file_manager = FileManager(self.paths, adapter)
self.service = ConanService(authorizer, self.file_manager, "lasote")
files = hello_source_files("test")
save_files(self.paths.export(self.conan_reference), files)
self.conan_digest = FileTreeManifest.create(
self.paths.export(self.conan_reference))
conan_digest_path = os.path.join(
self.paths.export(self.conan_reference), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.paths.package(self.package_reference), files)
def package_files(self, reference, path, profile):
""" 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 = path
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager,
remote_name=None, update=False, check_updates=False,
manifest_manager=None)
loader = ConanFileLoader(self._runner, self._client_cache.settings, 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]
packages_folder = self._client_cache.packages(reference)
package_folder = os.path.join(packages_folder, conanfile.info.package_id())
shutil.copytree(path, package_folder)
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
# Create the digest for the package
digest = FileTreeManifest.create(package_folder)
save(os.path.join(package_folder, CONAN_MANIFEST), str(digest))
def setUp(self):
self.ref = ConanFileReference.loads("openssl/2.0.3@lasote/testing#%s" % DEFAULT_REVISION_V1)
self.pref = PackageReference(self.ref, "123123123", DEFAULT_REVISION_V1)
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret", timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.server_store = ServerStore(storage_adapter=adapter)
self.service = ConanService(authorizer, self.server_store, "lasote")
self.search_service = SearchService(authorizer, self.server_store, "lasote")
files = hello_source_files("test")
save_files(self.server_store.export(self.ref), files)
self.server_store.update_last_revision(self.ref)
self.conan_digest = FileTreeManifest.create(self.server_store.export(self.ref))
conan_digest_path = os.path.join(self.server_store.export(self.ref), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.server_store.package(self.pref), files)
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 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 test_tree_manifest(self):
tmp_dir = temp_folder()
files = {"one.ext": "aalakjshdlkjahsdlkjahsdljkhsadljkhasljkdhlkjashd",
"path/to/two.txt": "asdas13123",
"two.txt": "asdasdasdasdasdasd",
"folder/damn.pyc": "binarythings",
"folder/damn.pyo": "binarythings2",
"pythonfile.pyc": "binarythings3"}
for filename, content in files.items():
save(os.path.join(tmp_dir, filename), content)
manifest = FileTreeManifest.create(tmp_dir)
save(os.path.join(tmp_dir, "THEMANIFEST.txt"), str(manifest))
readed_manifest = FileTreeManifest.loads(load(os.path.join(tmp_dir, "THEMANIFEST.txt")))
self.assertEqual(readed_manifest.time, manifest.time)
self.assertEqual(readed_manifest, manifest)
# Not included the pycs or pyo
self.assertEquals(set(manifest.file_sums.keys()),
set(["one.ext", "path/to/two.txt", "two.txt"]))
for filepath, md5readed in manifest.file_sums.items():
content = files[filepath]
self.assertEquals(md5(content), md5readed)
def method_called_test(self):
save(
os.path.join(self.client_cache.package(self.package_reference),
CONANINFO), "asdasd")
manifest = FileTreeManifest.create(
self.client_cache.package(self.package_reference))
save(
os.path.join(self.client_cache.package(self.package_reference),
CONAN_MANIFEST), str(manifest))
self.assertFalse(self.remote_client.upload_package.called)
self.manager.upload_package(self.package_reference,
Remote("other", "url", True), 1, 0)
self.assertTrue(self.remote_client.upload_package.called)
self.assertFalse(self.remote_client.get_conan_digest.called)
self.manager.get_conan_digest(self.conan_reference,
Remote("other", "url", True))
self.assertTrue(self.remote_client.get_conan_digest.called)
self.assertFalse(self.remote_client.get_recipe.called)
self.manager.get_recipe(self.conan_reference, temp_folder(),
Remote("other", "url", True))
self.assertTrue(self.remote_client.get_recipe.called)
self.assertFalse(self.remote_client.get_package.called)
self.manager.get_package(self.package_reference, temp_folder(),
Remote("other", "url", True))
self.assertTrue(self.remote_client.get_package.called)
def setUp(self):
hello_files = cpp_hello_conan_files("Hello")
test_conanfile_contents = hello_files[CONANFILE]
self.server_folder = temp_folder()
test_server = TestServer(users={"myuser": "******"},
base_path=self.server_folder) # exported users and passwords
self.server = test_server
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("myuser", "mypass")]})
# Conans with and without packages created
self.root_folder = {"H1": 'Hello/1.4.10@myuser/testing',
"H2": 'Hello/2.4.11@myuser/testing',
"B": 'Bye/0.14@myuser/testing',
"O": 'Other/1.2@myuser/testing'}
files = {}
pack_refs = []
for key, folder in self.root_folder.items():
ref = ConanFileReference.loads(folder)
folder = folder.replace("@", "/")
files["%s/%s/conanfile.py" % (folder, EXPORT_FOLDER)] = test_conanfile_contents
files["%s/%s/conanmanifest.txt" % (folder, EXPORT_FOLDER)] = "%s\nconanfile.py: 234234234" % fake_recipe_hash
files["%s/%s/conans.txt" % (folder, SRC_FOLDER)] = ""
for pack_id in (1, 2):
i = pack_id
pack_id = "%s_%s" % (pack_id, key)
pack_refs.append(PackageReference(ref, str(pack_id)))
files["%s/%s/%s/conans.txt" % (folder, BUILD_FOLDER, pack_id)] = ""
files["%s/%s/%s/conans.txt" % (folder, PACKAGES_FOLDER, pack_id)] = ""
files["%s/%s/%s/%s" % (folder, PACKAGES_FOLDER, pack_id, CONANINFO)] = conaninfo % str(i) + "905eefe3570dd09a8453b30b9272bb44"
files["%s/%s/%s/%s" % (folder, PACKAGES_FOLDER, pack_id, CONAN_MANIFEST)] = ""
exports_sources_dir = client.client_cache.export_sources(ref)
os.makedirs(exports_sources_dir)
client.save(files, client.client_cache.store)
# Create the manifests to be able to upload
for pack_ref in pack_refs:
pkg_folder = client.client_cache.package(pack_ref)
expected_manifest = FileTreeManifest.create(pkg_folder)
files["%s/%s/%s/%s" % (pack_ref.conan.dir_repr(),
PACKAGES_FOLDER,
pack_ref.package_id,
CONAN_MANIFEST)] = repr(expected_manifest)
client.save(files, client.client_cache.store)
self.client = client
for folder in self.root_folder.values():
client.run("upload %s --all" % folder)
self.assert_folders({"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
{"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
{"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
{"H1": True, "H2": True, "B": True, "O": True})
def _put_in_cache(self, ref, conanfile):
layout = self.cache.package_layout(ref)
save(layout.conanfile(), str(conanfile))
# Need to complete de metadata = revision + manifest
with layout.update_metadata() as metadata:
metadata.recipe.revision = "123"
manifest = FileTreeManifest.create(layout.export())
manifest.save(layout.export())
def _export_conanfile(conanfile_path, output, client_cache, conanfile,
conan_ref, keep_source):
exports_folder = client_cache.export(conan_ref)
exports_source_folder = client_cache.export_sources(
conan_ref, conanfile.short_paths)
previous_digest = _init_export_folder(exports_folder,
exports_source_folder)
origin_folder = os.path.dirname(conanfile_path)
export_recipe(conanfile, origin_folder, exports_folder, output)
export_source(conanfile, origin_folder, exports_source_folder, output)
shutil.copy2(conanfile_path, os.path.join(exports_folder, CONANFILE))
scm_data, captured_revision = _capture_export_scm_data(
conanfile, os.path.dirname(conanfile_path), exports_folder, output,
client_cache, conan_ref)
digest = FileTreeManifest.create(exports_folder, exports_source_folder)
if previous_digest and previous_digest == digest:
output.info("The stored package has not changed")
modified_recipe = False
digest = previous_digest # Use the old one, keep old timestamp
else:
output.success('A new %s version was exported' % CONANFILE)
output.info('Folder: %s' % exports_folder)
modified_recipe = True
digest.save(exports_folder)
revision = scm_data.revision if scm_data and captured_revision else digest.summary_hash
with client_cache.update_metadata(conan_ref) as metadata:
# Note that there is no time set, the time will come from the remote
metadata.recipe.revision = revision
# FIXME: Conan 2.0 Clear the registry entry if the recipe has changed
source = client_cache.source(conan_ref, conanfile.short_paths)
remove = False
if is_dirty(source):
output.info("Source folder is corrupted, forcing removal")
remove = True
elif modified_recipe and not keep_source and os.path.exists(source):
output.info(
"Package recipe modified in export, forcing source folder removal")
output.info("Use the --keep-source, -k option to skip it")
remove = True
if remove:
output.info(
"Removing 'source' folder, this can take a while for big packages")
try:
# remove only the internal
rmdir(source)
except BaseException as e:
output.error("Unable to delete source folder. "
"Will be marked as corrupted for deletion")
output.warn(str(e))
set_dirty(source)
def setUp(self):
hello_files = cpp_hello_conan_files("Hello")
test_conanfile_contents = hello_files[CONANFILE]
self.server_folder = temp_folder()
test_server = TestServer(users={"fenix": "mypass"},
base_path=self.server_folder) # exported users and passwords
self.server = test_server
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("fenix", "mypass")]})
# Conans with and without packages created
self.root_folder = {"H1": 'Hello/1.4.10/fenix/testing',
"H2": 'Hello/2.4.11/fenix/testing',
"B": 'Bye/0.14/fenix/testing',
"O": 'Other/1.2/fenix/testing'}
files = {}
pack_refs = []
for key, folder in self.root_folder.items():
ref = ConanFileReference.loads(folder)
files["%s/%s/conanfile.py" % (folder, EXPORT_FOLDER)] = test_conanfile_contents
files["%s/%s/conanmanifest.txt" % (folder, EXPORT_FOLDER)] = ""
files["%s/%s/conans.txt" % (folder, SRC_FOLDER)] = ""
for pack_id in (1, 2):
i = pack_id
pack_id = "%s_%s" % (pack_id, key)
pack_refs.append(PackageReference(ref, str(pack_id)))
files["%s/%s/%s/conans.txt" % (folder, BUILD_FOLDER, pack_id)] = ""
files["%s/%s/%s/conans.txt" % (folder, PACKAGES_FOLDER, pack_id)] = ""
files["%s/%s/%s/%s" % (folder, PACKAGES_FOLDER, pack_id, CONANINFO)] = conaninfo % str(i)
files["%s/%s/%s/%s" % (folder, PACKAGES_FOLDER, pack_id, CONAN_MANIFEST)] = ""
exports_sources_dir = os.path.join(client.client_cache.export(ref), EXPORT_SOURCES_DIR)
os.makedirs(exports_sources_dir)
client.save(files, client.client_cache.store)
# Create the manifests to be able to upload
for pack_ref in pack_refs:
digest_path = client.client_cache.digestfile_package(pack_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
files["%s/%s/%s/%s" % ("/".join(pack_ref.conan),
PACKAGES_FOLDER,
pack_ref.package_id,
CONAN_MANIFEST)] = str(expected_manifest)
client.save(files, client.client_cache.store)
self.client = client
for folder in self.root_folder.values():
client.run("upload %s --all" % folder.replace("/fenix", "@fenix"))
self.assert_folders({"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
{"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
{"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
{"H1": True, "H2": True, "B": True, "O": True})
def _handle_recipe(self, node, verify, interactive):
ref = node.ref
export = self._cache.export(ref)
exports_sources_folder = self._cache.export_sources(ref)
read_manifest = FileTreeManifest.load(export)
expected_manifest = FileTreeManifest.create(export, exports_sources_folder)
self._check_not_corrupted(ref, read_manifest, expected_manifest)
folder = self._paths.export(ref)
self._handle_folder(folder, ref, read_manifest, interactive, node.remote, verify)
def _cache_recipe(self, reference, test_conanfile, revision=None):
if isinstance(test_conanfile, TestConanFile):
test_conanfile.info = True
ref = ConanFileReference.loads(reference)
save(self.cache.package_layout(ref).conanfile(), str(test_conanfile))
with self.cache.package_layout(ref).update_metadata() as metadata:
metadata.recipe.revision = revision or "123"
manifest = FileTreeManifest.create(self.cache.package_layout(ref).export())
manifest.save(self.cache.package_layout(ref).export())
def valid_digest(self, digest_path):
if not os.path.exists(digest_path):
return False
expected_digest = FileTreeManifest.create(os.path.dirname(digest_path))
del expected_digest.file_sums[CONAN_MANIFEST] # Exclude the MANIFEST itself
expected_digest.file_sums.pop(CONANFILE + "c", None) # Exclude the CONANFILE.pyc
expected_digest.file_sums.pop(".DS_Store", None) # Exclude tmp in mac
readed_digest = FileTreeManifest.loads(load(digest_path))
return readed_digest.file_sums == expected_digest.file_sums
def _handle_package(self, node, verify, interactive):
ref = node.ref
pref = PackageReference(ref, node.package_id)
package_folder = self._cache.package(pref)
read_manifest = FileTreeManifest.load(package_folder)
expected_manifest = FileTreeManifest.create(package_folder)
self._check_not_corrupted(pref, read_manifest, expected_manifest)
folder = self._paths.package(pref)
self._handle_folder(folder, pref, read_manifest, interactive, node.remote, verify)
def setUp(self):
self.client = self._get_client()
conan_digest = FileTreeManifest('123123123', {})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn(
"There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"
},
path=reg_folder)
exports_sources_dir = os.path.join(reg_folder, EXPORT_SOURCES_DIR)
os.makedirs(exports_sources_dir)
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(
self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"),
"//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(
os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin",
"executable")).st_mode | stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(
self.package_ref)
expected_manifest = FileTreeManifest.create(
os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST),
str(expected_manifest))
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def _handle_package(self, node, verify, interactive):
ref = node.ref
pref = PackageReference(ref, node.package_id)
package_folder = self._cache.package_layout(pref.ref).package(pref)
read_manifest = FileTreeManifest.load(package_folder)
expected_manifest = FileTreeManifest.create(package_folder)
self._check_not_corrupted(pref, read_manifest, expected_manifest)
folder = os.path.join(self._target_folder, ref.dir_repr(),
PACKAGES_FOLDER, pref.id)
self._handle_folder(folder, pref, read_manifest, interactive,
node.remote, verify)
def _cache_recipe(self, ref, test_conanfile, revision=None):
if isinstance(test_conanfile, GenConanfile):
name, version = test_conanfile._name, test_conanfile._version
test_conanfile = test_conanfile.with_package_info(
cpp_info={"libs": ["mylib{}{}lib".format(name, version)]},
env_info={"MYENV": ["myenv{}{}env".format(name, version)]})
save(self.cache.package_layout(ref).conanfile(), str(test_conanfile))
with self.cache.package_layout(ref).update_metadata() as metadata:
metadata.recipe.revision = revision or "123"
manifest = FileTreeManifest.create(self.cache.package_layout(ref).export())
manifest.save(self.cache.package_layout(ref).export())
def valid_digest(self, digest_path):
if not os.path.exists(digest_path):
return False
expected_digest = FileTreeManifest.create(os.path.dirname(digest_path))
del expected_digest.file_sums[
CONAN_MANIFEST] # Exclude the MANIFEST itself
expected_digest.file_sums.pop(CONANFILE + "c",
None) # Exclude the CONANFILE.pyc
expected_digest.file_sums.pop(".DS_Store", None) # Exclude tmp in mac
readed_digest = FileTreeManifest.loads(load(digest_path))
return readed_digest.file_sums == expected_digest.file_sums
def _handle_recipe(self, node, verify, interactive):
ref = node.ref
layout = self._cache.package_layout(ref)
export = layout.export()
exports_sources_folder = layout.export_sources()
read_manifest = FileTreeManifest.load(export)
expected_manifest = FileTreeManifest.create(export,
exports_sources_folder)
self._check_not_corrupted(ref, read_manifest, expected_manifest)
folder = os.path.join(self._target_folder, ref.dir_repr(),
EXPORT_FOLDER)
self._handle_folder(folder, ref, read_manifest, interactive,
node.remote, verify)
def upload_same_package_dont_compress_test(self):
# Create a manifest for the faked package
pack_path = self.client.paths.package(self.package_ref)
digest_path = self.client.client_cache.digestfile_package(self.package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(pack_path, CONAN_MANIFEST), str(expected_manifest))
self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
self.assertIn("Compressing package", str(self.client.user_io.out))
self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
self.assertNotIn("Compressing package", str(self.client.user_io.out))
self.assertIn("Package is up to date", str(self.client.user_io.out))
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_alias(reference, target_reference, client_cache):
conanfile = """
from conans import ConanFile
class AliasConanfile(ConanFile):
alias = "%s"
""" % str(target_reference)
export_path = client_cache.export(reference)
mkdir(export_path)
save(os.path.join(export_path, CONANFILE), conanfile)
mkdir(client_cache.export_sources(reference))
digest = FileTreeManifest.create(export_path)
digest.save(export_path)
def _create_aux_files(build_folder, package_folder):
""" auxiliary method that creates CONANINFO in
the package_folder
"""
try:
logger.debug("Creating config files to %s" % package_folder)
shutil.copy(os.path.join(build_folder, CONANINFO), package_folder)
# Create the digest for the package
digest = FileTreeManifest.create(package_folder)
save(os.path.join(package_folder, CONAN_MANIFEST), str(digest))
except IOError:
raise ConanException("%s does not exist inside of your % folder. Try to re-build it again"
" to solve it." % (CONANINFO, build_folder))
def upload_same_package_dont_compress_test(self):
# Create a manifest for the faked package
pack_path = self.client.paths.package(self.package_ref)
digest_path = self.client.client_cache.digestfile_package(self.package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(pack_path, CONAN_MANIFEST), str(expected_manifest))
self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
self.assertIn("Compressing exported files", self.client.user_io.out)
self.assertIn("Compressing package", str(self.client.user_io.out))
self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
self.assertNotIn("Compressing exported files", self.client.user_io.out)
self.assertNotIn("Compressing package", str(self.client.user_io.out))
self.assertIn("Package is up to date", str(self.client.user_io.out))
def _create_aux_files(build_folder, package_folder):
""" auxiliary method that creates CONANINFO in
the package_folder
"""
try:
logger.debug("Creating config files to %s" % package_folder)
shutil.copy(os.path.join(build_folder, CONANINFO), package_folder)
# Create the digest for the package
digest = FileTreeManifest.create(package_folder)
save(os.path.join(package_folder, CONAN_MANIFEST), str(digest))
except IOError:
raise ConanException("%s does not exist inside of your % folder. Try to re-build it again"
" to solve it." % (CONANINFO, build_folder))
def export_alias(package_layout, target_ref, output, revisions_enabled):
conanfile = """
from conans import ConanFile
class AliasConanfile(ConanFile):
alias = "%s"
""" % target_ref.full_repr()
save(package_layout.conanfile(), conanfile)
digest = FileTreeManifest.create(package_layout.export())
digest.save(folder=package_layout.export())
# Create the metadata for the alias
_update_revision_in_metadata(package_layout=package_layout, revisions_enabled=revisions_enabled,
output=output, path=None, digest=digest)
def upload_same_package_dont_compress_test(self):
# Create a manifest for the faked package
pack_path = self.client.cache.package(self.pref)
package_path = self.client.cache.package(self.pref)
expected_manifest = FileTreeManifest.create(package_path)
expected_manifest.save(pack_path)
self.client.run("upload %s --all" % str(self.ref))
self.assertIn("Compressing recipe", self.client.user_io.out)
self.assertIn("Compressing package", str(self.client.user_io.out))
self.client.run("upload %s --all" % str(self.ref))
self.assertNotIn("Compressing recipe", self.client.user_io.out)
self.assertNotIn("Compressing package", str(self.client.user_io.out))
self.assertIn("Package is up to date", str(self.client.user_io.out))
def _export_conanfile(conanfile_path, output, paths, conanfile, conan_ref,
keep_source):
exports_folder = paths.export(conan_ref)
exports_source_folder = paths.export_sources(conan_ref,
conanfile.short_paths)
previous_digest = _init_export_folder(exports_folder,
exports_source_folder)
_execute_export(conanfile_path, conanfile, exports_folder,
exports_source_folder, output)
shutil.copy2(conanfile_path, os.path.join(exports_folder, CONANFILE))
_capture_export_scm_data(conanfile, os.path.dirname(conanfile_path),
exports_folder, output, paths, conan_ref)
digest = FileTreeManifest.create(exports_folder, exports_source_folder)
if previous_digest and previous_digest == digest:
output.info("The stored package has not changed")
modified_recipe = False
digest = previous_digest # Use the old one, keep old timestamp
else:
output.success('A new %s version was exported' % CONANFILE)
output.info('Folder: %s' % exports_folder)
modified_recipe = True
digest.save(exports_folder)
source = paths.source(conan_ref, conanfile.short_paths)
remove = False
if is_dirty(source):
output.info("Source folder is corrupted, forcing removal")
remove = True
elif modified_recipe and not keep_source and os.path.exists(source):
output.info(
"Package recipe modified in export, forcing source folder removal")
output.info("Use the --keep-source, -k option to skip it")
remove = True
if remove:
output.info(
"Removing 'source' folder, this can take a while for big packages")
try:
# remove only the internal
rmdir(source)
except BaseException as e:
output.error("Unable to delete source folder. "
"Will be marked as corrupted for deletion")
output.warn(str(e))
set_dirty(source)
def setUp(self):
servers = {}
# All can write (for avoid authentication until we mock user_io)
self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers["default"] = self.test_server
conan_digest = FileTreeManifest('123123123', {})
self.client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save({CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"}, path=reg_folder)
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"), "//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin", "executable")).st_mode |
stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(self.package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest))
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_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 export_conanfile(output, paths, file_patterns, origin_folder, conan_ref):
destination_folder = paths.export(conan_ref)
previous_digest = _init_export_folder(destination_folder)
_export(file_patterns, origin_folder, destination_folder)
digest = FileTreeManifest.create(destination_folder)
if previous_digest and previous_digest.file_sums == digest.file_sums:
digest = previous_digest
else:
output.success('A new %s version was exported' % CONANFILE)
save(os.path.join(destination_folder, CONAN_MANIFEST), str(digest))
output.success('%s exported as %s.\nFolder: %s' % (CONANFILE,
str(conan_ref),
destination_folder))
def _create_aux_files(install_folder, package_folder, conanfile, copy_info):
""" auxiliary method that creates CONANINFO and manifest in
the package_folder
"""
logger.debug("Creating config files to %s" % package_folder)
if copy_info:
try:
shutil.copy(os.path.join(install_folder, CONANINFO), package_folder)
except IOError:
raise ConanException("%s does not exist inside of your %s folder. "
"Try to re-build it again to solve it."
% (CONANINFO, install_folder))
else:
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
# Create the digest for the package
digest = FileTreeManifest.create(package_folder)
digest.save(package_folder)
def setUp(self):
self.client = self._get_client()
conan_digest = FileTreeManifest('123123123', {})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save({CONANFILE: myconan1,
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"}, path=reg_folder)
conan_digest.save(reg_folder)
mkdir(self.client.client_cache.export_sources(self.conan_ref))
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"), "//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin", "executable")).st_mode |
stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(self.package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
expected_manifest.save(package_folder)
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def test_tree_manifest(self):
tmp_dir = temp_folder()
files = {"one.ext": "aalakjshdlkjahsdlkjahsdljkhsadljkhasljkdhlkjashd",
"path/to/two.txt": "asdas13123",
"two.txt": "asdasdasdasdasdasd"}
for filename, content in files.iteritems():
save(os.path.join(tmp_dir, filename), content)
manifest = FileTreeManifest.create(tmp_dir)
save(os.path.join(tmp_dir, "THEMANIFEST.txt"), str(manifest))
readed_manifest = FileTreeManifest.loads(load(os.path.join(tmp_dir, "THEMANIFEST.txt")))
self.assertEquals(readed_manifest, manifest)
for filepath, md5readed in manifest.file_sums.iteritems():
content = files[filepath]
self.assertEquals(md5(content), md5readed)
def export_conanfile(output, paths, file_patterns, origin_folder, conan_ref, keep_source=False):
destination_folder = paths.export(conan_ref)
previous_digest = _init_export_folder(destination_folder)
_export(file_patterns, origin_folder, destination_folder)
digest = FileTreeManifest.create(destination_folder)
save(os.path.join(destination_folder, CONAN_MANIFEST), str(digest))
if previous_digest and previous_digest.file_sums == digest.file_sums:
digest = previous_digest
output.info("The stored package has not changed")
else:
output.success('A new %s version was exported' % CONANFILE)
if not keep_source:
rmdir(paths.source(conan_ref))
output.success('%s exported to local storage' % CONANFILE)
output.success('Folder: %s' % destination_folder)
def method_called_test(self):
save(os.path.join(self.client_cache.package(self.package_reference), CONANINFO), "asdasd")
manifest = FileTreeManifest.create(self.client_cache.package(self.package_reference))
save(os.path.join(self.client_cache.package(self.package_reference), CONAN_MANIFEST), str(manifest))
self.assertFalse(self.remote_client.upload_package.called)
self.manager.upload_package(self.package_reference, Remote("other", "url"))
self.assertTrue(self.remote_client.upload_package.called)
self.assertFalse(self.remote_client.get_conan_digest.called)
self.manager.get_conan_digest(self.conan_reference, Remote("other", "url"))
self.assertTrue(self.remote_client.get_conan_digest.called)
self.assertFalse(self.remote_client.get_recipe.called)
self.manager.get_recipe(self.conan_reference, temp_folder(), Remote("other", "url"))
self.assertTrue(self.remote_client.get_recipe.called)
self.assertFalse(self.remote_client.get_package.called)
self.manager.get_package(self.package_reference, temp_folder(), Remote("other", "url"))
self.assertTrue(self.remote_client.get_package.called)
def export_conanfile(output, paths, file_patterns, origin_folder, conan_ref, short_paths,
keep_source):
destination_folder = paths.export(conan_ref)
previous_digest = _init_export_folder(destination_folder)
_export(file_patterns, origin_folder, destination_folder, output)
digest = FileTreeManifest.create(destination_folder)
save(os.path.join(destination_folder, CONAN_MANIFEST), str(digest))
if previous_digest and previous_digest.file_sums == digest.file_sums:
digest = previous_digest
output.info("The stored package has not changed")
modified_recipe = False
else:
output.success('A new %s version was exported' % CONANFILE)
output.info('Folder: %s' % destination_folder)
modified_recipe = True
source = paths.source(conan_ref, short_paths)
dirty = os.path.join(source, DIRTY_FILE)
remove = False
if os.path.exists(dirty):
output.info("Source folder is dirty, forcing removal")
remove = True
elif modified_recipe and not keep_source and os.path.exists(source):
output.info("Package recipe modified in export, forcing source folder removal")
output.info("Use the --keep-source, -k option to skip it")
remove = True
if remove:
output.info("Removing 'source' folder, this can take a while for big packages")
try:
# remove only the internal
rmdir(source)
except BaseException as e:
output.error("Unable to delete source folder. "
"Will be marked as dirty for deletion")
output.warn(str(e))
save(os.path.join(source, DIRTY_FILE), "")
def package_files(self, reference, 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 = ConanFileLoader(self._runner, self._client_cache.settings, 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]
packages_folder = self._client_cache.packages(reference)
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
dest_package_folder = os.path.join(packages_folder, pkg_id)
if os.path.exists(dest_package_folder):
if force:
shutil.rmtree(dest_package_folder)
else:
raise ConanException("Package already exists. "
"Please use --force, -f to overwrite it")
shutil.copytree(package_folder, dest_package_folder)
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
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 _digests(self, digest_path):
if not path_exists(digest_path, self.store):
return None, None
readed_digest = FileTreeManifest.loads(load(digest_path))
expected_digest = FileTreeManifest.create(os.path.dirname(digest_path))
return readed_digest, expected_digest
def valid_digest(self, digest_path):
if not os.path.exists(digest_path):
return False
expected_digest = FileTreeManifest.create(os.path.dirname(digest_path))
readed_digest = FileTreeManifest.loads(load(digest_path))
return readed_digest.file_sums == expected_digest.file_sums
def generate_manifest(package_folder):
# Create the digest for the package
digest = FileTreeManifest.create(package_folder)
save(os.path.join(package_folder, CONAN_MANIFEST), str(digest))
def _digests(self, digest_path):
readed_digest = FileTreeManifest.loads(load(digest_path))
expected_digest = FileTreeManifest.create(os.path.dirname(digest_path))
return readed_digest, expected_digest
def _create_manifest(self, package_reference):
# Create the manifest to be able to upload the package
pack_path = self.client.paths.package(package_reference)
digest_path = self.client.client_cache.digestfile_package(package_reference)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(pack_path, CONAN_MANIFEST), str(expected_manifest))
def complete_test(self):
""" basic installation of a new conans
"""
servers = {}
# All can write (for avoid authentication until we mock user_io)
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers["default"] = test_server
conan_digest = FileTreeManifest(123123123, {})
client = TestClient(servers=servers)
client.init_dynamic_vars()
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.paths.export(conan_ref)
files = hello_source_files()
client.save(files, path=reg_folder)
client.save({CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy"}, path=reg_folder)
package_ref = PackageReference(conan_ref, "fakeid")
package_folder = client.paths.package(package_ref)
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
digest_path = client.client_cache.digestfile_package(package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest))
client.run("upload %s" % str(conan_ref))
client.run("upload %s -p %s" % (str(conan_ref), package_ref.package_id))
client2 = TestClient(servers=servers)
client2.init_dynamic_vars()
installer = ConanProxy(client2.paths, client2.user_io, client2.remote_manager, "default")
installer.get_recipe(conan_ref)
installer.get_package(package_ref, force_build=False, short_paths=False, check_outdated=False)
# Check that the output is done in order
lines = [line.strip() for line in str(client2.user_io.out).splitlines()
if line.startswith("Downloading")]
self.assertEqual(lines, ["Downloading conanmanifest.txt",
"Downloading conanfile.py",
"Downloading conan_export.tgz",
"Downloading conanmanifest.txt",
"Downloading conaninfo.txt",
"Downloading conan_package.tgz"
])
reg_path = client2.paths.export(ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
pack_folder = client2.paths.package(package_ref)
# Test the file in the downloaded conans
files = ['CMakeLists.txt',
'my_lib/debug/libd.a',
'hello.cpp',
'hello0.h',
CONANFILE,
CONAN_MANIFEST,
'main.cpp',
'include/math/lib1.h',
'my_data/readme.txt']
for _file in files:
self.assertTrue(os.path.exists(os.path.join(reg_path, _file)))
self.assertTrue(os.path.exists(pack_folder))
# Test the file in the downloaded package
self.assertTrue(os.path.exists(pack_folder))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "include",
"lib1.h")))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "lib",
"my_lib/libd.a")))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "res",
"shares/readme.txt")))
