Make get_collector_config return Option<CollectorConfig>

Since the config can be missing.

Author: Kobzol

collector/src/bin/collector.rs

@@ -1340,8 +1340,9 @@ Make sure to modify `{dir}/perf-config.json` if the category/artifact don't matc
 
             // Obtain the configuration and validate that it matches the
             // collector's setup
-            let collector_config: database::CollectorConfig =
-                rt.block_on(conn.get_collector_config(&collector_name))?;
+            let collector_config: database::CollectorConfig = rt
+                .block_on(conn.get_collector_config(&collector_name))?
+                .unwrap();
 
             let collector_target = collector_config.target();
             if collector_target.as_str() != target {

database/src/pool.rs

@@ -243,10 +243,13 @@ pub trait Connection: Send + Sync {
         is_active: bool,
     ) -> anyhow::Result<CollectorConfig>;
 
-    /// Get the confiuguration for a collector by the name of the collector
-    async fn get_collector_config(&self, collector_name: &str) -> anyhow::Result<CollectorConfig>;
+    /// Get the configuration for a collector by its name.
+    async fn get_collector_config(
+        &self,
+        collector_name: &str,
+    ) -> anyhow::Result<Option<CollectorConfig>>;
 
-    /// Dequeue benchmark job
+    /// Dequeues a single job for the given collector, target and benchmark set.
     async fn dequeue_benchmark_job(
         &self,
         collector_name: &str,
@@ -775,9 +778,9 @@ mod tests {
         run_postgres_test(|ctx| async {
             let db = ctx.db_client().connection().await;
 
-            let collector_config_result = db.get_collector_config("collector-1").await;
+            let collector_config_result = db.get_collector_config("collector-1").await.unwrap();
 
-            assert!(collector_config_result.is_err());
+            assert!(collector_config_result.is_none());
 
             Ok(ctx)
         })
@@ -789,17 +792,20 @@ mod tests {
         run_postgres_test(|ctx| async {
             let db = ctx.db_client().connection().await;
 
-            let insert_config_result = db
+            let inserted_config = db
                 .add_collector_config("collector-1", &Target::X86_64UnknownLinuxGnu, 1, true)
-                .await;
-            assert!(insert_config_result.is_ok());
+                .await
+                .unwrap();
 
-            let get_config_result = db.get_collector_config("collector-1").await;
-            assert!(get_config_result.is_ok());
+            let config = db
+                .get_collector_config("collector-1")
+                .await
+                .unwrap()
+                .expect("collector config not found");
 
             // What we entered into the database should be identical to what is
             // returned from the database
-            assert_eq!(insert_config_result.unwrap(), get_config_result.unwrap());
+            assert_eq!(inserted_config, config);
             Ok(ctx)
         })
         .await;
@@ -880,7 +886,7 @@ mod tests {
             );
             assert_eq!(
                 benchmark_job.benchmark_set(),
-                collector_config.benchmark_set()
+                *collector_config.benchmark_set()
             );
             assert_eq!(
                 benchmark_job.collector_name().unwrap(),

database/src/pool/postgres.rs

@@ -1783,10 +1783,13 @@ where
         Ok(collector_config)
     }
 
-    async fn get_collector_config(&self, collector_name: &str) -> anyhow::Result<CollectorConfig> {
+    async fn get_collector_config(
+        &self,
+        collector_name: &str,
+    ) -> anyhow::Result<Option<CollectorConfig>> {
         let row = self
             .conn()
-            .query_one(
+            .query_opt(
                 "SELECT
                     target,
                     benchmark_set,
@@ -1801,15 +1804,19 @@ where
             )
             .await?;
 
-        let collector_config = CollectorConfig {
-            name: collector_name.into(),
-            target: Target::from_str(&row.get::<_, String>(0)).map_err(|e| anyhow::anyhow!(e))?,
-            benchmark_set: BenchmarkSet(row.get::<_, i32>(1) as u32),
-            is_active: row.get::<_, bool>(2),
-            last_heartbeat_at: row.get::<_, DateTime<Utc>>(3),
-            date_added: row.get::<_, DateTime<Utc>>(4),
-        };
-        Ok(collector_config)
+        Ok(row
+            .map(|row| {
+                anyhow::Ok(CollectorConfig {
+                    name: collector_name.into(),
+                    target: Target::from_str(row.get::<_, &str>(0))
+                        .map_err(|e| anyhow::anyhow!(e))?,
+                    benchmark_set: BenchmarkSet(row.get::<_, i32>(1) as u32),
+                    is_active: row.get::<_, bool>(2),
+                    last_heartbeat_at: row.get::<_, DateTime<Utc>>(3),
+                    date_added: row.get::<_, DateTime<Utc>>(4),
+                })
+            })
+            .transpose()?)
     }
 
     async fn dequeue_benchmark_job(

database/src/pool/sqlite.rs

@@ -1331,7 +1331,10 @@ impl Connection for SqliteConnection {
             .collect::<Result<_, _>>()?)
     }
 
-    async fn get_collector_config(&self, _collector_name: &str) -> anyhow::Result<CollectorConfig> {
+    async fn get_collector_config(
+        &self,
+        _collector_name: &str,
+    ) -> anyhow::Result<Option<CollectorConfig>> {
         no_queue_implementation_abort!()
     }