Use github token if available

Author: lsbardel

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 edition = "2024"
 name = "rops"
-version = "0.5.1"
+version = "0.5.2"
 
 [dependencies]
 base64 = "0.22.1"

Cargo.toml

@@ -16,7 +16,7 @@ It will download the latest release from GitHub and place the executable in `$HO
 export ROPS_INSTALL_DIR=/your/custom/path
 ```
 
-If `GITHUB_TOKEN` is set in your environment, the installer will use it to authenticate with the GitHub API and avoid rate limits. You can set it with:
+If `GITHUB_TOKEN` is set in your environment, github installers will use it to authenticate with the GitHub API and avoid rate limits. You can set it with:
 
 ```bash
 export GITHUB_TOKEN=your_token

readme.md

@@ -1,7 +1,7 @@
 use crate::{
     error::{RopsError, RopsResult},
     settings::Settings,
-    utils::{StreamCommand, rimraf},
+    utils::{Secret, StreamCommand, rimraf},
 };
 use reqwest::blocking::Client;
 use serde::{Deserialize, Serialize};
@@ -15,14 +15,16 @@ pub struct GitSettings {
     pub branch: String,
     #[serde(default = "GitSettings::get_git_sha")]
     pub sha: String,
+    #[serde(default = "GitSettings::get_github_token", skip_deserializing)]
+    pub github_token: Option<Secret>,
 }
 
 #[derive(Clone, Debug)]
 pub struct GithubDownloadRelease {
     pub repo: String,
     pub file_name: String,
     pub client: Client,
-    pub token: Option<String>,
+    pub token: Option<Secret>,
     pub version: Option<String>,
     /// A different download url
     pub download_url: Option<String>,
@@ -56,6 +58,10 @@ impl GitSettings {
         std::env::var("GIT_DEFAULT_BRANCH").unwrap_or_else(|_| "main".to_string())
     }
 
+    pub fn get_github_token() -> Option<Secret> {
+        std::env::var("GITHUB_TOKEN").ok().map(Secret::new)
+    }
+
     /// Derives the Git SHA by executing `git rev-parse HEAD`.
     fn get_git_sha() -> String {
         match Command::new("git").arg("rev-parse").arg("HEAD").output() {
@@ -134,25 +140,24 @@ impl GitSettings {
             )))
         }
     }
+
+    pub fn release_downloader(&self, repo: &str, file_name: &str) -> GithubDownloadRelease {
+        GithubDownloadRelease::new(repo, file_name, self.github_token.clone())
+    }
 }
 
 impl GithubDownloadRelease {
-    pub fn new(repo: &str, file_name: &str) -> Self {
+    pub fn new(repo: &str, file_name: &str, token: Option<Secret>) -> Self {
         Self {
             repo: repo.to_string(),
             file_name: file_name.to_string(),
             client: Client::new(),
-            token: None,
+            token,
             version: None,
             download_url: None,
         }
     }
 
-    pub fn with_token<S: Into<String>>(mut self, token: S) -> Self {
-        self.token = Some(token.into());
-        self
-    }
-
     pub fn with_version<S: Into<String>>(mut self, version: S) -> Self {
         self.version = Some(version.into());
         self
@@ -166,7 +171,7 @@ impl GithubDownloadRelease {
     pub fn request(&self, url: String) -> reqwest::blocking::RequestBuilder {
         let mut builder = self.client.get(url).header("User-Agent", "quantmind/rops");
         if let Some(ref token) = self.token {
-            builder = builder.header("Authorization", format!("Bearer {}", token));
+            builder = builder.header("Authorization", format!("Bearer {}", token.value()));
         }
         builder
     }

src/git.rs

@@ -1,17 +1,12 @@
-use crate::git;
-use std::env;
-
 use crate::{
     error::{RopsError, RopsResult},
     settings::Settings,
 };
 
 pub fn self_update(settings: &Settings) -> RopsResult<()> {
-    let github_token = env::var("GITHUB_TOKEN").map_err(|_| {
-        RopsError::Error("GITHUB_TOKEN not set - add it to the .env file".to_string())
-    })?;
-    let installer =
-        git::GithubDownloadRelease::new("quantmind/devops", "rops-{arch}").with_token(github_token);
+    let installer = settings
+        .git
+        .release_downloader("quantmind/rops", "rops-{arch}");
     let asset = installer.download(settings)?;
 
     self_replace::self_replace(&asset.name).map_err(|err| RopsError::Error(err.to_string()))?;

src/self_update.rs

@@ -1,7 +1,7 @@
 use super::settings::Settings;
 use crate::{
     error::{RopsError, RopsResult},
-    git::GithubDownloadRelease,
+    git::{GitSettings, GithubDownloadRelease},
     utils,
 };
 use std::collections::HashMap;
@@ -70,6 +70,7 @@ impl Default for Tools {
                         GithubDownloadRelease::new(
                             "helm/helm",
                             "helm-{version}-{os}-{arch}.tar.gz",
+                            GitSettings::get_github_token(),
                         )
                         .with_download_url("https://get.helm.sh"),
                     ),
@@ -80,6 +81,7 @@ impl Default for Tools {
                     InstallMethod::GithubDownload(GithubDownloadRelease::new(
                         "derailed/k9s",
                         "k9s_{os}_{arch}.tar.gz",
+                        GitSettings::get_github_token(),
                     )),
                 ),
                 ThirdPartyTool::new(
@@ -88,6 +90,7 @@ impl Default for Tools {
                     InstallMethod::GithubDownload(GithubDownloadRelease::new(
                         "tamasfe/taplo",
                         "taplo-{os}-{arch}.gz",
+                        GitSettings::get_github_token(),
                     )),
                 ),
                 ThirdPartyTool::new(
@@ -96,6 +99,7 @@ impl Default for Tools {
                     InstallMethod::GithubDownload(GithubDownloadRelease::new(
                         "getsops/sops",
                         "sops-{version}.{os}.{arch}",
+                        GitSettings::get_github_token(),
                     )),
                 ),
             ]

src/tools.rs

@@ -11,6 +11,9 @@ pub trait FromEnv: Sized {
     fn from_env(key: &str, default: Self) -> Self;
 }
 
+#[derive(Clone)]
+pub struct Secret(String);
+
 /// Implementation for simple String types.
 impl FromEnv for String {
     fn from_env(key: &str, default: Self) -> Self {
@@ -28,6 +31,42 @@ impl FromEnv for Option<String> {
     }
 }
 
+impl Secret {
+    pub fn new(value: String) -> Self {
+        Self(value)
+    }
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for Secret {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.0.len() <= 3 {
+            write!(f, "***")
+        } else {
+            let prefix = &self.0[..3];
+            write!(f, "{}***", prefix)
+        }
+    }
+}
+
+impl serde::Serialize for Secret {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl std::fmt::Debug for Secret {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Secret(\"{}\")", self)
+    }
+}
+
 /// Gets a value from an environment variable, returning a default if not present.
 pub fn get_default_from_env<T: FromEnv>(key: &str, default: T) -> T {
     T::from_env(key, default)