Page MenuHomePhorge
Files F32098198

D15401.1765011374.diff
No OneTemporary
Actions

Size
21 KB
Referenced Files
None
Subscribers
None

D15401.1765011374.diff
View Options

diff --git a/native/cpp/CommonCpp/DatabaseManagers/DatabaseManager.cpp b/native/cpp/CommonCpp/DatabaseManagers/DatabaseManager.cpp
--- a/native/cpp/CommonCpp/DatabaseManagers/DatabaseManager.cpp
+++ b/native/cpp/CommonCpp/DatabaseManagers/DatabaseManager.cpp
@@ -304,14 +304,26 @@
logID = "1";
}
+ Logger::log(
+ "BACKUP_LOG: Starting log generation - backupID=" + backupID +
+ ", logID=" + logID);
+
bool newLogCreated =
DatabaseManager::mainConnectionManager->captureNextLog(backupID, logID);
if (!newLogCreated) {
+ Logger::log(
+ "BACKUP_LOG: No changes detected, skipping log generation - backupID=" +
+ backupID + ", logID=" + logID);
return;
}
+ int nextLogID = std::stoi(logID) + 1;
DatabaseManager::getQueryExecutor().setMetadata(
- "logID", std::to_string(std::stoi(logID) + 1));
+ "logID", std::to_string(nextLogID));
+
+ Logger::log(
+ "BACKUP_LOG: Log generated successfully - backupID=" + backupID +
+ ", logID=" + logID + ", nextLogID=" + std::to_string(nextLogID));
}
void DatabaseManager::triggerBackupFileUpload() {
diff --git a/native/cpp/CommonCpp/DatabaseManagers/NativeSQLiteConnectionManager.cpp b/native/cpp/CommonCpp/DatabaseManagers/NativeSQLiteConnectionManager.cpp
--- a/native/cpp/CommonCpp/DatabaseManagers/NativeSQLiteConnectionManager.cpp
+++ b/native/cpp/CommonCpp/DatabaseManagers/NativeSQLiteConnectionManager.cpp
@@ -53,12 +53,19 @@
PlatformSpecificTools::getBackupLogFilePath(backupID, logID, false);
std::string tempFilePath = finalFilePath + "_tmp";
+ Logger::log(
+ "BACKUP_LOG: Starting file write - backupID=" + backupID +
+ ", logID=" + logID + ", size=" + std::to_string(patchsetSize) +
+ ", path=" + finalFilePath);
+
std::ofstream tempFile(
tempFilePath, std::ofstream::out | std::ofstream::trunc);
if (!tempFile.is_open()) {
std::string errorMessage{
- "Failed to open temporary file when persisting log"};
+ "BACKUP_LOG: Failed to open temporary file when persisting log - "
+ "backupID=" +
+ backupID + ", logID=" + logID + ", path=" + tempFilePath};
Logger::log(errorMessage);
throw std::runtime_error(errorMessage);
}
@@ -80,15 +87,24 @@
if (std::rename(tempFilePath.c_str(), finalFilePath.c_str())) {
std::string errorMessage{
- "Failed to rename complete log file from temporary path to target when "
- "persisting log"};
+ "BACKUP_LOG: Failed to rename complete log file from temporary path to "
+ "target when persisting log - backupID=" +
+ backupID + ", logID=" + logID + ", tempPath=" + tempFilePath +
+ ", finalPath=" + finalFilePath};
Logger::log(errorMessage);
throw std::runtime_error(errorMessage);
}
+ Logger::log(
+ "BACKUP_LOG: File written successfully - backupID=" + backupID +
+ ", logID=" + logID + ", path=" + finalFilePath);
+
std::vector<std::string> attachments =
getAttachmentsFromLog(patchsetPtr, patchsetSize);
if (attachments.empty()) {
+ Logger::log(
+ "BACKUP_LOG: No attachments found - backupID=" + backupID +
+ ", logID=" + logID);
return;
}
@@ -96,12 +112,19 @@
PlatformSpecificTools::getBackupLogFilePath(backupID, logID, true);
std::string tempAttachmentsPath = finalAttachmentsPath + "_tmp";
+ Logger::log(
+ "BACKUP_LOG: Starting attachment file write - backupID=" + backupID +
+ ", logID=" + logID + ", attachments=" +
+ std::to_string(attachments.size()) + ", path=" + finalAttachmentsPath);
+
std::ofstream tempAttachmentsFile(
tempAttachmentsPath, std::ofstream::out | std::ofstream::trunc);
if (!tempAttachmentsFile.is_open()) {
std::string errorMessage{
- "Failed to open temporary log attachments file when persisting log"};
+ "BACKUP_LOG: Failed to open temporary log attachments file when "
+ "persisting log - backupID=" +
+ backupID + ", logID=" + logID + ", path=" + tempAttachmentsPath};
Logger::log(errorMessage);
throw std::runtime_error(errorMessage);
}
@@ -113,11 +136,18 @@
if (std::rename(tempAttachmentsPath.c_str(), finalAttachmentsPath.c_str())) {
std::string errorMessage{
- "Failed to rename complete log attachments file from temporary path to "
- "target path when persisting log"};
+ "BACKUP_LOG: Failed to rename complete log attachments file from "
+ "temporary path to target path when persisting log - backupID=" +
+ backupID + ", logID=" + logID + ", tempPath=" + tempAttachmentsPath +
+ ", finalPath=" + finalAttachmentsPath};
Logger::log(errorMessage);
throw std::runtime_error(errorMessage);
}
+
+ Logger::log(
+ "BACKUP_LOG: Attachment file written successfully - backupID=" +
+ backupID + ", logID=" + logID + ", attachments=" +
+ std::to_string(attachments.size()) + ", path=" + finalAttachmentsPath);
}
std::vector<std::string> NativeSQLiteConnectionManager::getAttachmentsFromLog(
diff --git a/native/native_rust_library/src/backup/upload_handler.rs b/native/native_rust_library/src/backup/upload_handler.rs
--- a/native/native_rust_library/src/backup/upload_handler.rs
+++ b/native/native_rust_library/src/backup/upload_handler.rs
@@ -169,15 +169,19 @@
Ok(async move {
println!("Backup handler task id={task_id} started.");
'task_loop: loop {
+ println!("BACKUP_LOG: Attempting to establish WebSocket connection");
let logs_upload_stream = tokio::select!(
result = backup_client.upload_logs(&user_identity) => result,
_ = cancel_token.cancelled() => { break 'task_loop; }
);
let (tx, rx) = match logs_upload_stream {
- Ok(ws) => ws,
+ Ok(ws) => {
+ println!("BACKUP_LOG: WebSocket connection established successfully");
+ ws
+ }
Err(err) => {
println!(
- "Backup handler error when estabilishing connection: '{err:?}'"
+ "BACKUP_LOG: Failed to establish WebSocket connection: '{err:?}'"
);
tokio::time::sleep(BACKUP_SERVICE_CONNECTION_RETRY_DELAY).await;
continue;
@@ -197,14 +201,27 @@
_ = cancel_token.cancelled() => { break 'task_loop; }
};
- println!("Backup handler error: '{err:?}'");
+ println!("BACKUP_LOG: Backup handler error occurred: '{err:?}'");
match err {
BackupHandlerError::BackupError(_)
| BackupHandlerError::WSClosed
- | BackupHandlerError::LockError => break,
+ | BackupHandlerError::LockError => {
+ println!(
+ "BACKUP_LOG: Connection error, breaking to restart connection"
+ );
+ break;
+ }
BackupHandlerError::IoError(_)
- | BackupHandlerError::CxxException(_) => continue,
- BackupHandlerError::FromUtf8Error(_) => break,
+ | BackupHandlerError::CxxException(_) => {
+ println!(
+ "BACKUP_LOG: IO/CXX error, continuing with current connection"
+ );
+ continue;
+ }
+ BackupHandlerError::FromUtf8Error(_) => {
+ println!("BACKUP_LOG: UTF8 error, breaking to restart connection");
+ break;
+ }
}
}
@@ -212,9 +229,9 @@
_ = tokio::time::sleep(BACKUP_SERVICE_CONNECTION_RETRY_DELAY) => (),
_ = cancel_token.cancelled() => { break 'task_loop; }
);
- println!("Retrying backup log upload");
+ println!("BACKUP_LOG: Retrying backup log upload after delay");
}
- println!("Backup handler task id={task_id} stopped.");
+ println!("BACKUP_LOG: Backup handler task id={task_id} stopped.");
})
}
@@ -250,15 +267,28 @@
// handled when we iterate over the corresponding files with the
// main content
if additional_data.is_some() {
+ println!("BACKUP_LOG: Skipping attachment file - path={:?}", path);
continue;
}
match log_id {
- Some(id) => logs.push((path, backup_id, id)),
+ Some(id) => {
+ println!(
+ "BACKUP_LOG: Found log file - backupID={}, logID={}, path={:?}",
+ backup_id, id, path
+ );
+ logs.push((path, backup_id, id));
+ }
None => {
+ println!(
+ "BACKUP_LOG: Found compaction file - backupID={}, path={:?}",
+ backup_id, path
+ );
compaction_ids.insert(backup_id);
}
}
+ } else {
+ println!("BACKUP_LOG: Skipping unrecognized file - path={:?}", path);
}
}
@@ -268,13 +298,19 @@
for (path, backup_id, log_id) in logs {
if logs_waiting_for_confirmation.lock().await.contains(&path) {
+ println!("BACKUP_LOG: Skipping already processing file - backupID={}, logID={}, path={:?}", backup_id, log_id, path);
continue;
}
- log::upload_files(tx, backup_id, log_id).await?;
+ println!(
+ "BACKUP_LOG: Starting upload - backupID={}, logID={}, path={:?}",
+ backup_id, log_id, path
+ );
+ log::upload_files(tx, backup_id.clone(), log_id).await?;
logs_waiting_for_confirmation
.lock()
.await
.insert(path.clone());
+ println!("BACKUP_LOG: Log sent, added to waiting confirmation - backupID={}, logID={}", backup_id, log_id);
}
TRIGGER_BACKUP_FILE_UPLOAD.notified().await;
@@ -290,16 +326,32 @@
while let Some(LogUploadConfirmation { backup_id, log_id }) =
rx.next().await.transpose()?
{
+ println!(
+ "BACKUP_LOG: Received upload confirmation - backupID={}, logID={}",
+ backup_id, log_id
+ );
+
let path =
get_backup_log_file_path(&backup_id, &log_id.to_string(), false)?;
- logs_waiting_for_confirmation
+ let was_removed = logs_waiting_for_confirmation
.lock()
.await
.remove(&PathBuf::from(path));
+ if was_removed {
+ println!("BACKUP_LOG: Removed from waiting confirmation set - backupID={}, logID={}", backup_id, log_id);
+ } else {
+ println!("BACKUP_LOG: WARNING: Confirmation received but log not in waiting set - backupID={}, logID={}", backup_id, log_id);
+ }
+
+ println!(
+ "BACKUP_LOG: Starting file cleanup - backupID={}, logID={}",
+ backup_id, log_id
+ );
tokio::spawn(log::cleanup_files(backup_id, log_id));
}
+ println!("BACKUP_LOG: WebSocket closed, exiting confirmation handler");
Err(BackupHandlerError::WSClosed)
}
@@ -311,41 +363,126 @@
user_identity: &UserIdentity,
backup_id: String,
) -> Result<(), BackupHandlerError> {
+ println!(
+ "BACKUP_LOG: Starting compaction upload - backupID={}",
+ backup_id
+ );
+
let user_data_path = get_backup_file_path(&backup_id, false, false)?;
let user_data = match tokio::fs::read(&user_data_path).await {
- Ok(data) => Some(data),
- Err(err) if err.kind() == ErrorKind::NotFound => None,
- Err(err) => return Err(err.into()),
+ Ok(data) => {
+ println!(
+ "BACKUP_LOG: User data file read - backupID={}, size={}, path={}",
+ backup_id,
+ data.len(),
+ user_data_path
+ );
+ Some(data)
+ }
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: User data file not found - backupID={}, path={}",
+ backup_id, user_data_path
+ );
+ None
+ }
+ Err(err) => {
+ println!("BACKUP_LOG: Error reading user data file - backupID={}, path={}, error={:?}", backup_id, user_data_path, err);
+ return Err(err.into());
+ }
};
let user_keys_path = get_backup_user_keys_file_path(&backup_id)?;
let user_keys = match tokio::fs::read(&user_keys_path).await {
- Ok(data) => Some(data),
- Err(err) if err.kind() == ErrorKind::NotFound => None,
- Err(err) => return Err(err.into()),
+ Ok(data) => {
+ println!(
+ "BACKUP_LOG: User keys file read - backupID={}, size={}, path={}",
+ backup_id,
+ data.len(),
+ user_keys_path
+ );
+ Some(data)
+ }
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: User keys file not found - backupID={}, path={}",
+ backup_id, user_keys_path
+ );
+ None
+ }
+ Err(err) => {
+ println!("BACKUP_LOG: Error reading user keys file - backupID={}, path={}, error={:?}", backup_id, user_keys_path, err);
+ return Err(err.into());
+ }
};
let attachments_path = get_backup_file_path(&backup_id, true, false)?;
let attachments = match tokio::fs::read(&attachments_path).await {
- Ok(data) => data.lines().collect::<Result<_, _>>()?,
- Err(err) if err.kind() == ErrorKind::NotFound => Vec::new(),
- Err(err) => return Err(err.into()),
+ Ok(data) => {
+ let lines: Vec<_> = data.lines().collect::<Result<_, _>>()?;
+ println!(
+ "BACKUP_LOG: Attachments file read - backupID={}, lines={}, path={}",
+ backup_id,
+ lines.len(),
+ attachments_path
+ );
+ lines
+ }
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: Attachments file not found - backupID={}, path={}",
+ backup_id, attachments_path
+ );
+ Vec::new()
+ }
+ Err(err) => {
+ println!("BACKUP_LOG: Error reading attachments file - backupID={}, path={}, error={:?}", backup_id, attachments_path, err);
+ return Err(err.into());
+ }
};
let siwe_backup_msg_path = get_siwe_backup_message_path(&backup_id)?;
let siwe_backup_msg = match tokio::fs::read(&siwe_backup_msg_path).await {
Ok(data) => match String::from_utf8(data) {
- Ok(valid_string) => Some(valid_string),
- Err(err) => return Err(err.into()),
+ Ok(valid_string) => {
+ println!("BACKUP_LOG: SIWE backup message read - backupID={}, size={}, path={}", backup_id, valid_string.len(), siwe_backup_msg_path);
+ Some(valid_string)
+ }
+ Err(err) => {
+ println!("BACKUP_LOG: Error parsing SIWE backup message as UTF8 - backupID={}, path={}, error={:?}", backup_id, siwe_backup_msg_path, err);
+ return Err(err.into());
+ }
},
- Err(err) if err.kind() == ErrorKind::NotFound => None,
- Err(err) => return Err(err.into()),
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: SIWE backup message not found - backupID={}, path={}",
+ backup_id, siwe_backup_msg_path
+ );
+ None
+ }
+ Err(err) => {
+ println!("BACKUP_LOG: Error reading SIWE backup message - backupID={}, path={}, error={:?}", backup_id, siwe_backup_msg_path, err);
+ return Err(err.into());
+ }
};
let db_version_path = get_backup_file_path(&backup_id, false, true)?;
let db_version = match tokio::fs::read_to_string(&db_version_path).await {
- Ok(data) => data.parse::<u16>().ok(),
- Err(err) if err.kind() == ErrorKind::NotFound => None,
- Err(err) => return Err(err.into()),
+ Ok(data) => {
+ let parsed_version = data.parse::<u16>().ok();
+ println!("BACKUP_LOG: DB version file read - backupID={}, version={:?}, path={}", backup_id, parsed_version, db_version_path);
+ parsed_version
+ }
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: DB version file not found - backupID={}, path={}",
+ backup_id, db_version_path
+ );
+ None
+ }
+ Err(err) => {
+ println!("BACKUP_LOG: Error reading DB version file - backupID={}, path={}, error={:?}", backup_id, db_version_path, err);
+ return Err(err.into());
+ }
};
let version_info = backup_client::BackupVersionInfo {
@@ -363,12 +500,36 @@
version_info,
};
+ println!(
+ "BACKUP_LOG: Starting compaction upload to backup service - backupID={}",
+ backup_id
+ );
let result = backup_client
.upload_backup(user_identity, backup_data)
.await
.map_err(|e| e.to_string());
+ match &result {
+ Ok(()) => println!(
+ "BACKUP_LOG: Compaction upload succeeded - backupID={}",
+ backup_id
+ ),
+ Err(err) => println!(
+ "BACKUP_LOG: Compaction upload failed - backupID={}, error={}",
+ backup_id, err
+ ),
+ }
+
+ println!(
+ "BACKUP_LOG: Starting compaction file cleanup - backupID={}",
+ backup_id
+ );
cleanup_files(backup_id.clone()).await;
+
+ println!(
+ "BACKUP_LOG: Resolving compaction upload promise - backupID={}",
+ backup_id
+ );
compaction_upload_promises::resolve(&backup_id, result);
Ok(())
@@ -382,6 +543,11 @@
}
}
pub async fn cleanup_files(backup_id: String) {
+ println!(
+ "BACKUP_LOG: Starting compaction files cleanup - backupID={}",
+ backup_id
+ );
+
let backup_files_cleanup = async {
let paths_to_remove = vec![
get_backup_file_path(&backup_id, false, false)?,
@@ -391,9 +557,16 @@
get_siwe_backup_message_path(&backup_id)?,
];
+ println!(
+ "BACKUP_LOG: Will remove {} compaction files - backupID={}",
+ paths_to_remove.len(),
+ backup_id
+ );
+
for path in paths_to_remove {
- if let Err(e) = remove_file_if_exists(&path).await {
- println!("Error occurred while removing a file: {:?}", e);
+ match remove_file_if_exists(&path).await {
+ Ok(()) => println!("BACKUP_LOG: Compaction file removed - backupID={}, path={}", backup_id, path),
+ Err(e) => println!("BACKUP_LOG: Error removing compaction file - backupID={}, path={}, error={:?}", backup_id, path, e),
}
}
@@ -401,7 +574,12 @@
};
if let Err(err) = backup_files_cleanup.await {
- println!("Error when cleaning up the backup files: {:?}", err);
+ println!("BACKUP_LOG: Error during compaction files cleanup - backupID={}, error={:?}", backup_id, err);
+ } else {
+ println!(
+ "BACKUP_LOG: Compaction files cleanup completed - backupID={}",
+ backup_id
+ );
}
}
}
@@ -419,45 +597,99 @@
let log_id_string = log_id.to_string();
let content_path =
get_backup_log_file_path(&backup_id, &log_id_string, false)?;
+
+ println!(
+ "BACKUP_LOG: Reading file content - backupID={}, logID={}, path={}",
+ backup_id, log_id, content_path
+ );
let content = tokio::fs::read(&content_path).await?;
+ println!(
+ "BACKUP_LOG: File content read - backupID={}, logID={}, size={}",
+ backup_id,
+ log_id,
+ content.len()
+ );
let attachments_path =
get_backup_log_file_path(&backup_id, &log_id_string, true)?;
let attachments = match tokio::fs::read(&attachments_path).await {
- Ok(data) => Some(data.lines().collect::<Result<_, _>>()?),
- Err(err) if err.kind() == ErrorKind::NotFound => None,
+ Ok(data) => {
+ let lines: Vec<_> = data.lines().collect::<Result<_, _>>()?;
+ println!(
+ "BACKUP_LOG: Attachments file read - backupID={}, logID={}, lines={}",
+ backup_id,
+ log_id,
+ lines.len()
+ );
+ Some(lines)
+ }
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: No attachments file found - backupID={}, logID={}",
+ backup_id, log_id
+ );
+ None
+ }
Err(err) => return Err(err.into()),
};
let log_data = UploadLogRequest {
- backup_id,
+ backup_id: backup_id.clone(),
log_id,
content,
attachments,
};
+
+ println!(
+ "BACKUP_LOG: Sending log data via WebSocket - backupID={}, logID={}",
+ backup_id, log_id
+ );
tx.send(log_data.clone()).await?;
+ println!(
+ "BACKUP_LOG: Log data sent successfully - backupID={}, logID={}",
+ backup_id, log_id
+ );
Ok(())
}
pub async fn cleanup_files(backup_id: String, log_id: usize) {
let backup_files_cleanup = async {
- let log_id = log_id.to_string();
+ let log_id_string = log_id.to_string();
- let path = get_backup_log_file_path(&backup_id, &log_id, false)?;
+ let path = get_backup_log_file_path(&backup_id, &log_id_string, false)?;
+ println!(
+ "BACKUP_LOG: Deleting main log file - backupID={}, logID={}, path={}",
+ backup_id, log_id, path
+ );
tokio::fs::remove_file(&path).await?;
+ println!(
+ "BACKUP_LOG: Main log file deleted - backupID={}, logID={}",
+ backup_id, log_id
+ );
let attachments_path =
- get_backup_log_file_path(&backup_id, &log_id, true)?;
+ get_backup_log_file_path(&backup_id, &log_id_string, true)?;
match tokio::fs::remove_file(&attachments_path).await {
- Ok(()) => Result::<_, Box<dyn Error>>::Ok(()),
- Err(err) if err.kind() == ErrorKind::NotFound => Ok(()),
+ Ok(()) => {
+ println!("BACKUP_LOG: Attachments file deleted - backupID={}, logID={}, path={}", backup_id, log_id, attachments_path);
+ Result::<_, Box<dyn Error>>::Ok(())
+ }
+ Err(err) if err.kind() == ErrorKind::NotFound => {
+ println!(
+ "BACKUP_LOG: No attachments file to delete - backupID={}, logID={}",
+ backup_id, log_id
+ );
+ Ok(())
+ }
Err(err) => Err(err.into()),
}
};
if let Err(err) = backup_files_cleanup.await {
- println!("{err:?}");
+ println!("BACKUP_LOG: ERROR during file cleanup - backupID={}, logID={}, error={:?}", backup_id, log_id, err);
+ } else {
+ println!("BACKUP_LOG: File cleanup completed successfully - backupID={}, logID={}", backup_id, log_id);
}
}
}

File Metadata

Mime Type
text/plain
Expires
Sat, Dec 6, 8:56 AM (14 h, 31 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5834798
Default Alt Text
D15401.1765011374.diff (21 KB)

Event Timeline