Initial commit

src/app.rs

@@ -0,0 +1,141 @@
+use std::{
+    path::PathBuf,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use crate::{
+    db::{self, UploadId, UploadKind},
+    notifies::Notifies,
+    post_queue,
+    schemas::novel::Novel,
+    schemas::sanity::ensure_slug,
+    subs,
+};
+
+#[derive(Debug)]
+pub struct App {
+    db: db::Db,
+
+    notifies: Arc<Notifies>,
+
+    pub subs: subs::Subs,
+    pub queue: post_queue::Queue,
+}
+
+fn measure<O>(f: impl FnOnce() -> O) -> (O, Duration) {
+    let start = Instant::now();
+    (f(), start.elapsed())
+}
+
+impl App {
+    pub fn begin_upload(&self, slug: &str, kind: UploadKind) -> eyre::Result<(UploadId, PathBuf)> {
+        ensure_slug(slug)?;
+        let entry = self.db.entry(slug);
+        Ok(entry.start_upload(slug, kind))
+    }
+
+    pub fn finish_upload(&self, slug: &str, id: UploadId, file_name: &str) -> eyre::Result<()> {
+        ensure_slug(slug)?;
+        let entry = self.db.entry(slug);
+        entry.finish_upload(id, file_name)?;
+
+        Ok(())
+    }
+}
+
+impl App {
+    pub fn novel(&self, slug: &str) -> eyre::Result<db::Entry> {
+        ensure_slug(slug)?;
+        Ok(self.db.entry(slug))
+    }
+
+    pub fn enumerate_novels(&self) -> Vec<(String, db::Entry)> {
+        self.db.enumerate()
+    }
+
+    pub fn add_novel(&mut self, slug: impl Into<String>, novel: Novel) -> eyre::Result<()> {
+        let slug = slug.into();
+        ensure_slug(&slug)?;
+        let db_entry = self.db.entry(&slug);
+        db_entry.init(&novel)?;
+
+        self.queue.add(post_queue::Item {
+            novel: slug,
+            post_at: novel.post_at,
+        });
+
+        // While storing permit seems unnecessary, but actually
+        // it prevents race condition, so keep it.
+        self.notifies.update.notify_one();
+
+        Ok(())
+    }
+}
+
+impl App {
+    pub fn mark_posted_until(&mut self, ts: jiff::Zoned) {
+        self.db.update_state(move |s| {
+            s.posted_until = Some(ts);
+        });
+    }
+
+    pub fn reload_queue(&mut self) -> eyre::Result<()> {
+        tracing::info!("loading full database...");
+        let old_entries = self.queue.len();
+
+        let (queue, dur) = measure(|| {
+            let queue: post_queue::Queue = self
+                .db
+                .enumerate()
+                .into_iter()
+                .filter_map(|(slug, e)| {
+                    let result = e.read_info();
+
+                    match result {
+                        Ok(n) => {
+                            if let Some(ref posted_until) = self.db.state().posted_until {
+                                if &n.post_at <= posted_until {
+                                    return None;
+                                }
+                            }
+
+                            Some(Ok(post_queue::Item {
+                                novel: slug,
+                                post_at: n.post_at,
+                            }))
+                        }
+
+                        Err(e) => Some(Err(e)),
+                    }
+                })
+                .collect::<eyre::Result<_>>()?;
+
+            Ok::<_, eyre::Report>(queue)
+        });
+
+        self.queue = queue?;
+        tracing::info!(
+            took = ?dur,
+            old = old_entries,
+            new = self.queue.len(),
+            "loaded database and created queue",
+        );
+        self.notifies.update.notify_one();
+
+        Ok(())
+    }
+
+    pub fn new(db: db::Db, notifies: Arc<Notifies>) -> eyre::Result<Self> {
+        let queue = post_queue::Queue::default();
+        let mut this = Self {
+            db,
+            queue,
+            subs: subs::Subs::new(Arc::clone(&notifies)),
+            notifies,
+        };
+        this.reload_queue()?;
+
+        Ok(this)
+    }
+}