entertainarr 0.1.1

entertainarr server
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
133
134
135
136
137
138

use anyhow::Context;
use entertainarr_adapter_rss::RssClient;
use entertainarr_adapter_sqlite::Pool;
use entertainarr_adapter_worker::Publisher;
use entertainarr_domain::auth::AuthenticationService;
use entertainarr_domain::media::MediaService;
use entertainarr_domain::podcast::PodcastService;
use entertainarr_domain::task::TaskService;
use entertainarr_domain::tvshow::TvShowService;

mod client;
pub mod tracing;

/// Entertainarr main configuration
#[derive(serde::Deserialize)]
pub struct Config {
    #[serde(default)]
    pub http_server: entertainarr_adapter_http::server::Config,
    #[serde(default)]
    pub jsonwebtoken: entertainarr_adapter_jsonwebtoken::Config,
    #[serde(default)]
    pub rss: entertainarr_adapter_rss::Config,
    #[serde(default)]
    pub scheduler: entertainarr_adapter_scheduler::Config,
    #[serde(default)]
    pub sqlite: entertainarr_adapter_sqlite::Config,
    #[serde(default)]
    pub storage: entertainarr_adapter_filesystem::Config,
    pub tmdb: entertainarr_adapter_tmdb::Config,
    #[serde(default)]
    pub worker: entertainarr_adapter_worker::Config,
}

impl Config {
    pub fn from_path<P: AsRef<std::path::Path>>(path: P) -> anyhow::Result<Self> {
        let data = std::fs::read(path.as_ref())
            .with_context(|| format!("unable to open configuration file on {:?}", path.as_ref()))?;
        toml::from_slice(data.as_ref()).context("unable to deserialize config")
    }

    pub async fn build(self) -> anyhow::Result<Application> {
        let http_server = self.http_server.builder()?;
        let jsonwebtoken = self.jsonwebtoken.build()?;
        let rss_client = self.rss.build()?;
        let scheduler = self.scheduler.build();
        let sqlite_pool = self.sqlite.build().await?;
        let storage = self.storage.build().await?;
        let tmdb = self.tmdb.build()?;
        let worker = self.worker.build();
        let publisher = worker.publisher(sqlite_pool.clone());
        let authentication_service = AuthenticationService::builder()
            .authentication_repository(sqlite_pool.clone())
            .token_repository(jsonwebtoken)
            .build();
        let media_service = MediaService::builder()
            .media_repository(sqlite_pool.clone())
            .media_store(storage)
            .task_publisher(publisher.clone())
            .build();
        let podcast_service = PodcastService::builder()
            .rss_feed_loader(rss_client)
            .podcast_repository(sqlite_pool.clone())
            .podcast_episode_repository(sqlite_pool.clone())
            .podcast_subscription_repository(sqlite_pool.clone())
            .podcast_task_repository(sqlite_pool.clone())
            .task_publisher(publisher.clone())
            .build();
        let task_service = TaskService::builder()
            .task_repository(sqlite_pool.clone())
            .build();
        let tvshow_service = TvShowService::builder()
            .task_publisher(publisher.clone())
            .tvshow_provider(tmdb)
            .tvshow_repository(sqlite_pool.clone())
            .tvshow_episode_repository(sqlite_pool.clone())
            .tvshow_episode_file_repository(sqlite_pool.clone())
            .tvshow_season_repository(sqlite_pool.clone())
            .tvshow_subscription_repository(sqlite_pool.clone())
            .build();

        let http_server = http_server
            .with_authentication_service(authentication_service)
            .with_client_service(crate::client::ClientService)
            .with_media_service(media_service.clone())
            .with_podcast_service(podcast_service.clone())
            .with_tvshow_service(tvshow_service.clone())
            .build()?;
        let scheduler = scheduler
            .with_media_service(media_service.clone())
            .with_podcast_service(podcast_service.clone())
            .with_tvshow_service(tvshow_service.clone());
        let worker = worker
            .with_media_service(media_service)
            .with_podcast_service(podcast_service)
            .with_task_service(task_service)
            .with_tvshow_service(tvshow_service);

        Ok(Application {
            http_server,
            scheduler,
            worker,
        })
    }
}

/// Entertainarr application
pub struct Application {
    http_server: entertainarr_adapter_http::server::HttpServer,
    #[allow(clippy::type_complexity)]
    scheduler: entertainarr_adapter_scheduler::Runner<
        MediaService<Pool, entertainarr_adapter_filesystem::Client, Publisher>,
        PodcastService<RssClient, Pool, Pool, Pool, Pool, Publisher>,
        TvShowService<entertainarr_adapter_tmdb::Client, Pool, Pool, Pool, Pool, Pool, Publisher>,
    >,
    #[allow(clippy::type_complexity)]
    worker: entertainarr_adapter_worker::Runner<
        MediaService<Pool, entertainarr_adapter_filesystem::Client, Publisher>,
        PodcastService<RssClient, Pool, Pool, Pool, Pool, Publisher>,
        TaskService<Pool>,
        TvShowService<entertainarr_adapter_tmdb::Client, Pool, Pool, Pool, Pool, Pool, Publisher>,
    >,
}

impl Application {
    pub async fn run(self) -> anyhow::Result<()> {
        let scheduler = self.scheduler.start();
        let worker = self.worker.start();
        let server_res = self.http_server.run().await;
        let scheduler_res = scheduler.shutdown().await;
        let worker_res = worker.shutdown().await;
        match (server_res, scheduler_res, worker_res) {
            (Ok(_), Ok(_), Ok(_)) => Ok(()),
            other => Err(anyhow::anyhow!(
                "server, scheduler or worker failed {other:?}"
            )),
        }
    }
}