mirror of
https://github.com/openai/codex.git
synced 2026-11-18 15:01:48 +00:00
Further investigation of the sqlite incidents showed that the problems are due to corruption from the older version of SQLite that we recently upgraded, and that the data is truly corrupted in the root database -- recovery of all data is not possible. Given that the data is reconstructable from the rollouts on disk, we should just auto-backup the database and let codex rebuild the rollout info from the disk rollouts. The new behavior is that appserver auto-backs-up and rebuilds (with logs reflecting that behavior). The CLI now pops a message letting you know this happened and the paths of the backed-up corrupt db and the new database. There is also context added so that the desktop app can read the rebuild info from it and inform the user with it.
106 lines
3.7 KiB
Rust
106 lines
3.7 KiB
Rust
use super::*;
|
|
use crate::runtime::test_support::unique_temp_dir;
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[tokio::test]
|
|
async fn backup_moves_only_requested_runtime_db_files_to_backup_folder() -> std::io::Result<()> {
|
|
let sqlite_home = unique_temp_dir();
|
|
tokio::fs::create_dir_all(sqlite_home.as_path()).await?;
|
|
let runtime_paths = super::super::runtime_db_paths(sqlite_home.as_path());
|
|
let mut expected_paths = Vec::new();
|
|
for db_path in runtime_paths.iter().map(|db| db.path.as_path()) {
|
|
for path in sqlite_paths(db_path) {
|
|
tokio::fs::write(path.as_path(), path.display().to_string()).await?;
|
|
expected_paths.push(path);
|
|
}
|
|
}
|
|
let failed_db_path = super::super::logs_db_path(sqlite_home.as_path());
|
|
let failed_paths = sqlite_paths(failed_db_path.as_path());
|
|
|
|
let backups = backup_runtime_db_for_fresh_start(failed_db_path.as_path()).await?;
|
|
|
|
assert_eq!(backups.len(), failed_paths.len());
|
|
for path in &failed_paths {
|
|
assert!(!tokio::fs::try_exists(path.as_path()).await?);
|
|
}
|
|
for path in expected_paths
|
|
.iter()
|
|
.filter(|path| !failed_paths.contains(path))
|
|
{
|
|
assert!(tokio::fs::try_exists(path.as_path()).await?);
|
|
}
|
|
for backup in backups {
|
|
assert!(
|
|
backup
|
|
.backup_path
|
|
.starts_with(sqlite_home.join(BACKUP_DIR_NAME))
|
|
);
|
|
assert!(tokio::fs::try_exists(backup.backup_path.as_path()).await?);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn backup_replaces_blocking_sqlite_home_file() -> std::io::Result<()> {
|
|
let temp_dir = unique_temp_dir();
|
|
tokio::fs::create_dir_all(temp_dir.as_path()).await?;
|
|
let sqlite_home = temp_dir.join("sqlite-home");
|
|
tokio::fs::write(sqlite_home.as_path(), b"not-a-directory").await?;
|
|
|
|
let backups = backup_runtime_db_for_fresh_start(
|
|
super::super::state_db_path(sqlite_home.as_path()).as_path(),
|
|
)
|
|
.await?;
|
|
|
|
assert_eq!(backups.len(), 1);
|
|
assert!(tokio::fs::metadata(sqlite_home.as_path()).await?.is_dir());
|
|
assert!(
|
|
backups[0]
|
|
.backup_path
|
|
.starts_with(temp_dir.join(format!("sqlite-home.{BACKUP_DIR_NAME}")))
|
|
);
|
|
assert!(tokio::fs::try_exists(backups[0].backup_path.as_path()).await?);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn sqlite_error_detail_classifies_corruption_and_lock_errors() {
|
|
assert!(sqlite_error_detail_is_corruption("file is not a database"));
|
|
assert!(sqlite_error_detail_is_corruption(
|
|
"error returned from database: (code: 11) database disk image is malformed"
|
|
));
|
|
assert!(!sqlite_error_detail_is_corruption("database is locked"));
|
|
assert!(sqlite_error_detail_is_lock("database is locked"));
|
|
assert!(sqlite_error_detail_is_lock("database is busy"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn runtime_db_path_for_corruption_error_returns_failed_database_path() -> std::io::Result<()>
|
|
{
|
|
let sqlite_home = unique_temp_dir();
|
|
tokio::fs::create_dir_all(sqlite_home.as_path()).await?;
|
|
let path = super::super::state_db_path(sqlite_home.as_path());
|
|
tokio::fs::write(path.as_path(), b"not sqlite").await?;
|
|
|
|
let err = match super::super::StateRuntime::init(sqlite_home, "openai".to_string()).await {
|
|
Ok(_) => panic!("malformed sqlite should fail to initialize"),
|
|
Err(err) => err,
|
|
};
|
|
|
|
assert_eq!(runtime_db_path_for_corruption_error(&err), Some(path));
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn runtime_db_path_for_corruption_error_ignores_corrupt_word_in_path() {
|
|
let path = PathBuf::from("/tmp/sqlite_corrupt/state_5.sqlite");
|
|
let err = anyhow::Error::new(RuntimeDbInitError::new(
|
|
"state DB",
|
|
"open",
|
|
path.as_path(),
|
|
anyhow::anyhow!("permission denied"),
|
|
));
|
|
|
|
assert_eq!(runtime_db_path_for_corruption_error(&err), None);
|
|
}
|