feat: allow disabling restart and launch wrapper functionality

adds a new config option `restart`, and makes `run` optional. these allow the wrapper to be used both as a pre-launch command (by not setting the `run` option), or as a wrapper that is managed by a tool that handles restarting, such as pterodactyl

Author: ashhhleyyy

src/config.rs

@@ -13,14 +13,17 @@ mod destinations;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
-    pub run: Vec<String>,
+    #[serde(default)]
+    pub run: Option<Vec<String>>,
     #[serde(default = "Default::default")]
     pub status: Status,
     #[serde(default = "Default::default")]
     pub tokens: Tokens,
     pub triggers: HashMap<String, Trigger>,
     #[serde(default = "default_min_restart_interval")]
     pub min_restart_interval_seconds: u64,
+    #[serde()]
+    pub restart: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
@@ -45,7 +48,7 @@ pub enum Trigger {
 impl Default for Config {
     fn default() -> Self {
         Config {
-            run: vec!["java -jar fabric-server-launch.jar".to_owned()],
+            run: Some(vec!["java -jar fabric-server-launch.jar".to_owned()]),
             tokens: Tokens::default(),
             status: Status::default(),
             triggers: {
@@ -54,6 +57,7 @@ impl Default for Config {
                 triggers
             },
             min_restart_interval_seconds: default_min_restart_interval(),
+            restart: default_restart(),
         }
     }
 }
@@ -62,21 +66,27 @@ fn default_min_restart_interval() -> u64 {
     240
 }
 
+fn default_restart() -> bool {
+    true
+}
+
 pub async fn load<P, T>(path: P) -> T
 where
     P: AsRef<Path>,
     T: Serialize + DeserializeOwned + Default,
 {
     let path = path.as_ref();
-    if path.exists() {
+    let mut config = if path.exists() {
         read_config(path).await.expect("failed to read config")
     } else {
         let config = T::default();
         write_config(path, &config)
             .await
             .expect("failed to write default config");
         config
-    }
+    };
+
+    config
 }
 
 async fn write_config<T: Serialize>(path: &Path, config: &T) -> io::Result<()> {

src/main.rs

@@ -34,9 +34,17 @@ pub async fn main() {
     let destinations_path = std::env::args().nth(2).unwrap_or_else(|| "destinations.toml".to_owned());
 
     loop {
-        let config: Config = config::load(&config_path).await;
+        let mut config: Config = config::load(&config_path).await;
         let destinations: config::Destinations = config::load(&destinations_path).await;
 
+        if config.run.is_none() && config.restart {
+            eprintln!("warning: `restart = true` has no effect if `run` is not set");
+            config.restart = false;
+        }
+
+        // make immutable just to be sure
+        let config = config;
+
         let min_restart_interval = Duration::from_secs(config.min_restart_interval_seconds);
 
         let status = match config.status.webhook {
@@ -102,28 +110,34 @@ pub async fn main() {
 
         ctx.status.write(payload);
 
-        let start = Instant::now();
-
-        let mut executor = Executor::new(config.run);
-        if let Err(err) = executor.run().await {
-            eprintln!("server exited with error: {:?}", err);
-        } else {
-            println!("server closed");
-        }
-
-        let interval = Instant::now() - start;
-        if interval < min_restart_interval {
-            println!("server restarted very quickly! waiting a bit...");
+        if let Some(run) = config.run {
+            let start = Instant::now();
 
-            let delay = min_restart_interval - interval;
-            ctx.status.write(format!(
-                "Server restarted too quickly! Waiting for {} seconds...",
-                delay.as_secs()
-            ));
+            let mut executor = Executor::new(run);
+            if let Err(err) = executor.run().await {
+                eprintln!("server exited with error: {:?}", err);
+            } else {
+                println!("server closed");
+            }
 
-            tokio::time::sleep(delay.into()).await;
-        } else {
-            ctx.status.write("Server closed! Restarting...");
+            let interval = Instant::now() - start;
+            if config.restart && interval < min_restart_interval {
+                println!("server restarted very quickly! waiting a bit...");
+
+                let delay = min_restart_interval - interval;
+                ctx.status.write(format!(
+                    "Server restarted too quickly! Waiting for {} seconds...",
+                    delay.as_secs()
+                ));
+
+                tokio::time::sleep(delay.into()).await;
+            } else {
+                ctx.status.write(if config.restart {
+                    "Server closed! Restarting..."
+                } else {
+                    "Server closed!"
+                });
+            }
         }
     }
 }