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;
}
