From 012bf0593df7bf93afb73db5c87dd8ccc36e851f Mon Sep 17 00:00:00 2001
From: Max Audron <audron@cocaine.farm>
Date: Tue, 7 Jun 2022 12:28:18 +0200
Subject: move to mostly sync architecture

the git repository struct is not sharable between threads, thus go
single threaded for now and only call onto the tokio runtime for lookups
towards gitlab.
---
 src/main.rs | 61 ++++++++++++++++++++++++++++++++-----------------------------
 1 file changed, 32 insertions(+), 29 deletions(-)

(limited to 'src/main.rs')

diff --git a/src/main.rs b/src/main.rs
index eeec4a3..bad9436 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,9 @@
+use std::{thread, sync::Arc};
+
 use anyhow::{Context, Result};
 use clap::Parser;
-use derivative::Derivative;
 
+use tokio::runtime::Runtime;
 use tracing::{debug, metadata::LevelFilter, Level};
 use tracing_subscriber::{fmt::format::FmtSpan, prelude::*, EnvFilter};
 
@@ -19,18 +21,18 @@ mod update;
 #[cfg(test)]
 mod tests;
 
-#[derive(Derivative)]
-#[derivative(Debug)]
+#[derive(Debug)]
 struct GTree {
     figment: figment::Figment,
     config: config::Config,
     args: config::args::Args,
     forge: forge::Forge,
+    rt: Runtime,
 }
 
 impl GTree {
     #[tracing::instrument(level = "trace")]
-    pub async fn new() -> Result<GTree> {
+    pub fn new() -> Result<GTree> {
         let args = config::args::Args::parse();
 
         let figment = config::Config::figment()?;
@@ -41,72 +43,73 @@ impl GTree {
             .next()
             .context("No Forge configured, please setup a forge")?;
 
-        let forge = forge::Forge::new(forge_config).await?;
+        let rt = Runtime::new()?;
+
+
+        let forge = rt.block_on(forge::Forge::new(forge_config))?;
 
         Ok(GTree {
             figment,
             config,
             args,
             forge,
+            rt
         })
     }
 
     #[tracing::instrument(level = "trace")]
-    pub async fn run(self) -> Result<()> {
-        let scope = self.args.scope.as_ref().map_or("", |x| x);
+    pub fn run(self) -> Result<()> {
+        let scope = Arc::new(self.args.scope.as_ref().map_or("", |x| x).to_string());
 
         // TODO select a specific forge
-        let (_name, forge) = self
+        let forge = Arc::new(self
             .config
             .iter()
             .next()
-            .context("No Forge configured, please setup a forge")?;
+            .context("No Forge configured, please setup a forge")?.1.clone());
+
+        let scope_t = scope.clone();
+        let forge_t = forge.clone();
+        let handle = thread::spawn(move || {
+            Repos::from_local(&forge_t.root(), &scope_t)
+        });
 
-        let (local, remote) = tokio::join!(
-            Repos::from_local(forge.root(), scope),
-            Repos::from_forge(forge.root(), self.forge.projects(scope).await?)
-        );
+        let projects = self.rt.block_on(self.forge.projects(&scope))?;
+        let remote = Repos::from_forge(forge.root(), projects);
 
-        let repos = Repos::aggregate(local, remote).await;
+        let local = handle.join().unwrap();
+        let repos = Repos::aggregate(local, remote);
 
         match self.args.command {
-            config::args::Commands::Sync => self.sync(repos).await,
-            config::args::Commands::Update => self.update(repos).await,
-            config::args::Commands::List => self.list(repos).await?,
+            config::args::Commands::Sync => self.sync(repos),
+            config::args::Commands::Update => self.update(repos),
+            config::args::Commands::List => self.list(repos)?,
         };
 
         Ok(())
     }
 }
 
-#[tokio::main]
-async fn main() -> Result<()> {
-    use tracing_flame::FlameLayer;
-
+fn main() -> Result<()> {
     let filter = tracing_subscriber::filter::Targets::new()
         .with_default(Level::TRACE)
         .with_target("hyper", LevelFilter::OFF)
+        .with_target("hyper", LevelFilter::OFF)
         .with_target("reqwest", LevelFilter::OFF);
 
     let env_filter = EnvFilter::from_default_env();
 
-    let (flame_layer, _guard) = FlameLayer::with_file("./tracing.folded").unwrap();
-    let flameguard = flame_layer.flush_on_drop();
-
     tracing_subscriber::registry()
         .with(tracing_subscriber::fmt::layer().with_span_events(FmtSpan::ACTIVE))
         .with(filter)
         .with(env_filter)
-        .with(flame_layer)
         .init();
 
     debug!("starting");
 
-    let gtree = GTree::new().await?;
-
-    gtree.run().await?;
+    let gtree = GTree::new()?;
 
-    flameguard.flush()?;
+    gtree.run()?;
 
     Ok(())
 }
-- 
cgit v1.2.3