Add admin button to update repo

src/main.rs

@@ -176,10 +176,10 @@ async fn run() -> somehow::Result<()> {
                 tokio::task::spawn(launch_local_workers(config, command.local_worker));
             }
 
-            let server = Server::new(&config.server, command).await?;
+            let (server, recurring_rx) = Server::new(&config.server, command).await?;
             select! {
                 _ = wait_for_signal() => {}
-                _ = server.run() => {}
+                _ = server.run(recurring_rx) => {}
             }
 
             select! {

src/server.rs

@@ -18,7 +18,7 @@ use sqlx::{
     sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions, SqliteSynchronous},
     SqlitePool,
 };
-use tokio::select;
+use tokio::{select, sync::mpsc};
 
 use crate::{args::ServerCommand, config::ServerConfig, somehow};
 
@@ -117,13 +117,14 @@ pub struct Server {
     repo: Option<Repo>,
     bench_repo: Option<BenchRepo>,
     workers: Arc<Mutex<Workers>>,
+    recurring_tx: Arc<mpsc::UnboundedSender<()>>,
 }
 
 impl Server {
     pub async fn new(
         config: &'static ServerConfig,
         command: ServerCommand,
-    ) -> somehow::Result<Self> {
+    ) -> somehow::Result<(Self, mpsc::UnboundedReceiver<()>)> {
         let repo = if let Some(path) = command.repo.as_ref() {
             let repo = open_repo(path, &config.repo_fetch_url, &config.repo_fetch_refspecs)?;
             Some(Repo(Arc::new(repo)))
@@ -138,20 +139,24 @@ impl Server {
             None
         };
 
-        Ok(Self {
+        let (recurring_tx, recurring_rx) = mpsc::unbounded_channel();
+        let server = Self {
             config,
             db: open_db(&command.db).await?,
             repo,
             bench_repo,
             workers: Arc::new(Mutex::new(Workers::new(config))),
-        })
+            recurring_tx: Arc::new(recurring_tx),
+        };
+
+        Ok((server, recurring_rx))
     }
 
-    pub async fn run(&self) -> somehow::Result<()> {
+    pub async fn run(&self, recurring_rx: mpsc::UnboundedReceiver<()>) -> somehow::Result<()> {
         if let Some(repo) = self.repo.clone() {
             select! {
                 e = web::run(self.clone()) => e,
-                () = recurring::run(self.clone(), repo) => Ok(()),
+                () = recurring::run(self.clone(), repo, recurring_rx) => Ok(()),
             }
         } else {
             web::run(self.clone()).await

src/server/recurring.rs

@@ -4,14 +4,17 @@ mod fetch;
 mod queue;
 mod repo;
 
+use tokio::sync::mpsc;
+
 use super::{Repo, Server};
 
-pub(super) async fn run(server: Server, repo: Repo) {
+pub(super) async fn run(server: Server, repo: Repo, mut recurring_rx: mpsc::UnboundedReceiver<()>) {
     loop {
         fetch::update(server.config, repo.clone()).await;
         repo::update(&server.db, repo.clone()).await;
         queue::update(&server.db).await;
 
-        tokio::time::sleep(server.config.repo_update).await;
+        let _ = tokio::time::timeout(server.config.repo_update, recurring_rx.recv()).await;
+        while let Ok(()) = recurring_rx.try_recv() {}
     }
 }

src/server/web.rs

@@ -12,9 +12,12 @@ use axum_extra::routing::RouterExt;
 use crate::somehow;
 
 use self::{
-    admin::queue::{
+    admin::{
-        post_admin_queue_add, post_admin_queue_decrease, post_admin_queue_delete,
+        queue::{
-        post_admin_queue_increase,
+            post_admin_queue_add, post_admin_queue_decrease, post_admin_queue_delete,
+            post_admin_queue_increase,
+        },
+        repo::post_admin_repo_update,
     },
     api::worker::{
         get_api_worker_bench_repo_by_hash_tree_tar_gz, get_api_worker_repo_by_hash_tree_tar_gz,
@@ -55,6 +58,7 @@ pub async fn run(server: Server) -> somehow::Result<()> {
         .typed_post(post_admin_queue_decrease)
         .typed_post(post_admin_queue_delete)
         .typed_post(post_admin_queue_increase)
+        .typed_post(post_admin_repo_update)
         .merge(post_api_worker_status)
         .fallback(get(r#static::static_handler))
         .with_state(server.clone());

src/server/web/admin.rs

@@ -1 +1,2 @@
 pub mod queue;
+pub mod repo;

src/server/web/admin/repo.rs

@@ -0,0 +1,29 @@
+use std::sync::Arc;
+
+use axum::{
+    extract::State,
+    response::{IntoResponse, Redirect},
+};
+use log::info;
+use tokio::sync::mpsc;
+
+use crate::{
+    config::ServerConfig,
+    server::web::{
+        base::Base,
+        paths::{PathAdminRepoUpdate, PathIndex},
+    },
+    somehow,
+};
+
+pub async fn post_admin_repo_update(
+    _path: PathAdminRepoUpdate,
+    State(config): State<&'static ServerConfig>,
+    State(recurring_tx): State<Arc<mpsc::UnboundedSender<()>>>,
+) -> somehow::Result<impl IntoResponse> {
+    let _ = recurring_tx.send(());
+    info!("Admin updated repo");
+
+    let link = Base::link_with_config(config, PathIndex {});
+    Ok(Redirect::to(&link.to_string()))
+}

src/server/web/pages/index.rs

@@ -6,9 +6,9 @@ use sqlx::SqlitePool;
 use crate::{
     config::ServerConfig,
     server::web::{
-        base::{Base, Tab},
+        base::{Base, Link, Tab},
         link::LinkCommit,
-        paths::PathIndex,
+        paths::{PathAdminRepoUpdate, PathIndex},
     },
     somehow,
 };
@@ -22,7 +22,9 @@ struct Ref {
 #[derive(Template)]
 #[template(path = "pages/index.html")]
 struct IndexTemplate {
+    link_admin_repo_update: Link,
     base: Base,
+
     tracked_refs: Vec<Ref>,
     untracked_refs: Vec<Ref>,
 }
@@ -62,7 +64,9 @@ pub async fn get_index(
     }
 
     Ok(IndexTemplate {
+        link_admin_repo_update: base.link(PathAdminRepoUpdate {}),
         base: Base::new(config, Tab::Index),
+
         tracked_refs,
         untracked_refs,
     })

src/server/web/paths.rs

@@ -53,6 +53,10 @@ pub struct PathWorkerByName {
 // Admin actions //
 ///////////////////
 
+#[derive(Deserialize, TypedPath)]
+#[typed_path("/admin/repo/update")]
+pub struct PathAdminRepoUpdate {}
+
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/admin/queue/add")]
 pub struct PathAdminQueueAdd {}

templates/pages/index.html

@@ -6,6 +6,10 @@
 
 <h2>Refs</h2>
 
+<form method="post" action="{{ link_admin_repo_update }}">
+    <button>Update</button>
+</form>
+
 <details open>
     <summary>Tracked ({{ tracked_refs.len() }})</summary>
     <dl>