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 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 _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 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 _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, 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()