static int metadatalocation_init(_MetadataLocationObject *self, PyObject *args, G_GNUC_UNUSED PyObject *kwds) { char *repopath; PyObject *py_ignore_db = NULL; GError *tmp_err = NULL; if (!PyArg_ParseTuple(args, "sO|:metadatalocation_init", &repopath, &py_ignore_db)) return -1; /* Free all previous resources when reinitialization */ if (self->ml) { cr_metadatalocation_free(self->ml); } /* Init */ self->ml = cr_locate_metadata(repopath, PyObject_IsTrue(py_ignore_db), &tmp_err); if (tmp_err) { nice_exception(&tmp_err, NULL); return -1; } return 0; }
static void test_cr_metadata_locate_and_load_xml(void) { test_helper_check_keys(TEST_REPO_00, CR_HT_KEY_HASH, REPO_SIZE_00, REPO_HASH_KEYS_00); test_helper_check_keys(TEST_REPO_00, CR_HT_KEY_NAME, REPO_SIZE_00, REPO_NAME_KEYS_00); test_helper_check_keys(TEST_REPO_00, CR_HT_KEY_FILENAME, REPO_SIZE_00, REPO_FILENAME_KEYS_00); test_helper_check_keys(TEST_REPO_01, CR_HT_KEY_HASH, REPO_SIZE_01, REPO_HASH_KEYS_01); test_helper_check_keys(TEST_REPO_01, CR_HT_KEY_NAME, REPO_SIZE_01, REPO_NAME_KEYS_01); test_helper_check_keys(TEST_REPO_01, CR_HT_KEY_FILENAME, REPO_SIZE_01, REPO_FILENAME_KEYS_01); test_helper_check_keys(TEST_REPO_02, CR_HT_KEY_HASH, REPO_SIZE_02, REPO_HASH_KEYS_02); test_helper_check_keys(TEST_REPO_02, CR_HT_KEY_NAME, REPO_SIZE_02, REPO_NAME_KEYS_02); test_helper_check_keys(TEST_REPO_02, CR_HT_KEY_FILENAME, REPO_SIZE_02, REPO_FILENAME_KEYS_02); #ifdef WITH_LIBMODULEMD test_helper_check_keys(TEST_REPO_03, CR_HT_KEY_HASH, REPO_SIZE_03, REPO_HASH_KEYS_03); test_helper_check_keys(TEST_REPO_03, CR_HT_KEY_NAME, REPO_SIZE_03, REPO_NAME_KEYS_03); test_helper_check_keys(TEST_REPO_03, CR_HT_KEY_FILENAME, REPO_SIZE_03, REPO_FILENAME_KEYS_03); #else /* If we don't have libmodulemd support, this should fail to locate and * return CRE_MODULEMD */ struct cr_MetadataLocation *ml; g_autoptr (GError) err = NULL; ml = cr_locate_metadata(TEST_REPO_03, TRUE, &err); g_assert_error (err, CREATEREPO_C_ERROR, CRE_MODULEMD); #endif /* WITH_LIBMODULEMD */ }
int cr_metadata_locate_and_load_xml(cr_Metadata *md, const char *repopath, GError **err) { int ret; struct cr_MetadataLocation *ml; GError *tmp_err = NULL; assert(md); assert(repopath); ml = cr_locate_metadata(repopath, TRUE, &tmp_err); if (!ml) { int code = tmp_err->code; g_propagate_error(err, tmp_err); return code; } ret = cr_metadata_load_xml(md, ml, err); cr_metadatalocation_free(ml); return ret; }
static gboolean generate_sqlite_from_xml(const gchar *path, cr_CompressionType compression_type, cr_ChecksumType checksum_type, gboolean local_sqlite, gboolean force, gboolean keep_old, GError **err) { _cleanup_free_ gchar *in_dir = NULL; // path/to/repo/ _cleanup_free_ gchar *in_repo = NULL; // path/to/repo/repodata/ _cleanup_free_ gchar *out_dir = NULL; // path/to/out_repo/ _cleanup_free_ gchar *out_repo = NULL; // path/to/out_repo/repodata/ _cleanup_free_ gchar *tmp_out_repo = NULL; // usually path/to/out_repo/.repodata/ _cleanup_free_ gchar *lock_dir = NULL; // path/to/out_repo/.repodata/ gboolean ret; GError *tmp_err = NULL; // Check if input dir exists in_dir = cr_normalize_dir_path(path); if (!g_file_test(in_dir, G_FILE_TEST_IS_DIR)) { g_set_error(err, CREATEREPO_C_ERROR, CRE_IO, "Directory %s must exist\n", in_dir); return FALSE; } // Set other paths in_repo = g_build_filename(in_dir, "repodata/", NULL); out_dir = g_strdup(in_dir); out_repo = g_strdup(in_repo); lock_dir = g_build_filename(out_dir, ".repodata/", NULL); tmp_out_repo = g_build_filename(out_dir, ".repodata/", NULL); // Block signals that terminates the process if (!cr_block_terminating_signals(err)) return FALSE; // Check if lock exists & Create lock dir if (!cr_lock_repo(out_dir, FALSE, &lock_dir, &tmp_out_repo, err)) return FALSE; // Setup cleanup handlers if (!cr_set_cleanup_handler(lock_dir, tmp_out_repo, err)) return FALSE; // Unblock the blocked signals if (!cr_unblock_terminating_signals(err)) return FALSE; // Locate repodata struct cr_MetadataLocation *md_loc = NULL; _cleanup_free_ gchar *pri_xml_path = NULL; _cleanup_free_ gchar *fil_xml_path = NULL; _cleanup_free_ gchar *oth_xml_path = NULL; _cleanup_free_ gchar *repomd_path = NULL; md_loc = cr_locate_metadata(in_dir, TRUE, NULL); if (!md_loc || !md_loc->repomd) { g_set_error(err, CREATEREPO_C_ERROR, CRE_NOFILE, "repomd.xml doesn't exist"); return FALSE; } repomd_path = g_build_filename(md_loc->repomd, NULL); if (md_loc->pri_xml_href) pri_xml_path = g_build_filename(md_loc->pri_xml_href, NULL); if (md_loc->fil_xml_href) fil_xml_path = g_build_filename(md_loc->fil_xml_href, NULL); if (md_loc->oth_xml_href) oth_xml_path = g_build_filename(md_loc->oth_xml_href, NULL); cr_metadatalocation_free(md_loc); // Parse repomd.xml int rc; cr_Repomd *repomd = cr_repomd_new(); rc = cr_xml_parse_repomd(repomd_path, repomd, warningcb, (void *) repomd_path, err); if (rc != CRE_OK) return FALSE; // Check if DBs already exist or not gboolean dbs_already_exist = FALSE; if (cr_repomd_get_record(repomd, "primary_db") || cr_repomd_get_record(repomd, "filename_db") || cr_repomd_get_record(repomd, "other_db")) { dbs_already_exist = TRUE; } if (dbs_already_exist && !force) { g_set_error(err, CREATEREPO_C_ERROR, CRE_ERROR, "Repository already has sqlitedb present " "in repomd.xml (You may use --force)"); return FALSE; } // Auto-detect used checksum algorithm if not specified explicitly if (checksum_type == CR_CHECKSUM_UNKNOWN) { cr_RepomdRecord *rec = cr_repomd_get_record(repomd, "primary"); if (!rec) { g_set_error(err, CREATEREPO_C_ERROR, CRE_ERROR, "repomd.xml is missing primary metadata"); return FALSE; } if (rec->checksum_type) checksum_type = cr_checksum_type(rec->checksum_type); else if (rec->checksum_open_type) checksum_type = cr_checksum_type(rec->checksum_open_type); if (checksum_type == CR_CHECKSUM_UNKNOWN) { g_debug("Cannot auto-detect checksum type, using default %s", cr_checksum_name_str(DEFAULT_CHECKSUM)); checksum_type = DEFAULT_CHECKSUM; } } // Open sqlite databases _cleanup_free_ gchar *pri_db_filename = NULL; _cleanup_free_ gchar *fil_db_filename = NULL; _cleanup_free_ gchar *oth_db_filename = NULL; cr_SqliteDb *pri_db = NULL; cr_SqliteDb *fil_db = NULL; cr_SqliteDb *oth_db = NULL; _cleanup_file_close_ int pri_db_fd = -1; _cleanup_file_close_ int fil_db_fd = -1; _cleanup_file_close_ int oth_db_fd = -1; g_message("Preparing sqlite DBs"); if (!local_sqlite) { g_debug("Creating databases"); pri_db_filename = g_strconcat(tmp_out_repo, "/primary.sqlite", NULL); fil_db_filename = g_strconcat(tmp_out_repo, "/filelists.sqlite", NULL); oth_db_filename = g_strconcat(tmp_out_repo, "/other.sqlite", NULL); } else { g_debug("Creating databases localy"); const gchar *tmpdir = g_get_tmp_dir(); pri_db_filename = g_build_filename(tmpdir, "primary.XXXXXX.sqlite", NULL); fil_db_filename = g_build_filename(tmpdir, "filelists.XXXXXX.sqlite", NULL); oth_db_filename = g_build_filename(tmpdir, "other.XXXXXXX.sqlite", NULL); pri_db_fd = g_mkstemp(pri_db_filename); g_debug("%s", pri_db_filename); if (pri_db_fd == -1) { g_set_error(err, CREATEREPO_C_ERROR, CRE_IO, "Cannot open %s: %s", pri_db_filename, g_strerror(errno)); return FALSE; } fil_db_fd = g_mkstemp(fil_db_filename); g_debug("%s", fil_db_filename); if (fil_db_fd == -1) { g_set_error(err, CREATEREPO_C_ERROR, CRE_IO, "Cannot open %s: %s", fil_db_filename, g_strerror(errno)); return FALSE; } oth_db_fd = g_mkstemp(oth_db_filename); g_debug("%s", oth_db_filename); if (oth_db_fd == -1) { g_set_error(err, CREATEREPO_C_ERROR, CRE_IO, "Cannot open %s: %s", oth_db_filename, g_strerror(errno)); return FALSE; } } pri_db = cr_db_open_primary(pri_db_filename, err); if (!pri_db) return FALSE; fil_db = cr_db_open_filelists(fil_db_filename, err); assert(fil_db || tmp_err); if (!fil_db) return FALSE; oth_db = cr_db_open_other(oth_db_filename, err); assert(oth_db || tmp_err); if (!oth_db) return FALSE; // XML to Sqlite ret = xml_to_sqlite(pri_xml_path, fil_xml_path, oth_xml_path, pri_db, fil_db, oth_db, err); if (!ret) return FALSE; // Put checksums of XML files into Sqlite ret = sqlite_dbinfo_update(repomd, pri_db, fil_db, oth_db, err); if (!ret) return FALSE; // Close dbs cr_db_close(pri_db, NULL); cr_db_close(fil_db, NULL); cr_db_close(oth_db, NULL); // Repomd records cr_RepomdRecord *pri_db_rec = NULL; cr_RepomdRecord *fil_db_rec = NULL; cr_RepomdRecord *oth_db_rec = NULL; // Compress DB files and fill records ret = compress_sqlite_dbs(tmp_out_repo, pri_db_filename, &pri_db_rec, fil_db_filename, &fil_db_rec, oth_db_filename, &oth_db_rec, compression_type, checksum_type, err); if (!ret) return FALSE; // Prepare new repomd.xml ret = gen_new_repomd(tmp_out_repo, repomd, pri_db_rec, fil_db_rec, oth_db_rec, err); if (!ret) return FALSE; // Move the results (compressed DBs and repomd.xml) into in_repo ret = move_results(tmp_out_repo, in_repo, err); if (!ret) return FALSE; // Remove old DBs if (dbs_already_exist && force && !keep_old) { ret = remove_old_if_different(in_dir, cr_repomd_get_record(repomd, "primary_db"), pri_db_rec, err); if (!ret) return FALSE; ret = remove_old_if_different(in_dir, cr_repomd_get_record(repomd, "filelists_db"), fil_db_rec, err); if (!ret) return FALSE; ret = remove_old_if_different(in_dir, cr_repomd_get_record(repomd, "other_db"), oth_db_rec, err); if (!ret) return FALSE; } // Remove tmp_out_repo g_rmdir(tmp_out_repo); // Clean up cr_repomd_free(repomd); cr_repomd_record_free(pri_db_rec); cr_repomd_record_free(fil_db_rec); cr_repomd_record_free(oth_db_rec); return TRUE; }