tyler
/
proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tape/drive: fix logging when requesting media 

we try to load the correct media in a loop until we find the correct tape.
when encountering an error or wrong tape, we want to log that (and send
an email if one is set) that requests the correct tape.

while trying to avoid printing the same errors more than once in a row,
we had at least one case (starting with an empty tape in the drive)
which would not print/send any tape request.

reworking that code to use a custom 'TapeRequest' enum, which contains
the state + error message, and a helper that prints and sends an email
when the state changes

this reduces the change check/log to a single variable, instead of 4
(tried, last_media_uuid, last_error, failure_reason)

Signed-off-by: Dominik Csapak <d.csapak@proxmox.com>
Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
This commit is contained in:
Dominik Csapak 2021-06-29 11:58:14 +02:00 committed by Dietmar Maurer
parent 414be8b675
commit 9ac8b73e07
1 changed files with 88 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
src/tape/drive/mod.rs
View File

@ -321,6 +321,37 @@ pub fn open_drive(
} }
} }
#[derive(PartialEq, Eq)]
enum TapeRequestError {
None,
EmptyTape,
OpenFailed(String),
WrongLabel(String),
ReadFailed(String),
}
impl std::fmt::Display for TapeRequestError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
TapeRequestError::None => {
write!(f, "no error")
},
TapeRequestError::OpenFailed(reason) => {
write!(f, "tape open failed - {}", reason)
}
TapeRequestError::WrongLabel(label) => {
write!(f, "wrong media label {}", label)
}
TapeRequestError::EmptyTape => {
write!(f, "found empty media without label (please label all tapes first)")
}
TapeRequestError::ReadFailed(reason) => {
write!(f, "tape read failed - {}", reason)
}
}
}
}
/// Requests a specific 'media' to be inserted into 'drive'. Within a /// Requests a specific 'media' to be inserted into 'drive'. Within a
/// loop, this then tries to read the media label and waits until it /// loop, this then tries to read the media label and waits until it
/// finds the requested media. /// finds the requested media.
@ -388,49 +419,62 @@ pub fn request_and_load_media(
return Ok((handle, media_id)); return Ok((handle, media_id));
} }
let mut last_media_uuid = None; let mut last_error = TapeRequestError::None;
let mut last_error = None;
let mut tried = false; let update_and_log_request_error =
let mut failure_reason = None; |old: &mut TapeRequestError, new: TapeRequestError| -> Result<(), Error>
{
if new != *old {
task_log!(worker, "{}", new);
task_log!(
worker,
"Please insert media '{}' into drive '{}'",
label_text,
drive
);
if let Some(to) = notify_email {
send_load_media_email(
drive,
&label_text,
to,
Some(new.to_string()),
)?;
}
*old = new;
}
Ok(())
};
loop { loop {
worker.check_abort()?; worker.check_abort()?;
if tried { if last_error != TapeRequestError::None {
if let Some(reason) = failure_reason {
task_log!(worker, "Please insert media '{}' into drive '{}'", label_text, drive);
if let Some(to) = notify_email {
send_load_media_email(drive, &label_text, to, Some(reason))?;
}
}
failure_reason = None;
for _ in 0..50 { // delay 5 seconds for _ in 0..50 { // delay 5 seconds
worker.check_abort()?; worker.check_abort()?;
std::thread::sleep(std::time::Duration::from_millis(100)); std::thread::sleep(std::time::Duration::from_millis(100));
} }
} else {
task_log!(
worker,
"Checking for media '{}' in drive '{}'",
label_text,
drive
);
} }
tried = true;
let mut handle = match drive_config.open() { let mut handle = match drive_config.open() {
Ok(handle) => handle, Ok(handle) => handle,
Err(err) => { Err(err) => {
let err = err.to_string(); update_and_log_request_error(
if Some(err.clone()) != last_error { &mut last_error,
task_log!(worker, "tape open failed - {}", err); TapeRequestError::OpenFailed(err.to_string()),
last_error = Some(err); )?;
failure_reason = last_error.clone();
}
continue; continue;
} }
}; };
match handle.read_label() { let request_error = match handle.read_label() {
Ok((Some(media_id), _)) => { Ok((Some(media_id), _)) if media_id.label.uuid == label.uuid => {
if media_id.label.uuid == label.uuid {
task_log!( task_log!(
worker, worker,
"found media label {} ({})", "found media label {} ({})",
@ -438,34 +482,24 @@ pub fn request_and_load_media(
media_id.label.uuid.to_string(), media_id.label.uuid.to_string(),
); );
return Ok((Box::new(handle), media_id)); return Ok((Box::new(handle), media_id));
} else if Some(media_id.label.uuid.clone()) != last_media_uuid { }
let err = format!( Ok((Some(media_id), _)) => {
"wrong media label {} ({})", let label_string = format!(
"{} ({})",
media_id.label.label_text, media_id.label.label_text,
media_id.label.uuid.to_string(), media_id.label.uuid.to_string(),
); );
task_log!(worker, "{}", err); TapeRequestError::WrongLabel(label_string)
last_media_uuid = Some(media_id.label.uuid);
failure_reason = Some(err);
}
} }
Ok((None, _)) => { Ok((None, _)) => {
if last_media_uuid.is_some() { TapeRequestError::EmptyTape
let err = "found empty media without label (please label all tapes first)";
task_log!(worker, "{}", err);
last_media_uuid = None;
failure_reason = Some(err.to_string());
}
} }
Err(err) => { Err(err) => {
let err = err.to_string(); TapeRequestError::ReadFailed(err.to_string())
if Some(err.clone()) != last_error {
task_log!(worker, "tape open failed - {}", err);
last_error = Some(err);
failure_reason = last_error.clone();
}
}
} }
};
update_and_log_request_error(&mut last_error, request_error)?;
} }
} }
_ => bail!("drive type '{}' not implemented!"), _ => bail!("drive type '{}' not implemented!"),