Merge pull request #487 from LnL7/lapin-comment-poster

lapin github-comment-poster

ofborg/src/bin/github-comment-poster.rs

@@ -1,22 +1,26 @@
-use ofborg::config;
-use ofborg::easyamqp::{self, ChannelExt, ConsumerExt};
-use ofborg::tasks;
-use ofborg::worker;
-
 use std::env;
+use std::error::Error;
 
-use amqp::Basic;
+use async_std::task;
 use tracing::info;
 
-fn main() {
-    let cfg = config::load(env::args().nth(1).unwrap().as_ref());
+use ofborg::config;
+use ofborg::easyamqp::{self, ChannelExt, ConsumerExt};
+use ofborg::easylapin;
+use ofborg::tasks;
+
+fn main() -> Result<(), Box<dyn Error>> {
     ofborg::setup_log();
 
-    let mut session = easyamqp::session_from_config(&cfg.rabbitmq).unwrap();
-    let mut channel = session.open_channel(1).unwrap();
+    let arg = env::args()
+        .nth(1)
+        .expect("usage: github-comment-poster <config>");
+    let cfg = config::load(arg.as_ref());
 
-    channel
-        .declare_exchange(easyamqp::ExchangeConfig {
+    let conn = easylapin::from_config(&cfg.rabbitmq)?;
+    let mut chan = task::block_on(conn.create_channel())?;
+
+    chan.declare_exchange(easyamqp::ExchangeConfig {
         exchange: "build-results".to_owned(),
         exchange_type: easyamqp::ExchangeType::Fanout,
         passive: false,
@@ -24,35 +28,26 @@ fn main() {
         auto_delete: false,
         no_wait: false,
         internal: false,
-        })
-        .unwrap();
+    })?;
 
-    channel
-        .declare_queue(easyamqp::QueueConfig {
+    chan.declare_queue(easyamqp::QueueConfig {
         queue: "build-results".to_owned(),
         passive: false,
         durable: true,
         exclusive: false,
         auto_delete: false,
         no_wait: false,
-        })
-        .unwrap();
+    })?;
 
-    channel
-        .bind_queue(easyamqp::BindQueueConfig {
+    chan.bind_queue(easyamqp::BindQueueConfig {
         queue: "build-results".to_owned(),
         exchange: "build-results".to_owned(),
         routing_key: None,
         no_wait: false,
-        })
-        .unwrap();
+    })?;
 
-    channel.basic_prefetch(1).unwrap();
-    let mut channel = channel
-        .consume(
-            worker::new(tasks::githubcommentposter::GitHubCommentPoster::new(
-                cfg.github_app_vendingmachine(),
-            )),
+    let handle = chan.consume(
+        tasks::githubcommentposter::GitHubCommentPoster::new(cfg.github_app_vendingmachine()),
         easyamqp::ConsumeConfig {
             queue: "build-results".to_owned(),
             consumer_tag: format!("{}-github-comment-poster", cfg.whoami()),
@@ -61,15 +56,11 @@ fn main() {
             no_wait: false,
             exclusive: false,
         },
-        )
-        .unwrap();
+    )?;
 
-    channel.start_consuming();
+    task::block_on(handle);
 
-    info!("Finished consuming?");
-
-    channel.close(200, "Bye").unwrap();
-    info!("Closed the channel");
-    session.close(200, "Good Bye");
+    drop(conn); // Close connection.
     info!("Closed the session... EOF");
+    Ok(())
 }

ofborg/src/message/buildresult.rs

@@ -133,6 +133,13 @@ impl BuildResult {
         }
     }
 
+    pub fn pr(&self) -> Pr {
+        match self {
+            BuildResult::Legacy { pr, .. } => pr.to_owned(),
+            BuildResult::V1 { pr, .. } => pr.to_owned(),
+        }
+    }
+
     pub fn status(&self) -> BuildStatus {
         match *self {
             BuildResult::Legacy {

ofborg/src/tasks/githubcommentposter.rs

@@ -6,7 +6,7 @@ use crate::worker;
 
 use chrono::{DateTime, Utc};
 use hubcaps::checks::{CheckRunOptions, CheckRunState, Conclusion, Output};
-use tracing::info;
+use tracing::{debug, debug_span, info};
 
 pub struct GitHubCommentPoster {
     github_vend: GithubAppVendingMachine,
@@ -50,22 +50,33 @@ impl worker::SimpleWorker for GitHubCommentPoster {
         let mut checks: Vec<CheckRunOptions> = vec![];
         let repo: Repo;
 
-        match job {
+        let pr = match job {
             PostableEvent::BuildQueued(queued_job) => {
                 repo = queued_job.job.repo.clone();
                 for architecture in queued_job.architectures.iter() {
                     checks.push(job_to_check(&queued_job.job, &architecture, Utc::now()));
                 }
+                queued_job.job.pr.to_owned()
             }
             PostableEvent::BuildFinished(finished_job) => {
                 let result = finished_job.legacy();
                 repo = result.repo.clone();
                 checks.push(result_to_check(&result, Utc::now()));
+                finished_job.pr()
             }
-        }
+        };
+
+        let span = debug_span!("job", pr = ?pr.number);
+        let _enter = span.enter();
 
         for check in checks {
-            info!(":{:?}", check);
+            info!(
+                "check {:?} {} {}",
+                check.status,
+                check.name,
+                check.details_url.as_ref().unwrap_or(&String::from("-"))
+            );
+            debug!("{:?}", check);
 
             let check_create_attempt = self
                 .github_vend