feat: Update Main workflow + Action

Author: GeekMasher

action.yml

@@ -17,9 +17,11 @@ inputs:
     required: true
   packs:
     description: Query Packs to use
-  codeql_version:
+  codeql-version:
     description: CodeQL Version
     default: latest
+  working-directory:
+    description: Working Directory
   attestation:
     description: Attestation
     default: 'false'

src/action.rs

@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+use std::path::PathBuf;
+
 use anyhow::{Context, Result};
 use ghactions::prelude::*;
 use ghactions_core::repository::reference::RepositoryReference as Repository;
@@ -41,22 +43,49 @@ pub struct Action {
     packs: Vec<String>,
 
     /// CodeQL Version
-    #[input(description = "CodeQL Version", default = "latest")]
+    #[input(
+        description = "CodeQL Version",
+        rename = "codeql-version",
+        default = "latest"
+    )]
     codeql_version: String,
 
+    /// Working Directory (defualt: `./`)
+    #[input(
+        description = "Working Directory",
+        rename = "working-directory",
+        default = "./"
+    )]
+    working_directory: String,
+
     /// Attestation
     #[input(description = "Attestation", default = "false")]
     attestation: bool,
 
     /// Version of the extractor to use
     #[output(description = "Version of the extractor to use")]
     version: String,
+
     /// Path to the extractor
     #[output(description = "Path to the extractor")]
     extractor_path: String,
 }
 
 impl Action {
+    pub fn working_directory(&self) -> Result<PathBuf> {
+        if self.working_directory.is_empty() {
+            log::debug!("No working directory provided, using the current directory");
+            return std::env::current_dir().context("Failed to get current directory");
+        }
+        log::debug!("Using the provided working directory");
+        Ok(std::path::PathBuf::from(&self.working_directory)
+            .canonicalize()
+            .context(format!(
+                "Failed to get working directory `{}`",
+                self.working_directory
+            ))?)
+    }
+
     /// Gets the repository to use for the extractor. If the repository is not provided,
     /// it will use the repository that the action is running in.
     pub fn extractor_repository(&self) -> Result<Repository> {

src/extractors.rs

@@ -79,18 +79,15 @@ pub async fn fetch_extractor(
         log::info!("No attestation requested");
     }
 
-    if extractor_pack.exists() {
-        log::info!("Removing existing asset {:?}", extractor_pack);
-        std::fs::remove_dir_all(&extractor_pack)?;
-    }
-
-    log::info!("Extracting asset to {:?}", extractor_path);
-    toolcache
-        .extract_archive(&extractor_tarball, &output)
-        .await?;
+    if !extractor_pack.exists() {
+        log::info!("Extracting asset to {:?}", extractor_path);
+        toolcache
+            .extract_archive(&extractor_tarball, &output)
+            .await?;
 
-    if !extractor_path.exists() {
-        return Err(anyhow::anyhow!("Extractor not found"));
+        if !extractor_path.exists() {
+            return Err(anyhow::anyhow!("Extractor not found"));
+        }
     }
 
     Ok(extractor_pack.canonicalize()?)

src/main.rs

@@ -87,23 +87,32 @@ async fn main() -> Result<()> {
 
     groupend!();
 
-    let databases = PathBuf::from("./.codeql");
+    let cwd = action
+        .working_directory()
+        .context("Failed to get working directory")?;
+    let databases = cwd.join(".codeql");
     let sarif_output = databases.join("results");
 
     std::fs::create_dir_all(&sarif_output).context("Failed to create results directory")?;
 
     for language in action.languages() {
-        let group = format!("Running {} extractor", language.language());
-        group!(group);
+        group!(format!("Running {} extractor", language.language()));
 
         log::info!("Running extractor for language :: {}", language);
 
         let database_path = databases.join(format!("db-{}", language));
+        log::info!("Database Path :: {:?}", database_path);
+        if database_path.exists() {
+            std::fs::remove_dir_all(&database_path).with_context(|| {
+                format!("Failed to remove database directory {:?}", database_path)
+            })?;
+        }
+
         let sarif_path = sarif_output.join(format!("{}-results.sarif", language.language()));
 
-        let database = CodeQLDatabase::init()
+        let mut database = CodeQLDatabase::init()
             .name(action.get_repository_name()?)
-            .source(".".to_string())
+            .source(cwd.display().to_string())
             .path(database_path.display().to_string())
             .language(language.language())
             .build()
@@ -116,7 +125,7 @@ async fn main() -> Result<()> {
             .create()
             .await
             .context("Failed to create database")?;
-        log::info!("Created database :: {:?}", database);
+        log::debug!("Created database :: {:?}", database);
 
         // TODO: Queries
         let queries = CodeQLQueries::from(format!(
@@ -126,7 +135,8 @@ async fn main() -> Result<()> {
         ));
         log::info!("Queries :: {:?}", queries);
 
-        log::info!("Running analysis...");
+        groupend!();
+        group!(format!("Running {} analysis", language.language()));
         match codeql
             .database(&database)
             .queries(queries)
@@ -145,6 +155,10 @@ async fn main() -> Result<()> {
             }
         }
 
+        // Reload the database to get analysis info
+        database.reload()?;
+        log::info!("CodeQL Database LoC :: {}", database.lines_of_code());
+
         log::info!("Analysis complete :: {:?}", database);
         groupend!();
     }