e786def refactor: rename log or logfile to adminlog, for clarity — radicle-native-ci

rad:z3qg5TKmN83afz2fj9z3fQjU8vaYE

Radicle CI adapter for native CI

refactor: rename log or logfile to adminlog, for clarity

Lars Wirzenius committed 2 years ago

commit e786def6cd7b40af8a395016fcba6bd1c2e2833f
parent 3a56190

1 file changed +24 -23

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

@@ -55,11 +55,11 @@ fn main() {

 fn fallible_main() -> Result<(), NativeError> {
     let config = Config::load_via_env()?;
     let mut logfile = config.open_log()?;
     let mut adminlog = config.open_log()?;
     let mut builder = RunInfo::builder();
     let result = fallible_main_inner(&config, &mut logfile, &mut builder);
     let result = fallible_main_inner(&config, &mut adminlog, &mut builder);
     let ri = builder.build()?;
     match &ri.result {

@@ -71,22 +71,22 @@ fn fallible_main() -> Result<(), NativeError> {

     ri.write()?;
     logfile.writeln(&format!("update report page in {}", config.state.display()))?;
     adminlog.writeln(&format!("update report page in {}", config.state.display()))?;
     if let Err(e) = report::build_report(&config.state) {
         logfile.writeln(&format!("report generation failed: {}", e))?;
         adminlog.writeln(&format!("report generation failed: {}", e))?;
     }
     logfile.writeln(&format!("radicle-native-ci ends: {:?}", result))?;
     adminlog.writeln(&format!("radicle-native-ci ends: {:?}", result))?;
     result
 }
 fn fallible_main_inner(
     config: &Config,
     logfile: &mut AdminLog,
     adminlog: &mut AdminLog,
     builder: &mut RunInfoBuilder,
 ) -> Result<(), NativeError> {
     let (run_id, run_dir) = mkdir_run(config)?;
     let run_id = RunId::from(format!("{}", run_id).as_str());
     logfile.writeln(&format!("run directory {}", run_dir.display()))?;
     adminlog.writeln(&format!("run directory {}", run_dir.display()))?;
     let src = run_dir.join("src");
     let run_log = run_dir.join("log.html");

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

     let storage = profile.storage.path();
     let req = read_request()?;
     logfile.writeln(&format!("request: {:#?}", req))?;
     adminlog.writeln(&format!("request: {:#?}", req))?;
     builder.run_id(run_id.clone());
     builder.log(&config.state, run_log.clone());

@@ -113,24 +113,24 @@ fn fallible_main_inner(

             .repo(repo)
             .commit(commit)
             .src(&src)
             .log(logfile)
             .adminlog(adminlog)
             .run_log(run_log)
             .timeout(config.timeout)
             .builder(builder)
             .build()?;
         let result = runner.run();
         if let Err(e) = result {
             logfile.writeln(&format!("CI failed: {:?}", e))?;
             adminlog.writeln(&format!("CI failed: {:?}", e))?;
             builder.result(RunResult::Error(format!("{}", e)));
             return Err(e);
         }
         logfile.writeln("CI run exited zero")?;
         adminlog.writeln("CI run exited zero")?;
         builder.result(RunResult::Success);
     } else {
         builder.result(RunResult::Error("first request was not Trigger".into()));
     };
     logfile.writeln("radicle-native-ci ends successfully")?;
     adminlog.writeln("radicle-native-ci ends successfully")?;
     Ok(())
 }

@@ -154,7 +154,7 @@ struct Runner<'a> {

     repo: Id,
     commit: Oid,
     src: PathBuf,
     log: &'a mut AdminLog,
     adminlog: &'a mut AdminLog,
     run_log: RunLog,
     timeout: Option<usize>,
     builder: &'a mut RunInfoBuilder,

@@ -162,7 +162,7 @@ struct Runner<'a> {

 impl<'a> Runner<'a> {
     fn git_clone(&mut self, repo_path: &Path) -> Result<(), NativeError> {
         self.log.writeln("clone repository")?;
         self.adminlog.writeln("clone repository")?;
         runcmd(
             &mut self.run_log,
             &[

@@ -177,7 +177,7 @@ impl<'a> Runner<'a> {

     }
     fn git_checkout(&mut self) -> Result<(), NativeError> {
         self.log.writeln("check out commit")?;
         self.adminlog.writeln("check out commit")?;
         runcmd(
             &mut self.run_log,
             &["git", "checkout", &self.commit.to_string()],

@@ -188,7 +188,7 @@ impl<'a> Runner<'a> {

     /// Perform the CI run.
     fn run(&mut self) -> Result<(), NativeError> {
         self.log
         self.adminlog
             .writeln(&format!("CI run on {}, {}", self.repo, self.commit))?;
         self.run_log.title("Log from Radicle native CI");

@@ -203,9 +203,10 @@ impl<'a> Runner<'a> {

         self.git_checkout()?;
         let runspec = RunSpec::from_file(&self.src.join(RUNSPEC_PATH))?;
         self.log.writeln(&format!("CI run spec: {:#?}", runspec))?;
         self.adminlog
             .writeln(&format!("CI run spec: {:#?}", runspec))?;
         self.log.writeln("run shell snippet in repository")?;
         self.adminlog.writeln("run shell snippet in repository")?;
         let snippet = format!("set -xeuo pipefail\n{}", &runspec.shell);
         let runcmd_result = if let Some(timeout) = self.timeout {
             let timeout = format!("{}", timeout);

@@ -233,7 +234,7 @@ impl<'a> Runner<'a> {

         self.builder.result(result);
         if let Err(e) = self.run_log.write() {
             self.log
             self.adminlog
                 .writeln(&format!("failed to write run log: {}", e))?;
         }

@@ -252,7 +253,7 @@ struct RunnerBuilder<'a> {

     repo: Option<Id>,
     commit: Option<Oid>,
     src: Option<PathBuf>,
     log: Option<&'a mut AdminLog>,
     adminlog: Option<&'a mut AdminLog>,
     run_log: Option<RunLog>,
     timeout: Option<usize>,
     builder: Option<&'a mut RunInfoBuilder>,

@@ -284,8 +285,8 @@ impl<'a> RunnerBuilder<'a> {

         self
     }
     fn log(mut self, log: &'a mut AdminLog) -> Self {
         self.log = Some(log);
     fn adminlog(mut self, log: &'a mut AdminLog) -> Self {
         self.adminlog = Some(log);
         self
     }

@@ -311,7 +312,7 @@ impl<'a> RunnerBuilder<'a> {

             repo: self.repo.ok_or(NativeError::Unset("repo"))?,
             commit: self.commit.ok_or(NativeError::Unset("commit"))?,
             src: self.src.ok_or(NativeError::Unset("src"))?,
             log: self.log.ok_or(NativeError::Unset("log"))?,
             adminlog: self.adminlog.ok_or(NativeError::Unset("log"))?,
             run_log: self.run_log.ok_or(NativeError::Unset("run_log"))?,
             timeout: self.timeout,
             builder: self.builder.ok_or(NativeError::Unset("builder"))?,