Merge pull request #279 from K900/maintenance

Boring maintenance work

Author: RaitoBezarius

Cargo.lock

@@ -26,9 +26,8 @@ name = "nix-index"
 name = "nix-locate"
 
 [dependencies]
-bincode = "1.3.3"
+bincode = { version = "2.0.1", features = ["serde"] }
 byteorder = "1.5.0"
-error-chain = "0.12.4"
 futures = "0.3.30"
 grep = "0.3.1"
 atty = "0.2.14"
@@ -38,22 +37,18 @@ indexmap = "2.2.6"
 owo-colors = { version = "4.0.0", features = ["supports-colors"] }
 rayon = "1.10.0"
 regex = "1.10.4"
-regex-syntax = "0.7.4"
-reqwest = { version = "0.12.3", features = [ "brotli" ] }
+regex-syntax = "0.8.5"
+reqwest = { version = "0.12.3", default-features = false, features = [ "brotli", "http2", "rustls-tls" ] }
 separator = "0.4.1"
 serde = { version = "1.0.198", features = [ "derive" ] }
 serde_bytes = "0.11.14"
 serde_json = "1.0.116"
+thiserror = "2.0.12"
 tokio-retry = "0.3.0"
-xdg = "2.5.2"
+xdg = "3.0.0"
 xml-rs = "0.8.20"
 xz2 = "0.1.7"
-zstd = { version = "0.12.4", features = [ "zstdmt" ] }
-
-[dependencies.hyper]
-features = ["client", "http1", "http2", "runtime", "stream"]
-version = "0.14.27"
-
+zstd = { version = "0.13.3", features = [ "zstdmt" ] }
 
 [dependencies.tokio]
 features = ["full"]
@@ -65,7 +60,7 @@ features = ["derive", "env"]
 
 [dependencies.rusqlite]
 features = ["backup"]
-version = "0.31.0"
+version = "0.37.0"
 
 [[example]]
 name = "nix-index-debug"

Cargo.toml

@@ -33,9 +33,7 @@
             lockFile = ./Cargo.lock;
           };
 
-          nativeBuildInputs = [ pkg-config ];
-          buildInputs = [ openssl curl sqlite ]
-            ++ lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.Security ];
+          buildInputs = [ sqlite ];
 
           postInstall = ''
             substituteInPlace command-not-found.sh \
@@ -66,18 +64,9 @@
         minimal = with nixpkgsFor.${system}; mkShell {
           name = "nix-index";
 
-          nativeBuildInputs = [
-            pkg-config
-          ];
-
-          buildInputs = [
-            openssl
-            sqlite
-          ] ++ lib.optionals stdenv.isDarwin [
-            darwin.apple_sdk.frameworks.Security
-          ];
+          nativeBuildInputs = [ pkg-config ];
 
-          env.LD_LIBRARY_PATH = lib.makeLibraryPath [ openssl ];
+          buildInputs = [ sqlite ];
         };
 
         default = with nixpkgsFor.${system}; mkShell {
@@ -87,10 +76,7 @@
 
           nativeBuildInputs = [ rustc cargo clippy rustfmt ];
 
-          env = {
-            LD_LIBRARY_PATH = lib.makeLibraryPath [ openssl ];
-            RUST_SRC_PATH = rustPlatform.rustLibSrc;
-          };
+          env.RUST_SRC_PATH = rustPlatform.rustLibSrc;
         };
       });
 

flake.lock

@@ -6,19 +6,20 @@ use std::path::PathBuf;
 use std::process;
 
 use clap::Parser;
-use error_chain::ChainedError;
 use futures::{future, StreamExt};
 use nix_index::files::{FileNode, FileType};
 use nix_index::hydra::Fetcher;
-use nix_index::listings::fetch_listings;
+use nix_index::listings;
 use nix_index::{errors::*, CACHE_URL};
-use rusqlite::{Connection, DatabaseName};
+use rusqlite::Connection;
 
 /// The main function of this module: creates a new command-not-found database.
 async fn update_index(args: &Args) -> Result<()> {
-    let fetcher = Fetcher::new(CACHE_URL.to_string()).map_err(ErrorKind::ParseProxy)?;
-    let connection =
-        Connection::open_in_memory().map_err(|_| ErrorKind::CreateDatabase(args.output.clone()))?;
+    let fetcher = Fetcher::new(CACHE_URL.to_string()).map_err(Error::ParseProxy)?;
+    let connection = Connection::open_in_memory().map_err(|e| Error::CreateDatabase {
+        path: args.output.clone(),
+        source: Box::new(e),
+    })?;
 
     connection
         .execute(
@@ -32,10 +33,15 @@ async fn update_index(args: &Args) -> Result<()> {
     "#,
             (),
         )
-        .map_err(|_| ErrorKind::CreateDatabase(args.output.clone()))?;
-
-    let debug_connection = Connection::open_in_memory()
-        .map_err(|_| ErrorKind::CreateDatabase(args.debug_output.clone()))?;
+        .map_err(|e| Error::CreateDatabase {
+            path: args.output.clone(),
+            source: Box::new(e),
+        })?;
+
+    let debug_connection = Connection::open_in_memory().map_err(|e| Error::CreateDatabase {
+        path: args.debug_output.clone(),
+        source: Box::new(e),
+    })?;
     debug_connection
         .execute(
             r#"
@@ -48,7 +54,10 @@ async fn update_index(args: &Args) -> Result<()> {
     "#,
             (),
         )
-        .map_err(|_| ErrorKind::CreateDatabase(args.debug_output.clone()))?;
+        .map_err(|e| Error::CreateDatabase {
+            path: args.debug_output.clone(),
+            source: Box::new(e),
+        })?;
 
     let systems = match &args.systems {
         Some(systems) => systems.iter().map(|x| Some(x.as_str())).collect(),
@@ -57,12 +66,12 @@ async fn update_index(args: &Args) -> Result<()> {
 
     eprint!("+ querying available packages");
     let (files, watch) =
-        fetch_listings(&fetcher, args.jobs, &args.nixpkgs, systems, args.show_trace)?;
+        listings::fetch(&fetcher, args.jobs, &args.nixpkgs, systems, args.show_trace)?;
 
     // Treat request errors as if the file list were missing
     let files = files.map(|r| {
         r.unwrap_or_else(|e| {
-            eprint!("\n{}", e.display_chain());
+            eprint!("\n{:?}", e);
             None
         })
     });
@@ -117,7 +126,7 @@ async fn update_index(args: &Args) -> Result<()> {
                             "insert or replace into Programs(name, system, package) values (?, ?, ?)",
                             (binary, system, attr),
                         )
-                        .map_err(|_| ErrorKind::CreateDatabase(args.output.clone()))?;
+                        .map_err(|e| Error::CreateDatabase { path: args.output.clone(), source: Box::new(e) })?;
                 }
 
                 if let Ok(debuginfo) = path.strip_prefix("/lib/debug/.build-id") {
@@ -139,7 +148,7 @@ async fn update_index(args: &Args) -> Result<()> {
                             "insert or replace into DebugInfo(build_id, url, filename) values (?, ?, ?)",
                             (build_id, format!("../{}", nar), path.to_string_lossy().strip_prefix('/')),
                         )
-                        .map_err(|_| ErrorKind::CreateDatabase(args.debug_output.clone()))?;
+                        .map_err(|e| Error::CreateDatabase { path: args.debug_output.clone(), source: Box::new(e) })?;
                 }
             }
         }
@@ -149,12 +158,18 @@ async fn update_index(args: &Args) -> Result<()> {
     eprint!("+ dumping index");
 
     connection
-        .backup(DatabaseName::Main, &args.output, None)
-        .map_err(|_| ErrorKind::CreateDatabase(args.output.clone()))?;
+        .backup("main", &args.output, None)
+        .map_err(|e| Error::CreateDatabase {
+            path: args.output.clone(),
+            source: Box::new(e),
+        })?;
 
     debug_connection
-        .backup(DatabaseName::Main, &args.debug_output, None)
-        .map_err(|_| ErrorKind::CreateDatabase(args.debug_output.clone()))?;
+        .backup("main", &args.debug_output, None)
+        .map_err(|e| Error::CreateDatabase {
+            path: args.debug_output.clone(),
+            source: Box::new(e),
+        })?;
 
     Ok(())
 }
@@ -192,15 +207,7 @@ async fn main() {
     let args = Args::parse();
 
     if let Err(e) = update_index(&args).await {
-        eprintln!("error: {}", e);
-
-        for e in e.iter().skip(1) {
-            eprintln!("caused by: {}", e);
-        }
-
-        if let Some(backtrace) = e.backtrace() {
-            eprintln!("backtrace: {:?}", backtrace);
-        }
+        eprintln!("error: {:?}", e);
         process::exit(2);
     }
 }

flake.nix

@@ -6,14 +6,13 @@ use std::path::PathBuf;
 use std::process;
 
 use clap::Parser;
-use error_chain::ChainedError;
 use futures::future::Either;
 use futures::{future, StreamExt};
 use nix_index::database::Writer;
 use nix_index::errors::*;
 use nix_index::files::FileTree;
 use nix_index::hydra::Fetcher;
-use nix_index::listings::{fetch_listings, try_load_paths_cache};
+use nix_index::listings::{self, try_load_paths_cache};
 use nix_index::package::StorePath;
 use nix_index::CACHE_URL;
 use separator::Separatable;
@@ -31,11 +30,11 @@ async fn update_index(args: &Args) -> Result<()> {
     };
 
     eprintln!("+ querying available packages");
-    let fetcher = Fetcher::new(CACHE_URL.to_string()).map_err(ErrorKind::ParseProxy)?;
+    let fetcher = Fetcher::new(CACHE_URL.to_string()).map_err(Error::ParseProxy)?;
     let (files, watch) = match cached {
         Some((f, w)) => (Either::Left(f), w),
         None => {
-            let (f, w) = fetch_listings(
+            let (f, w) = listings::fetch(
                 &fetcher,
                 args.jobs,
                 &args.nixpkgs,
@@ -49,7 +48,7 @@ async fn update_index(args: &Args) -> Result<()> {
     // Treat request errors as if the file list were missing
     let files = files.map(|r| {
         r.unwrap_or_else(|e| {
-            eprint!("\n{}", e.display_chain());
+            eprint!("\n{:?}", e);
             None
         })
     });
@@ -76,10 +75,17 @@ async fn update_index(args: &Args) -> Result<()> {
         eprint!(" (filtering by `{}`)", args.filter_prefix);
     }
     eprint!("\r");
-    fs::create_dir_all(&args.database)
-        .chain_err(|| ErrorKind::CreateDatabaseDir(args.database.clone()))?;
-    let mut db = Writer::create(args.database.join("files"), args.compression_level)
-        .chain_err(|| ErrorKind::CreateDatabase(args.database.clone()))?;
+    fs::create_dir_all(&args.database).map_err(|e| Error::CreateDatabaseDir {
+        path: args.database.clone(),
+        source: e,
+    })?;
+    let mut db =
+        Writer::create(args.database.join("files"), args.compression_level).map_err(|e| {
+            Error::CreateDatabase {
+                path: args.database.clone(),
+                source: Box::new(e),
+            }
+        })?;
 
     let mut results: Vec<(StorePath, String, FileTree)> = Vec::new();
     while let Some(entry) = files.next().await {
@@ -88,29 +94,38 @@ async fn update_index(args: &Args) -> Result<()> {
         }
         let (path, _, files) = entry;
         db.add(path, files, args.filter_prefix.as_bytes())
-            .chain_err(|| ErrorKind::WriteDatabase(args.database.clone()))?;
+            .map_err(|e| Error::WriteDatabase {
+                path: args.database.clone(),
+                source: e,
+            })?;
     }
     eprintln!();
 
     if args.path_cache {
         eprintln!("+ writing path cache");
-        let mut output = io::BufWriter::new(
-            File::create("paths.cache").chain_err(|| ErrorKind::WritePathsCache)?,
-        );
-        bincode::serialize_into(&mut output, &results).chain_err(|| ErrorKind::WritePathsCache)?;
+        let mut output = io::BufWriter::new(File::create("paths.cache").map_err(|e| {
+            Error::WritePathsCache {
+                source: Box::new(e),
+            }
+        })?);
+        bincode::serde::encode_into_std_write(&results, &mut output, bincode::config::standard())
+            .map_err(|e| Error::WritePathsCache {
+            source: Box::new(e),
+        })?;
     }
 
-    let index_size = db
-        .finish()
-        .chain_err(|| ErrorKind::WriteDatabase(args.database.clone()))?;
+    let index_size = db.finish().map_err(|e| Error::WriteDatabase {
+        path: args.database.clone(),
+        source: e,
+    })?;
     eprintln!("+ wrote index of {} bytes", index_size.separated_string());
 
     Ok(())
 }
 
 fn cache_dir() -> &'static OsStr {
-    let base = xdg::BaseDirectories::with_prefix("nix-index").unwrap();
-    let cache_dir = Box::new(base.get_cache_home());
+    let base = xdg::BaseDirectories::with_prefix("nix-index");
+    let cache_dir = Box::new(base.get_cache_home().unwrap());
     let cache_dir = Box::leak(cache_dir);
     cache_dir.as_os_str()
 }
@@ -160,15 +175,7 @@ async fn main() {
     let args = Args::parse();
 
     if let Err(e) = update_index(&args).await {
-        eprintln!("error: {}", e);
-
-        for e in e.iter().skip(1) {
-            eprintln!("caused by: {}", e);
-        }
-
-        if let Some(backtrace) = e.backtrace() {
-            eprintln!("backtrace: {:?}", backtrace);
-        }
+        eprintln!("error: {:?}", e);
         process::exit(2);
     }
 }