feat: auto update + update notification

Author: pxseu

Cargo.lock

@@ -1,12 +1,13 @@
 [package]
 name = "hop"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 
 [dependencies]
 log = "0.4"
 dirs = "4.0"
 regex = "1.5"
+runas = "0.2"
 ignore = "0.4"
 console = "0.15"
 tabwriter = "1.2"
@@ -31,3 +32,6 @@ reqwest = { version = "0.11", features = [
 
 ], default-features = false }
 tokio-tungstenite = { version = "0.17", features = ["rustls-tls-webpki-roots"] }
+
+[target.'cfg(windows)'.dependencies]
+async_zip = "0.0.8"

Cargo.toml

@@ -7,14 +7,16 @@ use tokio::sync::mpsc::{channel, Sender};
 use tokio::task;
 
 use crate::commands::ignite::util::parse_key_val;
-use crate::config::{PAT_FALLBACK_URL, WEB_AUTH_URL};
 use crate::state::State;
 
+const WEB_AUTH_URL: &str = "https://console.hop.io/cli-auth";
+const PAT_FALLBACK_URL: &str = "https://console.hop.io/settings/pats";
+
 #[derive(Debug, Parser)]
 #[clap(about = "Login to Hop")]
 pub struct LoginOptions {
-    #[clap(long = "browserless", help = "Do not use a browser to login")]
-    pub browserless: bool,
+    #[clap(name = "pat", help = "Personal Access Token")]
+    pub pat: Option<String>,
 }
 
 async fn request_handler(
@@ -89,6 +91,33 @@ async fn web_auth(port: u16) -> Result<String, std::io::Error> {
 }
 
 pub async fn handle_login(options: LoginOptions, mut state: State) -> Result<(), std::io::Error> {
+    let token = match options.pat {
+        Some(pat) => pat,
+        None => browser_login().await,
+    };
+
+    // update the token assuming it's a valid PAT
+    state.update_http_token(token.clone());
+
+    // for sanity fetch the user info
+    state.login().await;
+
+    let me = state.ctx.me.clone().unwrap();
+
+    // save the state
+    state.auth.authorized.insert(me.user.id.clone(), token);
+    state.auth.save().await?;
+
+    state.ctx.default_user = Some(me.user.id);
+    state.ctx.save().await?;
+
+    // output the login info
+    log::info!("Logged in as: `{}` ({})", me.user.username, me.user.email);
+
+    Ok(())
+}
+
+async fn browser_login() -> String {
     let port = portpicker::pick_unused_port().unwrap();
 
     let callback_url = format!("http://localhost:{}/", port);
@@ -99,43 +128,21 @@ pub async fn handle_login(options: LoginOptions, mut state: State) -> Result<(),
     );
 
     // lunch a web server to handle the auth request
-    let token = if !options.browserless && webbrowser::open(&auth_url).is_ok() {
+    if webbrowser::open(&auth_url).is_ok() {
         log::info!("Opening browser to: {}", auth_url);
 
         web_auth(port)
             .await
             .expect("Error while starting web auth server")
     } else {
-        if !options.browserless {
-            log::info!("Could not open web a browser.");
-            log::info!("Please provide a personal access token manually.");
-            log::info!("You can create one at {}", PAT_FALLBACK_URL);
-        }
+        log::info!("Could not open web a browser.");
+        log::info!("Please provide a personal access token manually.");
+        log::info!("You can create one at {}", PAT_FALLBACK_URL);
 
         // falback to simpe input
         dialoguer::Password::new()
             .with_prompt("Enter your token")
             .interact()
             .unwrap()
-    };
-
-    // update the token assuming it's a valid PAT
-    state.update_http_token(token.clone());
-
-    // for sanity fetch the user info
-    state.login().await;
-
-    let me = state.ctx.me.clone().unwrap();
-
-    // save the state
-    state.auth.authorized.insert(me.user.id.clone(), token);
-    state.auth.save().await?;
-
-    state.ctx.default_user = Some(me.user.id);
-    state.ctx.save().await?;
-
-    // output the login info
-    log::info!("Logged in as: `{}` ({})", me.user.username, me.user.email);
-
-    Ok(())
+    }
 }

src/commands/auth/login.rs

@@ -1,5 +1,6 @@
 use clap::Parser;
 
+use crate::config::EXEC_NAME;
 use crate::state::State;
 use crate::store::context::Context;
 
@@ -14,7 +15,10 @@ pub async fn hanndle_logout(
     let user_id = state.ctx.default_user;
 
     if user_id.is_none() {
-        panic!("You are not logged in. Please run `hop auth login` first.");
+        panic!(
+            "You are not logged in. Please run `{} auth login` first.",
+            EXEC_NAME
+        );
     }
 
     // clear all state

src/commands/auth/logout.rs

@@ -14,13 +14,15 @@ use self::types::{Event, Message};
 use self::util::{compress, env_file_to_map};
 use crate::commands::containers::types::ContainerOptions;
 use crate::commands::containers::utils::{create_containers, rollout};
-use crate::commands::ignite::create::{CreateOptions, DeploymentConfig};
+use crate::commands::ignite::create::{CreateOptions, DeploymentConfig, WEB_DEPLOYMENTS_URL};
 use crate::commands::ignite::types::SingleDeployment;
 use crate::commands::ignite::util::{create_deployment, create_deployment_config};
-use crate::config::{HOP_BUILD_BASE_URL, HOP_REGISTRY_URL, WEB_DEPLOYMENTS_URL};
 use crate::state::State;
 use crate::store::hopfile::HopFile;
 
+const HOP_BUILD_BASE_URL: &str = "https://builder.hop.io/v1";
+const HOP_REGISTRY_URL: &str = "registry.hop.io";
+
 #[derive(Debug, Parser)]
 #[structopt(about = "Deploy a new container")]
 pub struct DeployOptions {

src/commands/deploy/mod.rs

@@ -4,9 +4,10 @@ use super::types::{Env, RamSizes, ScalingStrategy};
 use crate::commands::containers::types::ContainerType;
 use crate::commands::containers::utils::create_containers;
 use crate::commands::ignite::util::{create_deployment, create_deployment_config};
-use crate::config::WEB_DEPLOYMENTS_URL;
 use crate::state::State;
 
+pub const WEB_DEPLOYMENTS_URL: &str = "https://console.hop.io/ignite/deployment/";
+
 #[derive(Debug, Parser, Default, PartialEq, Clone)]
 pub struct DeploymentConfig {
     #[clap(short = 'n', long = "name", help = "Name of the deployment")]
@@ -67,7 +68,7 @@ pub struct DeploymentConfig {
     pub env: Option<Vec<Env>>,
 }
 
-#[derive(Debug, Parser)]
+#[derive(Debug, Parser, Default, PartialEq, Clone)]
 pub struct CreateOptions {
     #[clap(flatten)]
     pub config: DeploymentConfig,
@@ -86,7 +87,7 @@ pub async fn handle_create(options: CreateOptions, state: State) -> Result<(), s
         project.id
     );
 
-    let is_not_guided = options.config != DeploymentConfig::default();
+    let is_not_guided = options != CreateOptions::default();
 
     let (deployment_config, container_options) =
         create_deployment_config(options, is_not_guided, None).await;

src/commands/ignite/create.rs

@@ -2,10 +2,11 @@ pub mod auth;
 pub mod containers;
 pub mod deploy;
 pub mod ignite;
-pub mod link;
+mod link;
 pub mod projects;
-pub mod secrets;
-pub mod whoami;
+mod secrets;
+pub mod update;
+mod whoami;
 
 use clap::Subcommand;
 
@@ -15,6 +16,7 @@ use self::ignite::{handle_deployments, IgniteOptions};
 use self::link::{handle_link, LinkOptions};
 use self::projects::{handle_projects, ProjectsOptions};
 use self::secrets::{handle_secrets, SecretsOptions};
+use self::update::{handle_update, UpdateOptions};
 use self::whoami::{handle_whoami, WhoamiOptions};
 use crate::state::State;
 
@@ -28,18 +30,21 @@ pub enum Commands {
     Whoami(WhoamiOptions),
     Ignite(IgniteOptions),
     Link(LinkOptions),
+    Update(UpdateOptions),
 }
 
 pub async fn handle_command(command: Commands, mut state: State) -> Result<(), std::io::Error> {
     match command {
         Commands::Auth(options) => handle_auth(options, state).await,
+        Commands::Update(options) => handle_update(options, state).await,
 
         authorized_command => {
             // login so these commands can run
             state.login().await;
 
             match authorized_command {
                 Commands::Auth(_) => unreachable!(),
+                Commands::Update(_) => unreachable!(),
                 Commands::Projects(options) => handle_projects(options, state).await,
                 Commands::Secrets(options) => handle_secrets(options, state).await,
                 Commands::Deploy(options) => handle_deploy(options, state).await,

src/commands/mod.rs

@@ -15,12 +15,7 @@ pub struct DeleteOptions {
 }
 
 pub async fn handle_delete(options: DeleteOptions, mut state: State) -> Result<(), std::io::Error> {
-    let projects = state
-        .ctx
-        .me
-        .clone()
-        .expect("You are not logged in. Please run `hop auth login` first.")
-        .projects;
+    let projects = state.ctx.me.clone().unwrap().projects;
 
     if projects.is_empty() {
         panic!("No projects found");

src/commands/projects/delete.rs

@@ -11,12 +11,7 @@ pub struct SwitchOptions {
 }
 
 pub async fn handle_switch(options: SwitchOptions, mut state: State) -> Result<(), std::io::Error> {
-    let projects = state
-        .ctx
-        .me
-        .clone()
-        .expect("You are not logged in. Please run `hop auth login` first.")
-        .projects;
+    let projects = state.ctx.me.clone().unwrap().projects;
 
     if projects.is_empty() {
         panic!("No projects found");

src/commands/projects/switch.rs

@@ -0,0 +1,47 @@
+pub mod types;
+pub mod util;
+
+use clap::Parser;
+
+use self::util::{check_version, download, swap_executables, unpack};
+use crate::config::VERSION;
+use crate::state::http::HttpClient;
+use crate::state::State;
+
+#[derive(Debug, Parser)]
+#[clap(about = "Update Hop to the latest version")]
+pub struct UpdateOptions {
+    #[clap(short = 'f', long = "force", help = "Force update")]
+    pub force: bool,
+
+    #[clap(short = 'b', long = "beta", help = "Update to beta version")]
+    pub beta: bool,
+}
+
+pub async fn handle_update(options: UpdateOptions, _state: State) -> Result<(), std::io::Error> {
+    let http = HttpClient::new(None, None);
+
+    let (update, version) = check_version(options.beta).await;
+
+    if !update && !options.force {
+        log::info!("CLI is up to date");
+        return Ok(());
+    } else {
+        log::info!("Found new version {} (current: {})", version, VERSION);
+    }
+
+    // download the new release
+    let packed_temp = download(http, version.clone())
+        .await
+        .expect("Failed to download");
+
+    // unpack the new release
+    let unpacked = unpack(packed_temp).await?;
+
+    // swap the executables
+    swap_executables(std::env::current_exe()?, unpacked).await?;
+
+    log::info!("Updated to {}", version);
+
+    Ok(())
+}