feat: run pike without plugin directory

src/commands/run.rs

@@ -173,6 +173,26 @@ fn enable_plugins(topology: &Topology, data_dir: &Path, picodata_path: &PathBuf)
     Ok(())
 }
 
+fn is_plugin_dir(path: &Path) -> bool {
+    if !path.is_dir() {
+        return false;
+    }
+    if !path.join("Cargo.toml").exists() {
+        return false;
+    }
+
+    if path.join("manifest.yaml.template").exists() {
+        return true;
+    }
+
+    fs::read_dir(path)
+        .unwrap()
+        .filter(Result::is_ok)
+        .map(|e| e.unwrap().path())
+        .filter(|e| e.is_dir())
+        .any(|dir| dir.join("manifest.yaml.template").exists())
+}
+
 pub struct PicodataInstance {
     instance_name: String,
     tier: String,
@@ -192,7 +212,7 @@ impl PicodataInstance {
         http_port: u16,
         pg_port: u16,
         first_instance_bin_port: u16,
-        plugins_dir: &Path,
+        plugins_dir: Option<&Path>,
         replication_factor: u8,
         tier: &str,
         run_params: &Params,
@@ -232,8 +252,6 @@ impl PicodataInstance {
             "run",
             data_dir_flag,
             instance_data_dir.to_str().expect("unreachable"),
-            "--plugin-dir",
-            plugins_dir.to_str().unwrap_or("target/debug"),
             listen_flag,
             &format!("127.0.0.1:{bin_port}"),
             "--peer",
@@ -248,6 +266,13 @@ impl PicodataInstance {
             tier,
         ]);
 
+        if let Some(plugins_dir) = plugins_dir {
+            child.args([
+                "--plugin-dir",
+                plugins_dir.to_str().unwrap_or("target/debug"),
+            ]);
+        }
+
         if run_params.daemon {
             child.stdout(Stdio::null()).stderr(Stdio::null());
             child.args(["--log", log_file_path.to_str().expect("unreachable")]);
@@ -417,22 +442,28 @@ pub fn cluster(params: &Params) -> Result<Vec<PicodataInstance>> {
     let mut params = params.clone();
     params.data_dir = params.plugin_path.join(&params.data_dir);
 
-    let plugins_dir = if params.use_release {
-        cargo_build(
-            lib::BuildType::Release,
-            &params.target_dir,
-            &params.plugin_path,
-        )?;
-        params.plugin_path.join(params.target_dir.join("release"))
-    } else {
-        cargo_build(
-            lib::BuildType::Debug,
-            &params.target_dir,
-            &params.plugin_path,
-        )?;
-        params.plugin_path.join(params.target_dir.join("debug"))
-    };
-    params.topology.find_plugin_versions(&plugins_dir)?;
+    let mut plugins_dir = None;
+    if is_plugin_dir(&params.plugin_path) {
+        plugins_dir = if params.use_release {
+            cargo_build(
+                lib::BuildType::Release,
+                &params.target_dir,
+                &params.plugin_path,
+            )?;
+            Some(params.plugin_path.join(params.target_dir.join("release")))
+        } else {
+            cargo_build(
+                lib::BuildType::Debug,
+                &params.target_dir,
+                &params.plugin_path,
+            )?;
+            Some(params.plugin_path.join(params.target_dir.join("debug")))
+        };
+    }
+
+    params
+        .topology
+        .find_plugin_versions(plugins_dir.as_ref().unwrap())?;
 
     info!("Running the cluster...");
 
@@ -451,7 +482,7 @@ pub fn cluster(params: &Params) -> Result<Vec<PicodataInstance>> {
                 params.base_http_port + instance_id,
                 params.base_pg_port + instance_id,
                 first_instance_bin_port,
-                &plugins_dir,
+                plugins_dir.as_deref(),
                 tier.replication_factor,
                 tier_name,
                 &params,
@@ -477,14 +508,16 @@ pub fn cluster(params: &Params) -> Result<Vec<PicodataInstance>> {
             thread::sleep(Duration::from_secs(5));
         }
 
-        let result = enable_plugins(&params.topology, &params.data_dir, &params.picodata_path);
-        if let Err(e) = result {
-            for process in &mut picodata_processes {
-                process.kill().unwrap_or_else(|e| {
-                    error!("failed to kill picodata instances: {:#}", e);
-                });
+        if plugins_dir.is_some() {
+            let result = enable_plugins(&params.topology, &params.data_dir, &params.picodata_path);
+            if let Err(e) = result {
+                for process in &mut picodata_processes {
+                    process.kill().unwrap_or_else(|e| {
+                        error!("failed to kill picodata instances: {:#}", e);
+                    });
+                }
+                return Err(e.context("failed to enable plugins"));
             }
-            return Err(e.context("failed to enable plugins"));
         }
     };
 

src/main.rs

@@ -218,12 +218,15 @@ fn run_child_killer() {
     process::exit(0)
 }
 
-fn check_plugin_directory(plugin_dir: &Path) {
-    if !plugin_dir.join("./topology.toml").exists() {
-        println!("{CARING_PIKE}");
-
-        process::exit(1);
+fn is_required_path_exists(plugin_dir: &Path, required_path: &Path) {
+    if required_path.exists() {
+        return;
+    }
+    if plugin_dir.join(required_path).exists() {
+        return;
     }
+    println!("{CARING_PIKE}");
+    process::exit(1);
 }
 
 // Add new member to Cargo.toml, additionally checks proper
@@ -283,7 +286,7 @@ fn main() -> Result<()> {
             disable_colors,
             plugin_path,
         } => {
-            check_plugin_directory(&plugin_path);
+            is_required_path_exists(&plugin_path, &topology);
 
             if !daemon {
                 run_child_killer();
@@ -317,7 +320,7 @@ fn main() -> Result<()> {
             data_dir,
             plugin_path,
         } => {
-            check_plugin_directory(&plugin_path);
+            is_required_path_exists(&plugin_path, &data_dir);
 
             run_child_killer();
             let params = commands::stop::ParamsBuilder::default()
@@ -339,7 +342,7 @@ fn main() -> Result<()> {
                     target_dir,
                     plugin_path,
                 } => {
-                    check_plugin_directory(&plugin_path);
+                    is_required_path_exists(&plugin_path, Path::new("Cargo.toml"));
 
                     commands::plugin::pack::cmd(debug, &target_dir, &plugin_path)
                         .context("failed to execute \"pack\" command")?;
@@ -349,7 +352,7 @@ fn main() -> Result<()> {
                     target_dir,
                     plugin_path,
                 } => {
-                    check_plugin_directory(&plugin_path);
+                    is_required_path_exists(&plugin_path, Path::new("Cargo.toml"));
 
                     commands::plugin::build::cmd(release, &target_dir, &plugin_path)
                         .context("failed to execute \"build\" command")?;
@@ -366,7 +369,7 @@ fn main() -> Result<()> {
                 } => commands::plugin::new::cmd(None, without_git, workspace)
                     .context("failed to execute \"init\" command")?,
                 Plugin::Add { path, plugin_path } => {
-                    check_plugin_directory(&plugin_path);
+                    is_required_path_exists(&plugin_path, Path::new("Cargo.toml"));
 
                     modify_workspace(path.file_name().unwrap().to_str().unwrap(), &plugin_path)
                         .context("failed to add new plugin to workspace")?;

tests/run.rs

@@ -11,6 +11,7 @@ use pike::cluster::{run, MigrationContextVar};
 use std::collections::BTreeMap;
 use std::process::Command;
 use std::time::Instant;
+use std::{env, thread};
 use std::{
     fs::{self},
     path::Path,
@@ -606,3 +607,63 @@ fn unpack_archive(path: &Path, unpack_to: &Path) {
 
     archive.unpack(unpack_to).unwrap();
 }
+
+#[test]
+fn test_run_without_plugin_directory() {
+    let run_dir = Path::new(TESTS_DIR);
+    let plugin_dir = Path::new("test_run_without_plugin_directory");
+    let data_dir = plugin_dir.join("tmp");
+
+    // Cleaning up metadata from past run
+    let _ = fs::remove_dir_all(run_dir.join(plugin_dir));
+
+    let tiers = BTreeMap::from([(
+        "default".to_string(),
+        Tier {
+            replicasets: 2,
+            replication_factor: 2,
+        },
+    )]);
+
+    let topology = Topology {
+        tiers,
+        ..Default::default()
+    };
+
+    let params = RunParamsBuilder::default()
+        .topology(topology)
+        .data_dir(run_dir.join(&data_dir))
+        .daemon(true)
+        .build()
+        .unwrap();
+
+    run(&params).unwrap();
+
+    let start = Instant::now();
+    let mut cluster_started = false;
+    while Instant::now().duration_since(start) < Duration::from_secs(60) {
+        let pico_instance = get_picodata_table(run_dir, &data_dir, "_pico_instance");
+
+        // Compare with 8, because table gives current state and target state
+        // both of them should be online
+        if pico_instance.matches("Online").count() == 8 {
+            cluster_started = true;
+            break;
+        }
+
+        thread::sleep(Duration::from_secs(1));
+    }
+
+    assert!(exec_pike(
+        vec!["stop"],
+        env::current_dir().unwrap(),
+        &vec![
+            "--data-dir".to_string(),
+            run_dir.join(&data_dir).to_str().unwrap().to_string()
+        ],
+    )
+    .unwrap()
+    .success());
+
+    assert!(cluster_started);
+}