Store artifact files in the jobs build directory

This will delete them once the job is completed.

Author: ColinKinloch

src/binaries.rs

@@ -1,9 +1,12 @@
-use std::{collections::HashMap, io, path::PathBuf};
+use std::{
+    collections::HashMap,
+    io,
+    path::{Path, PathBuf},
+};
 
 use color_eyre::eyre::{Report, Result, WrapErr};
 use futures_util::TryStreamExt;
 use open_build_service_api as obs;
-use tempfile::NamedTempFile;
 use tokio::fs::File as AsyncFile;
 use tokio_util::compat::FuturesAsyncReadCompatExt;
 use tracing::{info_span, instrument, Instrument};
@@ -13,6 +16,7 @@ use crate::retry::retry_request;
 #[instrument(skip(client))]
 pub async fn download_binaries(
     client: obs::Client,
+    build_dir: &Path,
     project: &str,
     package: &str,
     repository: &str,
@@ -33,7 +37,11 @@ pub async fn download_binaries(
             let binary = binary.clone();
             let client = client.clone();
             async move {
-                let (file, path) = NamedTempFile::new()?.keep()?;
+                let (file, path) = tempfile::Builder::new()
+                    .prefix("obs-glr-")
+                    .suffix(".bin")
+                    .tempfile_in(build_dir)?
+                    .keep()?;
 
                 let stream = client
                     .project(project.to_owned())
@@ -77,6 +85,10 @@ mod tests {
 
     #[tokio::test]
     async fn test_build_results() {
+        let build_dir = tempfile::Builder::new()
+            .prefix("obs-glr-test-bin-")
+            .tempdir()
+            .unwrap();
         let test_file = "test.bin";
         let test_contents = "123980238";
 
@@ -113,7 +125,15 @@ mod tests {
         let client = create_default_client(&mock);
 
         let mut binaries = assert_ok!(
-            download_binaries(client, TEST_PROJECT, TEST_PACKAGE_1, TEST_REPO, TEST_ARCH_1).await
+            download_binaries(
+                client,
+                build_dir.path(),
+                TEST_PROJECT,
+                TEST_PACKAGE_1,
+                TEST_REPO,
+                TEST_ARCH_1
+            )
+            .await
         );
         assert_eq!(binaries.len(), 1);
 

src/handler.rs

@@ -4,7 +4,7 @@ use std::{
     fs::File,
     hash::{Hash, Hasher},
     io::SeekFrom,
-    path::PathBuf,
+    path::{Path, PathBuf},
 };
 
 use async_trait::async_trait;
@@ -19,7 +19,6 @@ use gitlab_runner::{
 };
 use open_build_service_api as obs;
 use serde::{Deserialize, Serialize};
-use tempfile::NamedTempFile;
 use tokio::{fs::File as AsyncFile, io::AsyncSeekExt};
 use tokio_util::{compat::TokioAsyncReadCompatExt, io::ReaderStream};
 use tracing::{debug, error, instrument, warn};
@@ -242,9 +241,12 @@ impl UploadableFile for ObsArtifact {
 
 impl ObsBuildInfo {
     #[instrument]
-    fn save(&self) -> Result<PathBuf> {
-        let mut temp_file =
-            NamedTempFile::new().wrap_err("Failed to create file for build info")?;
+    fn save(&self, dir: &Path) -> Result<PathBuf> {
+        let mut temp_file = tempfile::Builder::new()
+            .prefix("obs-glr-build-info-")
+            .suffix(".yml")
+            .tempfile_in(dir)
+            .wrap_err("Failed to create file for build info")?;
         serde_yaml::to_writer(temp_file.as_file_mut(), self)
             .wrap_err("Failed to write build yaml to file")?;
         let (_file, path) = temp_file
@@ -373,7 +375,10 @@ impl ObsJobHandler {
         debug!("Saving initial build info: {:?}", build_info);
 
         let build_info_2 = build_info.clone();
-        let build_info_path = tokio::task::spawn_blocking(move || build_info_2.save()).await??;
+        let build_info_path = {
+            let build_dir = self.job.build_dir().to_owned();
+            tokio::task::spawn_blocking(move || build_info_2.save(&build_dir)).await??
+        };
 
         self.artifacts.replace(ObsArtifact::new_file(
             args.build_info_out.clone(),
@@ -454,7 +459,10 @@ impl ObsJobHandler {
         };
         debug!("Saving complete build info: {:?}", build_info);
 
-        let build_info_path = tokio::task::spawn_blocking(move || build_info.save()).await??;
+        let build_info_path = {
+            let build_dir = self.job.build_dir().to_owned();
+            tokio::task::spawn_blocking(move || build_info.save(&build_dir)).await??
+        };
         self.artifacts
             .replace(ObsArtifact::new_file(args.build_info_out, build_info_path));
 
@@ -524,7 +532,7 @@ impl ObsJobHandler {
             .await?;
         debug!("Completed with: {:?}", completion);
 
-        let log_file = monitor.download_build_log().await?;
+        let log_file = monitor.download_build_log(self.job.build_dir()).await?;
         self.artifacts.replace(ObsArtifact::new_file(
             args.build_log_out.clone(),
             log_file.path.clone(),
@@ -575,6 +583,7 @@ impl ObsJobHandler {
     async fn run_download_binaries(&mut self, args: DownloadBinariesAction) -> Result<()> {
         let binaries = download_binaries(
             self.client.clone(),
+            self.job.build_dir(),
             &args.project,
             &args.package,
             &args.repository,

src/monitor.rs

@@ -1,11 +1,13 @@
-use std::{path::PathBuf, time::Duration};
+use std::{
+    path::{Path, PathBuf},
+    time::Duration,
+};
 
 use color_eyre::eyre::{ensure, eyre, Context, Report, Result};
 use derivative::*;
 use futures_util::stream::StreamExt;
 use gitlab_runner::outputln;
 use open_build_service_api as obs;
-use tempfile::NamedTempFile;
 use tokio::{
     fs::File as AsyncFile,
     io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt},
@@ -243,11 +245,14 @@ impl ObsMonitor {
     }
 
     #[instrument]
-    pub async fn download_build_log(&self) -> Result<LogFile> {
+    pub async fn download_build_log(&self, dir: &Path) -> Result<LogFile> {
         const LOG_LEN_TO_CHECK_FOR_MD5: u64 = 2500;
 
         let (mut file, path) = retry_request(|| async {
-            let temp_file = NamedTempFile::new()?;
+            let temp_file = tempfile::Builder::new()
+                .prefix("obs-glr-build-log-")
+                .suffix(".txt")
+                .tempfile_in(dir)?;
             let (file, path) = temp_file.keep()?;
             let mut file = AsyncFile::from_std(file);
             let mut stream = self
@@ -371,6 +376,10 @@ mod tests {
 
     #[tokio::test]
     async fn test_download_log() {
+        let build_dir = tempfile::Builder::new()
+            .prefix("obs-glr-test-mon-")
+            .tempdir()
+            .unwrap();
         let srcmd5 = random_md5();
         let log_content = format!(
             "srcmd5 '{}'\n
@@ -428,7 +437,7 @@ mod tests {
             },
         );
 
-        let log_file = assert_ok!(monitor.download_build_log().await);
+        let log_file = assert_ok!(monitor.download_build_log(build_dir.path()).await);
         assert_eq!(log_file.len, log_content.len() as u64);
 
         let mut log = "".to_owned();
@@ -450,7 +459,7 @@ mod tests {
             true,
         );
 
-        let err = assert_err!(monitor.download_build_log().await);
+        let err = assert_err!(monitor.download_build_log(build_dir.path()).await);
         assert!(err.to_string().contains("unavailable"));
     }