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
|
use std::collections::{HashMap, HashSet};
use std::error::Error;
use std::sync::LazyLock;
use std::sync::Arc;
use std::future::Future;
use std::pin::Pin;
use std::fs;
use std::time::*;
use duration_str as ds;
use super::cache::AsyncCache;
use super::deserialize::{GetRecentTracks, GetUserInfo, Track, User};
use reqwest::Client;
use dotenv::var;
use tokio::sync::RwLock;
pub static STATE: LazyLock<Arc<State>> = LazyLock::new(|| {
State::new()
});
fn getter(username: &String) -> Pin<Box<dyn Future<Output = Result<(User, Track), &'static str>>>> {
Box::pin(async{Err("nope")})
}
type Cache = Arc<RwLock<AsyncCache<String, (User, Track), fn(&String) -> Pin<Box<dyn Future<Output = Result<(User, Track), &'static str>>>>>>>;
#[derive(Debug)]
enum Whitelist {
Exclusive{cache: Cache, whitelist: HashSet<String>},
Open{default_cache: Cache, whitelist_cache: Cache, whitelist: HashSet<String>}
}
#[derive(Debug)]
pub struct State {
api_key: Arc<str>,
whitelist: Whitelist,
port: u16,
custom_themes: HashMap<String, Arc<str>>,
send_refresh_header: bool
}
impl State {
fn new() -> Arc<Self> {
Arc::new(State {
api_key: var("LFME_API_KEY").expect("API key must be set").into(),
port: var("LFME_PORT").map(|p| p.parse().expect("cannot parse as a port number")).unwrap_or(9999),
send_refresh_header: var("LFME_SET_HEADER").map(|h| &h == "1").unwrap_or(false),
custom_themes: {
if let Ok(themes_dir) = var("LFME_THEMES_DIR") {
fs::read_dir(themes_dir).expect("error reading LFME_THEMES_DIR")
.map(|a| a.expect("error reading LFME_THEMES_DIR"))
.filter_map(|a| {
let path = a.path();
if fs::metadata(&path).map(|m| m.is_file()).unwrap_or(false) &&
path.extension() == Some("css".as_ref()) {
Some((path.file_stem().unwrap().to_str().expect("bad filename").to_string(), fs::read_to_string(&path).expect("couldn't read theme CSS").into()))
}
else { None }
})
.collect()
}
else { HashMap::new() }
},
whitelist: {
let cache_from_var = |v: &str, d: u64| -> Cache {
let refresh = var(v).map(|r| ds::parse(&r).expect("bad duration string")).unwrap_or_else(|_| Duration::from_secs(d));
Arc::new(RwLock::new(AsyncCache::new(refresh, getter as _)))
};
let default_cache = || cache_from_var("LFME_DEFAULT_REFRESH", 300);
let whitelist_cache = || cache_from_var("LFME_WHITELIST_REFRESH", 60);
let load_whitelist = || -> Option<HashSet<String>> {
var("LFME_WHITELIST").ok().map(
|w| w.split(",").map(|s| s.trim().to_string()).collect()
)
};
match var("LFME_WHITELIST_MODE").map(|m| m.to_ascii_lowercase()).unwrap_or_else(|_| "open".into()).as_str() {
"open" => {
Whitelist::Open{default_cache: default_cache(), whitelist_cache: whitelist_cache(), whitelist: load_whitelist().unwrap_or_default()}
},
"exclusive" => {
Whitelist::Exclusive{cache: whitelist_cache(), whitelist: load_whitelist().expect("LFME_WHITELIST not set, unable to serve anyone")}
},
m => {
panic!("Bad whitelist mode: `{m}`");
}
}
}
})
}
pub fn api_key(&self) -> Arc<str> { self.api_key.clone() }
pub fn port(&self) -> u16 { self.port }
}
|
