typo fixes all over the place

[proxmox-backup.git] / src / tape / drive / virtual_tape.rs

diff --git a/src/tape/drive/virtual_tape.rs b/src/tape/drive/virtual_tape.rs
index b600079b452746051d3736da99b6a37c11b95b73..6dcf31fb1d1f53b9c55c9770b74cd61a545a6c95 100644 (file)
--- a/src/tape/drive/virtual_tape.rs
+++ b/src/tape/drive/virtual_tape.rs
@@ -11,13 +11,17 @@ use proxmox::tools::{
 };
 
 use crate::{
+    backup::KeyConfig,
     tape::{
         TapeWrite,
         TapeRead,
-        MtxStatus,
-        DriveStatus,
-        ElementStatus,
-        changer::MediaChange,
+        changer::{
+            MediaChange,
+            MtxStatus,
+            DriveStatus,
+            ElementStatus,
+            StorageElementStatus,
+        },
         drive::{
             VirtualTapeDrive,
             TapeDriver,
@@ -26,12 +30,12 @@ use crate::{
             MediaSetLabel,
             MediaContentHeader,
             PROXMOX_BACKUP_MEDIA_SET_LABEL_MAGIC_1_0,
+            BlockedReader,
+            BlockedWriter,
         },
         helpers::{
             EmulateTapeReader,
             EmulateTapeWriter,
-            BlockedReader,
-            BlockedWriter,
         },
     },
 };
@@ -167,8 +171,8 @@ impl VirtualTapeHandle {
             if path.is_file() && path.extension() == Some(std::ffi::OsStr::new("json")) {
                 if let Some(name) = path.file_stem() {
                     if let Some(name) = name.to_str() {
-                        if name.starts_with("tape-") {
-                            list.push(name[5..].to_string());
+                        if let Some(label) = name.strip_prefix("tape-") {
+                            list.push(label.to_string());
                         }
                     }
                 }
@@ -325,10 +329,18 @@ impl TapeDriver for VirtualTapeHandle {
         }
     }
 
-    fn write_media_set_label(&mut self, media_set_label: &MediaSetLabel) -> Result<(), Error> {
+    fn write_media_set_label(
+        &mut self,
+        media_set_label: &MediaSetLabel,
+        key_config: Option<&KeyConfig>,
+    ) -> Result<(), Error> {
 
         self.set_encryption(None)?;
 
+        if key_config.is_some() {
+            bail!("encryption is not implemented - internal error");
+        }
+
         let mut status = self.load_status()?;
         match status.current_tape {
             Some(VirtualTapeStatus { ref name, ref mut pos }) => {
@@ -386,7 +398,11 @@ impl MediaChange for VirtualTapeHandle {
             drives.push(DriveStatus {
                 loaded_slot: None,
                 status: ElementStatus::VolumeTag(current_tape.name.clone()),
-            });
+                drive_serial_number: None,
+                vendor: None,
+                model: None,
+                element_address: 0,
+           });
         }
 
         // This implementation is lame, because we do not have fixed
@@ -397,25 +413,30 @@ impl MediaChange for VirtualTapeHandle {
         let max_slots = ((label_texts.len() + 7)/8) * 8;
 
         for i in 0..max_slots {
-            if let Some(label_text) = label_texts.get(i) {
-                slots.push((false,  ElementStatus::VolumeTag(label_text.clone())));
+            let status = if let Some(label_text) = label_texts.get(i) {
+                ElementStatus::VolumeTag(label_text.clone())
             } else {
-                slots.push((false,  ElementStatus::Empty));
-            }
+                ElementStatus::Empty
+            };
+            slots.push(StorageElementStatus {
+                import_export: false,
+                status,
+                element_address: (i + 1) as u16,
+            });
         }
 
-        Ok(MtxStatus { drives, slots })
+        Ok(MtxStatus { drives, slots, transports: Vec::new() })
     }
 
-    fn transfer_media(&mut self, _from: u64, _to: u64) -> Result<(), Error> {
-        bail!("media tranfer is not implemented!");
+    fn transfer_media(&mut self, _from: u64, _to: u64) -> Result<MtxStatus, Error> {
+        bail!("media transfer is not implemented!");
     }
 
     fn export_media(&mut self, _label_text: &str) -> Result<Option<u64>, Error> {
         bail!("media export is not implemented!");
     }
 
-    fn load_media_from_slot(&mut self, slot: u64) -> Result<(), Error> {
+    fn load_media_from_slot(&mut self, slot: u64) -> Result<MtxStatus, Error> {
         if slot < 1 {
             bail!("invalid slot ID {}", slot);
         }
@@ -433,7 +454,7 @@ impl MediaChange for VirtualTapeHandle {
     ///
     /// We automatically create an empty virtual tape here (if it does
     /// not exist already)
-    fn load_media(&mut self, label: &str) -> Result<(), Error> {
+    fn load_media(&mut self, label: &str) -> Result<MtxStatus, Error> {
         let name = format!("tape-{}.json", label);
         let mut path = self.path.clone();
         path.push(&name);
@@ -449,17 +470,20 @@ impl MediaChange for VirtualTapeHandle {
                 pos: 0,
             }),
         };
-        self.store_status(&status)
+        self.store_status(&status)?;
+
+        self.status()
     }
 
-    fn unload_media(&mut self, _target_slot: Option<u64>) -> Result<(), Error> {
+    fn unload_media(&mut self, _target_slot: Option<u64>) -> Result<MtxStatus, Error> {
         // Note: we currently simply ignore target_slot
         self.eject_media()?;
-        Ok(())
+        self.status()
     }
 
-    fn clean_drive(&mut self) -> Result<(), Error> {
-        Ok(())
+    fn clean_drive(&mut self) -> Result<MtxStatus, Error> {
+        // do nothing
+        self.status()
     }
 }
 
@@ -478,7 +502,7 @@ impl MediaChange for VirtualTapeDrive {
         handle.status()
     }
 
-    fn transfer_media(&mut self, from: u64, to: u64) -> Result<(), Error> {
+    fn transfer_media(&mut self, from: u64, to: u64) -> Result<MtxStatus, Error> {
         let mut handle = self.open()?;
         handle.transfer_media(from, to)
     }
@@ -488,20 +512,19 @@ impl MediaChange for VirtualTapeDrive {
         handle.export_media(label_text)
     }
 
-    fn load_media_from_slot(&mut self, slot: u64) -> Result<(), Error> {
+    fn load_media_from_slot(&mut self, slot: u64) -> Result<MtxStatus, Error> {
         let mut handle = self.open()?;
         handle.load_media_from_slot(slot)
     }
 
-    fn load_media(&mut self, label_text: &str) -> Result<(), Error> {
+    fn load_media(&mut self, label_text: &str) -> Result<MtxStatus, Error> {
         let mut handle = self.open()?;
         handle.load_media(label_text)
     }
 
-    fn unload_media(&mut self, target_slot: Option<u64>) -> Result<(), Error> {
+    fn unload_media(&mut self, target_slot: Option<u64>) -> Result<MtxStatus, Error> {
         let mut handle = self.open()?;
-        handle.unload_media(target_slot)?;
-        Ok(())
+        handle.unload_media(target_slot)
     }
 
     fn online_media_label_texts(&mut self) -> Result<Vec<String>, Error> {
@@ -509,8 +532,8 @@ impl MediaChange for VirtualTapeDrive {
         handle.online_media_label_texts()
     }
 
-    fn clean_drive(&mut self) -> Result<(), Error> {
-        Ok(())
+    fn clean_drive(&mut self) -> Result<MtxStatus, Error> {
+        let mut handle = self.open()?;
+        handle.clean_drive()
     }
-
 }