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

tape: rust fmt

Browse Source 
Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
This commit is contained in:
Thomas Lamprecht
2022-04-10 17:49:03 +02:00
parent 429bc9d0a2
commit 4de1c42c20
29 changed files with 1183 additions and 1116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/tape/test/alloc_writable_media.rs
View File

@ -2,10 +2,10 @@
//
// # cargo test --release tape::test::alloc_writable_media
use std::path::PathBuf;
use anyhow::Error;
use std::path::PathBuf;
use pbs_api_types::{RetentionPolicy, MediaSetPolicy};
use pbs_api_types::{MediaSetPolicy, RetentionPolicy};
use crate::tape::{Inventory, MediaPool};
@ -22,7 +22,6 @@ fn create_testdir(name: &str) -> Result<PathBuf, Error> {
#[test]
fn test_alloc_writable_media_1() -> Result<(), Error> {
let testdir = create_testdir("test_alloc_writable_media_1")?;
let mut ctime = 0;
@ -49,7 +48,6 @@ fn test_alloc_writable_media_1() -> Result<(), Error> {
#[test]
fn test_alloc_writable_media_2() -> Result<(), Error> {
let testdir = create_testdir("test_alloc_writable_media_2")?;
let mut inventory = Inventory::load(&testdir)?;
@ -87,7 +85,6 @@ fn test_alloc_writable_media_2() -> Result<(), Error> {
#[test]
fn test_alloc_writable_media_3() -> Result<(), Error> {
let testdir = create_testdir("test_alloc_writable_media_3")?;
let mut inventory = Inventory::load(&testdir)?;
@ -136,7 +133,6 @@ fn test_alloc_writable_media_3() -> Result<(), Error> {
#[test]
fn test_alloc_writable_media_4() -> Result<(), Error> {
let testdir = create_testdir("test_alloc_writable_media_4")?;
let mut inventory = Inventory::load(&testdir)?;

97
src/tape/test/compute_media_state.rs
View File

@ -2,20 +2,14 @@
//
// # cargo test --release tape::test::compute_media_state
use std::path::PathBuf;
use anyhow::Error;
use std::path::PathBuf;
use proxmox_uuid::Uuid;
use pbs_api_types::{MediaStatus, MediaSetPolicy, RetentionPolicy};
use pbs_api_types::{MediaSetPolicy, MediaStatus, RetentionPolicy};
use crate::tape::{
Inventory,
MediaPool,
file_formats::{
MediaSetLabel,
},
};
use crate::tape::{file_formats::MediaSetLabel, Inventory, MediaPool};
fn create_testdir(name: &str) -> Result<PathBuf, Error> {
let mut testdir: PathBuf = String::from("./target/testout").into();
@ -30,7 +24,6 @@ fn create_testdir(name: &str) -> Result<PathBuf, Error> {
#[test]
fn test_compute_media_state() -> Result<(), Error> {
let testdir = create_testdir("test_compute_media_state")?;
let ctime = 0;
@ -55,18 +48,21 @@ fn test_compute_media_state() -> Result<(), Error> {
let tape4_uuid = inventory.generate_used_tape("tape4", sl4, 0);
let tape5_uuid = inventory.generate_used_tape("tape5", sl5, 0);
let pool = MediaPool::new(
let pool = MediaPool::new(
"p1",
&testdir ,
MediaSetPolicy::AlwaysCreate,
RetentionPolicy::KeepForever,
None,
None,
false,
&testdir,
MediaSetPolicy::AlwaysCreate,
RetentionPolicy::KeepForever,
None,
None,
false,
)?;
// tape1 is free
assert_eq!(pool.lookup_media(&tape1_uuid)?.status(), &MediaStatus::Writable);
assert_eq!(
pool.lookup_media(&tape1_uuid)?.status(),
&MediaStatus::Writable
);
// intermediate tapes should be Full
assert_eq!(pool.lookup_media(&tape2_uuid)?.status(), &MediaStatus::Full);
@ -74,14 +70,16 @@ fn test_compute_media_state() -> Result<(), Error> {
assert_eq!(pool.lookup_media(&tape4_uuid)?.status(), &MediaStatus::Full);
// last tape is writable
assert_eq!(pool.lookup_media(&tape5_uuid)?.status(), &MediaStatus::Writable);
assert_eq!(
pool.lookup_media(&tape5_uuid)?.status(),
&MediaStatus::Writable
);
Ok(())
}
#[test]
fn test_media_expire_time() -> Result<(), Error> {
let testdir = create_testdir("test_media_expire_time")?;
let ctime = 0;
@ -97,7 +95,7 @@ fn test_media_expire_time() -> Result<(), Error> {
let tape1_uuid = inventory.generate_used_tape("tape1", sl1, 0);
// tape2: single tape media set
let sl2= MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime + 120, None);
let sl2 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime + 120, None);
let tape2_uuid = inventory.generate_used_tape("tape2", sl2, 0);
let event = "*:0/2".parse()?;
@ -105,7 +103,7 @@ fn test_media_expire_time() -> Result<(), Error> {
let pool = MediaPool::new(
"p1",
&testdir ,
&testdir,
MediaSetPolicy::CreateAt(event),
RetentionPolicy::ProtectFor(span),
None,
@ -115,19 +113,52 @@ fn test_media_expire_time() -> Result<(), Error> {
assert_eq!(pool.lookup_media(&tape0_uuid)?.status(), &MediaStatus::Full);
assert_eq!(pool.lookup_media(&tape1_uuid)?.status(), &MediaStatus::Full);
assert_eq!(pool.lookup_media(&tape2_uuid)?.status(), &MediaStatus::Writable);
assert_eq!(
pool.lookup_media(&tape2_uuid)?.status(),
&MediaStatus::Writable
);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 0), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 60), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 120), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 180), true);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 0),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 60),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 120),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape0_uuid)?, 180),
true
);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 0), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 60), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 120), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 180), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 190), false);
assert_eq!(pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 240), true);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 0),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 60),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 120),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 180),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 190),
false
);
assert_eq!(
pool.media_is_expired(&pool.lookup_media(&tape1_uuid)?, 240),
true
);
Ok(())
}

22
src/tape/test/current_set_usable.rs
View File

@ -2,22 +2,14 @@
//
// # cargo test --release tape::test::current_set_usable
use std::path::PathBuf;
use anyhow::Error;
use std::path::PathBuf;
use proxmox_uuid::Uuid;
use pbs_api_types::{RetentionPolicy, MediaSetPolicy};
use pbs_api_types::{MediaSetPolicy, RetentionPolicy};
use crate::{
tape::{
Inventory,
MediaPool,
file_formats::{
MediaSetLabel,
},
},
};
use crate::tape::{file_formats::MediaSetLabel, Inventory, MediaPool};
fn create_testdir(name: &str) -> Result<PathBuf, Error> {
let mut testdir: PathBuf = String::from("./target/testout").into();
@ -32,7 +24,6 @@ fn create_testdir(name: &str) -> Result<PathBuf, Error> {
#[test]
fn test_current_set_usable_1() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_1")?;
// pool without any media
@ -54,7 +45,6 @@ fn test_current_set_usable_1() -> Result<(), Error> {
#[test]
fn test_current_set_usable_2() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_2")?;
let ctime = 0;
@ -81,7 +71,6 @@ fn test_current_set_usable_2() -> Result<(), Error> {
#[test]
fn test_current_set_usable_3() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_3")?;
let ctime = 0;
@ -110,7 +99,6 @@ fn test_current_set_usable_3() -> Result<(), Error> {
#[test]
fn test_current_set_usable_4() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_4")?;
let ctime = 0;
@ -139,7 +127,6 @@ fn test_current_set_usable_4() -> Result<(), Error> {
#[test]
fn test_current_set_usable_5() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_5")?;
let ctime = 0;
@ -170,7 +157,6 @@ fn test_current_set_usable_5() -> Result<(), Error> {
#[test]
fn test_current_set_usable_6() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_6")?;
let ctime = 0;
@ -199,7 +185,6 @@ fn test_current_set_usable_6() -> Result<(), Error> {
#[test]
fn test_current_set_usable_7() -> Result<(), Error> {
let testdir = create_testdir("test_current_set_usable_7")?;
let ctime = 0;
@ -215,7 +200,6 @@ fn test_current_set_usable_7() -> Result<(), Error> {
inventory.generate_used_tape("tape2", sl2, ctime);
// pool with one two media in current set, one set to damaged
let pool = MediaPool::new(
"p1",

71
src/tape/test/inventory.rs
View File

@ -2,21 +2,14 @@
//
// # cargo test --release tape::test::inventory
use std::path::PathBuf;
use anyhow::{bail, Error};
use std::path::PathBuf;
use proxmox_uuid::Uuid;
use pbs_api_types::{MediaLocation, MediaStatus};
use crate::{
tape::{
Inventory,
file_formats::{
MediaSetLabel,
},
},
};
use crate::tape::{file_formats::MediaSetLabel, Inventory};
fn create_testdir(name: &str) -> Result<PathBuf, Error> {
let mut testdir: PathBuf = String::from("./target/testout").into();
@ -31,38 +24,56 @@ fn create_testdir(name: &str) -> Result<PathBuf, Error> {
#[test]
fn test_media_state_db() -> Result<(), Error> {
let testdir = create_testdir("test_media_state_db")?;
let mut inventory = Inventory::load(&testdir)?;
let uuid1: Uuid = inventory.generate_free_tape("tape1", 0);
assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Unknown, MediaLocation::Offline));
assert_eq!(
inventory.status_and_location(&uuid1),
(MediaStatus::Unknown, MediaLocation::Offline)
);
inventory.set_media_status_full(&uuid1)?;
assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Full, MediaLocation::Offline));
assert_eq!(
inventory.status_and_location(&uuid1),
(MediaStatus::Full, MediaLocation::Offline)
);
inventory.set_media_location_vault(&uuid1, "Office2")?;
assert_eq!(inventory.status_and_location(&uuid1),
(MediaStatus::Full, MediaLocation::Vault(String::from("Office2"))));
assert_eq!(
inventory.status_and_location(&uuid1),
(
MediaStatus::Full,
MediaLocation::Vault(String::from("Office2"))
)
);
inventory.set_media_location_offline(&uuid1)?;
assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Full, MediaLocation::Offline));
assert_eq!(
inventory.status_and_location(&uuid1),
(MediaStatus::Full, MediaLocation::Offline)
);
inventory.set_media_status_damaged(&uuid1)?;
assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Damaged, MediaLocation::Offline));
assert_eq!(
inventory.status_and_location(&uuid1),
(MediaStatus::Damaged, MediaLocation::Offline)
);
inventory.clear_media_status(&uuid1)?;
assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Unknown, MediaLocation::Offline));
assert_eq!(
inventory.status_and_location(&uuid1),
(MediaStatus::Unknown, MediaLocation::Offline)
);
Ok(())
}
#[test]
fn test_list_pool_media() -> Result<(), Error> {
let testdir = create_testdir("test_list_pool_media")?;
let mut inventory = Inventory::load(&testdir)?;
@ -81,10 +92,16 @@ fn test_list_pool_media() -> Result<(), Error> {
let list = inventory.list_pool_media("p1");
assert_eq!(list.len(), 2);
let tape2 = list.iter().find(|media_id| &media_id.label.uuid == &tape2_uuid).unwrap();
let tape2 = list
.iter()
.find(|media_id| &media_id.label.uuid == &tape2_uuid)
.unwrap();
assert!(tape2.media_set_label.is_none());
let tape3 = list.iter().find(|media_id| &media_id.label.uuid == &tape3_uuid).unwrap();
let tape3 = list
.iter()
.find(|media_id| &media_id.label.uuid == &tape3_uuid)
.unwrap();
match tape3.media_set_label {
None => bail!("missing media set label"),
Some(ref set) => {
@ -97,17 +114,15 @@ fn test_list_pool_media() -> Result<(), Error> {
#[test]
fn test_media_set_simple() -> Result<(), Error> {
let testdir = create_testdir("test_media_set_simple")?;
let mut inventory = Inventory::load(&testdir)?;
let ctime = 0;
let sl1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime + 10, None);
let sl2 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 1, ctime+ 20, None);
let sl2 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 1, ctime + 20, None);
let sl3 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 2, ctime + 30, None);
let tape1_uuid = inventory.generate_used_tape("tape1", sl1.clone(), 0);
let tape2_uuid = inventory.generate_used_tape("tape2", sl2, 0);
let tape3_uuid = inventory.generate_used_tape("tape3", sl3, 0);
@ -141,7 +156,6 @@ fn test_media_set_simple() -> Result<(), Error> {
// test media set start time
assert_eq!(inventory.media_set_start_time(&sl1.uuid), Some(ctime + 10));
// test pool p2
let media_set = inventory.compute_media_set_members(&sl4.uuid)?;
assert_eq!(media_set.uuid(), &sl4.uuid);
@ -158,10 +172,8 @@ fn test_media_set_simple() -> Result<(), Error> {
Ok(())
}
#[test]
fn test_latest_media_set() -> Result<(), Error> {
let testdir = create_testdir("test_latest_media_set")?;
let insert_tape = |inventory: &mut Inventory, pool, label, seq_nr, ctime| -> Uuid {
@ -176,7 +188,12 @@ fn test_latest_media_set() -> Result<(), Error> {
let set = inventory.compute_media_set_members(&latest_set).unwrap();
let media_list = set.media_list();
assert_eq!(media_list.iter().filter(|s| s.is_some()).count(), 1);
let media_uuid = media_list.iter().find(|s| s.is_some()).unwrap().clone().unwrap();
let media_uuid = media_list
.iter()
.find(|s| s.is_some())
.unwrap()
.clone()
.unwrap();
let media = inventory.lookup_media(&media_uuid).unwrap();
assert_eq!(media.label.label_text, label);
};

7
src/tape/test/mod.rs
View File

@ -1,5 +1,4 @@
mod inventory;
mod current_set_usable;
mod compute_media_state;
mod alloc_writable_media;
mod compute_media_state;
mod current_set_usable;
mod inventory;