partymode 0.2.1

Keeps your system awake while playing media
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use itertools::Itertools;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use thiserror::Error;

/**
Contains the error that occurred while loading the config file.
*/
#[derive(Debug, Error)]
pub enum LoadConfigError {
    /// The config file failed to parse.
    #[error("Error while reading config: {0}")]
    Parse(#[from] toml::de::Error),
    /// The config file could not be read.
    #[error("Could not open config file: {0}")]
    IO(#[from] std::io::Error),
}

/**
The configuration for partymode. Loaded from a config file at the default or user-specified location.
*/
#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "kebab-case")]
pub struct Config {
    pub default_enabled: bool,
    pub poll_interval: u64,
    #[serde(rename = "*")]
    pub default_rule: Rule,
    #[serde(flatten)]
    pub rules: HashMap<String, Rule>,
}

/**
Inhibit behavior rule applied to one or all players.
*/
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct Rule {
    /// Apply regardless of whether partymode is currently on or off.
    #[serde(default)]
    pub always: bool,
    /// Inhibit mode to use.
    pub mode: Option<InhibitMode>,
    /// What to inhibit.
    pub targets: Vec<InhibitTarget>,
}

impl Rule {
    pub fn targets_str(&self) -> Option<String> {
        if self.targets.is_empty() {
            return None;
        }

        Some(
            self.targets
                .iter()
                .map(|t| match t {
                    InhibitTarget::Idle => "idle",
                    InhibitTarget::Sleep => "sleep",
                    InhibitTarget::Shutdown => "shutdown",
                })
                .join(":"),
        )
    }

    pub fn with_defaults(&self, defaults: &Rule) -> Rule {
        Rule {
            always: self.always,
            mode: self.mode.clone().or(defaults.mode.clone()),
            targets: if self.targets.is_empty() {
                defaults.targets.clone()
            } else {
                self.targets.clone()
            },
        }
    }
}

/**
Inhibit mode as specified by [systemd-inhibit(1)](https://www.freedesktop.org/software/systemd/man/latest/systemd-inhibit.html#--mode=).
*/
#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "kebab-case")]
pub enum InhibitMode {
    Block,
    Delay,
    BlockWeak,
}
impl ToString for InhibitMode {
    fn to_string(&self) -> String {
        match self {
            InhibitMode::Block => "block".to_string(),
            InhibitMode::Delay => "delay".to_string(),
            InhibitMode::BlockWeak => "block_weak".to_string(),
        }
    }
}
/**
Inhibit target as specified by [systemd-inhibit(1)](https://www.freedesktop.org/software/systemd/man/latest/systemd-inhibit.html#--what=).
*/
#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "kebab-case")]
pub enum InhibitTarget {
    Idle,
    Sleep,
    Shutdown,
}

impl Config {
    pub fn load<P>(path: P) -> Result<Self, LoadConfigError>
    where
        P: AsRef<std::path::Path>,
    {
        let contents = std::fs::read_to_string(path)?;
        let result: Self = toml::from_str(&contents)?;
        Ok(result)
    }
}

impl Default for Config {
    fn default() -> Self {
        Config {
            default_enabled: true,
            default_rule: Rule {
                always: false,
                mode: Some(InhibitMode::Block),
                targets: vec![InhibitTarget::Idle],
            },
            poll_interval: 5000,
            rules: HashMap::new(),
        }
    }
}