Mirrors/polaris
2
0
Fork 0
mirror of https://github.com/agersant/polaris synced 2024-11-10 02:04:13 +00:00
Code Issues Projects Releases Packages Wiki Activity

Split configuration module (#117)

Browse source
This commit is contained in:
Antoine Gersant 2020-12-18 01:14:24 -08:00 committed by GitHub
parent e5c1d86577
commit 5e065c5e6a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
37 changed files with 1666 additions and 712 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

397
docs/swagger/polaris-api.json
View file

@ -16,18 +16,22 @@
"name": "Collection",
"description": "Browsing the music collection"
},
{
"name": "Configuration",
"description": "Managing the polaris installation"
},
{
"name": "Last.fm",
"description": "Integrating with Last.fm"
},
{
"name": "Settings",
"description": "Managing the polaris installation"
},
{
"name": "Playlists",
"description": "Managing playlists"
},
{
"name": "Users",
"description": "Managing user accounts"
},
{
"name": "Other"
}
@ -95,38 +99,13 @@
]
}
},
"/settings": {
"get": {
"tags": [
"Settings"
],
"summary": "Reads the existing server configuration",
"operationId": "getSettings",
"responses": {
"200": {
"description": "Successful operation",
"content": {
"application/json": {
"schema": {
"$ref": "#components/schemas/Config"
}
}
}
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
},
"/config": {
"put": {
"tags": [
"Settings"
"Configuration"
],
"summary": "Overwrites the server configuration",
"operationId": "getSettings",
"summary": "Amends the server settings, mount directories and list of users",
"operationId": "putConfig",
"requestBody": {
"required": true,
"content": {
@ -150,10 +129,250 @@
]
}
},
"/mount_dirs": {
"get": {
"tags": [
"Configuration"
],
"summary": "Reads the existing collection mount directories",
"operationId": "getMountDirs",
"responses": {
"200": {
"description": "Successful operation",
"content": {
"application/json": {
"schema": {
"type": "array",
"$ref": "#components/schemas/MountDir"
}
}
}
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
},
"put": {
"tags": [
"Configuration"
],
"summary": "Replaces the list collection mount directories",
"operationId": "putMountDirs",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"type": "array",
"$ref": "#components/schemas/MountDir"
}
}
}
},
"responses": {
"200": {
"description": "Successful operation"
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
}
},
"/settings": {
"get": {
"tags": [
"Configuration"
],
"summary": "Reads the existing server settings",
"operationId": "getSettings",
"responses": {
"200": {
"description": "Successful operation",
"content": {
"application/json": {
"schema": {
"$ref": "#components/schemas/Settings"
}
}
}
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
},
"put": {
"tags": [
"Configuration"
],
"summary": "Amends the server settings",
"operationId": "putSettings",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#components/schemas/Settings"
}
}
}
},
"responses": {
"200": {
"description": "Successful operation"
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
}
},
"/users": {
"get": {
"tags": [
"Users"
],
"summary": "List existing user accounts",
"operationId": "getUsers",
"responses": {
"200": {
"description": "Successful operation",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"$ref": "#/components/schemas/User"
}
}
}
}
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
}
},
"/user": {
"post": {
"tags": [
"Users"
],
"summary": "Creates a new user account",
"operationId": "postUser",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#components/schemas/NewUser"
}
}
}
},
"responses": {
"200": {
"description": "Successful operation"
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
}
},
"/user/{name}": {
"put": {
"tags": [
"Users"
],
"summary": "Updates properties of an existing user",
"operationId": "putUserName",
"parameters": [
{
"name": "name",
"in": "path",
"description": "Name of the affected user",
"schema": {
"type": "string"
}
}
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#components/schemas/UserUpdate"
}
}
}
},
"responses": {
"200": {
"description": "Successful operation"
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
},
"delete": {
"tags": [
"Users"
],
"summary": "Deletes an existing user",
"operationId": "deleteUserName",
"parameters": [
{
"name": "name",
"in": "path",
"description": "Name of the affected user",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "Successful operation"
}
},
"security": [
{
"admin_http_header": [],
"admin_cookie": []
}
]
}
},
"/preferences": {
"get": {
"tags": [
"Settings"
"Users"
],
"summary": "Reads the preferences of the current user",
"operationId": "getPreferences",
@ -175,12 +394,40 @@
"auth_cookie": []
}
]
},
"put": {
"tags": [
"Users"
],
"summary": "Saves the preferences of the current user",
"operationId": "putPreferences",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#components/schemas/Preferences"
}
}
}
},
"responses": {
"200": {
"description": "Successful operation"
}
},
"security": [
{
"auth_http_header": [],
"auth_cookie": []
}
]
}
},
"/auth": {
"post": {
"tags": [
"Other"
"Users"
],
"summary": "Signs in a user. Response has Set-Cookie headers for the session, username and admin permission of the user.",
"operationId": "postAuth",
@ -810,7 +1057,7 @@
}
}
},
"Config": {
"Settings": {
"type": "object",
"properties": {
"album_art_pattern": {
@ -821,18 +1068,6 @@
"type": "integer",
"example": 3600
},
"mount_dirs": {
"type": "array",
"items": {
"$ref": "#/components/schemas/MountPoint"
}
},
"users": {
"type": "array",
"items": {
"$ref": "#/components/schemas/ConfigUser"
}
},
"ydns": {
"type": "object",
"properties": {
@ -852,22 +1087,72 @@
}
}
},
"ConfigUser": {
"Config": {
"type": "object",
"properties": {
"settings": {
"$ref": "#/components/schemas/Settings"
},
"mount_dirs": {
"type": "array",
"items": {
"$ref": "#/components/schemas/MountDir"
}
},
"users": {
"type": "array",
"items": {
"$ref": "#/components/schemas/User"
}
}
}
},
"User": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"is_admin": {
"type": "boolean"
}
},
"required": [
"name",
"is_admin"
]
},
"NewUser": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"password": {
"type": "string",
"description": "Always blank when this field appear in a server response"
"type": "string"
},
"admin": {
"is_admin": {
"type": "boolean"
}
},
"required": [
"name",
"password",
"is_admin"
]
},
"UserUpdate": {
"type": "object",
"properties": {
"password": {
"type": "string"
},
"is_admin": {
"type": "boolean"
}
}
},
"MountPoint": {
"MountDir": {
"type": "object",
"properties": {
"source": {
@ -878,7 +1163,11 @@
"type": "string",
"example": "My Music"
}
}
},
"required": [
"source",
"name"
]
},
"Preferences": {
"type": "object",

8
src/app/config/error.rs
View file

@ -1,13 +1,5 @@
#[derive(thiserror::Error, Debug)]
pub enum Error {
#[error("Missing auth secret")]
AuthSecretNotFound,
#[error("Missing index sleep duration")]
IndexSleepDurationNotFound,
#[error("Missing index album art pattern")]
IndexAlbumArtPatternNotFound,
#[error("Index album art pattern is not a valid regex")]
IndexAlbumArtPatternInvalid,
#[error("Unspecified")]
Unspecified,
}

214
src/app/config/manager.rs
View file

@ -1,191 +1,83 @@
use diesel;
use diesel::prelude::*;
use regex::Regex;
use std::time::Duration;
use super::*;
use crate::app::user;
use crate::db::{ddns_config, misc_settings, mount_points, users, DB};
use crate::app::{ddns, settings, user, vfs};
#[derive(Clone)]
pub struct Manager {
pub db: DB,
settings_manager: settings::Manager,
user_manager: user::Manager,
vfs_manager: vfs::Manager,
ddns_manager: ddns::Manager,
}
impl Manager {
pub fn new(db: DB, user_manager: user::Manager) -> Self {
Self { db, user_manager }
pub fn new(
settings_manager: settings::Manager,
user_manager: user::Manager,
vfs_manager: vfs::Manager,
ddns_manager: ddns::Manager,
) -> Self {
Self {
settings_manager,
user_manager,
vfs_manager,
ddns_manager,
}
}
pub fn get_auth_secret(&self) -> Result<Vec<u8>, Error> {
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
misc_settings
.select(auth_secret)
.get_result(&connection)
.map_err(|e| match e {
diesel::result::Error::NotFound => Error::AuthSecretNotFound,
_ => Error::Unspecified,
})
}
pub fn get_index_sleep_duration(&self) -> Result<Duration, Error> {
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
misc_settings
.select(index_sleep_duration_seconds)
.get_result(&connection)
.map_err(|e| match e {
diesel::result::Error::NotFound => Error::IndexSleepDurationNotFound,
_ => Error::Unspecified,
})
.map(|s: i32| Duration::from_secs(s as u64))
}
pub fn get_index_album_art_pattern(&self) -> Result<Regex, Error> {
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
misc_settings
.select(index_album_art_pattern)
.get_result(&connection)
.map_err(|e| match e {
diesel::result::Error::NotFound => Error::IndexAlbumArtPatternNotFound,
_ => Error::Unspecified,
})
.map(|s: String| format!("(?i){}", s))
.and_then(|s| Regex::new(&s).map_err(|_| Error::IndexAlbumArtPatternInvalid))
}
pub fn read(&self) -> anyhow::Result<Config> {
use self::ddns_config::dsl::*;
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
let mut config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: None,
ydns: None,
};
let (art_pattern, sleep_duration) = misc_settings
.select((index_album_art_pattern, index_sleep_duration_seconds))
.get_result(&connection)?;
config.album_art_pattern = Some(art_pattern);
config.reindex_every_n_seconds = Some(sleep_duration);
let mount_dirs;
{
use self::mount_points::dsl::*;
mount_dirs = mount_points
.select((source, name))
.get_results(&connection)?;
config.mount_dirs = Some(mount_dirs);
pub fn apply(&self, config: &Config) -> Result<(), Error> {
if let Some(new_settings) = &config.settings {
self.settings_manager
.amend(new_settings)
.map_err(|_| Error::Unspecified)?;
}
let found_users: Vec<(String, i32)> = users::table
.select((users::columns::name, users::columns::admin))
.get_results(&connection)?;
config.users = Some(
found_users
.into_iter()
.map(|(name, admin)| ConfigUser {
name,
password: "".to_owned(),
admin: admin != 0,
})
.collect::<_>(),
);
let ydns = ddns_config
.select((host, username, password))
.get_result(&connection)?;
config.ydns = Some(ydns);
Ok(config)
}
pub fn amend(&self, new_config: &Config) -> anyhow::Result<()> {
let connection = self.db.connect()?;
if let Some(ref mount_dirs) = new_config.mount_dirs {
diesel::delete(mount_points::table).execute(&connection)?;
diesel::insert_into(mount_points::table)
.values(mount_dirs)
.execute(&*connection)?; // TODO https://github.com/diesel-rs/diesel/issues/1822
if let Some(mount_dirs) = &config.mount_dirs {
self.vfs_manager
.set_mount_dirs(&mount_dirs)
.map_err(|_| Error::Unspecified)?;
}
if let Some(ref config_users) = new_config.users {
let old_usernames: Vec<String> =
users::table.select(users::name).get_results(&connection)?;
if let Some(ddns_config) = &config.ydns {
self.ddns_manager
.set_config(&ddns_config)
.map_err(|_| Error::Unspecified)?;
}
if let Some(ref users) = config.users {
let old_users: Vec<user::User> =
self.user_manager.list().map_err(|_| Error::Unspecified)?;
// Delete users that are not in new list
let delete_usernames: Vec<String> = old_usernames
for old_user in old_users
.iter()
.cloned()
.filter(|old_name| config_users.iter().find(|u| &u.name == old_name).is_none())
.collect::<_>();
diesel::delete(users::table.filter(users::name.eq_any(&delete_usernames)))
.execute(&connection)?;
.filter(|old_user| !users.iter().any(|u| u.name == old_user.name))
{
self.user_manager
.delete(&old_user.name)
.map_err(|_| Error::Unspecified)?;
}
// Insert new users
let insert_users: Vec<&ConfigUser> = config_users
for new_user in users
.iter()
.filter(|u| {
!u.name.is_empty()
&& !u.password.is_empty()
&& old_usernames
.iter()
.find(|old_name| *old_name == &u.name)
.is_none()
})
.collect::<_>();
for config_user in &insert_users {
.filter(|u| !old_users.iter().any(|old_user| old_user.name == u.name))
{
self.user_manager
.create_user(&config_user.name, &config_user.password)?;
.create(new_user)
.map_err(|_| Error::Unspecified)?;
}
// Update users
for user in config_users.iter() {
// Update password if provided
if !user.password.is_empty() {
self.user_manager.set_password(&user.name, &user.password)?;
}
// Update admin rights
diesel::update(users::table.filter(users::name.eq(&user.name)))
.set(users::admin.eq(user.admin as i32))
.execute(&connection)?;
for user in users {
self.user_manager
.set_password(&user.name, &user.password)
.map_err(|_| Error::Unspecified)?;
self.user_manager
.set_is_admin(&user.name, user.admin)
.map_err(|_| Error::Unspecified)?;
}
}
if let Some(sleep_duration) = new_config.reindex_every_n_seconds {
diesel::update(misc_settings::table)
.set(misc_settings::index_sleep_duration_seconds.eq(sleep_duration as i32))
.execute(&connection)?;
}
if let Some(ref album_art_pattern) = new_config.album_art_pattern {
diesel::update(misc_settings::table)
.set(misc_settings::index_album_art_pattern.eq(album_art_pattern))
.execute(&connection)?;
}
if let Some(ref ydns) = new_config.ydns {
use self::ddns_config::dsl::*;
diesel::update(ddns_config)
.set((
host.eq(ydns.host.clone()),
username.eq(ydns.username.clone()),
password.eq(ydns.password.clone()),
))
.execute(&connection)?;
}
Ok(())
}
}

56
src/app/config/mod.rs
View file

@ -1,9 +1,8 @@
use crate::app::{ddns, vfs};
use core::ops::Deref;
use regex::Regex;
use serde::{Deserialize, Serialize};
use serde::Deserialize;
use std::io::Read;
use std::path::{self, PathBuf};
use std::path;
use crate::app::{ddns, settings, user, vfs};
mod error;
mod manager;
@ -13,20 +12,12 @@ mod test;
pub use error::*;
pub use manager::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConfigUser {
pub name: String,
pub password: String,
pub admin: bool,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[derive(Default, Deserialize)]
pub struct Config {
pub album_art_pattern: Option<String>,
pub reindex_every_n_seconds: Option<i32>,
pub mount_dirs: Option<Vec<vfs::MountPoint>>,
pub users: Option<Vec<ConfigUser>>,
pub settings: Option<settings::NewSettings>,
pub mount_dirs: Option<Vec<vfs::MountDir>>,
pub ydns: Option<ddns::Config>,
pub users: Option<Vec<user::NewUser>>,
}
impl Config {
@ -34,36 +25,7 @@ impl Config {
let mut config_file = std::fs::File::open(path)?;
let mut config_file_content = String::new();
config_file.read_to_string(&mut config_file_content)?;
let mut config = toml::de::from_str::<Config>(&config_file_content)?;
config.clean_paths()?;
let config = toml::de::from_str::<Self>(&config_file_content)?;
Ok(config)
}
fn clean_paths(&mut self) -> anyhow::Result<()> {
if let Some(ref mut mount_dirs) = self.mount_dirs {
for mount_dir in mount_dirs {
match Self::clean_path_string(&mount_dir.source).to_str() {
Some(p) => mount_dir.source = p.to_owned(),
_ => anyhow::bail!("Bad mount directory path"),
}
}
}
Ok(())
}
fn clean_path_string(path_string: &str) -> PathBuf {
let separator_regex = Regex::new(r"\\|/").unwrap();
let mut correct_separator = String::new();
correct_separator.push(path::MAIN_SEPARATOR);
let path_string = separator_regex.replace_all(path_string, correct_separator.as_str());
path::Path::new(path_string.deref()).iter().collect()
}
}
#[derive(Debug, Queryable)]
pub struct MiscSettings {
id: i32,
pub auth_secret: Vec<u8>,
pub index_sleep_duration_seconds: i32,
pub index_album_art_pattern: String,
}

317
src/app/config/test.rs
View file

@ -1,10 +1,9 @@
use diesel::prelude::*;
use std::fs;
use std::path::PathBuf;
use super::*;
use crate::app::{user, vfs};
use crate::db::{users, DB};
use crate::app::{settings, user, vfs};
use crate::db::DB;
use crate::test_name;
#[cfg(test)]
@ -22,249 +21,131 @@ fn get_test_db(name: &str) -> DB {
}
#[test]
fn test_amend() {
fn apply_saves_misc_settings() {
let db = get_test_db(&test_name!());
let settings_manager = settings::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let config_manager = Manager::new(db, user_manager);
let initial_config = Config {
album_art_pattern: Some("file\\.png".into()),
reindex_every_n_seconds: Some(123),
mount_dirs: Some(vec![vfs::MountPoint {
source: "C:\\Music".into(),
name: "root".into(),
}]),
users: Some(vec![ConfigUser {
name: "Teddy🐻".into(),
password: "Tasty🍖".into(),
admin: false,
}]),
ydns: None,
};
let vfs_manager = vfs::Manager::new(db.clone());
let ddns_manager = ddns::Manager::new(db.clone());
let config_manager = Manager::new(
settings_manager.clone(),
user_manager.clone(),
vfs_manager.clone(),
ddns_manager.clone(),
);
let new_config = Config {
album_art_pattern: Some("🖼️\\.jpg".into()),
reindex_every_n_seconds: None,
mount_dirs: Some(vec![vfs::MountPoint {
settings: Some(settings::NewSettings {
album_art_pattern: Some("🖼️\\.jpg".into()),
reindex_every_n_seconds: Some(100),
..Default::default()
}),
..Default::default()
};
config_manager.apply(&new_config).unwrap();
let settings = settings_manager.read().unwrap();
let new_settings = new_config.settings.unwrap();
assert_eq!(
settings.album_art_pattern,
new_settings.album_art_pattern.unwrap()
);
assert_eq!(
settings.reindex_every_n_seconds,
new_settings.reindex_every_n_seconds.unwrap()
);
}
#[test]
fn apply_saves_mount_points() {
let db = get_test_db(&test_name!());
let settings_manager = settings::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let vfs_manager = vfs::Manager::new(db.clone());
let ddns_manager = ddns::Manager::new(db.clone());
let config_manager = Manager::new(
settings_manager.clone(),
user_manager.clone(),
vfs_manager.clone(),
ddns_manager.clone(),
);
let new_config = Config {
mount_dirs: Some(vec![vfs::MountDir {
source: "/home/music".into(),
name: "🎵📁".into(),
}]),
users: Some(vec![ConfigUser {
name: "Kermit🐸".into(),
password: "🐞🐞".into(),
admin: false,
}]),
..Default::default()
};
config_manager.apply(&new_config).unwrap();
let actual_mount_dirs: Vec<vfs::MountDir> = vfs_manager.mount_dirs().unwrap();
assert_eq!(actual_mount_dirs, new_config.mount_dirs.unwrap());
}
#[test]
fn apply_saves_ddns_settings() {
use crate::app::ddns;
let db = get_test_db(&test_name!());
let settings_manager = settings::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let vfs_manager = vfs::Manager::new(db.clone());
let ddns_manager = ddns::Manager::new(db.clone());
let config_manager = Manager::new(
settings_manager.clone(),
user_manager.clone(),
vfs_manager.clone(),
ddns_manager.clone(),
);
let new_config = Config {
ydns: Some(ddns::Config {
host: "🐸🐸🐸.ydns.eu".into(),
username: "kfr🐸g".into(),
password: "tasty🐞".into(),
}),
..Default::default()
};
let mut expected_config = new_config.clone();
expected_config.reindex_every_n_seconds = initial_config.reindex_every_n_seconds;
if let Some(ref mut users) = expected_config.users {
users[0].password = "".into();
}
config_manager.amend(&initial_config).unwrap();
config_manager.amend(&new_config).unwrap();
let db_config = config_manager.read().unwrap();
assert_eq!(db_config, expected_config);
config_manager.apply(&new_config).unwrap();
let actual_ddns = ddns_manager.config().unwrap();
assert_eq!(actual_ddns, new_config.ydns.unwrap());
}
#[test]
fn test_amend_preserve_password_hashes() {
use self::users::dsl::*;
fn apply_can_toggle_admin() {
let db = get_test_db(&test_name!());
let settings_manager = settings::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let config_manager = Manager::new(db.clone(), user_manager);
let initial_hash: String;
let new_hash: String;
let vfs_manager = vfs::Manager::new(db.clone());
let ddns_manager = ddns::Manager::new(db.clone());
let config_manager = Manager::new(
settings_manager.clone(),
user_manager.clone(),
vfs_manager.clone(),
ddns_manager.clone(),
);
let initial_config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: Some(vec![ConfigUser {
name: "Teddy🐻".into(),
password: "Tasty🍖".into(),
admin: false,
}]),
ydns: None,
};
config_manager.amend(&initial_config).unwrap();
{
let connection = db.connect().unwrap();
initial_hash = users
.select(password_hash)
.filter(name.eq("Teddy🐻"))
.get_result(&connection)
.unwrap();
}
let new_config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: Some(vec![
ConfigUser {
name: "Kermit🐸".into(),
password: "tasty🐞".into(),
admin: false,
},
ConfigUser {
name: "Teddy🐻".into(),
password: "".into(),
admin: false,
},
]),
ydns: None,
};
config_manager.amend(&new_config).unwrap();
{
let connection = db.connect().unwrap();
new_hash = users
.select(password_hash)
.filter(name.eq("Teddy🐻"))
.get_result(&connection)
.unwrap();
}
assert_eq!(new_hash, initial_hash);
}
#[test]
fn test_amend_ignore_blank_users() {
use self::users::dsl::*;
let db = get_test_db(&test_name!());
let user_manager = user::Manager::new(db.clone());
let config_manager = Manager::new(db.clone(), user_manager);
{
let config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: Some(vec![ConfigUser {
name: "".into(),
password: "Tasty🍖".into(),
admin: false,
}]),
ydns: None,
};
config_manager.amend(&config).unwrap();
let connection = db.connect().unwrap();
let user_count: i64 = users.count().get_result(&connection).unwrap();
assert_eq!(user_count, 0);
}
{
let config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: Some(vec![ConfigUser {
name: "Teddy🐻".into(),
password: "".into(),
admin: false,
}]),
ydns: None,
};
config_manager.amend(&config).unwrap();
let connection = db.connect().unwrap();
let user_count: i64 = users.count().get_result(&connection).unwrap();
assert_eq!(user_count, 0);
}
}
#[test]
fn test_toggle_admin() {
use self::users::dsl::*;
let db = get_test_db(&test_name!());
let user_manager = user::Manager::new(db.clone());
let config_manager = Manager::new(db.clone(), user_manager);
let initial_config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: Some(vec![ConfigUser {
name: "Teddy🐻".into(),
users: Some(vec![user::NewUser {
name: "Walter".into(),
password: "Tasty🍖".into(),
admin: true,
}]),
ydns: None,
..Default::default()
};
config_manager.amend(&initial_config).unwrap();
{
let connection = db.connect().unwrap();
let is_admin: i32 = users.select(admin).get_result(&connection).unwrap();
assert_eq!(is_admin, 1);
}
config_manager.apply(&initial_config).unwrap();
assert!(user_manager.list().unwrap()[0].is_admin());
let new_config = Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
mount_dirs: None,
users: Some(vec![ConfigUser {
name: "Teddy🐻".into(),
password: "".into(),
users: Some(vec![user::NewUser {
name: "Walter".into(),
password: "Tasty🍖".into(),
admin: false,
}]),
ydns: None,
..Default::default()
};
config_manager.amend(&new_config).unwrap();
{
let connection = db.connect().unwrap();
let is_admin: i32 = users.select(admin).get_result(&connection).unwrap();
assert_eq!(is_admin, 0);
}
}
#[test]
fn test_clean_path_string() {
let mut correct_path = path::PathBuf::new();
if cfg!(target_os = "windows") {
correct_path.push("C:\\");
} else {
correct_path.push("/usr");
}
correct_path.push("some");
correct_path.push("path");
if cfg!(target_os = "windows") {
assert_eq!(correct_path, Config::clean_path_string(r#"C:/some/path"#));
assert_eq!(correct_path, Config::clean_path_string(r#"C:\some\path"#));
assert_eq!(correct_path, Config::clean_path_string(r#"C:\some\path\"#));
assert_eq!(
correct_path,
Config::clean_path_string(r#"C:\some\path\\\\"#)
);
assert_eq!(correct_path, Config::clean_path_string(r#"C:\some/path//"#));
} else {
assert_eq!(correct_path, Config::clean_path_string(r#"/usr/some/path"#));
assert_eq!(correct_path, Config::clean_path_string(r#"/usr\some\path"#));
assert_eq!(
correct_path,
Config::clean_path_string(r#"/usr\some\path\"#)
);
assert_eq!(
correct_path,
Config::clean_path_string(r#"/usr\some\path\\\\"#)
);
assert_eq!(
correct_path,
Config::clean_path_string(r#"/usr\some/path//"#)
);
}
config_manager.apply(&new_config).unwrap();
assert!(!user_manager.list().unwrap()[0].is_admin());
}

27
src/app/ddns/manager.rs
View file

@ -10,6 +10,7 @@ use crate::db::DB;
const DDNS_UPDATE_URL: &str = "https://ydns.io/api/v1/update/";
#[derive(Clone)]
pub struct Manager {
db: DB,
}
@ -20,7 +21,7 @@ impl Manager {
}
fn update_my_ip(&self) -> Result<()> {
let config = self.get_config()?;
let config = self.config()?;
if config.host.is_empty() || config.username.is_empty() {
info!("Skipping DDNS update because credentials are missing");
return Ok(());
@ -41,7 +42,7 @@ impl Manager {
Ok(())
}
fn get_config(&self) -> Result<Config> {
pub fn config(&self) -> Result<Config> {
use crate::db::ddns_config::dsl::*;
let connection = self.db.connect()?;
Ok(ddns_config
@ -49,7 +50,27 @@ impl Manager {
.get_result(&connection)?)
}
pub fn run(&self) {
pub fn set_config(&self, new_config: &Config) -> Result<()> {
use crate::db::ddns_config::dsl::*;
let connection = self.db.connect()?;
diesel::update(ddns_config)
.set((
host.eq(&new_config.host),
username.eq(&new_config.username),
password.eq(&new_config.password),
))
.execute(&connection)?;
Ok(())
}
pub fn begin_periodic_updates(&self) {
let cloned = self.clone();
std::thread::spawn(move || {
cloned.run();
});
}
fn run(&self) {
loop {
if let Err(e) = self.update_my_ip() {
error!("Dynamic DNS update error: {:?}", e);

10
src/app/index/mod.rs
View file

@ -3,7 +3,7 @@ use log::error;
use std::sync::{Arc, Condvar, Mutex};
use std::time::Duration;
use crate::app::{config, vfs};
use crate::app::{settings, vfs};
use crate::db::DB;
mod metadata;
@ -21,16 +21,16 @@ pub use self::update::*;
pub struct Index {
db: DB,
vfs_manager: vfs::Manager,
config_manager: config::Manager,
settings_manager: settings::Manager,
pending_reindex: Arc<(Mutex<bool>, Condvar)>,
}
impl Index {
pub fn new(db: DB, vfs_manager: vfs::Manager, config_manager: config::Manager) -> Self {
pub fn new(db: DB, vfs_manager: vfs::Manager, settings_manager: settings::Manager) -> Self {
let index = Self {
db,
vfs_manager,
config_manager,
settings_manager,
pending_reindex: Arc::new((Mutex::new(false), Condvar::new())),
};
@ -76,7 +76,7 @@ impl Index {
loop {
self.trigger_reindex();
let sleep_duration = self
.config_manager
.settings_manager
.get_index_sleep_duration()
.unwrap_or_else(|e| {
error!("Could not retrieve index sleep duration: {}", e);

7
src/app/index/test.rs
View file

@ -2,16 +2,15 @@ use diesel::prelude::*;
use std::path::{Path, PathBuf};
use super::*;
use crate::app::{config, user, vfs};
use crate::app::{index::Index, settings, vfs};
use crate::db::{self, directories, songs};
use crate::test_name;
fn get_context(test_name: &str) -> (db::DB, Index) {
let db = db::get_test_db(test_name);
let vfs_manager = vfs::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let config_manager = config::Manager::new(db.clone(), user_manager);
let index = Index::new(db.clone(), vfs_manager, config_manager);
let settings_manager = settings::Manager::new(db.clone());
let index = Index::new(db.clone(), vfs_manager, settings_manager);
(db, index)
}

6
src/app/index/update/mod.rs
View file

@ -18,7 +18,7 @@ impl Index {
let start = time::Instant::now();
info!("Beginning library index update");
let album_art_pattern = self.config_manager.get_index_album_art_pattern()?;
let album_art_pattern = self.settings_manager.get_index_album_art_pattern()?;
let cleaner = Cleaner::new(self.db.clone(), self.vfs_manager.clone());
cleaner.clean()?;
@ -38,9 +38,9 @@ impl Index {
let vfs = self.vfs_manager.get_vfs()?;
let traverser_thread = std::thread::spawn(move || {
let mount_points = vfs.get_mount_points();
let mounts = vfs.mounts();
let traverser = Traverser::new(collect_sender);
traverser.traverse(mount_points.values().map(|p| p.clone()).collect());
traverser.traverse(mounts.iter().map(|p| p.source.clone()).collect());
});
if let Err(e) = traverser_thread.join() {

1
src/app/mod.rs
View file

@ -3,6 +3,7 @@ pub mod ddns;
pub mod index;
pub mod lastfm;
pub mod playlist;
pub mod settings;
pub mod thumbnail;
pub mod user;
pub mod vfs;

7
src/app/playlist/test.rs
View file

@ -2,7 +2,7 @@ use core::clone::Clone;
use std::path::{Path, PathBuf};
use super::*;
use crate::app::{config, index::Index, user, vfs};
use crate::app::{index::Index, settings, vfs};
use crate::db;
use crate::test_name;
@ -58,9 +58,8 @@ fn test_delete_playlist() {
fn test_fill_playlist() {
let db = db::get_test_db(&test_name!());
let vfs_manager = vfs::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let config_manager = config::Manager::new(db.clone(), user_manager);
let index = Index::new(db.clone(), vfs_manager.clone(), config_manager);
let settings_manager = settings::Manager::new(db.clone());
let index = Index::new(db.clone(), vfs_manager.clone(), settings_manager);
let manager = Manager::new(db, vfs_manager);
index.update().unwrap();

21
src/app/settings/error.rs Normal file
View file

@ -0,0 +1,21 @@
#[derive(thiserror::Error, Debug)]
pub enum Error {
#[error("Missing auth secret")]
AuthSecretNotFound,
#[error("Auth secret does not have the expected format")]
InvalidAuthSecret,
#[error("Missing index sleep duration")]
IndexSleepDurationNotFound,
#[error("Missing index album art pattern")]
IndexAlbumArtPatternNotFound,
#[error("Index album art pattern is not a valid regex")]
IndexAlbumArtPatternInvalid,
#[error("Unspecified")]
Unspecified,
}
impl From<anyhow::Error> for Error {
fn from(_: anyhow::Error) -> Self {
Error::Unspecified
}
}

97
src/app/settings/manager.rs Normal file
View file

@ -0,0 +1,97 @@
use diesel;
use diesel::prelude::*;
use regex::Regex;
use std::convert::TryInto;
use std::time::Duration;
use super::*;
use crate::db::{misc_settings, DB};
#[derive(Clone)]
pub struct Manager {
pub db: DB,
}
impl Manager {
pub fn new(db: DB) -> Self {
Self { db }
}
pub fn get_auth_secret(&self) -> Result<AuthSecret, Error> {
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
let secret: Vec<u8> = misc_settings
.select(auth_secret)
.get_result(&connection)
.map_err(|e| match e {
diesel::result::Error::NotFound => Error::AuthSecretNotFound,
_ => Error::Unspecified,
})?;
secret
.try_into()
.map_err(|_| Error::InvalidAuthSecret)
.map(|key| AuthSecret { key })
}
pub fn get_index_sleep_duration(&self) -> Result<Duration, Error> {
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
misc_settings
.select(index_sleep_duration_seconds)
.get_result(&connection)
.map_err(|e| match e {
diesel::result::Error::NotFound => Error::IndexSleepDurationNotFound,
_ => Error::Unspecified,
})
.map(|s: i32| Duration::from_secs(s as u64))
}
pub fn get_index_album_art_pattern(&self) -> Result<Regex, Error> {
use self::misc_settings::dsl::*;
let connection = self.db.connect()?;
misc_settings
.select(index_album_art_pattern)
.get_result(&connection)
.map_err(|e| match e {
diesel::result::Error::NotFound => Error::IndexAlbumArtPatternNotFound,
_ => Error::Unspecified,
})
.and_then(|s: String| {
Regex::new(&format!("(?i){}", &s)).map_err(|_| Error::IndexAlbumArtPatternInvalid)
})
}
pub fn read(&self) -> Result<Settings, Error> {
let connection = self.db.connect()?;
let misc: MiscSettings = misc_settings::table
.get_result(&connection)
.map_err(|_| Error::Unspecified)?;
Ok(Settings {
auth_secret: misc.auth_secret,
album_art_pattern: misc.index_album_art_pattern,
reindex_every_n_seconds: misc.index_sleep_duration_seconds,
})
}
pub fn amend(&self, new_settings: &NewSettings) -> Result<(), Error> {
let connection = self.db.connect()?;
if let Some(sleep_duration) = new_settings.reindex_every_n_seconds {
diesel::update(misc_settings::table)
.set(misc_settings::index_sleep_duration_seconds.eq(sleep_duration as i32))
.execute(&connection)
.map_err(|_| Error::Unspecified)?;
}
if let Some(ref album_art_pattern) = new_settings.album_art_pattern {
diesel::update(misc_settings::table)
.set(misc_settings::index_album_art_pattern.eq(album_art_pattern))
.execute(&connection)
.map_err(|_| Error::Unspecified)?;
}
Ok(())
}
}

33
src/app/settings/mod.rs Normal file
View file

@ -0,0 +1,33 @@
use serde::Deserialize;
mod error;
mod manager;
pub use error::*;
pub use manager::*;
#[derive(Clone)]
pub struct AuthSecret {
pub key: [u8; 32],
}
#[derive(Debug, Queryable)]
struct MiscSettings {
id: i32,
auth_secret: Vec<u8>,
index_sleep_duration_seconds: i32,
index_album_art_pattern: String,
}
#[derive(Debug)]
pub struct Settings {
auth_secret: Vec<u8>,
pub reindex_every_n_seconds: i32,
pub album_art_pattern: String,
}
#[derive(Debug, Default, Deserialize)]
pub struct NewSettings {
pub reindex_every_n_seconds: Option<i32>,
pub album_art_pattern: Option<String>,
}

6
src/app/user/error.rs
View file

@ -1,7 +1,11 @@
#[derive(thiserror::Error, Debug)]
#[derive(thiserror::Error, Debug, PartialEq, Eq)]
pub enum Error {
#[error("Cannot use empty username")]
EmptyUsername,
#[error("Cannot use empty password")]
EmptyPassword,
#[error("Username does not exist")]
IncorrectUsername,
#[error("Unspecified")]
Unspecified,
}

71
src/app/user/manager.rs
View file

@ -17,17 +17,19 @@ impl Manager {
Self { db }
}
pub fn create_user(&self, username: &str, password: &str) -> Result<(), Error> {
if password.is_empty() {
return Err(Error::EmptyPassword);
pub fn create(&self, new_user: &NewUser) -> Result<(), Error> {
if new_user.name.is_empty() {
return Err(Error::EmptyUsername);
}
let password_hash = hash_password(password)?;
let password_hash = hash_password(&new_user.password)?;
let connection = self.db.connect()?;
let new_user = User {
name: username.to_owned(),
name: new_user.name.to_owned(),
password_hash,
admin: 0,
admin: new_user.admin as i32,
};
diesel::insert_into(users::table)
.values(&new_user)
.execute(&connection)
@ -35,17 +37,37 @@ impl Manager {
Ok(())
}
pub fn set_password(&self, username: &str, password: &str) -> Result<(), Error> {
let password_hash = hash_password(password)?;
pub fn delete(&self, username: &str) -> Result<(), Error> {
use crate::db::users::dsl::*;
let connection = self.db.connect()?;
diesel::update(users::table.filter(users::name.eq(username)))
.set(users::password_hash.eq(password_hash))
diesel::delete(users.filter(name.eq(username)))
.execute(&connection)
.map_err(|_| Error::Unspecified)?;
Ok(())
}
pub fn auth(&self, username: &str, password: &str) -> anyhow::Result<bool> {
pub fn set_password(&self, username: &str, password: &str) -> Result<(), Error> {
let hash = hash_password(password)?;
let connection = self.db.connect()?;
use crate::db::users::dsl::*;
diesel::update(users.filter(name.eq(username)))
.set(password_hash.eq(hash))
.execute(&connection)
.map_err(|_| Error::Unspecified)?;
Ok(())
}
pub fn set_is_admin(&self, username: &str, is_admin: bool) -> Result<(), Error> {
use crate::db::users::dsl::*;
let connection = self.db.connect()?;
diesel::update(users.filter(name.eq(username)))
.set(admin.eq(is_admin as i32))
.execute(&connection)
.map_err(|_| Error::Unspecified)?;
Ok(())
}
pub fn login(&self, username: &str, password: &str) -> Result<bool, Error> {
use crate::db::users::dsl::*;
let connection = self.db.connect()?;
match users
@ -53,15 +75,14 @@ impl Manager {
.filter(name.eq(username))
.get_result(&connection)
{
Err(diesel::result::Error::NotFound) => Ok(false),
Err(diesel::result::Error::NotFound) => Err(Error::IncorrectUsername),
Ok(hash) => {
let hash: String = hash;
Ok(verify_password(&hash, password))
}
Err(e) => Err(e.into()),
Err(_) => Err(Error::Unspecified),
}
}
pub fn count(&self) -> anyhow::Result<i64> {
use crate::db::users::dsl::*;
let connection = self.db.connect()?;
@ -69,13 +90,23 @@ impl Manager {
Ok(count)
}
pub fn exists(&self, username: &str) -> anyhow::Result<bool> {
pub fn list(&self) -> Result<Vec<User>, Error> {
use crate::db::users::dsl::*;
let connection = self.db.connect()?;
users
.select((name, password_hash, admin))
.get_results(&connection)
.map_err(|_| Error::Unspecified)
}
pub fn exists(&self, username: &str) -> Result<bool, Error> {
use crate::db::users::dsl::*;
let connection = self.db.connect()?;
let results: Vec<String> = users
.select(name)
.filter(name.eq(username))
.get_results(&connection)?;
.get_results(&connection)
.map_err(|_| Error::Unspecified)?;
Ok(results.len() > 0)
}
@ -134,11 +165,11 @@ impl Manager {
}
}
fn hash_password(password: &str) -> anyhow::Result<String> {
match pbkdf2::pbkdf2_simple(password, HASH_ITERATIONS) {
Ok(hash) => Ok(hash),
Err(e) => Err(e.into()),
fn hash_password(password: &str) -> Result<String, Error> {
if password.is_empty() {
return Err(Error::EmptyPassword);
}
pbkdf2::pbkdf2_simple(password, HASH_ITERATIONS).map_err(|_| Error::Unspecified)
}
fn verify_password(password_hash: &str, attempted_password: &str) -> bool {

15
src/app/user/mod.rs
View file

@ -1,3 +1,5 @@
use serde::Deserialize;
use crate::db::users;
mod error;
@ -17,3 +19,16 @@ pub struct User {
pub password_hash: String,
pub admin: i32,
}
impl User {
pub fn is_admin(&self) -> bool {
self.admin != 0
}
}
#[derive(Debug, Deserialize)]
pub struct NewUser {
pub name: String,
pub password: String,
pub admin: bool,
}

100
src/app/user/test.rs
View file

@ -1,11 +1,92 @@
use super::*;
use crate::db;
use crate::db::DB;
use crate::test_name;
#[cfg(test)]
pub fn get_test_db(name: &str) -> DB {
let mut db_path = std::path::PathBuf::new();
db_path.push("test-output");
std::fs::create_dir_all(&db_path).unwrap();
db_path.push(name);
if db_path.exists() {
std::fs::remove_file(&db_path).unwrap();
}
DB::new(&db_path).unwrap()
}
#[test]
fn test_preferences_read_write() {
let db = db::get_test_db(&test_name!());
let manager = Manager::new(db);
fn create_delete_user_golden_path() {
let db = get_test_db(&test_name!());
let user_manager = Manager::new(db);
let new_user = NewUser {
name: "Walter".to_owned(),
password: "super_secret!".to_owned(),
admin: false,
};
assert_eq!(user_manager.list().unwrap().len(), 0);
user_manager.create(&new_user).unwrap();
assert_eq!(user_manager.list().unwrap().len(), 1);
user_manager.delete(&new_user.name).unwrap();
assert_eq!(user_manager.list().unwrap().len(), 0);
}
#[test]
fn cannot_create_user_with_blank_username() {
let db = get_test_db(&test_name!());
let user_manager = Manager::new(db);
let new_user = NewUser {
name: "".to_owned(),
password: "super_secret!".to_owned(),
admin: false,
};
assert_eq!(
user_manager.create(&new_user).unwrap_err(),
Error::EmptyUsername
);
}
#[test]
fn cannot_create_user_with_blank_password() {
let db = get_test_db(&test_name!());
let user_manager = Manager::new(db);
let new_user = NewUser {
name: "Walter".to_owned(),
password: "".to_owned(),
admin: false,
};
assert_eq!(
user_manager.create(&new_user).unwrap_err(),
Error::EmptyPassword
);
}
#[test]
fn cannot_create_duplicate_user() {
let db = get_test_db(&test_name!());
let user_manager = Manager::new(db);
let new_user = NewUser {
name: "Walter".to_owned(),
password: "super_secret!".to_owned(),
admin: false,
};
user_manager.create(&new_user).unwrap();
user_manager.create(&new_user).unwrap_err();
}
#[test]
fn can_read_write_preferences() {
let db = get_test_db(&test_name!());
let user_manager = Manager::new(db);
let new_preferences = Preferences {
web_theme_base: Some("very-dark-theme".to_owned()),
@ -13,12 +94,17 @@ fn test_preferences_read_write() {
lastfm_username: None,
};
manager.create_user("Walter", "super_secret!").unwrap();
let new_user = NewUser {
name: "Walter".to_owned(),
password: "super_secret!".to_owned(),
admin: false,
};
user_manager.create(&new_user).unwrap();
manager
user_manager
.write_preferences("Walter", &new_preferences)
.unwrap();
let read_preferences = manager.read_preferences("Walter").unwrap();
let read_preferences = user_manager.read_preferences("Walter").unwrap();
assert_eq!(new_preferences, read_preferences);
}

25
src/app/vfs/manager.rs
View file

@ -1,6 +1,5 @@
use anyhow::*;
use diesel::prelude::*;
use std::path::Path;
use super::*;
use crate::db::mount_points;
@ -17,15 +16,27 @@ impl Manager {
}
pub fn get_vfs(&self) -> Result<VFS> {
let mount_dirs = self.mount_dirs()?;
let mounts = mount_dirs.into_iter().map(|p| p.into()).collect();
Ok(VFS::new(mounts))
}
pub fn mount_dirs(&self) -> Result<Vec<MountDir>> {
use self::mount_points::dsl::*;
let mut vfs = VFS::new();
let connection = self.db.connect()?;
let points: Vec<MountPoint> = mount_points
let mount_dirs: Vec<MountDir> = mount_points
.select((source, name))
.get_results(&connection)?;
for point in points {
vfs.mount(&Path::new(&point.source), &point.name)?;
}
Ok(vfs)
Ok(mount_dirs)
}
pub fn set_mount_dirs(&self, mount_dirs: &Vec<MountDir>) -> Result<()> {
use self::mount_points::dsl::*;
let connection = self.db.connect()?;
diesel::delete(mount_points).execute(&connection)?;
diesel::insert_into(mount_points)
.values(mount_dirs)
.execute(&*connection)?; // TODO https://github.com/diesel-rs/diesel/issues/1822
Ok(())
}
}

60
src/app/vfs/mod.rs
View file

@ -1,8 +1,8 @@
use anyhow::*;
use core::ops::Deref;
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::Path;
use std::path::PathBuf;
use std::path::{self, Path, PathBuf};
use crate::db::mount_points;
@ -14,32 +14,44 @@ pub use manager::*;
#[derive(Clone, Debug, Deserialize, Insertable, PartialEq, Queryable, Serialize)]
#[table_name = "mount_points"]
pub struct MountPoint {
pub struct MountDir {
pub source: String,
pub name: String,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Mount {
pub source: PathBuf,
pub name: String,
}
impl From<MountDir> for Mount {
fn from(m: MountDir) -> Self {
let separator_regex = Regex::new(r"\\|/").unwrap();
let mut correct_separator = String::new();
correct_separator.push(path::MAIN_SEPARATOR);
let path_string = separator_regex.replace_all(&m.source, correct_separator.as_str());
let source = PathBuf::from(path_string.deref());
Self {
name: m.name,
source: source,
}
}
}
pub struct VFS {
mount_points: HashMap<String, PathBuf>,
mounts: Vec<Mount>,
}
impl VFS {
pub fn new() -> VFS {
VFS {
mount_points: HashMap::new(),
}
}
pub fn mount(&mut self, real_path: &Path, name: &str) -> Result<()> {
self.mount_points
.insert(name.to_owned(), real_path.to_path_buf());
Ok(())
pub fn new(mounts: Vec<Mount>) -> VFS {
VFS { mounts }
}
pub fn real_to_virtual<P: AsRef<Path>>(&self, real_path: P) -> Result<PathBuf> {
for (name, target) in &self.mount_points {
if let Ok(p) = real_path.as_ref().strip_prefix(target) {
let mount_path = Path::new(&name);
for mount in &self.mounts {
if let Ok(p) = real_path.as_ref().strip_prefix(&mount.source) {
let mount_path = Path::new(&mount.name);
return if p.components().count() == 0 {
Ok(mount_path.to_path_buf())
} else {
@ -51,20 +63,20 @@ impl VFS {
}
pub fn virtual_to_real<P: AsRef<Path>>(&self, virtual_path: P) -> Result<PathBuf> {
for (name, target) in &self.mount_points {
let mount_path = Path::new(&name);
for mount in &self.mounts {
let mount_path = Path::new(&mount.name);
if let Ok(p) = virtual_path.as_ref().strip_prefix(mount_path) {
return if p.components().count() == 0 {
Ok(target.clone())
Ok(mount.source.clone())
} else {
Ok(target.join(p))
Ok(mount.source.join(p))
};
}
}
bail!("Virtual path has no match in VFS")
}
pub fn get_mount_points(&self) -> &HashMap<String, PathBuf> {
&self.mount_points
pub fn mounts(&self) -> &Vec<Mount> {
&self.mounts
}
}

57
src/app/vfs/test.rs
View file

@ -4,8 +4,10 @@ use super::*;
#[test]
fn test_virtual_to_real() {
let mut vfs = VFS::new();
vfs.mount(Path::new("test_dir"), "root").unwrap();
let vfs = VFS::new(vec![Mount {
name: "root".to_owned(),
source: Path::new("test_dir").to_owned(),
}]);
let mut correct_path = PathBuf::new();
correct_path.push("test_dir");
@ -23,8 +25,10 @@ fn test_virtual_to_real() {
#[test]
fn test_virtual_to_real_no_trail() {
let mut vfs = VFS::new();
vfs.mount(Path::new("test_dir"), "root").unwrap();
let vfs = VFS::new(vec![Mount {
name: "root".to_owned(),
source: Path::new("test_dir").to_owned(),
}]);
let correct_path = Path::new("test_dir");
let found_path = vfs.virtual_to_real(Path::new("root")).unwrap();
assert!(found_path.to_str() == correct_path.to_str());
@ -32,8 +36,10 @@ fn test_virtual_to_real_no_trail() {
#[test]
fn test_real_to_virtual() {
let mut vfs = VFS::new();
vfs.mount(Path::new("test_dir"), "root").unwrap();
let vfs = VFS::new(vec![Mount {
name: "root".to_owned(),
source: Path::new("test_dir").to_owned(),
}]);
let mut correct_path = PathBuf::new();
correct_path.push("root");
@ -48,3 +54,42 @@ fn test_real_to_virtual() {
let found_path = vfs.real_to_virtual(real_path.as_path()).unwrap();
assert!(found_path == correct_path);
}
#[test]
fn test_clean_path_string() {
let mut correct_path = path::PathBuf::new();
if cfg!(target_os = "windows") {
correct_path.push("C:\\");
} else {
correct_path.push("/usr");
}
correct_path.push("some");
correct_path.push("path");
let tests = if cfg!(target_os = "windows") {
vec![
r#"C:/some/path"#,
r#"C:\some\path"#,
r#"C:\some\path\"#,
r#"C:\some\path\\\\"#,
r#"C:\some/path//"#,
]
} else {
vec![
r#"/usr/some/path"#,
r#"/usr\some\path"#,
r#"/usr\some\path\"#,
r#"/usr\some\path\\\\"#,
r#"/usr\some/path//"#,
]
};
for test in tests {
let mount_dir = MountDir {
source: test.to_owned(),
name: "name".to_owned(),
};
let mount: Mount = mount_dir.into();
assert_eq!(mount.source, correct_path);
}
}

14
src/db/mod.rs
View file

@ -89,9 +89,7 @@ impl DB {
#[cfg(test)]
pub fn get_test_db(name: &str) -> DB {
use crate::app::{config, user};
let config_path = Path::new("test-data/config.toml");
let config = config::Config::from_path(&config_path).unwrap();
use crate::app::{config, ddns, settings, user, vfs};
let mut db_path = std::path::PathBuf::new();
db_path.push("test-output");
@ -103,10 +101,16 @@ pub fn get_test_db(name: &str) -> DB {
}
let db = DB::new(&db_path).unwrap();
let settings_manager = settings::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let config_manager = config::Manager::new(db.clone(), user_manager);
let vfs_manager = vfs::Manager::new(db.clone());
let ddns_manager = ddns::Manager::new(db.clone());
let config_manager =
config::Manager::new(settings_manager, user_manager, vfs_manager, ddns_manager);
config_manager.amend(&config).unwrap();
let config_path = Path::new("test-data/config.toml");
let config = config::Config::from_path(&config_path).unwrap();
config_manager.apply(&config).unwrap();
db
}

5
src/main.rs
View file

@ -148,10 +148,7 @@ fn main() -> Result<()> {
context.index.begin_periodic_updates();
// Start DDNS updates
let ddns_manager = app::ddns::Manager::new(context.db.clone());
std::thread::spawn(move || {
ddns_manager.run();
});
context.ddns_manager.begin_periodic_updates();
// Start server
info!("Starting up server");

169
src/service/actix/api.rs
View file

@ -19,12 +19,11 @@ use std::ops::Deref;
use std::path::Path;
use std::pin::Pin;
use std::str;
use time::Duration;
use crate::app::{
config,
config, ddns,
index::{self, Index},
lastfm, playlist, thumbnail, user, vfs,
lastfm, playlist, settings, thumbnail, user, vfs,
};
use crate::service::{dto, error::*};
@ -34,8 +33,17 @@ pub fn make_config() -> impl FnOnce(&mut ServiceConfig) + Clone {
cfg.app_data(JsonConfig::default().limit(4 * megabyte)) // 4MB
.service(version)
.service(initial_setup)
.service(apply_config)
.service(get_settings)
.service(put_settings)
.service(list_mount_dirs)
.service(put_mount_dirs)
.service(get_ddns_config)
.service(put_ddns_config)
.service(list_users)
.service(create_user)
.service(update_user)
.service(delete_user)
.service(get_preferences)
.service(put_preferences)
.service(trigger_index)
@ -65,6 +73,9 @@ impl ResponseError for APIError {
fn status_code(&self) -> StatusCode {
match self {
APIError::IncorrectCredentials => StatusCode::UNAUTHORIZED,
APIError::EmptyUsername => StatusCode::BAD_REQUEST,
APIError::EmptyPassword => StatusCode::BAD_REQUEST,
APIError::DeletingOwnAccount => StatusCode::CONFLICT,
APIError::OwnAdminPrivilegeRemoval => StatusCode::CONFLICT,
APIError::AudioFileIOError => StatusCode::NOT_FOUND,
APIError::ThumbnailFileIOError => StatusCode::NOT_FOUND,
@ -190,7 +201,7 @@ impl FromRequest for Auth {
.map(|s| s.as_ref())
.unwrap_or("")
.to_string();
let auth_result = block(move || user_manager.auth(&username, &password)).await?;
let auth_result = block(move || user_manager.login(&username, &password)).await?;
if auth_result {
Ok(Auth {
username: auth.user_id().to_string(),
@ -294,15 +305,13 @@ fn add_auth_cookies<T>(
username: &str,
is_admin: bool,
) -> Result<(), HttpError> {
let duration = Duration::days(1);
let mut cookies = cookies.clone();
cookies.add_signed(
Cookie::build(dto::COOKIE_SESSION, username.to_owned())
.same_site(cookie::SameSite::Lax)
.http_only(true)
.max_age(duration)
.permanent()
.finish(),
);
@ -310,7 +319,7 @@ fn add_auth_cookies<T>(
Cookie::build(dto::COOKIE_USERNAME, username.to_owned())
.same_site(cookie::SameSite::Lax)
.http_only(false)
.max_age(duration)
.permanent()
.path("/")
.finish(),
);
@ -319,7 +328,7 @@ fn add_auth_cookies<T>(
Cookie::build(dto::COOKIE_ADMIN, format!("{}", is_admin))
.same_site(cookie::SameSite::Lax)
.http_only(false)
.max_age(duration)
.permanent()
.path("/")
.finish(),
);
@ -360,42 +369,150 @@ async fn initial_setup(
user_manager: Data<user::Manager>,
) -> Result<Json<dto::InitialSetup>, APIError> {
let initial_setup = block(move || -> Result<dto::InitialSetup, APIError> {
let user_count = user_manager.count()?;
let users = user_manager.list()?;
let has_any_admin = users.iter().any(|u| u.is_admin());
Ok(dto::InitialSetup {
has_any_users: user_count > 0,
has_any_users: has_any_admin,
})
})
.await?;
Ok(Json(initial_setup))
}
#[put("/config")]
async fn apply_config(
_admin_rights: AdminRights,
config_manager: Data<config::Manager>,
config: Json<dto::Config>,
) -> Result<HttpResponse, APIError> {
block(move || config_manager.apply(&config.to_owned().into())).await?;
Ok(HttpResponse::new(StatusCode::OK))
}
#[get("/settings")]
async fn get_settings(
config_manager: Data<config::Manager>,
settings_manager: Data<settings::Manager>,
_admin_rights: AdminRights,
) -> Result<Json<config::Config>, APIError> {
let config = block(move || config_manager.read()).await?;
Ok(Json(config))
) -> Result<Json<dto::Settings>, APIError> {
let settings = block(move || settings_manager.read()).await?;
Ok(Json(settings.into()))
}
#[put("/settings")]
async fn put_settings(
admin_rights: AdminRights,
config_manager: Data<config::Manager>,
config: Json<config::Config>,
_admin_rights: AdminRights,
settings_manager: Data<settings::Manager>,
new_settings: Json<dto::NewSettings>,
) -> Result<HttpResponse, APIError> {
block(move || settings_manager.amend(&new_settings.to_owned().into())).await?;
Ok(HttpResponse::new(StatusCode::OK))
}
#[get("/mount_dirs")]
async fn list_mount_dirs(
vfs_manager: Data<vfs::Manager>,
_admin_rights: AdminRights,
) -> Result<Json<Vec<dto::MountDir>>, APIError> {
let mount_dirs = block(move || vfs_manager.mount_dirs()).await?;
let mount_dirs = mount_dirs.into_iter().map(|m| m.into()).collect();
Ok(Json(mount_dirs))
}
#[put("/mount_dirs")]
async fn put_mount_dirs(
_admin_rights: AdminRights,
vfs_manager: Data<vfs::Manager>,
new_mount_dirs: Json<Vec<dto::MountDir>>,
) -> Result<HttpResponse, APIError> {
let new_mount_dirs = new_mount_dirs
.to_owned()
.into_iter()
.map(|m| m.into())
.collect();
block(move || vfs_manager.set_mount_dirs(&new_mount_dirs)).await?;
Ok(HttpResponse::new(StatusCode::OK))
}
#[get("/ddns")]
async fn get_ddns_config(
ddns_manager: Data<ddns::Manager>,
_admin_rights: AdminRights,
) -> Result<Json<dto::DDNSConfig>, APIError> {
let ddns_config = block(move || ddns_manager.config()).await?;
Ok(Json(ddns_config.into()))
}
#[put("/ddns")]
async fn put_ddns_config(
_admin_rights: AdminRights,
ddns_manager: Data<ddns::Manager>,
new_ddns_config: Json<dto::DDNSConfig>,
) -> Result<HttpResponse, APIError> {
block(move || ddns_manager.set_config(&new_ddns_config.to_owned().into())).await?;
Ok(HttpResponse::new(StatusCode::OK))
}
#[get("/users")]
async fn list_users(
user_manager: Data<user::Manager>,
_admin_rights: AdminRights,
) -> Result<Json<Vec<dto::User>>, APIError> {
let users = block(move || user_manager.list()).await?;
let users = users.into_iter().map(|u| u.into()).collect();
Ok(Json(users))
}
#[post("/user")]
async fn create_user(
user_manager: Data<user::Manager>,
_admin_rights: AdminRights,
new_user: Json<dto::NewUser>,
) -> Result<HttpResponse, APIError> {
let new_user = new_user.to_owned().into();
block(move || user_manager.create(&new_user)).await?;
Ok(HttpResponse::new(StatusCode::OK))
}
#[put("/user/{name}")]
async fn update_user(
user_manager: Data<user::Manager>,
admin_rights: AdminRights,
name: web::Path<String>,
user_update: Json<dto::UserUpdate>,
) -> Result<HttpResponse, APIError> {
// Do not let users remove their own admin rights
if let Some(auth) = &admin_rights.auth {
if let Some(users) = &config.users {
for user in users {
if auth.username == user.name && !user.admin {
return Err(APIError::OwnAdminPrivilegeRemoval);
}
if auth.username == name.as_str() {
if user_update.new_is_admin == Some(false) {
return Err(APIError::OwnAdminPrivilegeRemoval);
}
}
}
block(move || config_manager.amend(&config)).await?;
block(move || -> Result<(), APIError> {
if let Some(password) = &user_update.new_password {
user_manager.set_password(&name, password)?;
}
if let Some(is_admin) = &user_update.new_is_admin {
user_manager.set_is_admin(&name, *is_admin)?;
}
Ok(())
})
.await?;
Ok(HttpResponse::new(StatusCode::OK))
}
#[delete("/user/{name}")]
async fn delete_user(
user_manager: Data<user::Manager>,
admin_rights: AdminRights,
name: web::Path<String>,
) -> Result<HttpResponse, APIError> {
if let Some(auth) = &admin_rights.auth {
if auth.username == name.as_str() {
return Err(APIError::DeletingOwnAccount);
}
}
block(move || user_manager.delete(&name)).await?;
Ok(HttpResponse::new(StatusCode::OK))
}
@ -435,7 +552,7 @@ async fn login(
) -> Result<HttpResponse, APIError> {
let username = credentials.username.clone();
let is_admin = block(move || {
if !user_manager.auth(&credentials.username, &credentials.password)? {
if !user_manager.login(&credentials.username, &credentials.password)? {
return Err(APIError::IncorrectCredentials);
}
user_manager

4
src/service/actix/mod.rs
View file

@ -16,11 +16,13 @@ pub mod test;
pub fn make_config(context: service::Context) -> impl FnOnce(&mut ServiceConfig) + Clone {
move |cfg: &mut ServiceConfig| {
let encryption_key = cookie::Key::derive_from(&context.auth_secret[..]);
let encryption_key = cookie::Key::derive_from(&context.auth_secret.key[..]);
cfg.app_data(web::Data::new(context.index))
.app_data(web::Data::new(context.config_manager))
.app_data(web::Data::new(context.ddns_manager))
.app_data(web::Data::new(context.lastfm_manager))
.app_data(web::Data::new(context.playlist_manager))
.app_data(web::Data::new(context.settings_manager))
.app_data(web::Data::new(context.thumbnail_manager))
.app_data(web::Data::new(context.user_manager))
.app_data(web::Data::new(context.vfs_manager))

3
src/service/actix/test.rs
View file

@ -50,7 +50,8 @@ impl ActixTestService {
Method::PUT => self.server.put(url),
Method::DELETE => self.server.delete(url),
_ => unimplemented!(),
};
}
.timeout(std::time::Duration::from_secs(30));
for (name, value) in request.headers() {
actix_request = actix_request.set_header(name, value.clone());

146
src/service/dto.rs
View file

@ -1,6 +1,8 @@
use serde::{Deserialize, Serialize};
pub const API_MAJOR_VERSION: i32 = 5;
use crate::app::{config, ddns, settings, user, vfs};
pub const API_MAJOR_VERSION: i32 = 6;
pub const API_MINOR_VERSION: i32 = 0;
pub const COOKIE_SESSION: &str = "session";
pub const COOKIE_USERNAME: &str = "username";
@ -44,4 +46,144 @@ pub struct LastFMLink {
pub content: String,
}
// TODO: Config, Preferences, CollectionFile, Song and Directory should have dto types
#[derive(Serialize, Deserialize)]
pub struct User {
pub name: String,
pub is_admin: bool,
}
impl From<user::User> for User {
fn from(u: user::User) -> Self {
Self {
name: u.name,
is_admin: u.admin != 0,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NewUser {
pub name: String,
pub password: String,
pub admin: bool,
}
impl From<NewUser> for user::NewUser {
fn from(u: NewUser) -> Self {
Self {
name: u.name,
password: u.password,
admin: u.admin,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct UserUpdate {
pub new_password: Option<String>,
pub new_is_admin: Option<bool>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DDNSConfig {
pub host: String,
pub username: String,
pub password: String,
}
impl From<DDNSConfig> for ddns::Config {
fn from(c: DDNSConfig) -> Self {
Self {
host: c.host,
username: c.username,
password: c.password,
}
}
}
impl From<ddns::Config> for DDNSConfig {
fn from(c: ddns::Config) -> Self {
Self {
host: c.host,
username: c.username,
password: c.password,
}
}
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MountDir {
pub source: String,
pub name: String,
}
impl From<MountDir> for vfs::MountDir {
fn from(m: MountDir) -> Self {
Self {
name: m.name,
source: m.source,
}
}
}
impl From<vfs::MountDir> for MountDir {
fn from(m: vfs::MountDir) -> Self {
Self {
name: m.name,
source: m.source,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct Config {
pub settings: Option<NewSettings>,
pub users: Option<Vec<NewUser>>,
pub mount_dirs: Option<Vec<MountDir>>,
pub ydns: Option<DDNSConfig>,
}
impl From<Config> for config::Config {
fn from(s: Config) -> Self {
Self {
settings: s.settings.map(|s| s.into()),
mount_dirs: s
.mount_dirs
.map(|v| v.into_iter().map(|m| m.into()).collect()),
users: s.users.map(|v| v.into_iter().map(|u| u.into()).collect()),
ydns: s.ydns.map(|c| c.into()),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct NewSettings {
pub album_art_pattern: Option<String>,
pub reindex_every_n_seconds: Option<i32>,
}
impl From<NewSettings> for settings::NewSettings {
fn from(s: NewSettings) -> Self {
Self {
album_art_pattern: s.album_art_pattern,
reindex_every_n_seconds: s.reindex_every_n_seconds,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct Settings {
pub album_art_pattern: String,
pub reindex_every_n_seconds: i32,
}
impl From<settings::Settings> for Settings {
fn from(s: settings::Settings) -> Self {
Self {
album_art_pattern: s.album_art_pattern,
reindex_every_n_seconds: s.reindex_every_n_seconds,
}
}
}
// TODO: Preferences, CollectionFile, Song and Directory should have dto types

42
src/service/error.rs
View file

@ -1,13 +1,19 @@
use thiserror::Error;
use crate::app::index::QueryError;
use crate::app::playlist;
use crate::app::{config, playlist, settings, user};
#[derive(Error, Debug)]
pub enum APIError {
#[error("Incorrect Credentials")]
IncorrectCredentials,
#[error("Cannot remove own admin privilege")]
#[error("EmptyUsername")]
EmptyUsername,
#[error("EmptyPassword")]
EmptyPassword,
#[error("Cannot delete your own account")]
DeletingOwnAccount,
#[error("Cannot remove your own admin privilege")]
OwnAdminPrivilegeRemoval,
#[error("Audio file could not be opened")]
AudioFileIOError,
@ -35,6 +41,14 @@ impl From<anyhow::Error> for APIError {
}
}
impl From<config::Error> for APIError {
fn from(error: config::Error) -> APIError {
match error {
config::Error::Unspecified => APIError::Unspecified,
}
}
}
impl From<playlist::Error> for APIError {
fn from(error: playlist::Error) -> APIError {
match error {
@ -53,3 +67,27 @@ impl From<QueryError> for APIError {
}
}
}
impl From<settings::Error> for APIError {
fn from(error: settings::Error) -> APIError {
match error {
settings::Error::AuthSecretNotFound => APIError::Unspecified,
settings::Error::InvalidAuthSecret => APIError::Unspecified,
settings::Error::IndexSleepDurationNotFound => APIError::Unspecified,
settings::Error::IndexAlbumArtPatternNotFound => APIError::Unspecified,
settings::Error::IndexAlbumArtPatternInvalid => APIError::Unspecified,
settings::Error::Unspecified => APIError::Unspecified,
}
}
}
impl From<user::Error> for APIError {
fn from(error: user::Error) -> APIError {
match error {
user::Error::EmptyUsername => APIError::EmptyUsername,
user::Error::EmptyPassword => APIError::EmptyPassword,
user::Error::IncorrectUsername => APIError::IncorrectCredentials,
user::Error::Unspecified => APIError::Unspecified,
}
}
}

24
src/service/mod.rs
View file

@ -1,7 +1,7 @@
use std::fs;
use std::path::PathBuf;
use crate::app::{config, index::Index, lastfm, playlist, thumbnail, user, vfs};
use crate::app::{config, ddns, index::Index, lastfm, playlist, settings, thumbnail, user, vfs};
use crate::db::DB;
mod dto;
@ -16,7 +16,7 @@ pub use actix::*;
#[derive(Clone)]
pub struct Context {
pub port: u16,
pub auth_secret: Vec<u8>,
pub auth_secret: settings::AuthSecret,
pub web_dir_path: PathBuf,
pub swagger_dir_path: PathBuf,
pub web_url: String,
@ -25,8 +25,10 @@ pub struct Context {
pub db: DB,
pub index: Index,
pub config_manager: config::Manager,
pub ddns_manager: ddns::Manager,
pub lastfm_manager: lastfm::Manager,
pub playlist_manager: playlist::Manager,
pub settings_manager: settings::Manager,
pub thumbnail_manager: thumbnail::Manager,
pub user_manager: user::Manager,
pub vfs_manager: vfs::Manager,
@ -81,18 +83,26 @@ impl ContextBuilder {
thumbnails_dir_path.push("thumbnails");
let vfs_manager = vfs::Manager::new(db.clone());
let settings_manager = settings::Manager::new(db.clone());
let ddns_manager = ddns::Manager::new(db.clone());
let user_manager = user::Manager::new(db.clone());
let config_manager = config::Manager::new(db.clone(), user_manager.clone());
let index = Index::new(db.clone(), vfs_manager.clone(), config_manager.clone());
let index = Index::new(db.clone(), vfs_manager.clone(), settings_manager.clone());
let config_manager = config::Manager::new(
settings_manager.clone(),
user_manager.clone(),
vfs_manager.clone(),
ddns_manager.clone(),
);
let playlist_manager = playlist::Manager::new(db.clone(), vfs_manager.clone());
let thumbnail_manager = thumbnail::Manager::new(thumbnails_dir_path);
let lastfm_manager = lastfm::Manager::new(index.clone(), user_manager.clone());
if let Some(config_path) = self.config_file_path {
let config = config::Config::from_path(&config_path)?;
config_manager.amend(&config)?;
config_manager.apply(&config)?;
}
let auth_secret = config_manager.get_auth_secret()?;
let auth_secret = settings_manager.get_auth_secret()?;
Ok(Context {
port: self.port.unwrap_or(5050),
@ -104,8 +114,10 @@ impl ContextBuilder {
swagger_dir_path,
index,
config_manager,
ddns_manager,
lastfm_manager,
playlist_manager,
settings_manager,
thumbnail_manager,
user_manager,
vfs_manager,

38
src/service/test/auth.rs
View file

@ -1,32 +1,42 @@
use cookie::Cookie;
use headers::{self, HeaderMapExt};
use http::{Response, StatusCode};
use time::Duration;
use crate::service::dto;
use crate::service::test::{constants::*, protocol, ServiceType, TestService};
use crate::test_name;
fn validate_cookies<T>(response: &Response<T>) {
fn validate_added_cookies<T>(response: &Response<T>) {
let twenty_years = Duration::days(365 * 20);
let cookies: Vec<Cookie> = response
.headers()
.get_all(http::header::SET_COOKIE)
.iter()
.map(|c| Cookie::parse(c.to_str().unwrap()).unwrap())
.collect();
let session = cookies
.iter()
.find_map(|c| {
if c.name() == dto::COOKIE_SESSION {
Some(c.value())
} else {
None
}
})
.find(|c| c.name() == dto::COOKIE_SESSION)
.unwrap();
assert_ne!(session, TEST_USERNAME);
assert_ne!(session, TEST_USERNAME_ADMIN);
assert!(cookies.iter().any(|c| c.name() == dto::COOKIE_USERNAME));
assert!(cookies.iter().any(|c| c.name() == dto::COOKIE_ADMIN));
assert_ne!(session.value(), TEST_USERNAME);
assert!(session.max_age().unwrap() >= twenty_years);
let username = cookies
.iter()
.find(|c| c.name() == dto::COOKIE_USERNAME)
.unwrap();
assert_eq!(username.value(), TEST_USERNAME);
assert!(session.max_age().unwrap() >= twenty_years);
let is_admin = cookies
.iter()
.find(|c| c.name() == dto::COOKIE_ADMIN)
.unwrap();
assert_eq!(is_admin.value(), false.to_string());
assert!(session.max_age().unwrap() >= twenty_years);
}
fn validate_no_cookies<T>(response: &Response<T>) {
@ -70,7 +80,7 @@ fn test_login_golden_path() {
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
validate_cookies(&response);
validate_added_cookies(&response);
}
#[test]
@ -124,5 +134,5 @@ fn test_authentication_via_http_header_golden_path() {
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
validate_cookies(&response);
validate_added_cookies(&response);
}

63
src/service/test/ddns.rs Normal file
View file

@ -0,0 +1,63 @@
use http::StatusCode;
use crate::service::dto;
use crate::service::test::{protocol, ServiceType, TestService};
use crate::test_name;
#[test]
fn test_get_ddns_config_requires_admin() {
let mut service = ServiceType::new(&test_name!());
let request = protocol::get_ddns_config();
service.complete_initial_setup();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
service.login();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn test_get_ddns_config_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login_admin();
let request = protocol::get_ddns_config();
let response = service.fetch_json::<_, dto::DDNSConfig>(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn test_put_ddns_config_requires_admin() {
let mut service = ServiceType::new(&test_name!());
let request = protocol::put_ddns_config(dto::DDNSConfig {
host: "test".to_owned(),
username: "test".to_owned(),
password: "test".to_owned(),
});
service.complete_initial_setup();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
service.login();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn test_put_ddns_config_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login_admin();
let request = protocol::put_ddns_config(dto::DDNSConfig {
host: "test".to_owned(),
username: "test".to_owned(),
password: "test".to_owned(),
});
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}

20
src/service/test/mod.rs
View file

@ -10,15 +10,17 @@ pub mod protocol;
mod admin;
mod auth;
mod collection;
mod ddns;
mod lastfm;
mod media;
mod playlist;
mod preferences;
mod settings;
mod swagger;
mod user;
mod web;
use crate::app::{config, index, vfs};
use crate::app::index;
use crate::service::dto;
use crate::service::test::constants::*;
pub use crate::service::actix::test::ServiceType;
@ -36,28 +38,26 @@ pub trait TestService {
) -> Response<U>;
fn complete_initial_setup(&mut self) {
let configuration = config::Config {
album_art_pattern: None,
reindex_every_n_seconds: None,
ydns: None,
let configuration = dto::Config {
users: Some(vec![
config::ConfigUser {
dto::NewUser {
name: TEST_USERNAME_ADMIN.into(),
password: TEST_PASSWORD_ADMIN.into(),
admin: true,
},
config::ConfigUser {
dto::NewUser {
name: TEST_USERNAME.into(),
password: TEST_PASSWORD.into(),
admin: false,
},
]),
mount_dirs: Some(vec![vfs::MountPoint {
mount_dirs: Some(vec![dto::MountDir {
name: TEST_MOUNT_NAME.into(),
source: TEST_MOUNT_SOURCE.into(),
}]),
..Default::default()
};
let request = protocol::put_settings(configuration);
let request = protocol::apply_config(configuration);
let response = self.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}

43
src/service/test/preferences.rs
View file

@ -1,43 +0,0 @@
use http::StatusCode;
use crate::app::user;
use crate::service::test::{protocol, ServiceType, TestService};
use crate::test_name;
#[test]
fn test_get_preferences_requires_auth() {
let mut service = ServiceType::new(&test_name!());
let request = protocol::get_preferences();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn test_get_preferences_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login();
let request = protocol::get_preferences();
let response = service.fetch_json::<_, user::Preferences>(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn test_put_preferences_requires_auth() {
let mut service = ServiceType::new(&test_name!());
let request = protocol::put_preferences(user::Preferences::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn test_put_preferences_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login();
let request = protocol::put_preferences(user::Preferences::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}

62
src/service/test/protocol.rs
View file

@ -2,7 +2,7 @@ use http::{method::Method, Request};
use percent_encoding::{percent_encode, NON_ALPHANUMERIC};
use std::path::Path;
use crate::app::{config, user};
use crate::app::user;
use crate::service::dto;
pub fn web_index() -> Request<()> {
@ -49,6 +49,14 @@ pub fn login(username: &str, password: &str) -> Request<dto::AuthCredentials> {
.unwrap()
}
pub fn apply_config(config: dto::Config) -> Request<dto::Config> {
Request::builder()
.method(Method::PUT)
.uri("/api/config")
.body(config)
.unwrap()
}
pub fn get_settings() -> Request<()> {
Request::builder()
.method(Method::GET)
@ -57,11 +65,59 @@ pub fn get_settings() -> Request<()> {
.unwrap()
}
pub fn put_settings(configuration: config::Config) -> Request<config::Config> {
pub fn put_settings(settings: dto::NewSettings) -> Request<dto::NewSettings> {
Request::builder()
.method(Method::PUT)
.uri("/api/settings")
.body(configuration)
.body(settings)
.unwrap()
}
pub fn get_ddns_config() -> Request<()> {
Request::builder()
.method(Method::GET)
.uri("/api/ddns")
.body(())
.unwrap()
}
pub fn put_ddns_config(ddns_config: dto::DDNSConfig) -> Request<dto::DDNSConfig> {
Request::builder()
.method(Method::PUT)
.uri("/api/ddns")
.body(ddns_config)
.unwrap()
}
pub fn list_users() -> Request<()> {
Request::builder()
.method(Method::GET)
.uri("/api/users")
.body(())
.unwrap()
}
pub fn create_user(new_user: dto::NewUser) -> Request<dto::NewUser> {
Request::builder()
.method(Method::POST)
.uri("/api/user")
.body(new_user)
.unwrap()
}
pub fn update_user(username: &str, user_update: dto::UserUpdate) -> Request<dto::UserUpdate> {
Request::builder()
.method(Method::PUT)
.uri(format!("/api/user/{}", username))
.body(user_update)
.unwrap()
}
pub fn delete_user(username: &str) -> Request<()> {
Request::builder()
.method(Method::DELETE)
.uri(format!("/api/user/{}", username))
.body(())
.unwrap()
}

29
src/service/test/settings.rs
View file

@ -1,7 +1,7 @@
use http::StatusCode;
use crate::app::config;
use crate::service::test::{constants::*, protocol, ServiceType, TestService};
use crate::service::dto;
use crate::service::test::{protocol, ServiceType, TestService};
use crate::test_name;
#[test]
@ -32,7 +32,7 @@ fn test_get_settings_golden_path() {
service.login_admin();
let request = protocol::get_settings();
let response = service.fetch_json::<_, config::Config>(&request);
let response = service.fetch_json::<_, dto::Settings>(&request);
assert_eq!(response.status(), StatusCode::OK);
}
@ -40,7 +40,7 @@ fn test_get_settings_golden_path() {
fn test_put_settings_requires_auth() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::put_settings(config::Config::default());
let request = protocol::put_settings(dto::NewSettings::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
@ -50,7 +50,7 @@ fn test_put_settings_requires_admin() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login();
let request = protocol::put_settings(config::Config::default());
let request = protocol::put_settings(dto::NewSettings::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
@ -61,24 +61,7 @@ fn test_put_settings_golden_path() {
service.complete_initial_setup();
service.login_admin();
let request = protocol::put_settings(config::Config::default());
let request = protocol::put_settings(dto::NewSettings::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn test_put_settings_cannot_unadmin_self() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login_admin();
let mut configuration = config::Config::default();
configuration.users = Some(vec![config::ConfigUser {
name: TEST_USERNAME_ADMIN.into(),
password: "".into(),
admin: false,
}]);
let request = protocol::put_settings(configuration);
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::CONFLICT);
}

180
src/service/test/user.rs Normal file
View file

@ -0,0 +1,180 @@
use http::StatusCode;
use std::default::Default;
use crate::app::user;
use crate::service::dto;
use crate::service::test::{constants::*, protocol, ServiceType, TestService};
use crate::test_name;
#[test]
fn list_users_requires_admin() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::list_users();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
service.login();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn list_users_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login_admin();
let request = protocol::list_users();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn create_user_requires_admin() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::create_user(dto::NewUser {
name: "Walter".into(),
password: "secret".into(),
admin: false,
});
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
service.login();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn create_user_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login_admin();
let new_user = dto::NewUser {
name: "Walter".into(),
password: "secret".into(),
admin: false,
};
let request = protocol::create_user(new_user);
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn update_user_requires_admin() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::update_user("Walter", dto::UserUpdate::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
service.login();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn update_user_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::update_user("Walter", dto::UserUpdate::default());
service.login_admin();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn update_user_cannot_unadmin_self() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::update_user(
TEST_USERNAME_ADMIN,
dto::UserUpdate {
new_is_admin: Some(false),
..Default::default()
},
);
service.login_admin();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::CONFLICT);
}
#[test]
fn delete_user_requires_admin() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::delete_user("Walter");
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
service.login();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn delete_user_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::delete_user("Walter");
service.login_admin();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn delete_user_cannot_delete_self() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
let request = protocol::delete_user(TEST_USERNAME_ADMIN);
service.login_admin();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::CONFLICT);
}
#[test]
fn get_preferences_requires_auth() {
let mut service = ServiceType::new(&test_name!());
let request = protocol::get_preferences();
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn get_preferences_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login();
let request = protocol::get_preferences();
let response = service.fetch_json::<_, user::Preferences>(&request);
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn put_preferences_requires_auth() {
let mut service = ServiceType::new(&test_name!());
let request = protocol::put_preferences(user::Preferences::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn put_preferences_golden_path() {
let mut service = ServiceType::new(&test_name!());
service.complete_initial_setup();
service.login();
let request = protocol::put_preferences(user::Preferences::default());
let response = service.fetch(&request);
assert_eq!(response.status(), StatusCode::OK);
}

1
test-data/config.toml
View file

@ -1,3 +1,4 @@
[settings]
album_art_pattern = '^Folder\.(png|jpg|jpeg)$'
[[mount_dirs]]