103 lines
3.7 KiB
Rust
103 lines
3.7 KiB
Rust
use anyhow::{
|
|
Context,
|
|
Result,
|
|
};
|
|
use chrono::{
|
|
Utc,
|
|
};
|
|
use clap::{
|
|
Parser,
|
|
};
|
|
use flake_tracker::{
|
|
flake::{
|
|
FlakeLocksNodeInputs,
|
|
FlakeMetadata,
|
|
FlakeUri,
|
|
},
|
|
};
|
|
use sqlx::{
|
|
sqlite::SqlitePoolOptions,
|
|
};
|
|
use std::process::Command;
|
|
|
|
#[derive(Parser)]
|
|
#[command(version, about, long_about = None)]
|
|
struct Cli {
|
|
flake_uri: String,
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<()> {
|
|
let cli = Cli::parse();
|
|
|
|
let scan_time = Utc::now().timestamp();
|
|
|
|
let db = SqlitePoolOptions::new().connect("sqlite://flake-tracker.db").await?;
|
|
|
|
let flake_metadata_raw = Command::new("nix")
|
|
.arg("flake")
|
|
.arg("metadata")
|
|
.arg("--json")
|
|
.arg(cli.flake_uri)
|
|
.output()
|
|
.context("Failed to fetch flake metadata")?;
|
|
|
|
let flake_metadata: FlakeMetadata = serde_json::from_slice(&flake_metadata_raw.stdout)
|
|
.context("Failed to parse flake metadata")?;
|
|
|
|
sqlx::query("INSERT INTO revisions (revision_uri, flake_uri, nix_store_path, nar_hash, last_modified, tracker_last_scanned)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(revision_uri) DO UPDATE SET
|
|
flake_uri=excluded.flake_uri,
|
|
nix_store_path=excluded.nix_store_path,
|
|
nar_hash=excluded.nar_hash,
|
|
last_modified=excluded.last_modified,
|
|
tracker_last_scanned=excluded.tracker_last_scanned
|
|
")
|
|
.bind(&flake_metadata.locked.flake_uri()?)
|
|
.bind(&flake_metadata.resolved.flake_uri()?)
|
|
.bind(&flake_metadata.path)
|
|
.bind(&flake_metadata.locked.narHash)
|
|
.bind(&flake_metadata.locked.lastModified)
|
|
.bind(&scan_time)
|
|
.execute(&db).await?;
|
|
|
|
let locks_root_name = &flake_metadata.locks.root;
|
|
let locks_root_node = flake_metadata.locks.nodes.get(locks_root_name)
|
|
.context("Failed to get locks root node")?;
|
|
|
|
for (input_name, locks_input_name) in locks_root_node.inputs.clone().context("No inputs found for flake")? {
|
|
|
|
if let FlakeLocksNodeInputs::String(locks_input_name) = locks_input_name {
|
|
let locks_input_node = flake_metadata.locks.nodes.get(&locks_input_name)
|
|
.context("Failed to find lock of input")?;
|
|
|
|
sqlx::query("INSERT INTO inputs (revision_uri, input_name, locked_revision_uri, locked_flake_uri, locked_nar_hash, last_modified)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(revision_uri, input_name) DO UPDATE SET
|
|
locked_revision_uri=excluded.locked_revision_uri,
|
|
locked_flake_uri=excluded.locked_flake_uri,
|
|
locked_nar_hash=excluded.locked_nar_hash,
|
|
last_modified=excluded.last_modified
|
|
")
|
|
.bind(flake_metadata.locked.flake_uri()?)
|
|
.bind(input_name)
|
|
.bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.flake_uri()?)
|
|
.bind(locks_input_node.original.clone().context("Unexpected missing lock")?.flake_uri()?)
|
|
.bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.narHash)
|
|
.bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.lastModified)
|
|
.execute(&db).await?;
|
|
|
|
sqlx::query("INSERT INTO revisions (revision_uri, flake_uri)
|
|
VALUES (?, ?)
|
|
ON CONFLICT(revision_uri) DO NOTHING
|
|
")
|
|
.bind(locks_input_node.locked.clone().context("Unexpected missing lock")?.flake_uri()?)
|
|
.bind(locks_input_node.original.clone().context("Unexpected missing lock")?.flake_uri()?)
|
|
.execute(&db).await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|