Logs wireup (#116)

* wireup

* Added live logs

* Finish up wireup

* Run linter

* finish most

* Fix most issues

* Finish page

* run lint

---------

Co-authored-by: Jai A <jaiagr+gpg@pm.me>
Co-authored-by: Geometrically <18202329+Geometrically@users.noreply.github.com>

theseus/src/api/jre.rs

@@ -138,84 +138,88 @@ pub async fn find_java17_jres() -> crate::Result<Vec<JavaVersion>> {
 }
 
 pub async fn auto_install_java(java_version: u32) -> crate::Result<PathBuf> {
-    let state = State::get().await?;
+    Box::pin(
+        async move {
+            let state = State::get().await?;
 
-    let loading_bar = init_loading(
-        LoadingBarType::JavaDownload {
-            version: java_version,
-        },
-        100.0,
-        "Downloading java version",
-    )
-    .await?;
-
-    #[derive(Deserialize)]
-    struct Package {
-        pub download_url: String,
-        pub name: PathBuf,
-    }
-
-    emit_loading(&loading_bar, 0.0, Some("Fetching java version")).await?;
-    let packages = fetch_json::<Vec<Package>>(
-        Method::GET,
-        &format!(
-            "https://api.azul.com/metadata/v1/zulu/packages?arch={}&java_version={}&os={}&archive_type=zip&javafx_bundled=false&java_package_type=jre&page_size=1",
-            std::env::consts::ARCH, java_version, std::env::consts::OS
-        ),
-        None,
-        None,
-        &state.fetch_semaphore,
-    ).await?;
-    emit_loading(&loading_bar, 10.0, Some("Downloading java version")).await?;
-
-    if let Some(download) = packages.first() {
-        let file = fetch_advanced(
-            Method::GET,
-            &download.download_url,
-            None,
-            None,
-            None,
-            Some((&loading_bar, 80.0)),
-            &state.fetch_semaphore,
-        )
-        .await?;
-
-        let path = state.directories.java_versions_dir();
-
-        if path.exists() {
-            tokio::fs::remove_dir_all(&path).await?;
-        }
-
-        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(file))
-            .map_err(|_| {
-                crate::Error::from(crate::ErrorKind::InputError(
-                    "Failed to read java zip".to_string(),
-                ))
-            })?;
-
-        emit_loading(&loading_bar, 0.0, Some("Extracting java")).await?;
-        archive.extract(&path).map_err(|_| {
-            crate::Error::from(crate::ErrorKind::InputError(
-                "Failed to extract java zip".to_string(),
-            ))
-        })?;
-        emit_loading(&loading_bar, 100.0, Some("Done extracting java")).await?;
-        Ok(path
-            .join(
-                download
-                    .name
-                    .file_stem()
-                    .unwrap_or_default()
-                    .to_string_lossy()
-                    .to_string(),
+            let loading_bar = init_loading(
+                LoadingBarType::JavaDownload {
+                    version: java_version,
+                },
+                100.0,
+                "Downloading java version",
             )
-            .join(format!("zulu-{}.jre/Contents/Home/bin/java", java_version)))
-    } else {
-        Err(crate::ErrorKind::LauncherError(format!(
-            "No Java Version found for Java version {}, OS {}, and Architecture {}",
-            java_version, std::env::consts::OS, std::env::consts::ARCH,
-        )).into())
-    }
+                .await?;
+
+            #[derive(Deserialize)]
+            struct Package {
+                pub download_url: String,
+                pub name: PathBuf,
+            }
+
+            emit_loading(&loading_bar, 0.0, Some("Fetching java version")).await?;
+            let packages = fetch_json::<Vec<Package>>(
+                Method::GET,
+                &format!(
+                    "https://api.azul.com/metadata/v1/zulu/packages?arch={}&java_version={}&os={}&archive_type=zip&javafx_bundled=false&java_package_type=jre&page_size=1",
+                    std::env::consts::ARCH, java_version, std::env::consts::OS
+                ),
+                None,
+                None,
+                &state.fetch_semaphore,
+            ).await?;
+            emit_loading(&loading_bar, 10.0, Some("Downloading java version")).await?;
+
+            if let Some(download) = packages.first() {
+                let file = fetch_advanced(
+                    Method::GET,
+                    &download.download_url,
+                    None,
+                    None,
+                    None,
+                    Some((&loading_bar, 80.0)),
+                    &state.fetch_semaphore,
+                )
+                    .await?;
+
+                let path = state.directories.java_versions_dir();
+
+                if path.exists() {
+                    tokio::fs::remove_dir_all(&path).await?;
+                }
+
+                let mut archive = zip::ZipArchive::new(std::io::Cursor::new(file))
+                    .map_err(|_| {
+                        crate::Error::from(crate::ErrorKind::InputError(
+                            "Failed to read java zip".to_string(),
+                        ))
+                    })?;
+
+                emit_loading(&loading_bar, 0.0, Some("Extracting java")).await?;
+                archive.extract(&path).map_err(|_| {
+                    crate::Error::from(crate::ErrorKind::InputError(
+                        "Failed to extract java zip".to_string(),
+                    ))
+                })?;
+                emit_loading(&loading_bar, 100.0, Some("Done extracting java")).await?;
+                Ok(path
+                    .join(
+                        download
+                            .name
+                            .file_stem()
+                            .unwrap_or_default()
+                            .to_string_lossy()
+                            .to_string(),
+                    )
+                    .join(format!("zulu-{}.jre/Contents/Home/bin/java", java_version)))
+            } else {
+                Err(crate::ErrorKind::LauncherError(format!(
+                    "No Java Version found for Java version {}, OS {}, and Architecture {}",
+                    java_version, std::env::consts::OS, std::env::consts::ARCH,
+                )).into())
+            }
+        }
+    ).await
 }
 
 // Get all JREs that exist on the system

theseus/src/api/logs.rs

@@ -5,44 +5,64 @@ use tokio::fs::read_to_string;
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Logs {
     pub datetime_string: String,
-    pub stdout: String,
-    pub stderr: String,
+    pub stdout: Option<String>,
+    pub stderr: Option<String>,
 }
 impl Logs {
     async fn build(
         profile_uuid: uuid::Uuid,
         datetime_string: String,
+        clear_contents: Option<bool>,
     ) -> crate::Result<Self> {
         Ok(Self {
-            stdout: get_stdout_by_datetime(profile_uuid, &datetime_string)
-                .await?,
-            stderr: get_stderr_by_datetime(profile_uuid, &datetime_string)
-                .await?,
+            stdout: if clear_contents.unwrap_or(false) {
+                None
+            } else {
+                Some(
+                    get_stdout_by_datetime(profile_uuid, &datetime_string)
+                        .await?,
+                )
+            },
+            stderr: if clear_contents.unwrap_or(false) {
+                None
+            } else {
+                Some(
+                    get_stderr_by_datetime(profile_uuid, &datetime_string)
+                        .await?,
+                )
+            },
             datetime_string,
         })
     }
 }
 
 #[tracing::instrument]
-pub async fn get_logs(profile_uuid: uuid::Uuid) -> crate::Result<Vec<Logs>> {
+pub async fn get_logs(
+    profile_uuid: uuid::Uuid,
+    clear_contents: Option<bool>,
+) -> crate::Result<Vec<Logs>> {
     let state = State::get().await?;
     let logs_folder = state.directories.profile_logs_dir(profile_uuid);
     let mut logs = Vec::new();
-    for entry in std::fs::read_dir(logs_folder)? {
-        let entry = entry?;
-        let path = entry.path();
-        if path.is_dir() {
-            if let Some(datetime_string) = path.file_name() {
-                logs.push(
-                    Logs::build(
-                        profile_uuid,
-                        datetime_string.to_string_lossy().to_string(),
-                    )
-                    .await,
-                );
+    if logs_folder.exists() {
+        for entry in std::fs::read_dir(logs_folder)? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_dir() {
+                if let Some(datetime_string) = path.file_name() {
+                    logs.push(
+                        Logs::build(
+                            profile_uuid,
+                            datetime_string.to_string_lossy().to_string(),
+                            clear_contents,
+                        )
+                        .await,
+                    );
+                }
             }
         }
     }
+
     let mut logs = logs.into_iter().collect::<crate::Result<Vec<Logs>>>()?;
     logs.sort_by_key(|x| x.datetime_string.clone());
     Ok(logs)
@@ -54,8 +74,12 @@ pub async fn get_logs_by_datetime(
     datetime_string: String,
 ) -> crate::Result<Logs> {
     Ok(Logs {
-        stdout: get_stdout_by_datetime(profile_uuid, &datetime_string).await?,
-        stderr: get_stderr_by_datetime(profile_uuid, &datetime_string).await?,
+        stdout: Some(
+            get_stdout_by_datetime(profile_uuid, &datetime_string).await?,
+        ),
+        stderr: Some(
+            get_stderr_by_datetime(profile_uuid, &datetime_string).await?,
+        ),
         datetime_string,
     })
 }