1 //! Backup media Inventory
3 //! The Inventory persistently stores the list of known backup
4 //! media. A backup media is identified by its 'MediaId', which is the
5 //! MediaLabel/MediaSetLabel combination.
7 use std
::collections
::{HashMap, BTreeMap}
;
8 use std
::path
::{Path, PathBuf}
;
10 use anyhow
::{bail, Error}
;
11 use serde
::{Serialize, Deserialize}
;
25 tools
::systemd
::time
::compute_next_event
,
39 changer
::OnlineStatusMap
,
43 /// Unique Media Identifier
45 /// This combines the label and media set label.
46 #[derive(Debug,Serialize,Deserialize,Clone)]
48 pub label
: MediaLabel
,
49 #[serde(skip_serializing_if="Option::is_none")]
50 pub media_set_label
: Option
<MediaSetLabel
>,
54 #[derive(Serialize,Deserialize)]
55 struct MediaStateEntry
{
57 #[serde(skip_serializing_if="Option::is_none")]
58 location
: Option
<MediaLocation
>,
59 #[serde(skip_serializing_if="Option::is_none")]
60 status
: Option
<MediaStatus
>,
64 pub struct Inventory
{
65 map
: BTreeMap
<Uuid
, MediaStateEntry
>,
67 inventory_path
: PathBuf
,
68 lockfile_path
: PathBuf
,
71 media_set_start_times
: HashMap
<Uuid
, i64>
76 pub const MEDIA_INVENTORY_FILENAME
: &'
static str = "inventory.json";
77 pub const MEDIA_INVENTORY_LOCKFILE
: &'
static str = ".inventory.lck";
79 fn new(base_path
: &Path
) -> Self {
81 let mut inventory_path
= base_path
.to_owned();
82 inventory_path
.push(Self::MEDIA_INVENTORY_FILENAME
);
84 let mut lockfile_path
= base_path
.to_owned();
85 lockfile_path
.push(Self::MEDIA_INVENTORY_LOCKFILE
);
89 media_set_start_times
: HashMap
::new(),
95 pub fn load(base_path
: &Path
) -> Result
<Self, Error
> {
96 let mut me
= Self::new(base_path
);
101 /// Reload the database
102 pub fn reload(&mut self) -> Result
<(), Error
> {
103 self.map
= Self::load_media_db(&self.inventory_path
)?
;
104 self.update_helpers();
108 fn update_helpers(&mut self) {
110 // recompute media_set_start_times
112 let mut set_start_times
= HashMap
::new();
114 for entry
in self.map
.values() {
115 let set
= match &entry
.id
.media_set_label
{
120 set_start_times
.insert(set
.uuid
.clone(), set
.ctime
);
124 self.media_set_start_times
= set_start_times
;
127 /// Lock the database
128 pub fn lock(&self) -> Result
<std
::fs
::File
, Error
> {
129 open_file_locked(&self.lockfile_path
, std
::time
::Duration
::new(10, 0), true)
132 fn load_media_db(path
: &Path
) -> Result
<BTreeMap
<Uuid
, MediaStateEntry
>, Error
> {
134 let data
= file_get_json(path
, Some(json
!([])))?
;
135 let media_list
: Vec
<MediaStateEntry
> = serde_json
::from_value(data
)?
;
137 let mut map
= BTreeMap
::new();
138 for entry
in media_list
.into_iter() {
139 map
.insert(entry
.id
.label
.uuid
.clone(), entry
);
145 fn replace_file(&self) -> Result
<(), Error
> {
146 let list
: Vec
<&MediaStateEntry
> = self.map
.values().collect();
147 let raw
= serde_json
::to_string_pretty(&serde_json
::to_value(list
)?
)?
;
149 let backup_user
= crate::backup
::backup_user()?
;
150 let mode
= nix
::sys
::stat
::Mode
::from_bits_truncate(0o0640);
151 let options
= CreateOptions
::new()
153 .owner(backup_user
.uid
)
154 .group(backup_user
.gid
);
156 replace_file(&self.inventory_path
, raw
.as_bytes(), options
)?
;
161 /// Stores a single MediaID persistently
164 mut media_id
: MediaId
,
165 clear_media_status
: bool
,
166 ) -> Result
<(), Error
> {
167 let _lock
= self.lock()?
;
168 self.map
= Self::load_media_db(&self.inventory_path
)?
;
170 let uuid
= media_id
.label
.uuid
.clone();
172 if let Some(previous
) = self.map
.remove(&media_id
.label
.uuid
) {
173 // do not overwrite unsaved pool assignments
174 if media_id
.media_set_label
.is_none() {
175 if let Some(ref set
) = previous
.id
.media_set_label
{
176 if set
.uuid
.as_ref() == [0u8;16] {
177 media_id
.media_set_label
= Some(set
.clone());
181 let entry
= MediaStateEntry
{
183 location
: previous
.location
,
184 status
: if clear_media_status
{
190 self.map
.insert(uuid
, entry
);
192 let entry
= MediaStateEntry { id: media_id, location: None, status: None }
;
193 self.map
.insert(uuid
, entry
);
196 self.update_helpers();
197 self.replace_file()?
;
201 /// Remove a single media persistently
202 pub fn remove_media(&mut self, uuid
: &Uuid
) -> Result
<(), Error
> {
203 let _lock
= self.lock()?
;
204 self.map
= Self::load_media_db(&self.inventory_path
)?
;
205 self.map
.remove(uuid
);
206 self.update_helpers();
207 self.replace_file()?
;
212 pub fn lookup_media(&self, uuid
: &Uuid
) -> Option
<&MediaId
> {
213 self.map
.get(uuid
).map(|entry
| &entry
.id
)
216 /// find media by label_text
217 pub fn find_media_by_label_text(&self, label_text
: &str) -> Option
<&MediaId
> {
218 self.map
.values().find_map(|entry
| {
219 if entry
.id
.label
.label_text
== label_text
{
227 /// Lookup media pool
229 /// Returns (pool, is_empty)
230 pub fn lookup_media_pool(&self, uuid
: &Uuid
) -> Option
<(&str, bool
)> {
231 match self.map
.get(uuid
) {
234 match entry
.id
.media_set_label
{
235 None
=> None
, // not assigned to any pool
237 let is_empty
= set
.uuid
.as_ref() == [0u8;16];
238 Some((&set
.pool
, is_empty
))
245 /// List all media assigned to the pool
246 pub fn list_pool_media(&self, pool
: &str) -> Vec
<MediaId
> {
247 let mut list
= Vec
::new();
249 for entry
in self.map
.values() {
250 match entry
.id
.media_set_label
{
251 None
=> continue, // not assigned to any pool
253 if set
.pool
!= pool
{
254 continue; // belong to another pool
257 if set
.uuid
.as_ref() == [0u8;16] { // should we do this??
259 label
: entry
.id
.label
.clone(),
260 media_set_label
: None
,
263 list
.push(entry
.id
.clone());
272 /// List all used media
273 pub fn list_used_media(&self) -> Vec
<MediaId
> {
274 let mut list
= Vec
::new();
276 for entry
in self.map
.values() {
277 match entry
.id
.media_set_label
{
278 None
=> continue, // not assigned to any pool
280 if set
.uuid
.as_ref() != [0u8;16] {
281 list
.push(entry
.id
.clone());
290 /// List media not assigned to any pool
291 pub fn list_unassigned_media(&self) -> Vec
<MediaId
> {
292 self.map
.values().filter_map(|entry
|
293 if entry
.id
.media_set_label
.is_none() {
294 Some(entry
.id
.clone())
301 pub fn media_set_start_time(&self, media_set_uuid
: &Uuid
) -> Option
<i64> {
302 self.media_set_start_times
.get(media_set_uuid
).copied()
305 /// Lookup media set pool
306 pub fn lookup_media_set_pool(&self, media_set_uuid
: &Uuid
) -> Result
<String
, Error
> {
308 let mut last_pool
= None
;
310 for entry
in self.map
.values() {
311 match entry
.id
.media_set_label
{
313 Some(MediaSetLabel { ref uuid, .. }
) => {
314 if uuid
!= media_set_uuid
{
317 if let Some((pool
, _
)) = self.lookup_media_pool(&entry
.id
.label
.uuid
) {
318 if let Some(last_pool
) = last_pool
{
319 if last_pool
!= pool
{
320 bail
!("detected media set with inconsistent pool assignment - internal error");
323 last_pool
= Some(pool
);
331 Some(pool
) => Ok(pool
.to_string()),
332 None
=> bail
!("media set {} is incomplete - unable to lookup pool"),
336 /// Compute a single media sets
337 pub fn compute_media_set_members(&self, media_set_uuid
: &Uuid
) -> Result
<MediaSet
, Error
> {
339 let mut set
= MediaSet
::with_data(media_set_uuid
.clone(), Vec
::new());
341 for entry
in self.map
.values() {
342 match entry
.id
.media_set_label
{
344 Some(MediaSetLabel { seq_nr, ref uuid, .. }
) => {
345 if uuid
!= media_set_uuid
{
348 set
.insert_media(entry
.id
.label
.uuid
.clone(), seq_nr
)?
;
356 /// Compute all media sets
357 pub fn compute_media_set_list(&self) -> Result
<HashMap
<Uuid
, MediaSet
>, Error
> {
359 let mut set_map
: HashMap
<Uuid
, MediaSet
> = HashMap
::new();
361 for entry
in self.map
.values() {
362 match entry
.id
.media_set_label
{
364 Some(MediaSetLabel { seq_nr, ref uuid, .. }
) => {
366 let set
= set_map
.entry(uuid
.clone()).or_insert_with(|| {
367 MediaSet
::with_data(uuid
.clone(), Vec
::new())
370 set
.insert_media(entry
.id
.label
.uuid
.clone(), seq_nr
)?
;
378 /// Returns the latest media set for a pool
379 pub fn latest_media_set(&self, pool
: &str) -> Option
<Uuid
> {
381 let mut last_set
: Option
<(Uuid
, i64)> = None
;
383 let set_list
= self.map
.values()
384 .filter_map(|entry
| entry
.id
.media_set_label
.as_ref())
385 .filter(|set
| set
.pool
== pool
&& set
.uuid
.as_ref() != [0u8;16]);
387 for set
in set_list
{
390 last_set
= Some((set
.uuid
.clone(), set
.ctime
));
392 Some((_
, last_ctime
)) => {
393 if set
.ctime
> last_ctime
{
394 last_set
= Some((set
.uuid
.clone(), set
.ctime
));
400 let (uuid
, ctime
) = match last_set
{
402 Some((uuid
, ctime
)) => (uuid
, ctime
),
405 // consistency check - must be the only set with that ctime
406 let set_list
= self.map
.values()
407 .filter_map(|entry
| entry
.id
.media_set_label
.as_ref())
408 .filter(|set
| set
.pool
== pool
&& set
.uuid
.as_ref() != [0u8;16]);
410 for set
in set_list
{
411 if set
.uuid
!= uuid
&& set
.ctime
>= ctime
{ // should not happen
412 eprintln
!("latest_media_set: found set with equal ctime ({}, {})", set
.uuid
, uuid
);
420 // Test if there is a media set (in the same pool) newer than this one.
421 // Return the ctime of the nearest media set
422 fn media_set_next_start_time(&self, media_set_uuid
: &Uuid
) -> Option
<i64> {
424 let (pool
, ctime
) = match self.map
.values()
425 .filter_map(|entry
| entry
.id
.media_set_label
.as_ref())
427 if &set
.uuid
== media_set_uuid
{
428 Some((set
.pool
.clone(), set
.ctime
))
433 Some((pool
, ctime
)) => (pool
, ctime
),
437 let set_list
= self.map
.values()
438 .filter_map(|entry
| entry
.id
.media_set_label
.as_ref())
439 .filter(|set
| (&set
.uuid
!= media_set_uuid
) && (set
.pool
== pool
));
441 let mut next_ctime
= None
;
443 for set
in set_list
{
444 if set
.ctime
> ctime
{
447 next_ctime
= Some(set
.ctime
);
449 Some(last_next_ctime
) => {
450 if set
.ctime
< last_next_ctime
{
451 next_ctime
= Some(set
.ctime
);
461 pub fn media_expire_time(
464 media_set_policy
: &MediaSetPolicy
,
465 retention_policy
: &RetentionPolicy
,
468 if let RetentionPolicy
::KeepForever
= retention_policy
{
472 let set
= match media
.media_set_label
{
473 None
=> return i64::MAX
,
474 Some(ref set
) => set
,
477 let set_start_time
= match self.media_set_start_time(&set
.uuid
) {
479 // missing information, use ctime from this
480 // set (always greater than ctime from seq_nr 0)
486 let max_use_time
= match media_set_policy
{
487 MediaSetPolicy
::ContinueCurrent
=> {
488 match self.media_set_next_start_time(&set
.uuid
) {
489 Some(next_start_time
) => next_start_time
,
490 None
=> return i64::MAX
,
493 MediaSetPolicy
::AlwaysCreate
=> {
496 MediaSetPolicy
::CreateAt(ref event
) => {
497 match compute_next_event(event
, set_start_time
, false) {
498 Ok(Some(next
)) => next
,
499 Ok(None
) | Err(_
) => return i64::MAX
,
504 match retention_policy
{
505 RetentionPolicy
::KeepForever
=> i64::MAX
,
506 RetentionPolicy
::OverwriteAlways
=> max_use_time
,
507 RetentionPolicy
::ProtectFor(time_span
) => {
508 let seconds
= f64::from(time_span
.clone()) as i64;
509 max_use_time
+ seconds
514 /// Generate a human readable name for the media set
516 /// The template can include strftime time format specifications.
517 pub fn generate_media_set_name(
519 media_set_uuid
: &Uuid
,
520 template
: Option
<String
>,
521 ) -> Result
<String
, Error
> {
523 if let Some(ctime
) = self.media_set_start_time(media_set_uuid
) {
524 let mut template
= template
.unwrap_or_else(|| String
::from("%c"));
525 template
= template
.replace("%id%", &media_set_uuid
.to_string());
526 proxmox
::tools
::time
::strftime_local(&template
, ctime
)
528 // We don't know the set start time, so we cannot use the template
529 Ok(media_set_uuid
.to_string())
533 // Helpers to simplify testing
535 /// Genreate and insert a new free tape (test helper)
536 pub fn generate_free_tape(&mut self, label_text
: &str, ctime
: i64) -> Uuid
{
538 let label
= MediaLabel
{
539 label_text
: label_text
.to_string(),
540 uuid
: Uuid
::generate(),
543 let uuid
= label
.uuid
.clone();
545 self.store(MediaId { label, media_set_label: None }
, false).unwrap();
550 /// Genreate and insert a new tape assigned to a specific pool
552 pub fn generate_assigned_tape(
559 let label
= MediaLabel
{
560 label_text
: label_text
.to_string(),
561 uuid
: Uuid
::generate(),
565 let uuid
= label
.uuid
.clone();
567 let set
= MediaSetLabel
::with_data(pool
, [0u8; 16].into(), 0, ctime
, None
);
569 self.store(MediaId { label, media_set_label: Some(set) }
, false).unwrap();
574 /// Genreate and insert a used tape (test helper)
575 pub fn generate_used_tape(
581 let label
= MediaLabel
{
582 label_text
: label_text
.to_string(),
583 uuid
: Uuid
::generate(),
586 let uuid
= label
.uuid
.clone();
588 self.store(MediaId { label, media_set_label: Some(set) }
, false).unwrap();
594 // Status/location handling
597 /// Returns status and location with reasonable defaults.
599 /// Default status is 'MediaStatus::Unknown'.
600 /// Default location is 'MediaLocation::Offline'.
601 pub fn status_and_location(&self, uuid
: &Uuid
) -> (MediaStatus
, MediaLocation
) {
603 match self.map
.get(uuid
) {
605 // no info stored - assume media is writable/offline
606 (MediaStatus
::Unknown
, MediaLocation
::Offline
)
609 let location
= entry
.location
.clone().unwrap_or(MediaLocation
::Offline
);
610 let status
= entry
.status
.unwrap_or(MediaStatus
::Unknown
);
616 // Lock database, reload database, set status, store database
617 fn set_media_status(&mut self, uuid
: &Uuid
, status
: Option
<MediaStatus
>) -> Result
<(), Error
> {
618 let _lock
= self.lock()?
;
619 self.map
= Self::load_media_db(&self.inventory_path
)?
;
620 if let Some(entry
) = self.map
.get_mut(uuid
) {
621 entry
.status
= status
;
622 self.update_helpers();
623 self.replace_file()?
;
626 bail
!("no such media '{}'", uuid
);
630 /// Lock database, reload database, set status to Full, store database
631 pub fn set_media_status_full(&mut self, uuid
: &Uuid
) -> Result
<(), Error
> {
632 self.set_media_status(uuid
, Some(MediaStatus
::Full
))
635 /// Lock database, reload database, set status to Damaged, store database
636 pub fn set_media_status_damaged(&mut self, uuid
: &Uuid
) -> Result
<(), Error
> {
637 self.set_media_status(uuid
, Some(MediaStatus
::Damaged
))
640 /// Lock database, reload database, set status to None, store database
641 pub fn clear_media_status(&mut self, uuid
: &Uuid
) -> Result
<(), Error
> {
642 self.set_media_status(uuid
, None
)
645 // Lock database, reload database, set location, store database
646 fn set_media_location(&mut self, uuid
: &Uuid
, location
: Option
<MediaLocation
>) -> Result
<(), Error
> {
647 let _lock
= self.lock()?
;
648 self.map
= Self::load_media_db(&self.inventory_path
)?
;
649 if let Some(entry
) = self.map
.get_mut(uuid
) {
650 entry
.location
= location
;
651 self.update_helpers();
652 self.replace_file()?
;
655 bail
!("no such media '{}'", uuid
);
659 /// Lock database, reload database, set location to vault, store database
660 pub fn set_media_location_vault(&mut self, uuid
: &Uuid
, vault
: &str) -> Result
<(), Error
> {
661 self.set_media_location(uuid
, Some(MediaLocation
::Vault(vault
.to_string())))
664 /// Lock database, reload database, set location to offline, store database
665 pub fn set_media_location_offline(&mut self, uuid
: &Uuid
) -> Result
<(), Error
> {
666 self.set_media_location(uuid
, Some(MediaLocation
::Offline
))
669 /// Update online status
670 pub fn update_online_status(&mut self, online_map
: &OnlineStatusMap
) -> Result
<(), Error
> {
671 let _lock
= self.lock()?
;
672 self.map
= Self::load_media_db(&self.inventory_path
)?
;
674 for (uuid
, entry
) in self.map
.iter_mut() {
675 if let Some(changer_name
) = online_map
.lookup_changer(uuid
) {
676 entry
.location
= Some(MediaLocation
::Online(changer_name
.to_string()));
677 } else if let Some(MediaLocation
::Online(ref changer_name
)) = entry
.location
{
678 match online_map
.online_map(changer_name
) {
680 // no such changer device
681 entry
.location
= Some(MediaLocation
::Offline
);
684 // got no info - do nothing
687 // media changer changed
688 entry
.location
= Some(MediaLocation
::Offline
);
694 self.update_helpers();
695 self.replace_file()?
;
702 // shell completion helper
704 /// List of known media uuids
705 pub fn complete_media_uuid(
707 _param
: &HashMap
<String
, String
>,
710 let inventory
= match Inventory
::load(Path
::new(TAPE_STATUS_DIR
)) {
711 Ok(inventory
) => inventory
,
712 Err(_
) => return Vec
::new(),
715 inventory
.map
.keys().map(|uuid
| uuid
.to_string()).collect()
718 /// List of known media sets
719 pub fn complete_media_set_uuid(
721 _param
: &HashMap
<String
, String
>,
724 let inventory
= match Inventory
::load(Path
::new(TAPE_STATUS_DIR
)) {
725 Ok(inventory
) => inventory
,
726 Err(_
) => return Vec
::new(),
729 inventory
.map
.values()
730 .filter_map(|entry
| entry
.id
.media_set_label
.as_ref())
731 .map(|set
| set
.uuid
.to_string()).collect()
734 /// List of known media labels (barcodes)
735 pub fn complete_media_label_text(
737 _param
: &HashMap
<String
, String
>,
740 let inventory
= match Inventory
::load(Path
::new(TAPE_STATUS_DIR
)) {
741 Ok(inventory
) => inventory
,
742 Err(_
) => return Vec
::new(),
745 inventory
.map
.values().map(|entry
| entry
.id
.label
.label_text
.clone()).collect()