26f9982 refactor: only expose the writeln method — radicle-native-ci

radicle-native-ci

rad:z3qg5TKmN83afz2fj9z3fQjU8vaYE

Radicle CI adapter for native CI

refactor: only expose the writeln method

Lars Wirzenius committed 2 years ago

commit 26f9982401d0cbcd6acfdef0589a9a8b13932ba3
parent 703c5c5

3 files changed +30 -37

modified src/bin/radicle-native-ci.rs

@@ -67,14 +67,11 @@ fn fallible_main() -> Result<(), NativeError> {

     }
     builder.build()?.write()?;
     logfile.write(format!(
         "update report page in {}\n",
         config.state.display()
     ))?;
     logfile.writeln(&format!("update report page in {}", config.state.display()))?;
     if let Err(e) = report::build_report(&mut logfile, &config.state) {
         logfile.write(format!("report generation failed: {}\n", e))?;
         logfile.writeln(&format!("report generation failed: {}", e))?;
     }
     logfile.write(format!("radicle-native-ci ends: {:?}\n", result))?;
     logfile.writeln(&format!("radicle-native-ci ends: {:?}", result))?;
     result
 }

@@ -85,7 +82,7 @@ fn fallible_main_inner(

 ) -> Result<(), NativeError> {
     let (run_id, run_dir) = mkdir_run(config)?;
     let run_id = RunId::from(format!("{}", run_id).as_str());
     logfile.write(format!("run directory {}\n", run_dir.display()))?;
     logfile.writeln(&format!("run directory {}", run_dir.display()))?;
     let src = run_dir.join("src");
     let run_log = run_dir.join("log.txt");

@@ -96,7 +93,7 @@ fn fallible_main_inner(

     // logfile.write(format!("profile: {:#?}\n", profile))?;
     let req = read_request()?;
     logfile.write(format!("request: {:#?}\n", req))?;
     logfile.writeln(&format!("request: {:#?}", req))?;
     builder.id(run_id.clone());
     builder.log(&config.state, run_log.clone());

@@ -119,17 +116,17 @@ fn fallible_main_inner(

         let result = runner.run();
         if let Err(e) = result {
             error!("CI run failed: {}", e);
             logfile.write(format!("CI failed: {:?}\n", e))?;
             logfile.writeln(&format!("CI failed: {:?}", e))?;
             builder.result(RunResult::Failure);
             return Err(e);
         }
         logfile.write_str("CI run exited zero")?;
         logfile.writeln("CI run exited zero")?;
     } else {
         write_response(&Response::error("first request was not Trigger\n"))?;
         builder.result(RunResult::Error("first request was not Trigger".into()));
     };
     logfile.write_str("radicle-native-ci ends successfully")?;
     logfile.writeln("radicle-native-ci ends successfully")?;
     info!("radicle-native-ci ends");
     Ok(())
 }

modified src/logfile.rs

@@ -24,60 +24,56 @@ impl LogFile {

     }
     pub fn h1(&mut self, text: &str) -> Result<(), LogError> {
         self.write_str("# ")?;
         self.write_str(text)?;
         self.write_str("\n\n")?;
         self.write("# ")?;
         self.write(text)?;
         self.write("\n\n")?;
         Ok(())
     }
     pub fn h2(&mut self, text: &str) -> Result<(), LogError> {
         self.write_str("## ")?;
         self.write_str(text)?;
         self.write_str("\n\n")?;
         self.write("## ")?;
         self.write(text)?;
         self.write("\n\n")?;
         Ok(())
     }
     pub fn h3(&mut self, text: &str) -> Result<(), LogError> {
         self.write_str("### ")?;
         self.write_str(text)?;
         self.write_str("\n\n")?;
         self.write("### ")?;
         self.write(text)?;
         self.write("\n\n")?;
         Ok(())
     }
     pub fn bullet_point(&mut self, text: String) -> Result<(), LogError> {
         self.write(text)?;
         self.write_str("\n")?;
         self.write(&text)?;
         self.write("\n")?;
         Ok(())
     }
     pub fn writeln(&mut self, text: &str) -> Result<(), LogError> {
         self.write_str(text)?;
         self.write_str("\n")?;
         self.write(text)?;
         self.write("\n")?;
         Ok(())
     }
     pub fn fenced(&mut self, msg: &str, data: &[u8]) -> Result<(), LogError> {
         const FENCED_BLOCK: &str = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
         self.h3(msg)?;
         self.write_str(FENCED_BLOCK)?;
         self.write(FENCED_BLOCK)?;
         if !data.is_empty() {
             let text = String::from_utf8_lossy(data);
             self.write_str(&text)?;
             self.write(&text)?;
             if !text.ends_with('\n') {
                 self.write_str("\n")?;
                 self.write("\n")?;
             }
         }
         self.write_str(FENCED_BLOCK)?;
         self.write_str("\n")?;
         self.write(FENCED_BLOCK)?;
         self.write("\n")?;
         Ok(())
     }
     pub fn write(&mut self, msg: String) -> Result<(), LogError> {
         self.write_str(&msg)
     }
     pub fn write_str(&mut self, msg: &str) -> Result<(), LogError> {
     fn write(&mut self, msg: &str) -> Result<(), LogError> {
         self.file
             .write_all(msg.as_bytes())
             .map_err(|e| LogError::WriteLogFile(self.filename.clone(), e))

modified src/runcmd.rs

@@ -12,8 +12,8 @@ pub fn runcmd(log: &mut LogFile, argv: &[&str], cwd: &Path) -> Result<(), RunCmd

     debug!("runcmd: cwd={:?}", cwd);
     log.h2("Run command")?;
     log.write(format!("~~~\n{:?}\n~~~\n\n", argv))?;
     log.write(format!("in directory: {}\n\n", cwd.display()))?;
     log.fenced("argv", format!("{:?}", argv).as_bytes())?;
     log.writeln(&format!("in directory: {}\n", cwd.display()))?;
     assert!(!argv.is_empty());
     let argv0 = argv[0];

@@ -26,7 +26,7 @@ pub fn runcmd(log: &mut LogFile, argv: &[&str], cwd: &Path) -> Result<(), RunCmd

     let exit = output.status;
     debug!("exit: {:?}", exit);
     log.write(format!("Exit: {}\n\n\n", exit.code().unwrap()))?;
     log.writeln(&format!("Exit: {}\n\n", exit.code().unwrap()))?;
     log.fenced("Standard output", &output.stdout)?;
     log.fenced("Standard error", &output.stderr)?;