fix(core): store the repository globally

coffee_core/src/coffee.rs

@@ -27,14 +27,14 @@
 use crate::config::CoffeeConf;
 use crate::CoffeeArgs;
 
-pub type PluginName = String;
+pub type RepoName = String;
 
 #[derive(Serialize, Deserialize)]
 /// FIXME: move the list of plugin
 /// and the list of repository inside this struct.
 pub struct CoffeeStorageInfo {
  pub config: config::CoffeeConf,
- pub repositories: HashMap<PluginName, RepositoryInfo>,
+ pub repositories: HashMap<RepoName, RepositoryInfo>,
 }
 
 impl From<&CoffeeManager> for CoffeeStorageInfo {
@@ -67,7 +67,7 @@
  cln_config: Option<CLNConf>,
  /// storage instance to make all the plugin manager
  /// information persistent on disk
- storage: Box<dyn StorageManager<CoffeeStorageInfo, Err = CoffeeError> + Send + Sync>,
+ storage: NoSQlStorage,
  /// core lightning rpc connection
  rpc: Option<Client>,
 }
@@ -79,7 +79,7 @@
  config: conf.clone(),
  coffee_cln_config: CLNConf::new(conf.config_path, true),
  repos: HashMap::new(),
- storage: Box::new(NoSQlStorage::new(&conf.root_path).await?),
+ storage: NoSQlStorage::new(&conf.root_path).await?,
  cln_config: None,
  rpc: None,
  };
@@ -90,22 +90,28 @@
  /// when coffee is configured, run an inventory to collect all the necessary information
  /// about the coffee ecosystem.
  async fn inventory(&mut self) -> Result<(), CoffeeError> {
- let Ok(store) = self.storage.load(&self.config.network).await else {
- log::debug!("storage do not exist");
- return Ok(());
- };
- // this is really needed? I think no, because coffee at this point
- // have a new conf loading
- self.config = store.config;
- store
- .repositories
- .iter()
- .for_each(|repo| match repo.1.kind {
- Kind::Git => {
- let repo = Github::from(repo.1);
- self.repos.insert(repo.name(), Box::new(repo));
- }
+ self.storage
+ .load::<CoffeeStorageInfo>(&self.config.network)
+ .await
+ .and_then(|store| {
+ self.config = store.config;
+ Ok(())
+ });
+ // FIXME: check if this exist in a better wai
+ self.storage
+ .load::<HashMap<RepoName, RepositoryInfo>>("repositories")
+ .await
+ .and_then(|item| {
+ log::debug!("repositories in store {:?}", item);
+ item.iter().for_each(|repo| match repo.1.kind {
+ Kind::Git => {
+ let repo = Github::from(repo.1);
+ self.repos.insert(repo.name(), Box::new(repo));
+ }
+ });
+ Ok(())
  });
+
  if let Err(err) = self.coffee_cln_config.parse() {
  log::error!("{}", err.cause);
  }
@@ -149,8 +155,12 @@
  }
 
  pub async fn flush(&self) -> Result<(), CoffeeError> {
+ let store_info = self.storage_info();
+ self.storage
+ .store(&self.config.network, &store_info)
+ .await?;
  self.storage
- .store(&self.config.network, &self.storage_info())
+ .store("repositories", &store_info.repositories)
  .await?;
  Ok(())
  }

coffee_github/src/repository.rs

@@ -164,7 +164,9 @@ impl Github {
  }
 
  let Some(exec_path) = exec_path else {
- return Err(error!("exec path not known, but we should know at this point."));
+ return Err(error!(
+ "exec path not known, but we should know at this point."
+ ));
  };
 
  debug!("exec path is {exec_path}");

coffee_lib/src/url.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 /// This struct will make sure our URLs are of the
 /// correct format and will also check correctness
 /// of associated fields
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct URL {
  /// the url name in case of remote
  pub name: String,

coffee_storage/src/file.rs

@@ -34,10 +34,10 @@ impl FileStorage {
 }
 
 #[async_trait]
-impl<T> StorageManager<T> for FileStorage {
+impl StorageManager for FileStorage {
  type Err = CoffeeError;
 
- async fn load<'c>(&self, _: &str) -> Result<T, Self::Err>
+ async fn load<T>(&self, _: &str) -> Result<T, Self::Err>
  where
  T: DeserializeOwned + Send + Sync,
  {
@@ -50,7 +50,7 @@ impl<T> StorageManager<T> for FileStorage {
  Ok(val)
  }
 
- async fn store(&self, _: &str, to_store: &T) -> Result<(), Self::Err>
+ async fn store<T>(&self, _: &str, to_store: &T) -> Result<(), Self::Err>
  where
  T: Serialize + Send + Sync,
  {

coffee_storage/src/model/repository.rs

@@ -3,12 +3,12 @@
 use coffee_lib::{plugin::Plugin, url::URL};
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub enum Kind {
  Git,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Repository {
  pub kind: Kind,
  pub name: String,

coffee_storage/src/nosql_db.rs

@@ -23,10 +23,10 @@ impl NoSQlStorage {
 }
 
 #[async_trait]
-impl<T> StorageManager<T> for NoSQlStorage {
+impl StorageManager for NoSQlStorage {
  type Err = CoffeeError;
 
- async fn load<'c>(&self, key: &str) -> Result<T, Self::Err>
+ async fn load<T>(&self, key: &str) -> Result<T, Self::Err>
  where
  T: serde::de::DeserializeOwned + Send + Sync,
  {
@@ -40,7 +40,7 @@ impl<T> StorageManager<T> for NoSQlStorage {
  Ok(value)
  }
 
- async fn store(&self, key: &str, to_store: &T) -> Result<(), Self::Err>
+ async fn store<T>(&self, key: &str, to_store: &T) -> Result<(), Self::Err>
  where
  T: serde::Serialize + Send + Sync,
  {

coffee_storage/src/storage.rs

@@ -6,18 +6,18 @@ use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Serialize};
 
 #[async_trait]
-pub trait StorageManager<T> {
+pub trait StorageManager {
  type Err;
 
  /// async call to persist the information
  /// on disk.
- async fn store(&self, key: &str, to_store: &T) -> Result<(), Self::Err>
+ async fn store<T>(&self, key: &str, to_store: &T) -> Result<(), Self::Err>
  where
  T: Serialize + Send + Sync;
 
  /// async call to load the data that was made persistent
  /// from the previous `store` call.
- async fn load<'c>(&self, key: &str) -> Result<T, Self::Err>
+ async fn load<T>(&self, key: &str) -> Result<T, Self::Err>
  where
  T: DeserializeOwned + Send + Sync;
 }

coffee_testing/src/btc.rs

@@ -50,13 +50,14 @@ impl Drop for BtcNode {
  fn drop(&mut self) {
  for process in self.process.iter() {
  let Some(child) = process.id() else {
- continue;
+  continue;
  };
  let Ok(mut kill) = std::process::Command::new("kill")
  .args(["-s", "SIGKILL", &child.to_string()])
- .spawn() else {
- continue;
- };
+ .spawn()
+ else {
+ continue;
+ };
  let _ = kill.wait();
  }
 

coffee_testing/src/cln.rs

@@ -56,13 +56,14 @@ impl Drop for Node {
  fn drop(&mut self) {
  for process in self.process.iter() {
  let Some(child) = process.id() else {
- continue;
+  continue;
  };
  let Ok(mut kill) = std::process::Command::new("kill")
  .args(["-s", "SIGKILL", &child.to_string()])
- .spawn() else {
- continue;
- };
+ .spawn()
+ else {
+ continue;
+ };
  let _ = kill.wait();
  }
 

coffee_testing/src/lib.rs

@@ -160,13 +160,14 @@ pub struct CoffeeHTTPDTesting {
 impl Drop for CoffeeHTTPDTesting {
  fn drop(&mut self) {
  let Some(child) = self.httpd_pid.id() else {
-  return;
-  };
+ return;
+ };
  let Ok(mut kill) = std::process::Command::new("kill")
- .args(["-s", "SIGKILL", &child.to_string()])
- .spawn() else {
- return;
- };
+ .args(["-s", "SIGKILL", &child.to_string()])
+ .spawn()
+ else {
+ return;
+ };
  let _ = kill.wait();
  }
 }

tests/src/coffee_integration_tests.rs

@@ -307,11 +307,8 @@ pub async fn install_plugin_in_two_networks() -> anyhow::Result<()> {
  };
  let mut manager = CoffeeTesting::tmp_with_args(&args, dir.clone()).await?;
  let root_path = manager.root_path().to_owned();
- manager
- .coffee()
- .setup(&lightning_regtest_dir)
- .await
- .unwrap();
+ let result = manager.coffee().setup(&lightning_regtest_dir).await;
+ assert!(result.is_ok(), "{:?}", result);
  // Add lightningd remote repository
  manager
  .coffee()
@@ -333,6 +330,7 @@ pub async fn install_plugin_in_two_networks() -> anyhow::Result<()> {
 
  // dropping the first coffee instance, but without delete the dir
  drop(manager);
+ log::info!("------ second run -------");
  // initialize a lightning node in testnet network
  let mut cln = Node::tmp("testnet").await.unwrap();
  let lightning_dir = cln.rpc().getinfo().unwrap().ligthning_dir;
@@ -345,12 +343,18 @@ pub async fn install_plugin_in_two_networks() -> anyhow::Result<()> {
  };
  let mut manager = CoffeeTesting::tmp_with_args(&new_args, dir.clone()).await?;
  let new_root_path = manager.root_path().to_owned();
- assert_eq!(root_path.path(), new_root_path.path());
+ assert_eq!(dir.path(), new_root_path.path());
  manager
  .coffee()
  .setup(&lightning_testnet_dir)
  .await
  .unwrap();
+
+ let result = manager
+ .coffee()
+ .add_remote("lightningd", "https://github.com/lightningd/plugins.git")
+ .await;
+ assert!(result.is_err(), "{:?}", result);
  // Install summary plugin
  // This should install summary plugin for testnet network
  manager