move stuff around + ws server

Cargo.toml

@@ -66,3 +66,5 @@ murmur2 = "0.1"
 futures = "0.3"
 indextree = "4.6"
 schemars = "0.8"
+ratatui = "0.27.0"
+tokio-tungstenite = "0.23.1"

src/api/app/actions/markdown/mod.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use anyhow::Result;
 
-use crate::api::{app::App, models::{markdown::{MarkdownOptions, MarkdownOutput}, AddonMetadata, AddonMetadataSource}};
+use crate::api::{app::App, models::{markdown::{MarkdownOptions, MarkdownOutput}, metadata::{AddonMetadata, AddonMetadataSource}}};
 
 impl App {
     pub async fn get_markdown_options(&self) -> Option<MarkdownOptions> {

src/api/app/actions/mod.rs

@@ -1,3 +1,4 @@
 mod build;
 mod init;
 mod markdown;
+mod script;

src/api/app/actions/script/mod.rs

@@ -0,0 +1,29 @@
+use anyhow::Result;
+
+use crate::api::{app::App, models::server::Server, utils::script::Shell};
+
+impl App {
+    pub fn get_server_execution_arguments(&self) -> Vec<String> {
+        todo!()
+    }
+
+    pub fn get_script_lines_for(&self, shell: Shell, server: &Server) -> Vec<String> {
+        let mut lines = vec![];
+
+        if shell == Shell::Bat {
+            lines.push(format!("title {}", server.name));
+        }
+
+        lines.extend(server.launcher.prelaunch.clone());
+
+        todo!();
+
+        lines.extend(server.launcher.postlaunch.clone());
+
+        lines
+    }
+
+    pub async fn action_generate_script(&self) -> Result<()> {
+        todo!()
+    }
+}

src/api/app/mod.rs

@@ -16,6 +16,8 @@ mod io;
 pub mod options;
 mod step;
 
+pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
+
 pub const APP_USER_AGENT: &str = concat!(
     env!("CARGO_PKG_NAME"),
     "/",

src/api/mod.rs

@@ -4,3 +4,4 @@ pub mod sources;
 pub mod step;
 pub mod tools;
 pub mod utils;
+pub mod ws;

src/api/models/addon/mod.rs

@@ -1,11 +1,9 @@
 mod addon;
-mod addon_metadata;
 mod addon_target;
 mod addon_type;
 mod holders;
 
 pub use addon::*;
-pub use addon_metadata::*;
 pub use addon_target::*;
 pub use addon_type::*;
 pub use holders::*;

src/api/models/launcher/mod.rs

@@ -0,0 +1,96 @@
+use serde::{Deserialize, Serialize};
+use std::{borrow::ToOwned, collections::HashMap, env};
+
+use crate::api::utils::serde::*;
+
+mod preset_flags;
+pub use preset_flags::*;
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
+#[serde(default)]
+pub struct ServerLauncher {
+    pub eula_args: bool,
+
+    #[serde(skip_serializing_if = "is_default")]
+    pub nogui: bool,
+    #[serde(skip_serializing_if = "is_default")]
+    pub preset_flags: PresetFlags,
+    #[serde(skip_serializing_if = "is_default")]
+    pub disable: bool,
+    #[serde(skip_serializing_if = "is_default")]
+    pub jvm_args: String,
+    #[serde(skip_serializing_if = "is_default")]
+    pub game_args: String,
+    #[serde(skip_serializing_if = "is_default")]
+    pub memory: String,
+    #[serde(skip_serializing_if = "is_default")]
+    pub properties: HashMap<String, String>,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub prelaunch: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub postlaunch: Vec<String>,
+
+    pub java_version: Option<String>,
+}
+
+impl ServerLauncher {
+    pub fn get_args(&self, exec: &str) -> Vec<String> {
+        let mut args = self
+            .jvm_args
+            .split_whitespace()
+            .map(ToOwned::to_owned)
+            .collect::<Vec<_>>();
+
+        if env::var("MC_MEMORY").is_ok() || !self.memory.is_empty() {
+            let m = env::var("MC_MEMORY").unwrap_or(self.memory.clone());
+            args.extend([format!("-Xms{m}"), format!("-Xmx{m}")]);
+        }
+
+        args.append(&mut self.preset_flags.get_flags());
+
+        if self.eula_args {
+            args.push(String::from("-Dcom.mojang.eula.agree=true"));
+        }
+
+        for (key, value) in &self.properties {
+            args.push(format!(
+                "-D{}={}",
+                key,
+                if value.contains(char::is_whitespace) {
+                    format!("\"{value}\"")
+                } else {
+                    value.clone()
+                }
+            ));
+        }
+
+        args.extend(exec.split_whitespace().map(ToOwned::to_owned));
+
+        if self.nogui && !matches!(self.preset_flags, PresetFlags::Proxy) {
+            args.push(String::from("--nogui"));
+        }
+
+        args.extend(self.game_args.split_whitespace().map(ToOwned::to_owned));
+
+        args
+    }
+}
+
+impl Default for ServerLauncher {
+    fn default() -> Self {
+        Self {
+            preset_flags: PresetFlags::None,
+            nogui: true,
+            jvm_args: String::new(),
+            game_args: String::new(),
+            disable: false,
+            eula_args: true,
+            memory: String::new(),
+            properties: HashMap::default(),
+            prelaunch: vec![],
+            postlaunch: vec![],
+            java_version: None,
+        }
+    }
+}

src/api/models/launcher/preset_flags.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum PresetFlags {
+    Aikars,
+    Proxy,
+    #[default]
+    None,
+}
+
+impl PresetFlags {
+    pub fn get_flags(&self) -> Vec<String> {
+        match self {
+            Self::Aikars => include_str!("../../../../res/aikars_flags"),
+            Self::Proxy => include_str!("../../../../res/proxy_flags"),
+            Self::None => "",
+        }
+        .split(char::is_whitespace)
+        .map(ToOwned::to_owned)
+        .collect()
+    }
+}

src/api/models/markdown/render.rs

@@ -1,4 +1,4 @@
-use crate::api::{models::AddonMetadata, utils::markdown::{HeaderAlignment, MarkdownHeader, MarkdownTable}};
+use crate::api::{models::metadata::AddonMetadata, utils::markdown::{HeaderAlignment, MarkdownHeader, MarkdownTable}};
 
 use super::{MarkdownOptions, MarkdownOutput, MdColumn};
 

src/api/models/addon/addon_metadata.rs → src/api/models/metadata/addon_metadata.rs

@@ -1,9 +1,7 @@
 use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
 
-use crate::api::{app::App, sources::{jenkins::jenkins_job_url, maven::maven_artifact_url}, utils::url::get_filename_from_url};
-
-use super::{Addon, AddonType};
+use crate::api::{app::App, models::{Addon, AddonType}, sources::{jenkins::jenkins_job_url, maven::maven_artifact_url}, utils::url::get_filename_from_url};
 
 #[derive(Debug, Serialize, Deserialize, Clone, Copy, Default, PartialEq, Eq, Hash)]
 pub enum AddonMetadataSource {

src/api/models/metadata/mod.rs

@@ -0,0 +1,7 @@
+mod addon_metadata;
+
+pub use addon_metadata::*;
+
+pub enum MetadataBlock {
+    Addons(Vec<AddonMetadata>),
+}

src/api/models/mod.rs

@@ -11,6 +11,8 @@ pub mod packwiz;
 pub mod server;
 pub mod unsup;
 pub mod markdown;
+pub mod metadata;
+pub mod launcher;
 
 pub use addon::*;
 pub use env::*;

src/api/models/modpack_source.rs

@@ -42,3 +42,13 @@ pub enum ModpackType {
     MRPack,
     Unsup,
 }
+
+impl ToString for ModpackType {
+    fn to_string(&self) -> String {
+        match self {
+            ModpackType::Packwiz => String::from("Packwiz"),
+            ModpackType::MRPack => String::from("MRPack"),
+            ModpackType::Unsup => String::from("Unsup"),
+        }
+    }
+}

src/api/models/server/mod.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use super::{markdown::MarkdownOptions, Source};
+use super::{launcher::ServerLauncher, markdown::MarkdownOptions, Source};
 
 mod server_flavor;
 mod server_type;
@@ -19,6 +19,8 @@ pub struct Server {
     pub jar: Option<ServerJar>,
     #[serde(default)]
     pub markdown: MarkdownOptions,
+    #[serde(default)]
+    pub launcher: ServerLauncher,
 
     #[serde(default = "Vec::new")]
     pub sources: Vec<Source>,
@@ -36,6 +38,7 @@ impl Default for Server {
             }),
 
             markdown: MarkdownOptions::default(),
+            launcher: ServerLauncher::default(),
 
             sources: vec![],
         }

src/api/models/source.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 
 use super::{mrpack::resolve_mrpack_addons, packwiz::resolve_packwiz_addons, Addon, AddonListFile, ModpackType};
@@ -24,26 +24,49 @@ pub enum Source {
 }
 
 impl Source {
+    pub fn source_name(&self) -> &'static str {
+        match self {
+            Source::File { .. } => "File",
+            Source::Folder { .. } => "Folder",
+            Source::Modpack { .. } => "Modpack",
+        }
+    }
+
+    pub fn source_accessor(&self) -> Result<String> {
+        match self {
+            Source::File { path } => Ok(path.clone()),
+            Source::Folder { path } => Ok(path.clone()),
+            Source::Modpack { modpack } => Ok(modpack.accessor()?.to_string()),
+        }
+    }
+
+    pub fn modpack_type(&self) -> Option<ModpackType> {
+        match self {
+            Source::Modpack { modpack } => Some(modpack.modpack_type()),
+            _ => None,
+        }
+    }
+
     pub async fn resolve_addons(&self, app: &App) -> Result<Vec<Addon>> {
         match self {
             Source::File { path } => {
                 let file: AddonListFile = read_toml(&PathBuf::from(if path.ends_with(".toml") {
                     path.clone()
                 } else {
                     format!("{path}.toml")
-                }))?;
+                })).with_context(|| format!("Source: File => {path}"))?;
                 Ok(file.flatten())
             },
 
-            Source::Folder { path } => Ok(vec![]),
+            Source::Folder { .. } => Ok(vec![]),
 
             Source::Modpack { modpack } => {
                 let accessor = modpack.accessor()?;
                 match modpack.modpack_type() {
                     ModpackType::MRPack => resolve_mrpack_addons(app, accessor).await,
                     ModpackType::Packwiz => resolve_packwiz_addons(app, accessor).await,
                     ModpackType::Unsup => todo!(),
-                }
+                }.with_context(|| format!("Source: Modpack/{} => {}", modpack.modpack_type().to_string(), modpack.accessor().unwrap().to_string()))
             }
         }
     }

src/api/utils/accessor.rs

@@ -19,6 +19,16 @@ pub enum Accessor {
     //Zip(ZipArchive<Box<dyn ReadSeek>>),
 }
 
+impl ToString for Accessor {
+    fn to_string(&self) -> String {
+        match self {
+            Accessor::Local(path) => path.to_string_lossy().into_owned(),
+            Accessor::Remote(url) => url.to_string(),
+            Accessor::ZipLocal(zip) => String::from("a zip archive"),
+        }
+    }
+}
+
 impl Accessor {
     pub fn from(str: &str) -> Result<Self> {
         if str.starts_with("http://") || str.starts_with("https://") {

src/api/utils/mod.rs

@@ -13,6 +13,7 @@ pub mod serde;
 pub mod url;
 pub mod console;
 pub mod markdown;
+pub mod script;
 
 pub fn try_find_toml_upwards<T: DeserializeOwned>(filename: &str) -> Result<Option<(PathBuf, T)>> {
     let mut path = std::env::current_dir()?;