def test_load_unload(self):
a = PackageMetadata()
a.recipe.revision = "rev"
a.recipe.checksums["somefile1"] = {
"md5": "50b2137a5d63567b7e88b743a3b594cf",
"sha1": "0b7e8ed59ff4eacb95fd3cc8e17a8034584a96c2"
}
a.packages["ID"].recipe_revision = "rec_rev"
a.packages["ID"].revision = "revp"
a.packages["ID"].properties["Someprop"] = "23"
a.packages["ID"].checksums["somefile2"] = {
"md5": "efb7597b146344532fe8da2b79860aaa",
"sha1": "cc3e6eae41eca26538630f4cd5b0bf4fb52e2d"
}
tmp = a.dumps()
b = PackageMetadata.loads(tmp)
self.assertEqual(b, a)
self.assertEqual(b.packages["ID"].properties["Someprop"], "23")
self.assertEqual(b.recipe.checksums["somefile1"]["md5"],
"50b2137a5d63567b7e88b743a3b594cf")
self.assertEqual(b.packages["ID"].checksums["somefile2"]["sha1"],
"cc3e6eae41eca26538630f4cd5b0bf4fb52e2d")
def update_metadata(self):
try:
metadata = self.load_metadata()
except RecipeNotFoundException:
metadata = PackageMetadata()
yield metadata
save(self.package_metadata(), metadata.dumps())
def update_metadata(self):
lockfile = self.package_metadata() + ".lock"
with fasteners.InterProcessLock(lockfile, logger=logger):
try:
metadata = self.load_metadata()
except RecipeNotFoundException:
metadata = PackageMetadata()
yield metadata
save(self.package_metadata(), metadata.dumps())
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.export(self.ref)
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 = hello_source_files()
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.conan(self.ref))
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.cache.export_sources(self.ref))
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(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)
package_path = self.client.cache.package(self.pref)
expected_manifest = FileTreeManifest.create(package_path)
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 test_load_unload(self):
a = PackageMetadata()
a.recipe.revision = "rev"
a.packages["ID"].recipe_revision = "rec_rev"
a.packages["ID"].revision = "revp"
a.packages["ID"].properties["Someprop"] = "23"
tmp = a.dumps()
b = PackageMetadata.loads(tmp)
self.assertEquals(b, a)
self.assertEqual(b.packages["ID"].properties["Someprop"], "23")
def test_other_types_than_str(self):
a = PackageMetadata()
a.recipe.revision = "rev"
a.packages["ID"].recipe_revision = 34
a.packages["ID"].revision = {"23": 45}
a.packages["ID"].properties["Someprop"] = [23, 2444]
tmp = a.dumps()
b = PackageMetadata.loads(tmp)
self.assertEquals(b, a)
self.assertEqual(b.packages["ID"].revision, {"23": 45})
self.assertEqual(b.packages["ID"].properties["Someprop"], [23, 2444])
def update_metadata(self):
metadata_path = self.package_metadata()
lockfile = metadata_path + ".lock"
with fasteners.InterProcessLock(lockfile, logger=logger):
lock_name = self.package_metadata() # The path is the thing that defines mutex
thread_lock = PackageCacheLayout._metadata_locks.setdefault(lock_name, threading.Lock())
thread_lock.acquire()
try:
try:
metadata = self.load_metadata()
except RecipeNotFoundException:
metadata = PackageMetadata()
yield metadata
save(metadata_path, metadata.dumps())
finally:
thread_lock.release()
def test_package_exists(self):
pref = PackageReference(self.ref, "999")
layout = self.cache.package_layout(self.ref)
self.assertFalse(layout.package_exists(pref))
mkdir(layout.export())
mkdir(layout.package(pref))
save(
os.path.join(
self.cache.package_layout(self.ref).package_metadata()),
PackageMetadata().dumps())
self.assertTrue(layout.package_exists(pref))
# But if ref has revision and it doesn't match, it doesn't exist
ref2 = self.ref.copy_with_rev("revision")
pref2 = PackageReference(ref2, "999", "prevision")
layout2 = self.cache.package_layout(ref2)
self.assertFalse(layout2.package_exists(pref2))
# Fake the metadata and check again
with layout2.update_metadata() as metadata:
metadata.recipe.revision = "revision"
metadata.packages[pref2.id].revision = "prevision"
self.assertTrue(layout2.package_exists(pref2))
def _create_conanfile(self, ref, paths, content="default_content"):
origin_reg = paths.package_layout(ref).export()
mkdir(origin_reg)
save(os.path.join(origin_reg, "conanfile.py"), content)
save(
paths.package_layout(ref).package_metadata(),
PackageMetadata().dumps())
mkdir(paths.package_layout(ref).export_sources())
def _migrate_create_metadata(cache, out):
out.warn("Migration: Generating missing metadata files")
refs = _get_refs(cache)
for ref in refs:
try:
base_folder = os.path.normpath(
os.path.join(cache.store, ref.dir_repr()))
# Force using a package cache layout for everything, we want to alter the cache,
# not the editables
layout = PackageCacheLayout(base_folder=base_folder,
ref=ref,
short_paths=False,
no_lock=True)
folder = layout.export()
try:
manifest = FileTreeManifest.load(folder)
rrev = manifest.summary_hash
except Exception:
rrev = DEFAULT_REVISION_V1
metadata_path = layout.package_metadata()
if not os.path.exists(metadata_path):
out.info("Creating {} for {}".format(PACKAGE_METADATA, ref))
prefs = _get_prefs(layout)
metadata = PackageMetadata()
metadata.recipe.revision = rrev
for pref in prefs:
try:
pmanifest = FileTreeManifest.load(layout.package(pref))
prev = pmanifest.summary_hash
except Exception:
prev = DEFAULT_REVISION_V1
metadata.packages[pref.id].revision = prev
metadata.packages[
pref.id].recipe_revision = metadata.recipe.revision
save(metadata_path, metadata.dumps())
except Exception as e:
raise ConanException(
"Something went wrong while generating the metadata.json files "
"in the cache, please try to fix the issue or wipe the cache: {}"
":{}".format(ref, e))
out.success("Migration: Generating missing metadata files finished OK!\n")
def test_recipe_exists(self):
layout = self.cache.package_layout(self.ref)
self.assertFalse(layout.recipe_exists())
mkdir(self.cache.export(self.ref))
self.assertTrue(layout.recipe_exists())
# But if ref has revision and it doesn't match, it doesn't exist
save(os.path.join(self.cache.conan(self.ref), "metadata.json"),
PackageMetadata().dumps())
ref2 = self.ref.copy_with_rev("revision")
layout2 = self.cache.package_layout(ref2)
self.assertFalse(layout2.recipe_exists())
# Fake the metadata and check again
with layout.update_metadata() as metadata:
metadata.recipe.revision = "revision"
self.assertTrue(layout2.recipe_exists())
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 = {}
prefs = []
for key, folder in self.root_folder.items():
ref = ConanFileReference.loads(folder)
folder = folder.replace("@", "/")
fake_metadata = PackageMetadata()
fake_metadata.recipe.revision = DEFAULT_REVISION_V1
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)
fake_metadata.packages[pack_id].revision = DEFAULT_REVISION_V1
prefs.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)] = ""
files["%s/metadata.json" % folder] = fake_metadata.dumps()
exports_sources_dir = client.cache.package_layout(
ref).export_sources()
os.makedirs(exports_sources_dir)
client.save(files, client.cache.store)
# Create the manifests to be able to upload
for pref in prefs:
pkg_folder = client.cache.package_layout(pref.ref).package(pref)
expected_manifest = FileTreeManifest.create(pkg_folder)
files["%s/%s/%s/%s" %
(pref.ref.dir_repr(), PACKAGES_FOLDER, pref.id,
CONAN_MANIFEST)] = repr(expected_manifest)
client.save(files, 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 load_metadata(self):
try:
text = load(self.package_metadata())
except IOError:
raise RecipeNotFoundException(self._ref)
return PackageMetadata.loads(text)
def load_metadata(self, conan_reference):
try:
text = load(self.package_metadata(conan_reference))
return PackageMetadata.loads(text)
except IOError:
return PackageMetadata()
def load_metadata(self):
try:
text = load(self.package_metadata())
return PackageMetadata.loads(text)
except IOError:
return PackageMetadata()
