//! The swarm builder's builds: the subject swarm-controller sends a build on,
//! and what travels each way.
//!
//! Three crates name these: the controller sends the request, the builder
//! answers it, and the auth-callout responder grants the one subject to each.

use std::time::Duration;

use serde::{Deserialize, Serialize};

/// The subject every build goes to. The controller is its one publisher and
/// the builder its one subscriber; the builder answers on the request's reply
/// subject.
pub const SUBJECT: &str = "$SWARM.builder.build";

/// The queue group the builder subscribes in, so a second instance shares the
/// requests instead of running each one twice.
pub const QUEUE_GROUP: &str = "builder";

/// The longest one build may take before the builder stops it and answers
/// with a timeout.
pub const BUILD_DEADLINE: Duration = Duration::from_hours(1);

/// How long the controller waits for the reply, and the queue lets the
/// builder answer: the build at its deadline, plus a minute for the rest.
pub const REPLY_DEADLINE: Duration = Duration::from_mins(61);

/// One build: an agent's config repo at one commit, on the builder's own
/// agent base.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildAgent {
    /// The agent, which is also its config repo's name.
    pub agent: String,
    /// The commit to build.
    pub rev: String,
    /// The PR the commit is the head of; its `refs/pull/<pr>/head` is the ref
    /// the builder fetches the commit through.
    pub pr: u64,
}

/// The builder's answer to one [`BuildAgent`].
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "state", rename_all = "kebab-case")]
pub enum Reply {
    /// The config built; `out_path` is the system closure's store path.
    Built { out_path: String },
    /// The build did not finish: the last lines `nix` printed, or why the
    /// builder could not start it.
    Failed { error_tail: String },
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn the_wire_tags_the_reply_by_state() {
        let json = serde_json::to_value(Reply::Built {
            out_path: "/nix/store/x".to_owned(),
        })
        .expect("encodes");
        assert_eq!(json["state"], "built");
        assert_eq!(json["out_path"], "/nix/store/x");
        let json = serde_json::to_value(Reply::Failed {
            error_tail: "e".to_owned(),
        })
        .expect("encodes");
        assert_eq!(json["state"], "failed");
    }

    #[test]
    fn the_reply_deadline_outlasts_the_build() {
        assert!(REPLY_DEADLINE > BUILD_DEADLINE);
    }
}