Implement tag rule manipulation in rebuildctl.

Author: Nihlus

daemon/src/lib.rs

@@ -110,7 +110,15 @@ pub async fn run_config(pool: db::Pool, config: Config, privkey: PrivateKey) ->
                                     .service(api::v1::create_worker_tag)
                                     .service(api::v1::delete_worker_tag),
                             )
-                            .service(scope("/tags").service(api::v1::get_tags)),
+                            .service(
+                                scope("/tags")
+                                    .service(api::v1::get_tags)
+                                    .service(api::v1::create_tag)
+                                    .service(api::v1::delete_tag)
+                                    .service(api::v1::get_tag_rules)
+                                    .service(api::v1::create_tag_rule)
+                                    .service(api::v1::delete_tag_rule),
+                            ),
                     ),
             )
     })

tools/src/args.rs

@@ -35,9 +35,12 @@ pub enum SubCommand {
     /// Queue related subcommands
     #[command(subcommand)]
     Queue(Queue),
-    // Worker related subcommands
+    /// Worker related subcommands
     #[command(subcommand)]
     Worker(WorkerCommand),
+    /// Tag related subcommands
+    #[command(subcommand)]
+    Tag(TagCommand),
     /// Generate shell completions
     Completions(Completions),
 }
@@ -213,29 +216,107 @@ pub enum WorkerCommand {
 
 #[derive(Debug, Parser)]
 pub enum WorkerTagCommand {
+    /// List tags attached to a worker
     List(WorkerTarget),
+
+    /// Set the tags attached to a worker
     Set(WorkerSetTags),
+
+    /// Add a single tag to a worker
     Add(WorkerTagTarget),
+
+    /// Remove a single tag from a worker
     Remove(WorkerTagTarget),
 }
 
 #[derive(Debug, Parser)]
 pub struct WorkerTarget {
+    /// The name of the worker
     pub name: String,
 }
 
 #[derive(Debug, Parser)]
 pub struct WorkerTagTarget {
+    /// The name of the worker
     pub name: String,
+
+    /// The name of the tag
     pub tag: String,
 }
 
 #[derive(Debug, Parser)]
 pub struct WorkerSetTags {
+    /// The name of the worker
     pub name: String,
+
+    /// The tags
     pub tags: Vec<String>,
 }
 
+#[derive(Debug, Parser)]
+pub enum TagCommand {
+    /// List registered tags
+    List,
+
+    /// Create a new tag
+    Create(TagTarget),
+
+    /// Delete a tag
+    Delete(TagTarget),
+
+    /// Operate on tag rules
+    #[command(subcommand)]
+    Rule(TagRuleCommand),
+}
+
+#[derive(Debug, Parser)]
+pub enum TagRuleCommand {
+    /// List rules for a tag
+    List(OptionalTagTarget),
+
+    /// Create a new tag rule
+    Create(CreateTagRuleCommand),
+
+    /// Delete a tag rule
+    Delete(TagRuleTarget),
+}
+
+#[derive(Debug, Parser)]
+pub struct TagTarget {
+    /// The name of the tag
+    pub tag: String,
+}
+
+#[derive(Debug, Parser)]
+pub struct OptionalTagTarget {
+    /// The name of the tag
+    pub tag: Option<String>,
+}
+
+#[derive(Debug, Parser)]
+pub struct CreateTagRuleCommand {
+    /// The name of the tag
+    pub tag: String,
+
+    /// The pattern to match source package names against. Must be compatible with SQLite's LIKE syntax.
+    #[arg(long)]
+    pub name_pattern: String,
+
+    /// The pattern to match source package versions against. Must be compatible with SQLite's LIKE syntax. Any version
+    /// will match if this pattern is omitted.
+    #[arg(long, default_missing_value(None))]
+    pub version_pattern: Option<String>,
+}
+
+#[derive(Debug, Parser)]
+pub struct TagRuleTarget {
+    /// The name of the tag
+    pub tag: String,
+
+    /// The ID of the rule
+    pub rule_id: i32,
+}
+
 #[derive(Debug, Parser)]
 pub struct Completions {
     pub shell: Shell,

tools/src/main.rs

@@ -8,8 +8,9 @@ use env_logger::Env;
 use glob::Pattern;
 use nom::AsBytes;
 use rebuilderd_common::api::v1::{
-    ArtifactStatus, BinaryPackage, BuildRestApi, IdentityFilter, OriginFilter, PackageReport,
-    PackageRestApi, Page, Priority, QueueJobRequest, QueueRestApi, Worker, WorkerRestApi,
+    ArtifactStatus, BinaryPackage, BuildRestApi, CreateTagRequest, CreateTagRuleRequest,
+    IdentityFilter, OriginFilter, PackageReport, PackageRestApi, Page, Priority, QueueJobRequest,
+    QueueRestApi, TagRestApi, Worker, WorkerRestApi,
 };
 use rebuilderd_common::api::Client;
 use rebuilderd_common::errors::*;
@@ -553,6 +554,81 @@ async fn main() -> Result<()> {
                 writeln!(io::stderr(), "Worker {} not found", tag_target.name.green())?;
             }
         }
+        SubCommand::Tag(TagCommand::List) => {
+            let tags = client.get_tags().await?;
+            writeln!(io::stdout(), "{}", tags.join("\n").cyan())?;
+        }
+        SubCommand::Tag(TagCommand::Create(tag_target)) => {
+            let authenticated_client = client.with_auth_cookie()?;
+
+            authenticated_client
+                .create_tag(CreateTagRequest {
+                    tag: tag_target.tag.clone(),
+                })
+                .await?;
+
+            writeln!(io::stdout(), "Tag {} created", tag_target.tag.cyan())?;
+        }
+        SubCommand::Tag(TagCommand::Delete(tag_target)) => {
+            let authenticated_client = client.with_auth_cookie()?;
+
+            authenticated_client
+                .delete_tag(tag_target.tag.clone())
+                .await?;
+
+            writeln!(io::stdout(), "Tag {} deleted", tag_target.tag.cyan())?;
+        }
+        SubCommand::Tag(TagCommand::Rule(TagRuleCommand::List(tag_target))) => {
+            writeln!(io::stdout(), "ID\tTag\tName pattern\tVersion pattern",)?;
+
+            let tags = if let Some(tag) = tag_target.tag {
+                vec![tag]
+            } else {
+                client.get_tags().await?
+            };
+
+            for tag in tags {
+                let tag_rules = client.get_tag_rules(tag.clone()).await?;
+                for tag_rule in tag_rules {
+                    writeln!(
+                        io::stdout(),
+                        "{}\t{}\t{}\t{}",
+                        tag_rule.id.to_string().yellow(),
+                        tag.cyan(),
+                        tag_rule.name_pattern.green(),
+                        tag_rule.version_pattern.unwrap_or("".to_string()).magenta()
+                    )?;
+                }
+            }
+        }
+        SubCommand::Tag(TagCommand::Rule(TagRuleCommand::Create(create_tag))) => {
+            let authenticated_client = client.with_auth_cookie()?;
+
+            let tag_rule = authenticated_client
+                .create_tag_rule(
+                    create_tag.tag,
+                    CreateTagRuleRequest {
+                        name_pattern: create_tag.name_pattern,
+                        version_pattern: create_tag.version_pattern,
+                    },
+                )
+                .await?;
+
+            writeln!(
+                io::stdout(),
+                "Rule created (ID {})",
+                tag_rule.id.to_string().yellow()
+            )?;
+        }
+        SubCommand::Tag(TagCommand::Rule(TagRuleCommand::Delete(tag_rule_target))) => {
+            let authenticated_client = client.with_auth_cookie()?;
+
+            authenticated_client
+                .delete_tag_rule(tag_rule_target.tag, tag_rule_target.rule_id)
+                .await?;
+
+            writeln!(io::stdout(), "Rule deleted")?;
+        }
         SubCommand::Completions(completions) => args::gen_completions(&completions)?,
     }