Add subcommands for getting and listing all default priorities

Author: Nemo157

src/bin/cratesfyi.rs

@@ -10,7 +10,8 @@ use docs_rs::cdn::CdnBackend;
 use docs_rs::db::{self, add_path_into_database, Overrides, Pool, PoolClient};
 use docs_rs::repositories::RepositoryStatsUpdater;
 use docs_rs::utils::{
-    get_config, queue_builder, remove_crate_priority, set_crate_priority, ConfigName,
+    get_config, get_crate_pattern_and_priority, list_crate_priorities, queue_builder,
+    remove_crate_priority, set_crate_priority, ConfigName,
 };
 use docs_rs::{
     start_web_server, BuildQueue, Config, Context, Index, Metrics, PackageKind, RustwideBuilder,
@@ -234,6 +235,14 @@ impl QueueSubcommand {
 
 #[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
 enum PrioritySubcommand {
+    /// Get priority for a crate
+    ///
+    /// (returns only the first matching pattern, there may be other matching patterns)
+    Get { crate_name: String },
+
+    /// List priorities for all patterns
+    List,
+
     /// Set all crates matching a pattern to a priority level
     Set {
         /// See https://www.postgresql.org/docs/current/functions-matching.html for pattern syntax
@@ -253,19 +262,37 @@ enum PrioritySubcommand {
 
 impl PrioritySubcommand {
     fn handle_args(self, ctx: BinContext) -> Result<()> {
+        let conn = &mut *ctx.conn()?;
         match self {
+            Self::List => {
+                for (pattern, priority) in list_crate_priorities(conn)? {
+                    println!("{pattern:>20} : {priority:>3}");
+                }
+            }
+
+            Self::Get { crate_name } => {
+                if let Some((pattern, priority)) =
+                    get_crate_pattern_and_priority(conn, &crate_name)?
+                {
+                    println!("{pattern} : {priority}");
+                } else {
+                    println!("No priority found for {crate_name}");
+                }
+            }
+
             Self::Set { pattern, priority } => {
-                set_crate_priority(&mut *ctx.conn()?, &pattern, priority)
+                set_crate_priority(conn, &pattern, priority)
                     .context("Could not set pattern's priority")?;
+                println!("Set pattern '{pattern}' to priority {priority}");
             }
 
             Self::Remove { pattern } => {
-                if let Some(priority) = remove_crate_priority(&mut *ctx.conn()?, &pattern)
+                if let Some(priority) = remove_crate_priority(conn, &pattern)
                     .context("Could not remove pattern's priority")?
                 {
-                    println!("Removed pattern with priority {priority}");
+                    println!("Removed pattern '{pattern}' with priority {priority}");
                 } else {
-                    println!("Pattern did not exist and so was not removed");
+                    println!("Pattern '{pattern}' did not exist and so was not removed");
                 }
             }
         }

src/utils/mod.rs

@@ -4,7 +4,10 @@ pub(crate) use self::cargo_metadata::{CargoMetadata, Package as MetadataPackage}
 pub(crate) use self::copy::copy_dir_all;
 pub use self::daemon::{start_daemon, watch_registry};
 pub(crate) use self::html::rewrite_lol;
-pub use self::queue::{get_crate_priority, remove_crate_priority, set_crate_priority};
+pub use self::queue::{
+    get_crate_pattern_and_priority, get_crate_priority, list_crate_priorities,
+    remove_crate_priority, set_crate_priority,
+};
 pub use self::queue_builder::queue_builder;
 pub(crate) use self::rustc_version::{get_correct_docsrs_style_file, parse_rustc_version};
 
@@ -62,7 +65,7 @@ pub fn set_config(
 ) -> anyhow::Result<()> {
     let name: &'static str = name.into();
     conn.execute(
-        "INSERT INTO config (name, value) 
+        "INSERT INTO config (name, value)
         VALUES ($1, $2)
         ON CONFLICT (name) DO UPDATE SET value = $2;",
         &[&name, &serde_json::to_value(value)?],

src/utils/queue.rs

@@ -5,22 +5,40 @@ use postgres::Client;
 
 const DEFAULT_PRIORITY: i32 = 0;
 
-/// Get the build queue priority for a crate
-pub fn get_crate_priority(conn: &mut Client, name: &str) -> Result<i32> {
+/// Get the build queue priority for a crate, returns the matching pattern too
+pub fn list_crate_priorities(conn: &mut Client) -> Result<Vec<(String, i32)>> {
+    Ok(conn
+        .query("SELECT pattern, priority FROM crate_priorities", &[])?
+        .into_iter()
+        .map(|r| (r.get(0), r.get(1)))
+        .collect())
+}
+
+/// Get the build queue priority for a crate with its matching pattern
+pub fn get_crate_pattern_and_priority(
+    conn: &mut Client,
+    name: &str,
+) -> Result<Option<(String, i32)>> {
     // Search the `priority` table for a priority where the crate name matches the stored pattern
     let query = conn.query(
-        "SELECT priority FROM crate_priorities WHERE $1 LIKE pattern LIMIT 1",
+        "SELECT pattern, priority FROM crate_priorities WHERE $1 LIKE pattern LIMIT 1",
         &[&name],
     )?;
 
     // If no match is found, return the default priority
     if let Some(row) = query.get(0) {
-        Ok(row.get(0))
+        Ok(Some((row.get(0), row.get(1))))
     } else {
-        Ok(DEFAULT_PRIORITY)
+        Ok(None)
     }
 }
 
+/// Get the build queue priority for a crate
+pub fn get_crate_priority(conn: &mut Client, name: &str) -> Result<i32> {
+    Ok(get_crate_pattern_and_priority(conn, name)?
+        .map_or(DEFAULT_PRIORITY, |(_, priority)| priority))
+}
+
 /// Set all crates that match [`pattern`] to have a certain priority
 ///
 /// Note: `pattern` is used in a `LIKE` statement, so it must follow the postgres like syntax