Improved output & new Release GitHub action

balain · balain · commit 862902b8a75d · 2024-12-27T21:40:00.000-05:00
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -1,29 +1,40 @@
 # .github/workflows/release.yml
 
 on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
+  release:
+    types:
+      - created
 
 jobs:
-  release:
-    name: release ${{ matrix.target }}
+  linux_windows:
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: x86_64-pc-windows-gnu
-            archive: zip
-          - target: x86_64-unknown-linux-musl
-            archive: tar.gz tar.xz tar.zst
     steps:
-      - uses: actions/checkout@master
-      - name: Compile and release
-        uses: rust-build/rust-build.action@v1.4.5
+      - name: Checkout the repository
+        uses: actions/checkout@v2
+
+      - name: Install Linux and Windows Cross Compilers
+        run: sudo apt-get install --yes --no-install-recommends musl-tools gcc-mingw-w64-x86-64-win32
+
+      - name: Install rustup targets
+        run: rustup target add x86_64-unknown-linux-musl x86_64-pc-windows-gnu
+
+      - name: Build the executable
+        run: cargo build --release --target x86_64-unknown-linux-musl --target x86_64-pc-windows-gnu
+
+      - name: Tar x86_64 binary
+        run: tar -czvf fingerprinter-rs-gnu-linux-x86_64.tar.gz -C target/x86_64-unknown-linux-musl/release fingerprinter-rs
+
+      - name: Zip windows binary
+        run: zip -j fingerprinter-rs-windows.zip target/x86_64-pc-windows-gnu/release/fingerprinter-rs.exe
+
+      - name: Generate SHA256 checksums
+        run: |
+          shasum -a 256 fingerprinter-rs-gnu-linux-x86_64.tar.gz > fingerprinter-rs-gnu-linux-x86_64.tar.gz.sha256
+          shasum -a 256 fingerprinter-rs-windows.zip > fingerprinter-rs-windows.zip.sha256
+
+      - name: Upload release binaries
+        uses: alexellis/upload-assets@0.4.0
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ github.token }}
         with:
-          RUSTTARGET: ${{ matrix.target }}
-          ARCHIVE_TYPES: ${{ matrix.archive }}
+          asset_paths: '["fingerprinter-rs-gnu-linux-x86_64.tar.gz", "fingerprinter-rs-windows.zip", "fingerprinter-rs-gnu-linux-x86_64.tar.gz.sha256", "fingerprinter-rs-windows.zip.sha256"]'
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,24 +1,24 @@
 [package]
 name = "fingerprinter-rs"
-version = "0.1.0"
+version = "0.1.3"
 edition = "2021"
 
 [dependencies]
-clap = { version = "4.5.9", features = ["derive"] }
+clap = { version = "4.5.20", features = ["derive"] }
 hex-literal = "0.4.1"
 jwalk = "0.8.1"
 rayon = "1.10.0"
 sha2 = "0.10.8"
 walkdir = "2.5.0"
 xxhash-rust = { version = "0.8.12", features = ["xxh3"] }
 
-serde_json = "1.0"
+serde_json = "1.0.132"
 serde = { version = "1.0.209", features = ["derive"] }
 chrono = "0.4.38"
 
 # https://stackoverflow.com/a/54842093
 [profile.release]
-opt-level = 'z' # Optimize for size.
+opt-level =  'z' # Optimize for size.
 lto = true
 codegen-units=1
 panic = 'abort'
diff --git a/src/main.rs b/src/main.rs
@@ -19,18 +19,18 @@ use sha2::{Digest, Sha256, Sha256VarCore};
 #[allow(unused_imports)]
 use xxhash_rust::xxh3::xxh3_64;
 
-use std::env;
 use std::fs::*;
 use std::io;
-use std::io::{Read,Write};
+use std::io::{Read, Write};
 #[allow(unused_imports)]
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
-use std::time::{Duration, Instant};
-
+use std::time::{Duration, Instant, UNIX_EPOCH};
+use std::{env, fs};
+use chrono::{DateTime, Local};
+use serde::Serialize;
 #[allow(unused_imports)]
 use serde_json::{json, Value};
-use serde::Serialize;
 
 /// Simple path processor
 #[derive(Parser, Debug)]
@@ -50,16 +50,20 @@ struct Args {
 struct FileRecordSha256 {
     file: String,
     hash: Output<Sha256VarCore>,
+    timestamp_mod: FileRecordsTimestamps,
+    // timestamp_cre: FileRecordsTimestamps,
 }
 
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
 #[allow(dead_code)]
 struct FileRecordXxhash {
     file: String,
-    hash: u64
+    hash: u64,
+    timestamp_mod: FileRecordsTimestamps,
+    // timestamp_cre: FileRecordsTimestamps,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Debug, Clone, Eq, Ord, PartialEq, PartialOrd)]
 struct FileRecordsTimestamps {
     epoch: u128,
     iso8601: String,
@@ -93,7 +97,7 @@ fn visit(path: &Path, cb: &mut dyn FnMut(PathBuf), exclude: Vec<&str>) -> io::Re
         // Only include files that don't have a component in the exclude vector
         // logic from: https://stackoverflow.com/a/29504547
         let match_count = components
-            .iter()
+            .par_iter()
             .filter(|&x| exclude.contains(&x.to_str().unwrap()))
             .count();
         if match_count == 0 {
@@ -142,7 +146,8 @@ fn main() {
 
         // To switch from Sha256 <-> Xxhash: 4 steps - #2: Set res to the right output
         // let res: Result<(&str, Output<Sha256VarCore>), bool> = match f2 { // Sha256
-        let res: Result<(&str, u64), bool> = match f2 { // xxhash
+        let res: Result<(&str, u64), bool> = match f2 {
+            // xxhash
             #[allow(unused_mut)]
             Ok(mut f2) => {
                 // To switch from Sha256 <-> Xxhash: 4 steps - #3: Change the implementation block
@@ -165,20 +170,22 @@ fn main() {
 
                 // Save full path?
                 // Working relative path
-                let filename = <PathBuf as AsRef<Path>>::as_ref(f).to_str().unwrap_or_default();
+                let filename = <PathBuf as AsRef<Path>>::as_ref(&f)
+                    .to_str()
+                    .unwrap_or_default();
                 // Convert to absolute path
                 // let filenameref = <PathBuf as AsRef<Path>>::as_ref(f);
                 // let filename = filenameref.clone().canonicalize().unwrap().to_str().unwrap_or_default();
-                    // .clone().canonicalize().unwrap().to_str().unwrap_or_default();
+                // .clone().canonicalize().unwrap().to_str().unwrap_or_default();
                 // let fullpath = Path::new(filename.to_owned().as_str()).canonicalize().unwrap().to_str().unwrap_or_default();
                 // TODO: Fix check for save_full_path argument
                 // if args.safe_full;path {
-                    // Result::Ok((Path::new(fullpath.clone()).clone().canonicalize().unwrap().to_str().unwrap(),
-                    //     xxhash_rust::xxh3::xxh3_64(&buffer)))
-                    // Result::Ok((filename, xxhash_rust::xxh3::xxh3_64(&buffer)))
+                // Result::Ok((Path::new(fullpath.clone()).clone().canonicalize().unwrap().to_str().unwrap(),
+                //     xxhash_rust::xxh3::xxh3_64(&buffer)))
+                // Result::Ok((filename, xxhash_rust::xxh3::xxh3_64(&buffer)))
                 //
                 // } else { // Only save relative path
-                    Result::Ok((filename, xxhash_rust::xxh3::xxh3_64(&buffer)))
+                Result::Ok((filename, xxhash_rust::xxh3::xxh3_64(&buffer)))
                 // }
             }
             Err(ref e) => {
@@ -187,45 +194,67 @@ fn main() {
             }
         };
         if res.is_ok() {
-            // Create a new struct instance and populate with filename and filehash
-            // To switch from Sha256 <-> Xxhash: 4 steps - #4: Change the record hash impl
-            // Sha256
-            //     let frs = FileRecordSha256 {
-            //         filename: res.unwrap().0.to_owned(),
-            //         filehash: res.unwrap().1,
-            //     };
-            //     filelist.lock().unwrap().push(frs);
+            let metadata =
+                fs::metadata(res.unwrap().0).expect("Unable to get metadata for file: @203");
+            if let Ok(modtime) = metadata.modified() {
+                let modtimemillis = modtime.duration_since(UNIX_EPOCH).unwrap().as_millis();
+                // let cretimemillis = metadata.created().unwrap().duration_since(UNIX_EPOCH).unwrap().as_millis();
+                // Create a new struct instance and populate with filename and filehash
+                // To switch from Sha256 <-> Xxhash: 4 steps - #4: Change the record hash impl
+                // Sha256
+                //     let frs = FileRecordSha256 {
+                //         filename: res.unwrap().0.to_owned(),
+                //         filehash: res.unwrap().1,
+                //         timestamp_mod: FileRecordsTimestamps {
+                //             epoch: time.duration_since(UNIX_EPOCH).unwrap().as_millis(),
+                //             iso8601: DateTime::from_timestamp_millis(time.duration_since(UNIX_EPOCH).unwrap().as_millis() as i64).expect("Unable to parse timestamp").to_rfc3339(),
+                //         },
+                //     };
+                //     filelist.lock().unwrap().push(frs);
+
+                // Xxhash
 
-            // Xxhash
-            let frs = FileRecordXxhash {
-                file: res.unwrap().0.to_owned(),
-                hash: res.unwrap().1,
-            };
-            filelist.lock().unwrap().push(frs);
+                let frs = FileRecordXxhash {
+                    file: res.unwrap().0.to_owned(),
+                    hash: res.unwrap().1,
+                    timestamp_mod: FileRecordsTimestamps {
+                        epoch: modtimemillis,
+                        iso8601: DateTime::from_timestamp_millis(modtimemillis as i64).expect("Unable to parse timestamp").with_timezone(&Local::now().timezone()).to_rfc3339(),
+                    },
+                    // timestamp_cre: FileRecordsTimestamps {
+                    //     epoch: cretimemillis,
+                    //     iso8601: DateTime::from_timestamp_millis(cretimemillis as i64).expect("Unable to parse timestamp").with_timezone(&Local::now().timezone()).to_rfc3339(),
+                    // },
+                };
+                filelist.lock().unwrap().push(frs);
+            }
         }
     });
 
     // Now sort and print vector (filelist)
     // TODO: Avoid creating a new variable to hold the list
     let mut fls2 = filelist.lock().unwrap().to_vec();
     fls2.sort(); // It just works!
-    let path_info = PathInfo{
+    let path_info = PathInfo {
         base: path.canonicalize().unwrap().to_str().unwrap().to_owned(),
         cmdline: args.path.clone(),
-        run_from: env::current_dir().unwrap().to_str().unwrap().to_owned()
+        run_from: env::current_dir().unwrap().to_str().unwrap().to_owned(),
     };
     let file_record: FileRecordsXxhash = FileRecordsXxhash {
         path: path_info,
         updated_on: get_time().unwrap(),
         count: fls2.len(),
-        files: fls2.clone()
+        files: fls2.clone(),
     };
     let file_record_json = serde_json::to_string(&file_record).unwrap();
     // for i2 in fls2.iter() {
     //     println!("{:?} == {:x}", i2.filename, i2.filehash);
     // }
 
-    File::create(args.output).unwrap().write_all(file_record_json.as_bytes()).unwrap();
+    File::create(args.output)
+        .unwrap()
+        .write_all(file_record_json.as_bytes())
+        .unwrap();
 
     let dur: Duration = start.elapsed(); // End timer
     eprintln!("Time elapsed: {:?}", dur); // Show elapsed time to STDERR
@@ -235,8 +264,8 @@ fn get_time() -> Result<FileRecordsTimestamps, std::io::Error> {
     use std::time::{SystemTime, UNIX_EPOCH};
 
     /* std::time attempt - can't format rfc3339 :(
-       so switched to chrono
-     */
+      so switched to chrono
+    */
     // let start = SystemTime::now();
     // let since_epoch = start
     //     .duration_since(UNIX_EPOCH)
@@ -247,10 +276,13 @@ fn get_time() -> Result<FileRecordsTimestamps, std::io::Error> {
     //     // (SystemTime::duration_from_millis(since_epoch).to_rfc3339()).to_string(),
     // })
 
-    use chrono::{Local};
+    use chrono::Local;
 
     Ok(FileRecordsTimestamps {
-        epoch: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis(),
+        epoch: SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_millis(),
         iso8601: Local::now().to_rfc3339(),
     })
 }
