stuff

Author: Xgames123

.fleet/run.json

@@ -39,3 +39,17 @@ pub fn spawn(helper: &str, operation: &str) -> Result<Child> {
             cmd
         })
 }
+
+pub fn run(helper: &str, operation: &str, params: Params) -> Result<params::Params> {
+    let process = spawn(helper, operation)?;
+    eprintln!("Opening stdin of helper");
+    let mut stdin = process.stdin.unwrap();
+    eprintln!("Writing to stdin of helper");
+    params.write_to(&mut stdin)?;
+
+    eprintln!("Opening to stdout of helper");
+    let stdout = process.stdout.unwrap();
+    let output = params::from_stream(stdout)?;
+    eprintln!("Parsing stdout of helper");
+    Ok(output)
+}

.idea/.gitignore

@@ -27,11 +27,11 @@ impl Params {
     pub fn add(&mut self, name: String, value: String) {
         self.hashmap.insert(name, value);
     }
-    
+
     pub fn contains(&self, name: String) -> bool {
         self.hashmap.contains_key(&name)
     }
-    
+
     pub fn add_from_string(&mut self, s: &String) -> Result<(), ParamParserError> {
         for (i, &character) in s.as_bytes().iter().enumerate() {
             if character == b'=' {
@@ -47,39 +47,41 @@ impl Params {
         });
     }
 
-    pub fn write_to_sdtout(&self) {
+    pub fn write_to_sdtout(&self) -> std::io::Result<()> {
         let mut stdout = io::stdout().lock();
-        self.write_to(&mut stdout);
+        self.write_to(&mut stdout)?;
+        Ok(())
     }
 
-    pub fn write_to<T: std::io::Write>(&self, stream: &mut T) {
+    pub fn write_to<T: std::io::Write>(&self, stream: &mut T) -> std::io::Result<()> {
         for (key, value) in self.hashmap.iter() {
-            stream.write_fmt(format_args!("{0}={1}", key, value));
+            stream.write_fmt(format_args!("{0}={1}", key, value))?;
         }
-        stream.write_all(b"\n");
+        stream.write_all(b"\n")?;
+        Ok(())
     }
 }
 
-pub fn from_stream<T: std::io::Read>(stream: T) -> Result<Params, ParamParserError> {
+pub fn from_stream<T: std::io::Read>(stream: T) -> Result<Params, Box<dyn std::error::Error>> {
     let mut params = Params {
         hashmap: HashMap::new(),
     };
-    
+
     let mut buf_reader = std::io::BufReader::new(stream);
+    let mut buffer = String::new();
     loop {
-        let mut buffer = String::new();
-        buf_reader.read_line(&mut buffer);
-        if buffer == "" {
+        buffer.clear();
+
+        buf_reader.read_line(&mut buffer)?;
+        if buffer.trim().is_empty() {
             break;
         }
         params.add_from_string(&buffer)?;
     }
     return Ok(params);
 }
 
-
-
-pub fn from_stdin() -> Result<Params, ParamParserError> {
+pub fn from_stdin() -> Result<Params, Box<dyn std::error::Error>> {
     let mut stdin = io::stdin().lock();
     from_stream(&mut stdin)
 }

.idea/misc.xml

@@ -5,7 +5,7 @@ use crate::ghauth::AccessTokenPollError;
 use clap::{Parser, Subcommand};
 use reqwest::Client;
 
-use std::string::String;
+use std::{io::Read, string::String};
 
 #[derive(Parser)]
 #[command(author, version)]
@@ -20,6 +20,10 @@ struct Cli {
     #[arg(short = 'p', long)]
     no_prompt: bool,
 
+    ///If set logs everything gh-login is doing to stderr
+    #[arg(short = 'l', long)]
+    log: bool,
+
     #[command(subcommand)]
     operation: Commands,
 }
@@ -56,24 +60,38 @@ async fn main() {
                 eprintln!("NOTE: use --no-prompt to disable this message");
             }
 
-            let process = credhelper::spawn(&cli.backing_helper, "get").unwrap();
-            let mut stdout = process.stdout.unwrap();
-            let mut stdin = process.stdin.unwrap();
+            if cli.log {
+                eprintln!("Reading parameters from stdin");
+            }
+            let params = credhelper::params::from_stdin().expect("Failled to read data from stdin");
 
-            std::io::copy(&mut std::io::stdin(), &mut stdin)
-                .expect("Error sending data to backing helper");
+            if cli.log {
+                eprintln!("Running backing helper '{}'", &cli.backing_helper);
+            }
+            let mut output = credhelper::run(&cli.backing_helper, "get", params)
+                .expect("Failled to run backing helper");
 
-            let mut returned_params = credhelper::params::from_stream(&mut stdout)
-                .expect("Invalid data returned by backing helper");
+            if cli.log {
+                eprintln!("Done running credentials helper '{}'", &cli.backing_helper);
+            }
 
-            if !returned_params.contains(String::from("password")) {
+            if !output.contains(String::from("password")) {
+                if cli.log {
+                    eprintln!("No password returned by helper. Fetching credentails..");
+                }
                 let client = reqwest::Client::new();
                 let access_token = get_access_token_via_device_code(&client).await;
 
-                returned_params.add(String::from("password"), access_token.access_token);
+                output.add(String::from("password"), access_token.access_token);
+            }
+
+            if cli.log {
+                eprintln!("Done. Writing credentails to stdout");
             }
 
-            returned_params.write_to_sdtout();
+            output
+                .write_to_sdtout()
+                .expect("Failled to write to stdout");
         }
     }
 }