rs_nomad/

types.rs

/*
MIT License

Copyright (c) 2023 Roblox

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

use serde::{Deserialize, Serialize};
use smart_default::SmartDefault;
use std::collections::HashMap;
use std::time::Duration;

use crate::serialization_helpers::*;

/// Represents a single job summary as part of the [Nomad::list_jobs](nomad::Nomad::list_jobs) api.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct ConciseJob {
    /// The ID of the nomad job.
    #[serde(rename = "ID")]
    pub id: String,
    /// The job ID of the parent nomad job.
    #[serde(rename = "ParentID")]
    pub parent_id: Option<String>,
    /// The type of the nomad job. See [JobType](nomad::types::JobType)
    #[serde(rename = "Type")]
    pub job_type: JobType,
    /// The name of the nomad job.
    pub name: String,
    /// The nomad datacenters for this nomad job.
    pub datacenters: Vec<String>,
    /// The priority of the nomad job. Can be between 1 and 100.
    pub priority: u8,
    /// Whether the job is scheduled at a fixed date/time/interval.
    pub periodic: bool,
    /// Whether the job is dispatched using a custom payload.
    pub parameterized_job: bool,
    /// Whether the job is stopped.
    pub stop: bool,
    /// The status of the job.
    pub status: Option<JobStatus>,
    /// The status description of the job.
    pub status_description: Option<String>,
    /// The create index.
    pub create_index: u64,
    /// The modify index.
    pub modify_index: u64,
    /// The modify index of the job.
    pub job_modify_index: u64,
    /// The time the job was submitted as a unix timestamp.
    pub submit_time: i64,
    /// The summary of the job. See also [JobSummary](nomad::types::JobSummary)
    pub job_summary: JobSummary,
}

/// The summary for instances of a particular job.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct SummaryInfo {
    /// The number of instances of this job that have been queued.
    pub queued: u32,
    /// The number of instances of this job that have completed.
    pub complete: u32,
    /// The number of instances of this job that have failed.
    pub failed: u32,
    /// The number of instances of this job that are running.
    pub running: u32,
    /// The number of instances of this job that are starting.
    pub starting: u32,
    /// The number of instances of this job that have been lost.
    pub lost: u32,
}

/// The summary information for a particular job.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct JobSummary {
    /// The ID of the job.
    #[serde(rename = "JobID")]
    job_id: String,
    /// The namespace of the job.
    namespace: String,
    /// The children of the given job. See also [Children](nomad::types::Children)
    children: Option<Children>,
    /// The summary of the job. See also [SummaryInfo](nomad::types::SummaryInfo)
    /// This is always a single element.
    summary: HashMap<String, SummaryInfo>,
}

/// The request to create or update a job. See also [list_jobs](nomad::Nomad::list_jobs)
#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct JobRegisterRequest {
    /// The job to create or update. See also [Job](nomad::types::Job)
    pub job: Job,
    /// If set, the job will only be registered if the passed job_modify_index matches the current job's index.
    /// If the index is zero, the register only occurs if the job is new. This paradigm allows check-and-set style job updating.
    pub enforce_index: bool,
    /// Specifies the job_modify_index to enforce the current job at.
    pub job_modify_index: u64,
    /// If set, any soft mandatory Sentinel policies will be overridden. This allows a job to be registered when it would be denied by policy.
    pub policy_override: bool,
    /// If set, preserves the count of instances of the job.
    pub preserve_counts: bool,
}

/// The response from nomad for a create or update a job request. See also [list_jobs](nomad::Nomad::list_jobs)
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct JobRegisterResponse {
    /// The ID of the evaluation for this request.
    #[serde(rename = "EvalID")]
    pub eval_id: String,
    /// Specifies the index of the current evaluation for this job.
    pub eval_create_index: u64,
    /// Specifies the job_modify_index to enforce the current job at.
    pub job_modify_index: u64,
}

/// The instance summary of the children for the current job.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Children {
    /// The number of instances in pending for the current job.
    pub pending: u32,
    /// The number of instances running for the current job.
    pub running: u32,
    /// The number of dead instances for the current job.
    pub dead: u32,
}

/// The request to create the plan to create or update a job.
#[derive(Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct CreateJobPlanRequest<'a> {
    /// The job to create or update. See also [Job](nomad::types::Job)
    pub job: &'a Job,
    /// If set, then the resulting difference report will be included in the response.
    pub diff: bool,
    /// If set, any soft mandatory Sentinel policies will be overridden. This allows a job to be registered when it would be denied by policy.
    pub policy_override: bool,
}

/// The request to create the plan to create or update a job.
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct CreateJobPlanResponse {
    /// The modify index of the job.
    pub job_modify_index: u64,
    /// Annotations for the generated plan.
    pub annotations: PlanAnnotations,
    /// The difference report for the deployed job.
    pub diff: JobDiff,
    /// The next launch of this periodic job, if it is one.
    #[serde(deserialize_with = "deserialize_duration_option")]
    #[serde(serialize_with = "serialize_duration_option")]
    pub next_periodic_launch: Option<Duration>,
    // TODO: Add CreatedEvals       []*Evaluation
    // TODO: Add:FailedTGAllocs     map[string]*AllocationMetric
    /// Contains any warnings about the given job. These may include deprecation warnings.
    pub warnings: String,
}

/// Contains annotations for the generated plan.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct PlanAnnotations {
    /// Statistics about desired updates on a per-taskgroup basis.
    #[serde(rename = "DesiredTGUpdates")]
    pub desired_task_group_updates: HashMap<String, DesiredUpdates>,
    // TODO: PreemptedAllocs
}

/// Statistics about desired updates.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct DesiredUpdates {
    /// Number of deployed groups to ignore.
    pub ignore: u64,
    /// Number of groups to newly place.
    pub place: u64,
    /// Number of groups to migrate.
    pub migrate: u64,
    /// Number of groups to stop.
    pub stop: u64,
    /// Number of deployed groups to update in-place.
    pub in_place_update: u64,
    /// Number of deployed groups to destroy.
    pub destructive_update: u64,
    /// Number of canary groups.
    pub canary: u64,
    /// TODO: What is this?
    pub preemptions: u64,
}

/// The type of action for a given difference.
#[derive(Debug, Deserialize, Eq, PartialEq, Serialize, Clone)]
pub enum DiffType {
    /// There was no change.
    None,
    /// Something was added.
    Added,
    /// Something was deleted.
    Deleted,
    /// Something was edited.
    Edited,
}

/// A difference report between a deployed job and another revision.
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct JobDiff {
    /// The type of change.
    pub r#type: DiffType,
    /// The ID of the job in question.
    #[serde(rename = "ID")]
    pub id: String,
    /// Difference between fields.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub fields: Vec<FieldDiff>,
    /// Difference between objects.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub objects: Vec<ObjectDiff>,
    /// Difference between task groups.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub task_groups: Vec<TaskGroupDiff>,
}

/// Difference for a given field.
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct FieldDiff {
    /// The type of change.
    pub r#type: DiffType,
    /// The name of the changed field.
    pub name: String,
    /// The previous value.
    pub old: String,
    /// The new value.
    pub new: String,
    /// Any annotations.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub annotations: Vec<String>,
}

/// Difference for a given object.
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct ObjectDiff {
    /// The type of change.
    pub r#type: DiffType,
    /// The name of the changed object.
    pub name: String,
    /// Changed fields for this object.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub fields: Vec<FieldDiff>,
    /// Changed children objects.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub objects: Vec<ObjectDiff>,
}

/// Difference for a task group.
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct TaskGroupDiff {
    /// The type of change.
    pub r#type: DiffType,
    /// The name of the changed object.
    pub name: String,
    /// Changed fields for this object.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub fields: Vec<FieldDiff>,
    /// Changed children objects.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub objects: Vec<ObjectDiff>,
    /// Difference between tasks.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub tasks: Vec<TaskDiff>,
    /// TODO: What is this?
    pub updates: Option<HashMap<String, u64>>,
}

/// Difference for a task.
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct TaskDiff {
    /// The type of change.
    pub r#type: DiffType,
    /// The name of the changed object.
    pub name: String,
    /// Changed fields for this object.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub fields: Vec<FieldDiff>,
    /// Changed children objects.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub objects: Vec<ObjectDiff>,
    /// Any annotations.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub annotations: Vec<String>,
}

/// The nomad job specification, representing a single job.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Job {
    /// The ID of the current job.
    #[serde(rename = "ID")]
    pub id: String,
    /// The ID of the parent of the current job.
    #[serde(rename = "ParentID")]
    pub parent_id: Option<String>,
    /// The type of the nomad job. See [JobType](nomad::types::JobType)
    #[serde(rename = "Type")]
    pub job_type: JobType,
    /// Whether the job should be stopped.
    pub stop: bool,
    #[default = "global"]
    /// The region of the job. Defaults to global.
    pub region: String,
    /// The namespace of the job. Defaults to default.
    #[default = "default"]
    pub namespace: String,
    /// The name of the job.
    pub name: String,
    /// The priority for the job. Valid values are between 1 and 100, both inclusive. Defaults to 50.
    #[default = 50]
    pub priority: u32,
    /// Controls whether the scheduler can make partial placements if optimistic scheduling resulted in an oversubscribed node.
    /// This does not control whether all allocations for the job, where all would be the desired count for each task group, must be placed atomically.
    /// This should only be used for special circumstances. Defaults to false.
    pub all_at_once: bool,
    /// The nomad datacenters to place this job in.
    pub datacenters: Vec<String>,
    /// The placement constraints for this job. See also [Constraint](nomad::types::Constraint)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub constraints: Vec<Constraint>,
    /// The task groups for this job. See also [TaskGroup](nomad::types::TaskGroup)
    pub task_groups: Vec<TaskGroup>,
    /// The update strategy for this job. See also [UpdateStrategy](nomad::types::UpdateStrategy)
    pub update: Option<UpdateStrategy>,
    /// The periodic schedule for this job. See also [PeriodicConfig](nomad::types::PeriodicConfig)
    pub periodic: Option<PeriodicConfig>,
    /// Specifies the job as a parameterized job such that it can be dispatched against a custom payload.
    pub parameterized_job: Option<ParameterizedJobConfig>,
    /// Whether the job was dispatched as with a parameterized payload.
    pub dispatched: bool,
    /// The payload may not be set when submitting a job but may appear in a dispatched job.
    /// The Payload will be a base64 encoded string containing the payload that the job was dispatched with.
    /// The payload has a maximum size of 16 KiB.
    pub payload: Option<Vec<u8>>,
    /// Specifies a reschedule policy to be applied to all task groups within the job.
    /// When specified both at the job level and the task group level, the reschedule blocks are merged, with the task group's taking precedence.
    pub reschedule: Option<ReschedulePolicy>,
    /// A key-value map that annotates the task group with metadata opaque to nomad.
    pub meta: Option<HashMap<String, String>>,
    /// The consul token to use for authentication.
    pub consul_token: Option<String>,
    /// The vault token to authentication.
    pub vault_token: Option<String>,
    /// The status of the job.
    pub status: Option<JobStatus>,
    /// The status description of the job.
    pub status_description: Option<String>,
    /// Specifies whether the job should be marked as stable or not.
    pub stable: bool,
    /// Specifies the version of the job.
    pub version: u64,
    /// The time the job was submitted as a unix timestamp.
    pub submit_time: i64,
    /// The create index.
    pub create_index: u64,
    /// The modify index.
    pub modify_index: u64,
    /// The modify index of the job.
    pub job_modify_index: u64,
}

/// The task groups defined for a particular job.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct TaskGroup {
    /// The placement constraints for this job. See also [Constraint](nomad::types::Constraint)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub constraints: Vec<Constraint>,
    /// A list to define placement preferences on nodes where a job can be run. See also [Affinity](nomad::types::Affinity)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub affinities: Vec<Affinity>,
    /// A list to define allocation spread across attributes. See also [Spread](nomad::types::Spread)
    #[serde(default)]
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub spreads: Vec<Spread>,
    /// Specifies the number of the task groups that should be running. Must be non-negative, defaults to one.
    #[default = 1]
    pub count: u32,
    /// A key-value map that annotates the task group with metadata opaque to nomad.
    pub meta: Option<HashMap<String, String>>,
    /// Specifies a migration strategy to be applied during node drains. See also [MigrateStrategy](nomad::types::MigrateStrategy)
    pub migrate: MigrateStrategy,
    /// The name of the task group. Must be specified.
    pub name: String,
    /// Specifies the restart policy to be applied to tasks in this group.
    /// If omitted, a default policy for batch and non-batch jobs is used based on the job type.
    /// See also [RestartPolicy](nomad::types::RestartPolicy)
    pub restart_policy: Option<RestartPolicy>,
    /// Specifies the reschedule policy to be applied to tasks in this group.
    /// If omitted, a default policy is used for batch and service jobs.
    /// System jobs are not eligible for rescheduling.
    /// See also [ReschedulePolicy](nomad::types::ReschedulePolicy)
    pub reschedule_policy: Option<ReschedulePolicy>,
    /// Specifies the autoscaling policy for the task group.
    /// This is primarily for supporting external autoscalers.
    /// See also [Scaling](nomad::types::Scaling)
    #[serde(default)]
    pub scaling: Option<Scaling>,
    /// Specifies the group's ephemeral disk requirements.
    /// See also [EphemeralDisk](nomad::types::EphemeralDisk)
    pub ephemeral_disk: EphemeralDisk,
    /// Specifies an update strategy to be applied to all task groups within the job.
    /// When specified both at the job level and the task group level, the update blocks are merged with the task group's taking precedence.
    /// See also [UpdateStrategy](nomad::types::UpdateStrategy)
    pub update: UpdateStrategy,
    /// A list of Task object that are part of the task group.
    /// See also [Task](nomad::types::Task)
    pub tasks: Vec<Task>,
    /// A list of network objects.
    #[serde(rename = "Networks")]
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub networks: Vec<NetworkConfig>,
    /// A Service object represents a routable and discoverable service on the network.
    /// Nomad integrates with Consul for service discovery and it automatically registers when a task is started and de-registers it when the task transitions to the dead state.
    /// See also [Service](nomad::types::Service)
    /// Note that this is deprecated and replaced by the services stanza at the task group level.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub services: Vec<Service>,
}

/// A map of key-value configuration passed into the driver to start the task.
/// The details of configurations are specific to each driver.
#[derive(Debug, Deserialize, PartialEq, Serialize, SmartDefault, Clone)]
#[serde(untagged)]
pub enum DriverConfig {
    /// A boolean value.
    Bool(bool),
    /// A string value.
    #[default]
    String(String),
    /// An integer value.
    Int(i64),
    /// A float value.
    Float(f64),
    /// An array/vector value.
    Vector(Vec<DriverConfig>),
    /// A map value to represent arbitrarily nested key-values.
    Map(HashMap<String, DriverConfig>),
}

/// Represents a task within a task group.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Task {
    /// Represents the artifacts to download for this task.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub artifacts: Vec<Artifact>,
    /// A map of key-value configuration passed into the driver to start the task.
    /// The details of configurations are specific to each driver.
    pub config: Option<HashMap<String, DriverConfig>>,
    /// The placement constraints for this job. See also [Constraint](nomad::types::Constraint)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub constraints: Vec<Constraint>,
    /// A list to define placement preferences on nodes where a job can be run. See also [Affinity](nomad::types::Affinity)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub affinities: Vec<Affinity>,
    /// A list to define allocation spread across attributes. See also [Spread](nomad::types::Spread)
    #[serde(default)]
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub spreads: Vec<Spread>,
    /// Configures the task to have access to dispatch payloads.
    /// See also [DispatchPayload](nomad::types::DispatchPayload)
    pub dispatch_payload: Option<DispatchPayload>,
    /// Specifies the task driver that should be used to run the task.
    /// See the [driver documentation](https://www.nomadproject.io/docs/drivers) for what is available.
    /// Examples include docker, qemu, java, and exec.
    pub driver: String,
    /// A map of key-value representing environment variables that will be passed along to the running process.
    /// Nomad variables are interpreted when set in the environment variable values.
    pub env: Option<HashMap<String, String>>,
    /// Specifies a configurable kill signal for a task, where the default is SIGINT.
    /// Note that this is only supported for drivers which accept sending signals
    #[default = "SIGINT"]
    pub kill_signal: String,
    /// KillTimeout is a time duration in nanoseconds.
    /// It can be used to configure the time between signaling a task it will be killed and actually killing it.
    /// Drivers first sends a task the SIGINT signal and then sends SIGTERM if the task doesn't die after the KillTimeout duration has elapsed.
    /// The default KillTimeout is 5 seconds.
    #[default(_code = "Duration::from_secs(5)")]
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub kill_timeout: Duration,
    /// Specifies whether the task is the leader task of the task group.
    /// If set to true, when the leader task completes, all other tasks within the task group will be gracefully shutdown.
    pub leader: bool,
    /// This allows configuring log rotation for the stdout and stderr buffers of a Task.
    pub log_config: LogConfig,
    /// A key-value map that annotates the Consul service with user-defined metadata.
    /// String interpolation is supported in meta.
    pub meta: Option<HashMap<String, String>>,
    /// The name of the task.
    pub name: String,
    /// Provides the resource requirements of the task.
    /// See also [Resources](nomad::types::Resources)
    pub resources: Resources,
    /// Specifies the restart policy to be applied to tasks in this group.
    /// If omitted, a default policy for batch and non-batch jobs is used based on the job type.
    /// See also [RestartPolicy](nomad::types::RestartPolicy)
    pub restart_policy: RestartPolicy,
    /// A Service object represents a routable and discoverable service on the network.
    /// Nomad integrates with Consul for service discovery and it automatically registers when a task is started and de-registers it when the task transitions to the dead state.
    /// See also [Service](nomad::types::Service)
    /// Note that this is deprecated and replaced by the services stanza at the task group level.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub services: Vec<Service>,
    /// Specifies the duration to wait when killing a task between removing it from Consul and sending it a shutdown signal.
    /// Ideally services would fail healthchecks once they receive a shutdown signal.
    /// Alternatively ShutdownDelay may be set to give in flight requests time to complete before shutting down.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub shutdown_delay: Duration,
    /// Specifies the set of Template objects to render for the task.
    /// Templates can be used to inject both static and dynamic configuration with data populated from environment variables, Consul and Vault.
    /// See also [Template](nomad::types::Template)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub templates: Vec<Template>,
    /// Set the user that will run the task. It defaults to the same user the Nomad client is being run as.
    /// This can only be set on Linux platforms.
    pub user: Option<String>,
    /// The vault configuration, if any.
    pub vault: Option<Vault>,
    /// The lifecycle configuration for the task, if any.
    /// See also [Template](nomad::types::Lifecycle)
    pub lifecycle: Option<Lifecycle>,
}

/// The lifecycle block in Nomad is used to define the order in which tasks are executed within a task group.
///  Main tasks are those without a lifecycle block,
/// and tasks with lifecycle hooks specify their execution timing relative to the main tasks. For more information
/// See https://developer.hashicorp.com/nomad/docs/job-specification/lifecycle for more details.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Lifecycle {
    /// Specifies when a task should be run within the lifecycle of a group.
    pub hook: String,
    /// Controls whether a task is ephemeral or long-lived within the task group.
    /// If a lifecycle task is ephemeral (sidecar = false), the task will not be restarted after it completes successfully.
    /// If a lifecycle task is long-lived (sidecar = true) and terminates, it will be restarted as long as the allocation is running.
    pub sidecar: bool,
}

/// The Template block instantiates an instance of a template renderer.
/// This creates a convenient way to ship configuration files that are populated from environment variables, Consul data, Vault secrets, or just general configurations within a Nomad task.
/// Nomad utilizes a tool called [Consul Template](https://github.com/hashicorp/consul-template).
/// Since Nomad v0.5.3, the template can reference [Nomad's runtime environment variables](https://www.nomadproject.io/docs/runtime/environment).
/// For a full list of the API template functions, please refer to the [Consul Template README](https://github.com/hashicorp/consul-template).
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Template {
    /// Specifies the behavior Nomad should take if the rendered template changes.
    /// The default value is `ChangeMode::Restart`
    /// See also [ChangeMode](nomad::types::ChangeMode)
    pub change_mode: ChangeMode,
    ///  Specifies the signal to send to the task as a string like "SIGUSR1" or "SIGINT".
    /// This option is required if the change_mode is signal. Defaults to empty.
    #[default(Some("".to_string()))]
    pub change_signal: Option<String>,
    /// Specifies the location where the resulting template should be rendered, relative to the task directory.
    pub dest_path: String,
    /// Specifies the raw template to execute.
    /// One of source_path or embedded_tmpl must be specified, but not both.
    /// This is useful for smaller templates, but we recommend using SourcePath for larger templates.
    pub embedded_tmpl: Option<String>,
    /// Specifies whether the template should be read back as environment variables for the task.
    pub envvars: bool,
    /// Specifies the left delimiter to use in the template.
    /// The default is "{{" for some templates, it may be easier to use a different delimiter that does not conflict with the output file itself.
    #[default = "{{"]
    pub left_delim: String,
    /// Specifies the right delimiter to use in the template.
    /// The default is "}}" for some templates, it may be easier to use a different delimiter that does not conflict with the output file itself.
    #[default = "}}"]
    pub right_delim: String,
    /// Specifies the rendered template's permissions.
    /// File permissions are given as octal of the Unix file permissions rwxrwxrwx.
    /// Defaults to 644.
    #[default = "644"]
    pub perms: String,
    /// Specifies the path to the template to be rendered.
    /// source_path is mutually exclusive with EmbeddedTmpl attribute. The source can be fetched using an Artifact resource. The template must exist on the machine prior to starting the task; it is not possible to reference a template inside of a Docker container, for example.
    pub source_path: Option<String>,
    /// Specifies a random amount of time to wait between 0 ms and the given splay value before invoking the change mode.
    /// Defaults to 5 seconds.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(5)")]
    pub splay: Duration,
}

/// Represents the CPU resource requirements of a task.
/// Defaults to `Cores(1)`
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub enum CpuResource {
    /// Specify the CPU in megahertz. See https://www.nomadproject.io/docs/job-specification/resources#cpu.
    #[serde(rename = "CPU")]
    Megahertz(u32),
    /// Specify the CPU in cores. See https://www.nomadproject.io/docs/job-specification/resources#cores.
    #[serde(rename = "Cores")]
    Cores(u32),
}

impl Default for CpuResource {
    fn default() -> Self {
        CpuResource::Cores(1)
    }
}

/// Represents the resource requirements of a task.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
pub struct Resources {
    /// The CPU required, mutually exclusively specified as cores or megahertz.
    #[serde(flatten)]
    pub cpu: CpuResource,
    /// The memory required in MB.
    #[serde(rename = "MemoryMB")]
    pub memory_mb: u32,
    /// The max memory allowed in MB. See https://www.nomadproject.io/docs/job-specification/resources#memory-oversubscription for more details.
    #[serde(rename = "MemoryMaxMB")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub memory_max_mb: Option<u32>,
    /// A list of network objects.
    /// Note that this is deprecated and moved to the task group level.
    #[serde(rename = "Networks")]
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub networks: Vec<NetworkConfig>,
    /// A list of device objects.
    #[serde(rename = "Devices")]
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub devices: Vec<Device>,
}

/// The network configuration for a task.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct NetworkConfig {
    /// The mode of the network.
    pub mode: String,
    /// The device for the network.
    pub device: String,
    /// The CIDR representation for the network address.
    #[serde(rename = "CIDR")]
    pub cidr: String,
    /// The ip of network device.
    #[serde(rename = "IP")]
    pub ip: String,
    /// The number of MBits in bandwidth required.
    pub m_bits: u32,
    /// The reserved ports for this task. See also [Port](nomad::types::Port)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub reserved_ports: Vec<Port>,
    /// The dynamic ports for this task. See also [Port](nomad::types::Port)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub dynamic_ports: Vec<Port>,
    /// A list of DNS servers to use instead of the DNS servers configured
    /// for the host.
    pub dns: Option<DnsSettings>,
}

/// The dns configuration for a Network
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct DnsSettings {
    /// A list of DNS servers, e.g., ["8.8.8.8", "8.8.4.4"]
    pub servers: Vec<String>,
    /// A list of search domains for hostname lookup, e.g., ["The.Best.Domain"]
    pub searches: Vec<String>,
}

/// The port configuration for a Network.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Port {
    /// The port number for static/reserved ports.
    /// If the port is dynamic, then this attribute is ignored
    pub value: u32,
    /// The label to annotate a port so that it can be referred in the service discovery block or environment variables.
    pub label: String,
    /// The static port this network points to on the driver.
    pub to: u32,
}

/// The device configuration for a task resource.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Device {
    /// Specifies the device required.
    /// Possible values can be:
    /// - <device_type>
    /// - vendor>/<device_type>
    /// - <vendor>/<device_type>/<model>
    pub name: String,
    /// The count of devices being requested per task. Defaults to 1.
    #[default = 1]
    pub count: u32,
    /// The placement constraints for this task. See also [Constraint](nomad::types::Constraint)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub constraints: Vec<Constraint>,
    /// A list to define placement preferences on nodes where a task can be run. See also [Affinity](nomad::types::Affinity)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub affinities: Vec<Affinity>,
}

/// Represents a parameterized job that can be dispatched with a custom payload.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct ParameterizedJobConfig {
    /// Specifies the set of metadata keys that may be provided when dispatching against the job as a string array.
    pub meta_optional: Vec<String>,
    ///  Specifies the set of metadata keys that must be provided when dispatching against the job as a string array.
    pub meta_required: Vec<String>,
    /// Specifies the requirement of providing a payload when dispatching against the parameterized job. The default value is `PayloadRequirement::Optional`.
    pub payload: PayloadRequirement,
}

/// Specifies that the job can be scheduled at fixed times, dates or intervals.
/// The periodic expression is always evaluated in the UTC timezone to ensure consistent evaluation when Nomad Servers span multiple time zones.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct PeriodicConfig {
    /// Enabled determines whether the periodic job will spawn child jobs.
    pub enabled: bool,
    /// Specifies the time zone to evaluate the next launch interval against.
    /// This is useful when wanting to account for day light savings in various time zones.
    /// The time zone must be parsable by Golang's [LoadLocation](https://golang.org/pkg/time/#LoadLocation). The default is UTC.
    #[default = "UTC"]
    pub time_zone: String,
    /// SpecType determines how Nomad is going to interpret the periodic expression.
    /// `SpecType::cron` is the only supported SpecType currently.
    pub spec_type: SpecType,
    ///  A cron expression configuring the interval the job is launched at.
    /// Supports predefined expressions such as "@daily" and "@weekly"
    pub spec: String,
    /// `ProhibitOverlap` can be set to true to enforce that the periodic job doesn't spawn a new instance of the job if any of the previous jobs are still running.
    /// It is defaulted to false.
    pub prohibit_overlap: bool,
}

/// CheckRestart is an object which enables restarting of tasks based upon Consul health checks.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct CheckRestart {
    /// The number of unhealthy checks allowed before the service is restarted. Defaults to 0 which disables health-based restarts.
    pub limit: u32,
    /// The duration to wait after a task starts or restarts before counting unhealthy checks count against the limit.
    /// Defaults to 1 second.
    #[default(_code = "Duration::from_secs(1)")]
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub grace: Duration,
    /// Treat checks that are warning as passing. Defaults to false which means warnings are considered unhealthy.
    pub ignore_warnings: bool,
}

/// A Service object represents a routable and discoverable service on the network.
/// Nomad integrates with Consul for [service discovery](https://www.nomadproject.io/docs/integrations/consul-integration#service-discovery).
/// Nomad automatically registers when a task is started and de-registers it when the task transitions to the dead state.
#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Service {
    /// An explicit name for the Service.
    /// Nomad will replace ${JOB}, ${TASKGROUP} and ${TASK} by the name of the job, task group or task, respectively.
    /// ${BASE} expands to the equivalent of ${JOB}-${TASKGROUP}-${TASK}, and is the default name for a Service.
    /// Each service defined for a given task must have a distinct name, so if a task has multiple services only one of them can use the default name and the others must be explicitly named.
    /// Names must adhere to [RFC-1123 §2.1](https://tools.ietf.org/html/rfc1123#section-2) and are limited to alphanumeric and hyphen characters (i.e. [a-z0-9\-]), and be less than 64 characters in length.
    pub name: String,
    /// A list of string tags associated with this Service.
    /// String interpolation is supported in tags.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub tags: Vec<String>,
    /// A key-value map that annotates the Consul service with user-defined metadata.
    /// String interpolation is supported in meta
    pub meta: Option<HashMap<String, String>>,
    /// A list of string tags associated with this Service while it is a canary.
    /// Once the canary is promoted, the registered tags will be updated to the set defined in the Tags field.
    /// String interpolation is supported in tags.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub canary_tags: Vec<String>,
    /// A key-value map that annotates this Service while it is a canary.
    /// Once the canary is promoted, the registered meta will be updated to the set defined in the Meta field or removed if the Meta field is not set.
    /// String interpolation is supported in meta keys and values.
    pub canary_meta: Option<HashMap<String, String>>,
    /// This is used to associate a port with the service.
    /// If specified, the port label must match one defined in the resources block.
    /// This could be a label of either a dynamic or a static port.
    pub port_label: Option<String>,
    /// Specifies what address (host or driver-specific) this service should advertise.
    /// This setting is supported in Docker since Nomad 0.6 and rkt since Nomad 0.7.
    pub address_mode: AddressMode,
    /// Checks define health checks associated with the service.
    /// Nomad supports the script, http and tcp Consul Checks.
    /// See also [ConsulCheck](nomad::types::ConsulCheck)
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub checks: Vec<ConsulCheck>,
    /// [Nomad Configuration](https://www.nomadproject.io/docs/job-specification/connect) for [ConsulConnect](https://www.nomadproject.io/docs/integrations/consul-connect)
    pub connect: Option<HashMap<String, DriverConfig>>,
}

/// Specifies what address (host or driver-specific) this service should advertise.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum AddressMode {
    /// Can be unspecified for ConsulCheck.
    #[serde(rename = "")]
    None,
    /// Allows the driver to determine whether the host or driver address should be used.
    /// Defaults to host and only implemented by Docker.
    /// If you use a Docker network plugin such as weave, Docker will automatically use its address.
    #[default]
    Auto,
    /// Use the IP specified by the driver, and the port specified in a port map.
    /// A numeric port may be specified since port maps aren't required by all network plugins. Useful for advertising SDN and overlay network addresses. Task will fail if driver network cannot be determined.
    /// Only implemented for Docker and rkt.
    Driver,
    /// Use the host IP and port.
    Host,
}

/// Configures the task to have access to dispatch payloads.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
pub struct DispatchPayload {
    /// Specifies the file name to write the content of dispatch payload to.
    /// The file is written relative to the task's local directory.
    #[serde(rename = "File")]
    pub file: String,
}

/// Checks define health checks associated with the service.
/// Nomad supports the script, http and tcp Consul Checks.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulCheck {
    /// This indicates the check types supported by Nomad.
    #[serde(rename = "Type")]
    pub check_type: CheckType,
    /// The name of the health check.
    pub name: String,
    /// The command to execute.
    pub command: String,
    /// The arguments to provide the command.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub args: Vec<String>,
    /// The path or route to use.
    pub path: Option<String>,
    /// The protocol to use. See also [Protocol](nomad::types::Protocol)
    pub protocol: Option<Protocol>,
    /// Whether to expose the check.
    pub expose: bool,
    /// The address mode to use. See also [AddressMode](nomad::types::AddressMode)
    pub address_mode: AddressMode,
    /// The port label to use.
    pub port_label: String,
    /// This indicates the frequency of the health checks that Consul will perform.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub interval: Duration,
    /// This indicates how long Consul will wait for a health check query to succeed.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub timeout: Duration,
    /// The initial status of the check.
    pub initial_status: Option<String>,
    /// If true, Consul will not attempt to verify the certificate when performing HTTPS checks.
    /// Requires Consul >= 0.7.2.
    #[serde(rename = "TLSSkipVerify")]
    pub tls_skip_verify: bool,
    /// The HTTP method to use for HTTP checks.
    /// Defaults to `HttpMethod::GET`.
    #[default(HttpMethod::Get)]
    pub method: HttpMethod,
    /// Headers for HTTP checks.
    /// Headers will be written once for each value.
    #[serde(rename = "Header")]
    pub header: Option<HashMap<String, Vec<String>>>,
    /// The grpc healthcheck.
    #[serde(rename = "GRPCService")]
    pub grpc_service: String,
    /// Whether the grpc healthcheck uses TLS.
    #[serde(rename = "GRPCUseTLS")]
    pub grpc_use_tls: bool,
    /// The name of the task for the check.
    #[serde(rename = "TaskName")]
    pub task_name: String,
    /// CheckRestart is an object which enables restarting of tasks based upon Consul health checks.
    #[serde(rename = "CheckRestart")]
    pub check_restart: CheckRestart,
}

/// This indicates the check types supported by Nomad.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckType {
    /// Script based check.
    #[default]
    Script,
    /// Http based check.
    Http,
    /// Https based check.
    Tcp,
    /// Grpc based check.
    Grpc,
}

/// The protocol (http/https)
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum Protocol {
    /// Unspecified.
    #[default]
    #[serde(rename = "")]
    None,
    /// http
    Http,
    /// https
    Https,
}

/// The HTTP Method type.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum HttpMethod {
    /// GET
    #[default]
    Get,
    /// PUT
    Put,
    /// POST
    Post,
    /// DELETE
    Delete,
    /// OPTIONS
    Options,
    /// HEAD
    Head,
    /// TRACE
    Trace,
    /// CONNECT
    Connect,
    /// PATCH
    Patch,
    /// None
    #[serde(untagged)]
    Unknown(String),
}

/// The LogConfig object configures the log rotation policy for a task's stdout and stderr
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct LogConfig {
    /// The maximum number of rotated files Nomad will retain for stdout and stderr, each tracked individually.
    pub max_files: u32,
    /// The size of each rotated file. The size is specified in MB.
    #[serde(rename = "MaxFileSizeMB")]
    pub max_file_size_in_mb: u32,
}

/// Nomad downloads artifacts using [go-getter](https://github.com/hashicorp/go-getter).
/// The go-getter library allows downloading of artifacts from various sources using a URL as the input source.
/// The key-value pairs given in the options block map directly to parameters appended to the supplied source URL.
/// These are then used by go-getter to appropriately download the artifact.
/// Nomad allows downloading http, https, and S3 artifacts.
/// If these artifacts are archives (zip, tar.gz, bz2, etc.), these will be unarchived before the task is started.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Artifact {
    /// The path to the artifact to download.
    pub getter_source: String,
    /// An optional path to download the artifact into relative to the root of the task's directory.
    /// If omitted, it will default to local/.
    #[default = "local/"]
    pub relative_dest: String,
    /// A map[string]string block of options for go-getter. [Details](https://github.com/hashicorp/go-getter/tree/ef5edd3d8f6f482b775199be2f3734fd20e04d4a#protocol-specific-options-1)
    pub getter_options: HashMap<String, String>,
}

/// SpecType determines how Nomad is going to interpret the periodic expression.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum SpecType {
    /// cron is the only supported SpecType currently.
    #[default]
    Cron,
}

/// Specifies the requirement of providing a payload when dispatching against the parameterized job.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PayloadRequirement {
    /// Optional. This is the default value.
    #[default]
    Optional,
    /// Required.
    Required,
    /// Forbidden.
    Forbidden,
}

/// Specifies the group's ephemeral disk requirements.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct EphemeralDisk {
    /// Specifies that the Nomad client should make a best-effort attempt to migrate the data from a remote machine if placement cannot be made on the original node.
    /// During data migration, the task will block starting until the data migration has completed.
    /// Defaults to false.
    pub migrate: bool,
    /// Specifies the size of the ephemeral disk in MB.
    /// Defaults to 300.
    #[default = 300]
    #[serde(rename = "SizeMB")]
    pub size_in_mb: u32,
    /// Specifies that Nomad should make a best-effort attempt to place the updated allocation on the same machine.
    /// This will move the local/ and alloc/data directories to the new allocation.
    /// Defaults to false.
    pub sticky: bool,
}

/// Scaling policies allow operators to attach autoscaling configuration to a task group.
/// This information can be queried by [external autoscalers](https://github.com/hashicorp/nomad-autoscaler).
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Scaling {
    /// The minimum allowable count for the task group.
    /// This is optional; if absent, the default is the Count specified in the task group.
    /// Attempts to set the task group Count below Min will result in a 400 error during job registration.
    pub min: Option<u32>,
    /// The maximum allowable count for the task group.
    /// This is required if a scaling policy is provided.
    /// This must be larger than Min.
    /// Attempts to set the task group Count above Max wil result in a 400 error during job registration.
    pub max: u32,
    /// An optional boolean (default: true).
    /// This indicates to the autoscaler that this scaling policy should be ignored.
    /// It is intended to allow autoscaling to be temporarily disabled for a task group.
    #[default = true]
    pub enabled: bool,
    /// An optional JSON block.
    /// This is opaque to Nomad; see the [documentation](https://github.com/hashicorp/nomad-autoscaler) for the external autoscaler.
    pub policy: HashMap<String, DriverConfig>,
}

/// Specifies the reschedule policy to be applied to tasks in this group.
/// If omitted, a default policy is used for batch and service jobs.
/// System jobs are not eligible for rescheduling.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct ReschedulePolicy {
    /// Attempts is the number of reschedule attempts allowed in an interval.
    pub attempts: u32,
    /// The Interval is a sliding window within which at most Attempts number of reschedule attempts are permitted.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub interval: Duration,
    /// A duration to wait before attempting rescheduling.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub delay: Duration,
    /// Specifies the function that is used to calculate subsequent reschedule delays.
    /// The initial delay is specified by the Delay parameter.
    pub delay_function: DelayFunction,
    /// max_delay is an upper bound on the delay beyond which it will not increase.
    /// This parameter is used when DelayFunction is exponential or fibonacci, and is ignored when constant delay is used.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    pub max_delay: Duration,
    /// Unlimited enables unlimited reschedule attempts.
    /// If this is set to true the Attempts and Interval fields are not used.
    pub unlimited: bool,
}

/// Specifies the function that is used to calculate subsequent reschedule delays.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum DelayFunction {
    /// The delay between reschedule attempts stays at the Delay value.
    #[default]
    Constant,
    /// The delay between reschedule attempts doubles.
    Exponential,
    /// The delay between reschedule attempts is calculated by adding the two most recent delays applied.
    Fibonacci,
}

/// Specifies the job type and switches which scheduler is used.
/// Nomad provides the service, system and batch schedulers, and defaults to service
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum JobType {
    /// The service scheduler is designed for scheduling long lived services that should never go down.
    /// As such, the service scheduler ranks a large portion of the nodes that meet the job's constraints and selects the optimal node to place a task group on.
    #[default]
    Service,
    /// The system scheduler is used to register jobs that should be run on all clients that meet the job's constraints.
    /// The system scheduler is also invoked when clients join the cluster or transition into the ready state.
    /// This means that all registered system jobs will be re-evaluated and their tasks will be placed on the newly available nodes if the constraints are met.
    Batch,
    /// Batch jobs are much less sensitive to short term performance fluctuations and are short lived, finishing in a few minutes to a few days.
    /// Although the batch scheduler is very similar to the service scheduler, it makes certain optimizations for the batch workload.
    System,
}

/// Specifies the job status. https://developer.hashicorp.com/nomad/api-docs/jobs#status
#[derive(Clone, Debug, Deserialize, Eq, SmartDefault, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum JobStatus {
    /// All of the job's allocations and evaluations are terminal.
    #[default]
    Dead,
    /// The job has non-terminal allocations.
    Running,
    /// The job is currently waiting on scheduling.
    Pending,
    /// The job is currently paused.
    Paused,
    /// The job failed.
    Failed,
    /// The job deployment was successful.
    Successful,
    /// The job deployment was cancelled.
    Cancelled,
    /// The job deployment is initializing.
    Initializing,
    /// The job deployment is blocked.
    Blocked,
    /// The job deployment is unblocking.
    Unblocking,
}

/// Specifies the behavior Nomad should take if the rendered template changes.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ChangeMode {
    /// take no action (continue running the task)
    Noop,
    /// restart the task (this is the default)
    #[default]
    Restart,
    /// end a configurable signal to the task
    Signal,
}

/// Specifies a migration strategy to be applied during [node drains](https://www.nomadproject.io/docs/commands/node/drain).
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct MigrateStrategy {
    /// Specifies how many allocations may be migrated at once.
    /// Defaults to 1.
    #[default = 1]
    pub max_parallel: u32,
    /// Indicates how task health should be determined: either via Consul health checks or whether the task was able to run successfully.
    /// See also [HealthCheck](nomad::types::HealthCheck)
    #[serde(deserialize_with = "deserialize_healthcheck")]
    pub health_check: HealthCheck,
    /// Specifies duration a task must be considered healthy before the migration is considered healthy.
    /// Defaults to 10 seconds.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(10)")]
    pub min_healthy_time: Duration,
    /// Specifies duration a task must become healthy within before it is considered unhealthy.
    /// Defaults to 5 minutes.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(300)")]
    pub healthy_deadline: Duration,
}

/// Specifies the task group update strategy.
/// When omitted, rolling updates are disabled.
/// The update stanza can be specified at the job or task group level.
/// When specified at the job, the update stanza is inherited by all task groups.
/// When specified in both the job and in a task group, the stanzas are merged with the task group's taking precedence.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct UpdateStrategy {
    /// Specifies the number of tasks that can be updated at the same time.
    /// Defaults to 1.
    #[default = 1]
    pub max_parallel: u32,
    /// Specifies the mechanism in which allocations health is determined.
    /// See also [HealthCheck](nomad::types::HealthCheck)
    #[serde(deserialize_with = "deserialize_healthcheck")]
    pub health_check: HealthCheck,
    /// Specifies the minimum time the allocation must be in the healthy state before it is marked as healthy and unblocks further allocations from being updated.
    /// Defaults to 10 seconds.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(10)")]
    pub min_healthy_time: Duration,
    /// Specifies the deadline in which the allocation must be marked as healthy after which the allocation is automatically transitioned to unhealthy.
    /// Defaults to 5 minutes.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(300)")]
    pub healthy_deadline: Duration,
    /// Specifies the deadline in which an allocation must be marked as healthy.
    /// The deadline begins when the first allocation for the deployment is created and is reset whenever an allocation as part of the deployment transitions to a healthy state.
    /// If no allocation transitions to the healthy state before the progress deadline, the deployment is marked as failed.
    /// If the progress_deadline is set to 0, the first allocation to be marked as unhealthy causes the deployment to fail.
    /// Defaults to 10 minutes.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(600)")]
    pub progress_deadline: Duration,
    /// Specifies if the job should auto-revert to the last stable job on deployment failure.
    /// A job is marked as stable if all the allocations as part of its deployment were marked healthy.
    /// Defaults to false.
    pub auto_revert: bool,
    /// Specifies that changes to the job that would result in destructive updates should create the specified number of canaries without stopping any previous allocations.
    /// Once the operator determines the canaries are healthy, they can be promoted which unblocks a rolling update of the remaining allocations at a rate of max_parallel.
    /// Defaults to 0.
    pub canary: u32,
    /// specifies if the job should automatically promote to the new deployment if all canaries become healthy.
    /// Defaults to false.
    pub auto_promote: bool,
    /// Specifies the delay between migrating allocations off nodes marked for draining.
    /// Defaults to 30 seconds.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(30)")]
    pub stagger: Duration,
}

/// Specifies the restart policy in case of task failure.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct RestartPolicy {
    /// Attempts is the number of restarts allowed in an Interval.
    /// Defaults to 1.
    #[default = 1]
    pub attempts: u32,
    /// The Interval begins when the first task starts and ensures that only Attempts number of restarts happens within it.
    /// If more than Attempts number of failures happen, behavior is controlled by Mode.
    /// Defaults to 30 minutes.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(1800)")]
    pub interval: Duration,
    /// A duration to wait before restarting a task.
    /// A random jitter of up to 25% is added to the delay.
    /// Defaults to 15 seconds.
    #[serde(deserialize_with = "deserialize_duration")]
    #[serde(serialize_with = "serialize_duration")]
    #[default(_code = "Duration::from_secs(15)")]
    pub delay: Duration,
    /// Mode controls the behavior when the task fails more than Attempts times in an Interval.
    /// See also [RestartMode](nomad::types::RestartMode)
    pub mode: RestartMode,
}

/// Indicates how task health should be determined: either via Consul health checks or whether the task was able to run successfully.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum HealthCheck {
    /// Specifies that the allocation should be considered healthy when all of its tasks are running and their associated checks are healthy, and unhealthy if any of the tasks fail or not all checks become healthy.
    /// This is a superset of "task_states" mode.
    #[default]
    Checks,
    /// Specifies that the allocation should be considered healthy when all its tasks are running and unhealthy if tasks fail.
    TaskStates,
    /// Specifies that Nomad should not automatically determine health and that the operator will specify allocation health using the HTTP API.
    Manual,
}

/// This controls the behavior when the task fails more than Attempts times in an Interval
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum RestartMode {
    /// delay will delay the next restart until the next Interval is reached.
    #[default]
    Delay,
    /// fail will not restart the task again.
    Fail,
}

/// Spread allow operators to target specific percentages of allocations based on any node attribute or metadata.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Spread {
    /// Specifies the attribute to examine for the spread.
    pub attribute: String,
    /// Specifies a list of attribute values and percentages.
    /// This is an optional field, when left empty Nomad will evenly spread allocations across values of the attribute.
    #[serde(default)]
    pub target: Vec<SpreadTarget>,
    /// A non zero weight, valid values are from -100 to 100. Used to express relative preference when there is more than one spread or affinity.
    pub weight: u8,
}

/// Specifies a list of attribute values and percentages.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct SpreadTarget {
    /// The value of a specific target attribute, like "dc1" for ${node.datacenter}.
    pub value: String,
    /// Desired percentage of allocations for this attribute value. The sum of all spread target percentages must add up to 100.
    pub percent: u8,
}

/// A representation of placement preferences on nodes where a job can be run.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Affinity {
    /// Specifies the attribute to examine for the affinity.
    pub l_target: Option<String>,
    /// specifies the value to compare the attribute against. This can be a literal value, another attribute or a regular expression if the Operator is in "regexp" mode.
    pub r_target: Option<String>,
    /// Specifies the test to be performed on the two targets.
    /// See also [AffinityOperator](nomad::types::AffinityOperator)
    pub operand: AffinityOperator,
    /// A non zero weight, valid values are from -100 to 100. Used to express relative preference when there is more than one affinity.
    pub weight: i8,
}

/// A representation to define additional constraints where a job can be run.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Constraint {
    /// Specifies the attribute to examine for the constraint.
    pub l_target: Option<String>,
    /// Specifies the value to compare the attribute against.
    /// This can be a literal value, another attribute or a regular expression if the Operator is in "regexp" mode.
    pub r_target: Option<String>,
    /// Specifies the test to be performed on the two targets.
    pub operand: ConstraintOperator,
}

/// Vault configuration for a given job/task group/task.
#[derive(Serialize, Deserialize, Default, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct Vault {
    /// The policies to load.
    #[serde(deserialize_with = "deserialize_vec_with_null_as_empty")]
    pub policies: Vec<String>,
    /// The Vault namespace to use, if any.
    pub namespace: Option<String>,
    /// The ChangeMode, if any.
    pub change_mode: Option<ChangeMode>,
    /// The ChangeSignal, if ChangeMode is set to [`ChangeMode::Signal`].
    pub change_signal: Option<String>,
}

/// The operand for [Constraint](nomad::types::Constraint)
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
pub enum ConstraintOperator {
    /// Equals
    #[default]
    #[serde(rename = "=")]
    Equals,
    /// Does not equal
    #[serde(rename = "!=")]
    NotEquals,
    /// Greater than
    #[serde(rename = ">")]
    GreaterThan,
    /// Greater than or equal to
    #[serde(rename = ">=")]
    GreaterThanOrEqual,
    /// Less than
    #[serde(rename = "<")]
    LessThan,
    /// Less than or equal to
    #[serde(rename = "<=")]
    LessThanOrEqual,
    /// Distinct hosts
    #[serde(rename = "distinct_hosts")]
    DistinctHosts,
    /// Distinct property
    #[serde(rename = "distinct_property")]
    DistinctProperty,
    /// Regular expression
    #[serde(rename = "regexp")]
    RegularExpression,
    /// Set contains
    #[serde(rename = "set_contains")]
    SetContains,
    /// Version
    #[serde(rename = "version")]
    Version,
    /// Semantic version
    #[serde(rename = "semver")]
    SemanticVersion,
    /// Is set
    #[serde(rename = "is_set")]
    IsSet,
    /// Is not set
    #[serde(rename = "is_not_set")]
    IsNotSet,
}

/// The operand for [Affinity](nomad::types::Affinity)
#[derive(Serialize, Deserialize, SmartDefault, Debug, Clone, Eq, PartialEq)]
pub enum AffinityOperator {
    /// Equals
    #[default]
    #[serde(rename = "=")]
    Equals,
    /// Does not equal
    #[serde(rename = "!=")]
    NotEquals,
    /// Greater than
    #[serde(rename = ">")]
    GreaterThan,
    /// Greater than or equal to
    #[serde(rename = ">=")]
    GreaterThanOrEqual,
    /// Less than
    #[serde(rename = "<")]
    LessThan,
    /// Less than or equal to
    #[serde(rename = "<=")]
    LessThanOrEqual,
    /// Regular expression
    #[serde(rename = "regexp")]
    RegularExpression,
    /// Set contains all
    #[serde(rename = "set_contains_all")]
    SetContainsAll,
    /// Set contains any
    #[serde(rename = "set_contains_any")]
    SetContainsAny,
    /// Version
    #[serde(rename = "version")]
    Version,
}

/// A nomad job deployment , representing a single deployment of a job.
#[derive(Serialize, Deserialize, SmartDefault, Debug, Eq, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub struct JobDeployment {
    /// The ID of the nomad job deployment.
    #[serde(rename = "ID")]
    pub id: String,
    /// The ID of the nomad job .
    #[serde(rename = "JobID")]
    pub job_id: String,
    /// Specifies the version of the job.
    pub job_version: u64,
    /// The status of the job.
    pub status: Option<JobStatus>,
    /// The status description of the job.
    pub status_description: Option<String>,
    // In the future we can add, if needed
    // the following:
    // JobModifyIndex, JobCreateIndex, TaskGroups, CreateIndex, ModifyIndex
}

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

    #[test]
    fn test_deserialize_resources_with_megahertz() {
        let content = r#"
        {
           "CPU": 2000,
           "MemoryMB": 20,
           "Networks": [],
           "Devices": []
        }
        "#;

        let resources: Resources = serde_json::from_str(content).expect("serialization to succeed");

        assert_eq!(resources.cpu, CpuResource::Megahertz(2000));
        assert_eq!(resources.memory_mb, 20);
    }

    #[test]
    fn test_deserialize_resources_with_cores() {
        let content = r#"
        {
           "Cores": 4,
           "MemoryMB": 20,
           "Networks": [],
           "Devices": []
        }
        "#;

        let resources: Resources = serde_json::from_str(content).expect("serialization to succeed");

        assert_eq!(resources.cpu, CpuResource::Cores(4));
        assert_eq!(resources.memory_mb, 20);
    }
}