Merge branch 'feature/runner-model' into development

Author: setoelkahfi

crates/cli/src/cli/mod.rs

@@ -1,7 +1,9 @@
-use crate::{account, project};
-use clap::{Parser, Subcommand};
-use smbcloud_network::environment::Environment;
-use spinners::Spinner;
+use {
+    crate::{account, project},
+    clap::{Parser, Subcommand},
+    smbcloud_network::environment::Environment,
+    spinners::Spinner,
+};
 
 pub struct CommandResult {
     pub spinner: Spinner,

crates/cli/src/deploy/config.rs

@@ -1,18 +1,20 @@
-use crate::{
-    deploy::setup::setup_project,
-    ui::{fail_message, fail_symbol, succeed_message, succeed_symbol},
+use {
+    crate::{
+        deploy::setup::setup_project,
+        ui::{fail_message, fail_symbol, succeed_message, succeed_symbol},
+    },
+    git2::{Cred, CredentialType, Error},
+    serde::{Deserialize, Serialize},
+    smbcloud_model::{
+        account::User,
+        error_codes::{ErrorCode, ErrorResponse},
+        project::Project,
+    },
+    smbcloud_network::environment::Environment,
+    smbcloud_networking_project::crud_project_read::get_project,
+    spinners::Spinner,
+    std::{fs, path::Path},
 };
-use git2::{Cred, CredentialType, Error};
-use serde::{Deserialize, Serialize};
-use smbcloud_model::{
-    account::User,
-    error_codes::{ErrorCode, ErrorResponse},
-    project::Project,
-};
-use smbcloud_network::environment::Environment;
-use smbcloud_networking_project::crud_project_read::get_project;
-use spinners::Spinner;
-use std::{fs, path::Path};
 
 pub(crate) async fn check_config(env: Environment) -> Result<Config, ErrorResponse> {
     let mut spinner: Spinner = Spinner::new(

crates/cli/src/deploy/detect_runner.rs

@@ -0,0 +1,70 @@
+use {
+    crate::ui::{fail_message, fail_symbol, succeed_message, succeed_symbol},
+    anyhow::Result,
+    smbcloud_model::runner::Runner,
+    spinners::Spinner,
+    std::{env::current_dir, path::Path},
+};
+
+pub(crate) async fn detect_runner() -> Result<Runner> {
+    let mut spinner: Spinner = Spinner::new(
+        spinners::Spinners::SimpleDotsScrolling,
+        succeed_message("Checking runner"),
+    );
+
+    let path = match current_dir() {
+        Ok(path) => path,
+        Err(_) => {
+            spinner.stop_and_persist(
+                &fail_symbol(),
+                fail_message(
+                    "Could not detect project runner: no package.json, Gemfile, or Package.swift found",
+                ),
+            );
+            anyhow::bail!(
+                "Could not detect project runner: no package.json, Gemfile, or Package.swift found"
+            );
+        }
+    };
+    let runner = match Runner::from(&path) {
+        Ok(runner) => runner,
+        Err(_) => {
+            spinner.stop_and_persist(
+                &fail_symbol(),
+                fail_message(
+                    "Could not detect project runner: no package.json, Gemfile, or Package.swift found",
+                ),
+            );
+            anyhow::bail!(
+                "Could not detect project runner: no package.json, Gemfile, or Package.swift found"
+            );
+        }
+    };
+
+    match runner {
+        Runner::NodeJs => {
+            spinner.stop_and_persist(
+                &succeed_symbol(),
+                succeed_message("NodeJs 🟩 runner detected"),
+            );
+        }
+        Runner::Ruby => {
+            if Path::new("Gemfile").exists() {
+                spinner.stop_and_persist(
+                    &succeed_symbol(),
+                    succeed_message("Ruby 🟥 runner with Rails app detected"),
+                );
+            }
+        }
+        Runner::Swift => {
+            if Path::new("Package.swift").exists() {
+                spinner.stop_and_persist(
+                    &succeed_symbol(),
+                    succeed_message("Swift 🟧 runner with Vapor app detected"),
+                );
+            }
+        }
+    };
+
+    Ok(runner)
+}

crates/cli/src/deploy/git.rs

@@ -1,9 +1,9 @@
 use {
-    crate::project::runner::Runner,
     crate::ui::{fail_message, fail_symbol, succeed_message, succeed_symbol},
     anyhow::{anyhow, Result},
     console::style,
     git2::{Remote, Repository},
+    smbcloud_model::runner::Runner,
     spinners::Spinner,
 };
 

crates/cli/src/deploy/mod.rs

@@ -1,215 +1,6 @@
 pub mod config;
+mod detect_runner;
 mod git;
+pub mod process_deploy;
 mod remote_messages;
 mod setup;
-
-use crate::token::get_smb_token;
-use crate::{
-    account::{lib::is_logged_in, login::process_login},
-    cli::CommandResult,
-    deploy::config::check_project,
-    project::runner::detect_runner,
-    ui::{fail_message, succeed_message, succeed_symbol},
-};
-use anyhow::{anyhow, Result};
-use config::check_config;
-use git::remote_deployment_setup;
-use git2::{PushOptions, RemoteCallbacks, Repository};
-use remote_messages::{build_next_app, start_server};
-use smbcloud_model::project::{DeploymentPayload, DeploymentStatus};
-use smbcloud_network::environment::Environment;
-use smbcloud_networking_account::me::me;
-use smbcloud_networking_project::{
-    crud_project_deployment_create::create_deployment, crud_project_deployment_update::update,
-};
-use spinners::Spinner;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-
-pub async fn process_deploy(env: Environment) -> Result<CommandResult> {
-    // Check credentials.
-    if !is_logged_in(env) {
-        let _ = process_login(env).await;
-    }
-
-    // Get current token
-    let access_token = get_smb_token(env).await?;
-
-    // Check config.
-    let config = check_config(env).await?;
-
-    // Check runner.
-    let runner = detect_runner().await?;
-
-    // Validate config with project.
-    check_project(env, &access_token, config.project.id).await?;
-
-    // Check remote repository setup.
-    let repo = match Repository::open(".") {
-        Ok(repo) => repo,
-        Err(_) => {
-            return Err(anyhow!(fail_message(
-                "No git repository found. Init with `git init` command."
-            )))
-        }
-    };
-
-    // Get the current branch
-    let head = match repo.head() {
-        Ok(head) => head,
-        Err(_) => {
-            return Err(anyhow!(fail_message(
-                "No HEAD reference found. Create a commit with `git commit` command."
-            )))
-        }
-    };
-
-    // Check if we're on the main branch
-    let branch_name = match head.shorthand() {
-        Some(name) => name,
-        None => {
-            return Err(anyhow!(fail_message(
-                "Unable to determine current branch name."
-            )))
-        }
-    };
-
-    if branch_name != "main" && branch_name != "master" {
-        return Err(anyhow!(fail_message(
-            &format!("Not on main branch. Current branch: '{}'. Switch to main branch with `git checkout main` command.", branch_name)
-        )));
-    }
-
-    let main_branch = head;
-
-    let repository = match &config.project.repository {
-        Some(repo) => repo,
-        None => return Err(anyhow!(fail_message("Repository not found."))),
-    };
-
-    let mut origin = remote_deployment_setup(&runner, &repo, repository).await?;
-
-    let commit_hash = match main_branch.resolve() {
-        Ok(result) => match result.target() {
-            Some(hash_id) => hash_id,
-            None => return Err(anyhow!("Should have at least one commit.")),
-        },
-        Err(_) => return Err(anyhow!("Cannot resolve main branch.")),
-    };
-    let payload = DeploymentPayload {
-        commit_hash: commit_hash.to_string(),
-        status: DeploymentStatus::Started,
-    };
-
-    let created_deployment =
-        create_deployment(env, &access_token, config.project.id, payload).await?;
-    let user = me(env, &access_token).await?;
-
-    let mut push_opts = PushOptions::new();
-    let mut callbacks = RemoteCallbacks::new();
-
-    // For updating status to failed
-    let deployment_failed_flag = Arc::new(AtomicBool::new(false));
-    let update_env = env; // Env is Copy
-    let update_access_token = access_token.clone();
-    let update_project_id = config.project.id;
-    let update_deployment_id = created_deployment.id;
-
-    // Set the credentials
-    callbacks.credentials(config.credentials(user));
-    callbacks.sideband_progress(|data| {
-        // Convert bytes to string, print line by line
-        if let Ok(text) = std::str::from_utf8(data) {
-            for line in text.lines() {
-                if line.contains(&build_next_app()) {
-                    println!("Building the app {}", succeed_symbol());
-                }
-                if line.contains(&start_server(repository)) {
-                    println!("App restart {}", succeed_symbol());
-                }
-            }
-        }
-        true // continue receiving.
-    });
-    callbacks.push_update_reference({
-        let flag_clone = deployment_failed_flag.clone();
-        let access_token_for_update_cb = update_access_token.clone();
-        let project_id_for_update_cb = update_project_id;
-        let deployment_id_for_update_cb = update_deployment_id;
-
-        move |_refname, status_message| {
-            if let Some(e) = status_message {
-                // Try to set the flag. If it was already true, do nothing.
-                if !flag_clone.swap(true, Ordering::SeqCst) {
-                    println!(
-                        "Deployment ref update failed: {}. Marking deployment as Failed.",
-                        e
-                    );
-
-                    let update_payload = DeploymentPayload {
-                        commit_hash: commit_hash.to_string(),
-                        status: DeploymentStatus::Failed,
-                    };
-
-                    // We are in a sync callback, so we need to block on the async task.
-                    let handle = tokio::runtime::Handle::current();
-                    let result = handle.block_on(async {
-                        update(
-                            update_env, // Env is Copy
-                            access_token_for_update_cb.clone(),
-                            project_id_for_update_cb,
-                            deployment_id_for_update_cb,
-                            update_payload,
-                        )
-                        .await
-                    });
-
-                    match result {
-                        Ok(_) => println!("Deployment status successfully updated to Failed."),
-                        Err(update_err) => {
-                            eprintln!("Error updating deployment status to Failed: {}", update_err)
-                        }
-                    }
-                }
-            }
-            Ok(()) // Report success for the git callback itself, error is handled above.
-        }
-    });
-    push_opts.remote_callbacks(callbacks);
-
-    let spinner = Spinner::new(
-        spinners::Spinners::Hamburger,
-        succeed_message("Deploying > "),
-    );
-
-    match origin.push(&["refs/heads/main:refs/heads/main"], Some(&mut push_opts)) {
-        Ok(_) => {
-            // Update deployment status to Done
-            let update_payload = DeploymentPayload {
-                commit_hash: commit_hash.to_string(),
-                status: DeploymentStatus::Done,
-            };
-            let result = update(
-                env,
-                access_token.clone(),
-                config.project.id,
-                created_deployment.id,
-                update_payload,
-            )
-            .await;
-            match result {
-                Ok(_) => println!("App is running {}", succeed_symbol()),
-                Err(update_err) => {
-                    eprintln!("Error updating deployment status to Done: {}", update_err)
-                }
-            }
-            Ok(CommandResult {
-                spinner,
-                symbol: succeed_symbol(),
-                msg: succeed_message("Deployment complete."),
-            })
-        }
-        Err(e) => Err(anyhow!(fail_message(&e.to_string()))),
-    }
-}