/*
* __wt_metadata_update --
* Update a row in the metadata.
*/
int
__wt_metadata_update(
WT_SESSION_IMPL *session, const char *key, const char *value)
{
WT_CURSOR *cursor;
WT_DECL_RET;
WT_RET(__wt_verbose(session, WT_VERB_METADATA,
"Update: key: %s, value: %s, tracking: %s, %s" "turtle",
key, value, WT_META_TRACKING(session) ? "true" : "false",
__metadata_turtle(key) ? "" : "not "));
if (__metadata_turtle(key))
return (__wt_turtle_update(session, key, value));
if (WT_META_TRACKING(session))
WT_RET(__wt_meta_track_update(session, key));
WT_RET(__wt_metadata_cursor(session, "overwrite", &cursor));
cursor->set_key(cursor, key);
cursor->set_value(cursor, value);
WT_ERR(cursor->insert(cursor));
err: WT_TRET(cursor->close(cursor));
return (ret);
}
/*
* __wt_metadata_update --
* Update a row in the metadata.
*/
int
__wt_metadata_update(
WT_SESSION_IMPL *session, const char *key, const char *value)
{
WT_CURSOR *cursor;
WT_DECL_RET;
WT_RET(__wt_verbose(session, WT_VERB_METADATA,
"Update: key: %s, value: %s, tracking: %s, %s" "turtle",
key, value, WT_META_TRACKING(session) ? "true" : "false",
__metadata_turtle(key) ? "" : "not "));
if (__metadata_turtle(key)) {
WT_WITH_TURTLE_LOCK(session, ret,
ret = __wt_turtle_update(session, key, value));
return (ret);
}
if (WT_META_TRACKING(session))
WT_RET(__wt_meta_track_update(session, key));
WT_RET(__wt_metadata_cursor(session, &cursor));
/* This cursor needs to have overwrite semantics. */
WT_ASSERT(session, F_ISSET(cursor, WT_CURSTD_OVERWRITE));
cursor->set_key(cursor, key);
cursor->set_value(cursor, value);
WT_ERR(cursor->insert(cursor));
err: WT_TRET(__wt_metadata_cursor_release(session, &cursor));
return (ret);
}
/*
* __wt_turtle_init --
* Check the turtle file and create if necessary.
*/
int
__wt_turtle_init(WT_SESSION_IMPL *session)
{
WT_DECL_RET;
int exist, exist_incr;
char *metaconf;
metaconf = NULL;
/*
* Discard any turtle setup file left-over from previous runs. This
* doesn't matter for correctness, it's just cleaning up random files.
*/
WT_RET(__wt_remove_if_exists(session, WT_METADATA_TURTLE_SET));
/*
* We could die after creating the turtle file and before creating the
* metadata file, or worse, the metadata file might be in some random
* state. Make sure that doesn't happen: if we don't find the turtle
* file, first create the metadata file, load any hot backup, and then
* create the turtle file. No matter what happens, if metadata file
* creation doesn't fully complete, we won't have a turtle file and we
* will repeat the process until we succeed.
*
* Incremental backups can occur only run recovery is run and it becomes
* live. So if there is a turtle file and an incremental backup file
* that is an error. Otherwise, if there's already a turtle file,
* we're done.
*/
WT_RET(__wt_exist(session, WT_INCREMENTAL_BACKUP, &exist_incr));
WT_RET(__wt_exist(session, WT_METADATA_TURTLE, &exist));
if (exist) {
if (exist_incr)
WT_RET_MSG(session, EINVAL,
"Incremental backup after running recovery "
"is not allowed.");
return (0);
}
if (exist_incr)
F_SET(S2C(session), WT_CONN_WAS_BACKUP);
/* Create the metadata file. */
WT_RET(__metadata_init(session));
/* Load any hot-backup information. */
WT_RET(__metadata_load_hot_backup(session));
/* Create any bulk-loaded file stubs. */
WT_RET(__metadata_load_bulk(session));
/* Create the turtle file. */
WT_RET(__metadata_config(session, &metaconf));
WT_ERR(__wt_turtle_update(session, WT_METAFILE_URI, metaconf));
/* Remove the backup files, we'll never read them again. */
WT_ERR(__wt_backup_file_remove(session));
err: __wt_free(session, metaconf);
return (ret);
}
/*
* __wt_turtle_init --
* Check the turtle file and create if necessary.
*/
int
__wt_turtle_init(WT_SESSION_IMPL *session)
{
WT_DECL_RET;
int exist;
char *metaconf;
metaconf = NULL;
/*
* Discard any turtle setup file left-over from previous runs. This
* doesn't matter for correctness, it's just cleaning up random files.
*/
WT_RET(__wt_exist(session, WT_METADATA_TURTLE_SET, &exist));
if (exist)
WT_RET(__wt_remove(session, WT_METADATA_TURTLE_SET));
/*
* We could die after creating the turtle file and before creating the
* metadata file, or worse, the metadata file might be in some random
* state. Make sure that doesn't happen: if we don't find the turtle
* file, first create the metadata file, load any hot backup, and then
* create the turtle file. No matter what happens, if metadata file
* creation doesn't fully complete, we won't have a turtle file and we
* will repeat the process until we succeed.
*
* If there's already a turtle file, we're done.
*/
WT_RET(__wt_exist(session, WT_METADATA_TURTLE, &exist));
if (exist)
return (0);
/* Create the metadata file. */
WT_RET(__metadata_init(session));
/* Load any hot-backup information. */
WT_RET(__metadata_load_hot_backup(session));
/* Create any bulk-loaded file stubs. */
WT_RET(__metadata_load_bulk(session));
/* Create the turtle file. */
WT_RET(__metadata_config(session, &metaconf));
WT_ERR(__wt_turtle_update(session, WT_METAFILE_URI, metaconf));
/* Remove the backup file if it exists, we'll never read it again. */
WT_ERR(__wt_exist(session, WT_METADATA_BACKUP, &exist));
if (exist)
WT_ERR(__wt_remove(session, WT_METADATA_BACKUP));
err: __wt_free(session, metaconf);
return (ret);
}
/*
* __wt_metadata_update --
* Update a row in the metadata.
*/
int
__wt_metadata_update(
WT_SESSION_IMPL *session, const char *key, const char *value)
{
WT_CURSOR *cursor;
WT_DECL_RET;
if (__metadata_turtle(key))
return (__wt_turtle_update(session, key, value));
if (WT_META_TRACKING(session))
WT_RET(__wt_meta_track_update(session, key));
WT_RET(__wt_metadata_cursor(session, "overwrite", &cursor));
cursor->set_key(cursor, key);
cursor->set_value(cursor, value);
WT_ERR(cursor->insert(cursor));
err: WT_TRET(cursor->close(cursor));
return (ret);
}
/*
* __wt_turtle_init --
* Check the turtle file and create if necessary.
*/
int
__wt_turtle_init(WT_SESSION_IMPL *session)
{
WT_DECL_RET;
bool exist_backup, exist_incr, exist_isrc, exist_turtle, load;
char *metaconf;
metaconf = NULL;
load = false;
/*
* Discard any turtle setup file left-over from previous runs. This
* doesn't matter for correctness, it's just cleaning up random files.
*/
WT_RET(__wt_remove_if_exists(session, WT_METADATA_TURTLE_SET, false));
/*
* We could die after creating the turtle file and before creating the
* metadata file, or worse, the metadata file might be in some random
* state. Make sure that doesn't happen: if we don't find the turtle
* file, first create the metadata file, load any hot backup, and then
* create the turtle file. No matter what happens, if metadata file
* creation doesn't fully complete, we won't have a turtle file and we
* will repeat the process until we succeed.
*
* Incremental backups can occur only if recovery is run and it becomes
* live. So, if there is a turtle file and an incremental backup file,
* that is an error. Otherwise, if there's already a turtle file, we're
* done.
*/
WT_RET(__wt_fs_exist(session, WT_INCREMENTAL_BACKUP, &exist_incr));
WT_RET(__wt_fs_exist(session, WT_INCREMENTAL_SRC, &exist_isrc));
WT_RET(__wt_fs_exist(session, WT_METADATA_BACKUP, &exist_backup));
WT_RET(__wt_fs_exist(session, WT_METADATA_TURTLE, &exist_turtle));
if (exist_turtle) {
/*
* We need to detect the difference between a source database
* that may have crashed with an incremental backup file
* and a destination database that incorrectly ran recovery.
*/
if (exist_incr && !exist_isrc)
WT_RET_MSG(session, EINVAL,
"Incremental backup after running recovery "
"is not allowed");
/*
* If we have a backup file and metadata and turtle files,
* we want to recreate the metadata from the backup.
*/
if (exist_backup) {
WT_RET(__wt_msg(session,
"Both %s and %s exist; recreating metadata from "
"backup",
WT_METADATA_TURTLE, WT_METADATA_BACKUP));
WT_RET(
__wt_remove_if_exists(session, WT_METAFILE, false));
WT_RET(__wt_remove_if_exists(
session, WT_METADATA_TURTLE, false));
load = true;
}
} else
load = true;
if (load) {
if (exist_incr)
F_SET(S2C(session), WT_CONN_WAS_BACKUP);
/* Create the metadata file. */
WT_RET(__metadata_init(session));
/* Load any hot-backup information. */
WT_RET(__metadata_load_hot_backup(session));
/* Create any bulk-loaded file stubs. */
WT_RET(__metadata_load_bulk(session));
/* Create the turtle file. */
WT_RET(__metadata_config(session, &metaconf));
WT_WITH_TURTLE_LOCK(session, ret,
ret = __wt_turtle_update(
session, WT_METAFILE_URI, metaconf));
WT_ERR(ret);
}
/* Remove the backup files, we'll never read them again. */
WT_ERR(__wt_backup_file_remove(session));
err: __wt_free(session, metaconf);
return (ret);
}