├── .gitignore ├── src ├── api │ ├── mod.rs │ ├── client.rs │ └── job.rs ├── models │ ├── node_disk_resources.rs │ ├── consul.rs │ ├── dispatch_payload_config.rs │ ├── eval_options.rs │ ├── node_device_locality.rs │ ├── node_memory_resources.rs │ ├── allocated_cpu_resources.rs │ ├── consul_mesh_gateway.rs │ ├── node_reserved_disk_resources.rs │ ├── node_reserved_cpu_resources.rs │ ├── node_reserved_memory_resources.rs │ ├── csi_topology.rs │ ├── reschedule_tracker.rs │ ├── consul_expose_config.rs │ ├── node_reserved_network_resources.rs │ ├── consul_terminating_config_entry.rs │ ├── wait_config.rs │ ├── fuzzy_match.rs │ ├── spread_target.rs │ ├── host_volume_info.rs │ ├── acl_token_role_link.rs │ ├── log_config.rs │ ├── task_lifecycle.rs │ ├── desired_transition.rs │ ├── drain_spec.rs │ ├── point_value.rs │ ├── task_handle.rs │ ├── csi_mount_options.rs │ ├── consul_ingress_service.rs │ ├── raft_configuration.rs │ ├── allocated_memory_resources.rs │ ├── csi_volume_capability.rs │ ├── multiregion_strategy.rs │ ├── multiregion.rs │ ├── csi_topology_request.rs │ ├── namespace_capabilities.rs │ ├── consul_ingress_config_entry.rs │ ├── ephemeral_disk.rs │ ├── job_children_summary.rs │ ├── allocated_resources.rs │ ├── constraint.rs │ ├── check_restart.rs │ ├── consul_gateway_bind_address.rs │ ├── dns_config.rs │ ├── gauge_value.rs │ ├── plan_annotations.rs │ ├── spread.rs │ ├── node_score_meta.rs │ ├── reschedule_event.rs │ ├── node_cpu_resources.rs │ ├── consul_ingress_listener.rs │ ├── operator_health_reply.rs │ ├── allocated_shared_resources.rs │ ├── parameterized_job_config.rs │ ├── port.rs │ ├── port_mapping.rs │ ├── affinity.rs │ ├── job_acl.rs │ ├── restart_policy.rs │ ├── change_script.rs │ ├── host_network_info.rs │ ├── alloc_deployment_status.rs │ ├── acl_policy_list_stub.rs │ ├── allocated_device_resource.rs │ ├── consul_expose_path.rs │ ├── quota_limit.rs │ ├── node_device.rs │ ├── object_diff.rs │ ├── volume_mount.rs │ ├── drain_strategy.rs │ ├── migrate_strategy.rs │ ├── multiregion_region.rs │ ├── consul_gateway_tls_config.rs │ ├── consul_sidecar_service.rs │ ├── requested_device.rs │ ├── attribute.rs │ ├── consul_connect.rs │ ├── field_diff.rs │ ├── consul_gateway.rs │ ├── consul_linked_service.rs │ ├── vault.rs │ ├── allocated_task_resources.rs │ ├── preemption_config.rs │ ├── periodic_config.rs │ ├── node_reserved_resources.rs │ ├── quota_spec.rs │ ├── task_diff.rs │ ├── drain_metadata.rs │ ├── job_diff.rs │ ├── one_time_token.rs │ ├── task_csi_plugin_config.rs │ ├── node_event.rs │ ├── driver_info.rs │ ├── node_device_resource.rs │ ├── alloc_file_info.rs │ ├── raft_server.rs │ ├── metrics_summary.rs │ ├── acl_policy.rs │ ├── task_artifact.rs │ ├── reschedule_policy.rs │ ├── variable_metadata.rs │ ├── consul_proxy.rs │ ├── task_group_scale_status.rs │ ├── scaling_policy_list_stub.rs │ ├── task_group_diff.rs │ ├── job_summary.rs │ ├── task_group_summary.rs │ ├── consul_upstream.rs │ ├── variable.rs │ ├── namespace.rs │ ├── csi_node_info.rs │ ├── desired_updates.rs │ ├── resources.rs │ ├── scaling_event.rs │ ├── node_resources.rs │ ├── volume_request.rs │ ├── task_state.rs │ ├── consul_gateway_proxy.rs │ ├── scheduler_configuration.rs │ ├── sampled_value.rs │ ├── csi_volume_external_stub.rs │ ├── network_resource.rs │ ├── update_strategy.rs │ ├── csi_plugin_list_stub.rs │ ├── csi_info.rs │ ├── scaling_policy.rs │ ├── acl_token_list_stub.rs │ ├── csi_snapshot.rs │ ├── deployment_state.rs │ ├── autopilot_configuration.rs │ ├── server_health.rs │ ├── service_registration.rs │ ├── sidecar_task.rs │ ├── acl_token.rs │ ├── deployment.rs │ ├── csi_controller_info.rs │ ├── csi_plugin.rs │ ├── template.rs │ ├── job_list_stub.rs │ ├── service.rs │ ├── allocation_metric.rs │ ├── evaluation_stub.rs │ ├── node_list_stub.rs │ ├── event.rs │ ├── csi_volume_list_stub.rs │ ├── task_group.rs │ ├── service_check.rs │ ├── task_event.rs │ ├── allocation_list_stub.rs │ ├── task.rs │ ├── evaluation.rs │ ├── node.rs │ ├── allocation.rs │ ├── csi_volume.rs │ ├── job.rs │ └── mod.rs └── lib.rs ├── README.md ├── Cargo.toml └── LICENSE /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | 3 | # MAC 4 | .DS_Store 5 | -------------------------------------------------------------------------------- /src/api/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod client; 2 | pub mod job; 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # nomad-rs 2 | 3 | This project is a fork of [nomad-client-rs](https://gitlab.com/buildline-gmbh/nomad_client_rs). 4 | -------------------------------------------------------------------------------- /src/models/node_disk_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeDiskResources { 5 | #[serde(rename = "DiskMB", skip_serializing_if = "Option::is_none")] 6 | pub disk_mb: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/consul.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Consul { 5 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 6 | pub namespace: Option, 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/models/dispatch_payload_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DispatchPayloadConfig { 5 | #[serde(rename = "File", skip_serializing_if = "Option::is_none")] 6 | pub file: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/eval_options.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct EvalOptions { 5 | #[serde(rename = "ForceReschedule", skip_serializing_if = "Option::is_none")] 6 | pub force_reschedule: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/node_device_locality.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeDeviceLocality { 5 | #[serde(rename = "PciBusID", skip_serializing_if = "Option::is_none")] 6 | pub pci_bus_id: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/node_memory_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeMemoryResources { 5 | #[serde(rename = "MemoryMB", skip_serializing_if = "Option::is_none")] 6 | pub memory_mb: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/allocated_cpu_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocatedCpuResources { 5 | #[serde(rename = "CpuShares", skip_serializing_if = "Option::is_none")] 6 | pub cpu_shares: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/consul_mesh_gateway.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulMeshGateway { 5 | #[serde(rename = "Mode", skip_serializing_if = "Option::is_none")] 6 | pub mode: Option, 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/models/node_reserved_disk_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeReservedDiskResources { 5 | #[serde(rename = "DiskMB", skip_serializing_if = "Option::is_none")] 6 | pub disk_mb: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/node_reserved_cpu_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeReservedCpuResources { 5 | #[serde(rename = "CpuShares", skip_serializing_if = "Option::is_none")] 6 | pub cpu_shares: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/node_reserved_memory_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeReservedMemoryResources { 5 | #[serde(rename = "MemoryMB", skip_serializing_if = "Option::is_none")] 6 | pub memory_mb: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/csi_topology.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiTopology { 5 | #[serde(rename = "Segments", skip_serializing_if = "Option::is_none")] 6 | pub segments: Option<::std::collections::HashMap>, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/reschedule_tracker.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct RescheduleTracker { 5 | #[serde(rename = "Events", skip_serializing_if = "Option::is_none")] 6 | pub events: Option>, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/consul_expose_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulExposeConfig { 5 | #[serde(rename = "Path", skip_serializing_if = "Option::is_none")] 6 | pub path: Option>, 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/models/node_reserved_network_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeReservedNetworkResources { 5 | #[serde(rename = "ReservedHostPorts", skip_serializing_if = "Option::is_none")] 6 | pub reserved_host_ports: Option, 7 | } 8 | -------------------------------------------------------------------------------- /src/models/consul_terminating_config_entry.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulTerminatingConfigEntry { 5 | #[serde(rename = "Services", skip_serializing_if = "Option::is_none")] 6 | pub services: Option>, 7 | } 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/models/wait_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct WaitConfig { 5 | #[serde(rename = "Max", skip_serializing_if = "Option::is_none")] 6 | pub max: Option, 7 | #[serde(rename = "Min", skip_serializing_if = "Option::is_none")] 8 | pub min: Option, 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/models/fuzzy_match.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct FuzzyMatch { 5 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 6 | pub id: Option, 7 | #[serde(rename = "Scope", skip_serializing_if = "Option::is_none")] 8 | pub scope: Option>, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/spread_target.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct SpreadTarget { 5 | #[serde(rename = "Percent", skip_serializing_if = "Option::is_none")] 6 | pub percent: Option, 7 | #[serde(rename = "Value", skip_serializing_if = "Option::is_none")] 8 | pub value: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/host_volume_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct HostVolumeInfo { 5 | #[serde(rename = "Path", skip_serializing_if = "Option::is_none")] 6 | pub path: Option, 7 | #[serde(rename = "ReadOnly", skip_serializing_if = "Option::is_none")] 8 | pub read_only: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/acl_token_role_link.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AclTokenRoleLink { 5 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 6 | pub id: Option, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/models/log_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct LogConfig { 5 | #[serde(rename = "MaxFileSizeMB", skip_serializing_if = "Option::is_none")] 6 | pub max_file_size_mb: Option, 7 | #[serde(rename = "MaxFiles", skip_serializing_if = "Option::is_none")] 8 | pub max_files: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/task_lifecycle.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskLifecycle { 5 | #[serde(rename = "Hook", skip_serializing_if = "Option::is_none")] 6 | pub hook: Option, 7 | #[serde(rename = "Sidecar", skip_serializing_if = "Option::is_none")] 8 | pub sidecar: Option, 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/models/desired_transition.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DesiredTransition { 5 | #[serde(rename = "Migrate", skip_serializing_if = "Option::is_none")] 6 | pub migrate: Option, 7 | #[serde(rename = "Reschedule", skip_serializing_if = "Option::is_none")] 8 | pub reschedule: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/drain_spec.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DrainSpec { 5 | #[serde(rename = "Deadline", skip_serializing_if = "Option::is_none")] 6 | pub deadline: Option, 7 | #[serde(rename = "IgnoreSystemJobs", skip_serializing_if = "Option::is_none")] 8 | pub ignore_system_jobs: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/point_value.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct PointValue { 5 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 6 | pub name: Option, 7 | #[serde(rename = "Points", skip_serializing_if = "Option::is_none")] 8 | pub points: Option>, 9 | } 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /src/models/task_handle.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskHandle { 5 | #[serde(rename = "DriverState", skip_serializing_if = "Option::is_none")] 6 | pub driver_state: Option, 7 | #[serde(rename = "Version", skip_serializing_if = "Option::is_none")] 8 | pub version: Option, 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/models/csi_mount_options.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiMountOptions { 5 | #[serde(rename = "FSType", skip_serializing_if = "Option::is_none")] 6 | pub fs_type: Option, 7 | #[serde(rename = "MountFlags", skip_serializing_if = "Option::is_none")] 8 | pub mount_flags: Option>, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/consul_ingress_service.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulIngressService { 5 | #[serde(rename = "Hosts", skip_serializing_if = "Option::is_none")] 6 | pub hosts: Option>, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/models/raft_configuration.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct RaftConfiguration { 5 | #[serde(rename = "Index", skip_serializing_if = "Option::is_none")] 6 | pub index: Option, 7 | #[serde(rename = "Servers", skip_serializing_if = "Option::is_none")] 8 | pub servers: Option>, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/allocated_memory_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocatedMemoryResources { 5 | #[serde(rename = "MemoryMB", skip_serializing_if = "Option::is_none")] 6 | pub memory_mb: Option, 7 | #[serde(rename = "MemoryMaxMB", skip_serializing_if = "Option::is_none")] 8 | pub memory_max_mb: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/csi_volume_capability.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiVolumeCapability { 5 | #[serde(rename = "AccessMode", skip_serializing_if = "Option::is_none")] 6 | pub access_mode: Option, 7 | #[serde(rename = "AttachmentMode", skip_serializing_if = "Option::is_none")] 8 | pub attachment_mode: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/multiregion_strategy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct MultiregionStrategy { 5 | #[serde(rename = "MaxParallel", skip_serializing_if = "Option::is_none")] 6 | pub max_parallel: Option, 7 | #[serde(rename = "OnFailure", skip_serializing_if = "Option::is_none")] 8 | pub on_failure: Option, 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/models/multiregion.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Multiregion { 5 | #[serde(rename = "Regions", skip_serializing_if = "Option::is_none")] 6 | pub regions: Option>, 7 | #[serde(rename = "Strategy", skip_serializing_if = "Option::is_none")] 8 | pub strategy: Option, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/csi_topology_request.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiTopologyRequest { 5 | #[serde(rename = "Preferred", skip_serializing_if = "Option::is_none")] 6 | pub preferred: Option>, 7 | #[serde(rename = "Required", skip_serializing_if = "Option::is_none")] 8 | pub required: Option>, 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/models/namespace_capabilities.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NamespaceCapabilities { 5 | #[serde(rename = "DisabledTaskDrivers", skip_serializing_if = "Option::is_none")] 6 | pub disabled_task_drivers: Option>, 7 | #[serde(rename = "EnabledTaskDrivers", skip_serializing_if = "Option::is_none")] 8 | pub enabled_task_drivers: Option>, 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/models/consul_ingress_config_entry.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulIngressConfigEntry { 5 | #[serde(rename = "Listeners", skip_serializing_if = "Option::is_none")] 6 | pub listeners: Option>, 7 | #[serde(rename = "TLS", skip_serializing_if = "Option::is_none")] 8 | pub tls: Option, 9 | } 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /src/models/ephemeral_disk.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct EphemeralDisk { 5 | #[serde(rename = "Migrate", skip_serializing_if = "Option::is_none")] 6 | pub migrate: Option, 7 | #[serde(rename = "SizeMB", skip_serializing_if = "Option::is_none")] 8 | pub size_mb: Option, 9 | #[serde(rename = "Sticky", skip_serializing_if = "Option::is_none")] 10 | pub sticky: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/job_children_summary.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct JobChildrenSummary { 5 | #[serde(rename = "Dead", skip_serializing_if = "Option::is_none")] 6 | pub dead: Option, 7 | #[serde(rename = "Pending", skip_serializing_if = "Option::is_none")] 8 | pub pending: Option, 9 | #[serde(rename = "Running", skip_serializing_if = "Option::is_none")] 10 | pub running: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/allocated_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocatedResources { 5 | #[serde(rename = "Shared", skip_serializing_if = "Option::is_none")] 6 | pub shared: Option, 7 | #[serde(rename = "Tasks", skip_serializing_if = "Option::is_none")] 8 | pub tasks: Option<::std::collections::HashMap>, 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/models/constraint.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Constraint { 5 | #[serde(rename = "LTarget", skip_serializing_if = "Option::is_none")] 6 | pub l_target: Option, 7 | #[serde(rename = "Operand", skip_serializing_if = "Option::is_none")] 8 | pub operand: Option, 9 | #[serde(rename = "RTarget", skip_serializing_if = "Option::is_none")] 10 | pub r_target: Option, 11 | } 12 | 13 | -------------------------------------------------------------------------------- /src/models/check_restart.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CheckRestart { 5 | #[serde(rename = "Grace", skip_serializing_if = "Option::is_none")] 6 | pub grace: Option, 7 | #[serde(rename = "IgnoreWarnings", skip_serializing_if = "Option::is_none")] 8 | pub ignore_warnings: Option, 9 | #[serde(rename = "Limit", skip_serializing_if = "Option::is_none")] 10 | pub limit: Option, 11 | } 12 | 13 | 14 | -------------------------------------------------------------------------------- /src/models/consul_gateway_bind_address.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulGatewayBindAddress { 5 | #[serde(rename = "Address", skip_serializing_if = "Option::is_none")] 6 | pub address: Option, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | #[serde(rename = "Port", skip_serializing_if = "Option::is_none")] 10 | pub port: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/dns_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DnsConfig { 5 | #[serde(rename = "Options", skip_serializing_if = "Option::is_none")] 6 | pub options: Option>, 7 | #[serde(rename = "Searches", skip_serializing_if = "Option::is_none")] 8 | pub searches: Option>, 9 | #[serde(rename = "Servers", skip_serializing_if = "Option::is_none")] 10 | pub servers: Option>, 11 | } 12 | 13 | -------------------------------------------------------------------------------- /src/models/gauge_value.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct GaugeValue { 5 | #[serde(rename = "Labels", skip_serializing_if = "Option::is_none")] 6 | pub labels: Option<::std::collections::HashMap>, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | #[serde(rename = "Value", skip_serializing_if = "Option::is_none")] 10 | pub value: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/plan_annotations.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct PlanAnnotations { 5 | #[serde(rename = "DesiredTGUpdates", skip_serializing_if = "Option::is_none")] 6 | pub desired_tg_updates: Option<::std::collections::HashMap>, 7 | #[serde(rename = "PreemptedAllocs", skip_serializing_if = "Option::is_none")] 8 | pub preempted_allocs: Option>, 9 | } 10 | -------------------------------------------------------------------------------- /src/models/spread.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Spread { 5 | #[serde(rename = "Attribute", skip_serializing_if = "Option::is_none")] 6 | pub attribute: Option, 7 | #[serde(rename = "SpreadTarget", skip_serializing_if = "Option::is_none")] 8 | pub spread_target: Option>, 9 | #[serde(rename = "Weight", skip_serializing_if = "Option::is_none")] 10 | pub weight: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/api/client.rs: -------------------------------------------------------------------------------- 1 | use reqwest::Method; 2 | 3 | use crate::{Nomad, NomadError}; 4 | 5 | impl Nomad { 6 | /// https://developer.hashicorp.com/nomad/api-docs/client#read-file 7 | pub async fn client_read_file( 8 | &self, 9 | alloc_id: &str, 10 | file_path: &str, 11 | ) -> Result { 12 | let req = self.request( 13 | Method::GET, 14 | &format!("client/fs/cat/{}?path={}", alloc_id, file_path), 15 | ); 16 | 17 | self.send_plain(req).await 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/models/node_score_meta.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeScoreMeta { 5 | #[serde(rename = "NodeID", skip_serializing_if = "Option::is_none")] 6 | pub node_id: Option, 7 | #[serde(rename = "NormScore", skip_serializing_if = "Option::is_none")] 8 | pub norm_score: Option, 9 | #[serde(rename = "Scores", skip_serializing_if = "Option::is_none")] 10 | pub scores: Option<::std::collections::HashMap>, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/reschedule_event.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct RescheduleEvent { 5 | #[serde(rename = "PrevAllocID", skip_serializing_if = "Option::is_none")] 6 | pub prev_alloc_id: Option, 7 | #[serde(rename = "PrevNodeID", skip_serializing_if = "Option::is_none")] 8 | pub prev_node_id: Option, 9 | #[serde(rename = "RescheduleTime", skip_serializing_if = "Option::is_none")] 10 | pub reschedule_time: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/node_cpu_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeCpuResources { 5 | #[serde(rename = "CpuShares", skip_serializing_if = "Option::is_none")] 6 | pub cpu_shares: Option, 7 | #[serde(rename = "ReservableCpuCores", skip_serializing_if = "Option::is_none")] 8 | pub reservable_cpu_cores: Option>, 9 | #[serde(rename = "TotalCpuCores", skip_serializing_if = "Option::is_none")] 10 | pub total_cpu_cores: Option, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/consul_ingress_listener.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulIngressListener { 5 | #[serde(rename = "Port", skip_serializing_if = "Option::is_none")] 6 | pub port: Option, 7 | #[serde(rename = "Protocol", skip_serializing_if = "Option::is_none")] 8 | pub protocol: Option, 9 | #[serde(rename = "Services", skip_serializing_if = "Option::is_none")] 10 | pub services: Option>, 11 | } 12 | 13 | -------------------------------------------------------------------------------- /src/models/operator_health_reply.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct OperatorHealthReply { 5 | #[serde(rename = "FailureTolerance", skip_serializing_if = "Option::is_none")] 6 | pub failure_tolerance: Option, 7 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 8 | pub healthy: Option, 9 | #[serde(rename = "Servers", skip_serializing_if = "Option::is_none")] 10 | pub servers: Option>, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/allocated_shared_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocatedSharedResources { 5 | #[serde(rename = "DiskMB", skip_serializing_if = "Option::is_none")] 6 | pub disk_mb: Option, 7 | #[serde(rename = "Networks", skip_serializing_if = "Option::is_none")] 8 | pub networks: Option>, 9 | #[serde(rename = "Ports", skip_serializing_if = "Option::is_none")] 10 | pub ports: Option>, 11 | } 12 | -------------------------------------------------------------------------------- /src/models/parameterized_job_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ParameterizedJobConfig { 5 | #[serde(rename = "MetaOptional", skip_serializing_if = "Option::is_none")] 6 | pub meta_optional: Option>, 7 | #[serde(rename = "MetaRequired", skip_serializing_if = "Option::is_none")] 8 | pub meta_required: Option>, 9 | #[serde(rename = "Payload", skip_serializing_if = "Option::is_none")] 10 | pub payload: Option, 11 | } 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /src/models/port.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Port { 5 | #[serde(rename = "HostNetwork", skip_serializing_if = "Option::is_none")] 6 | pub host_network: Option, 7 | #[serde(rename = "Label", skip_serializing_if = "Option::is_none")] 8 | pub label: Option, 9 | #[serde(rename = "To", skip_serializing_if = "Option::is_none")] 10 | pub to: Option, 11 | #[serde(rename = "Value", skip_serializing_if = "Option::is_none")] 12 | pub value: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/port_mapping.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct PortMapping { 5 | #[serde(rename = "HostIP", skip_serializing_if = "Option::is_none")] 6 | pub host_ip: Option, 7 | #[serde(rename = "Label", skip_serializing_if = "Option::is_none")] 8 | pub label: Option, 9 | #[serde(rename = "To", skip_serializing_if = "Option::is_none")] 10 | pub to: Option, 11 | #[serde(rename = "Value", skip_serializing_if = "Option::is_none")] 12 | pub value: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/affinity.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Affinity { 5 | #[serde(rename = "LTarget", skip_serializing_if = "Option::is_none")] 6 | pub l_target: Option, 7 | #[serde(rename = "Operand", skip_serializing_if = "Option::is_none")] 8 | pub operand: Option, 9 | #[serde(rename = "RTarget", skip_serializing_if = "Option::is_none")] 10 | pub r_target: Option, 11 | #[serde(rename = "Weight", skip_serializing_if = "Option::is_none")] 12 | pub weight: Option, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/job_acl.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct JobAcl { 5 | #[serde(rename = "Group", skip_serializing_if = "Option::is_none")] 6 | pub group: Option, 7 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 8 | pub job_id: Option, 9 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 10 | pub namespace: Option, 11 | #[serde(rename = "Task", skip_serializing_if = "Option::is_none")] 12 | pub task: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/restart_policy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct RestartPolicy { 5 | #[serde(rename = "Attempts", skip_serializing_if = "Option::is_none")] 6 | pub attempts: Option, 7 | #[serde(rename = "Delay", skip_serializing_if = "Option::is_none")] 8 | pub delay: Option, 9 | #[serde(rename = "Interval", skip_serializing_if = "Option::is_none")] 10 | pub interval: Option, 11 | #[serde(rename = "Mode", skip_serializing_if = "Option::is_none")] 12 | pub mode: Option, 13 | } 14 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "nomad-rs" 3 | version = "0.0.1-beta.3" 4 | edition = "2021" 5 | 6 | description = "A client to interact with Nomad by HashiCorp" 7 | repository = "https://github.com/unknown/nomad-rs" 8 | readme = "README.md" 9 | license-file = "LICENSE" 10 | 11 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 12 | 13 | [dependencies] 14 | reqwest = { version = "0.12.5", features = ["stream", "json", "rustls-tls"] } 15 | serde = { version = "1.0.203", features = ["derive"] } 16 | serde_json = "1.0.117" 17 | thiserror = "1.0.61" 18 | tokio = { version = "1.38.0", features = ["full"] } 19 | -------------------------------------------------------------------------------- /src/models/change_script.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ChangeScript { 5 | #[serde(rename = "Args", skip_serializing_if = "Option::is_none")] 6 | pub args: Option>, 7 | #[serde(rename = "Command", skip_serializing_if = "Option::is_none")] 8 | pub command: Option, 9 | #[serde(rename = "FailOnError", skip_serializing_if = "Option::is_none")] 10 | pub fail_on_error: Option, 11 | #[serde(rename = "Timeout", skip_serializing_if = "Option::is_none")] 12 | pub timeout: Option, 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/models/host_network_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct HostNetworkInfo { 5 | #[serde(rename = "CIDR", skip_serializing_if = "Option::is_none")] 6 | pub cidr: Option, 7 | #[serde(rename = "Interface", skip_serializing_if = "Option::is_none")] 8 | pub interface: Option, 9 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 10 | pub name: Option, 11 | #[serde(rename = "ReservedPorts", skip_serializing_if = "Option::is_none")] 12 | pub reserved_ports: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/alloc_deployment_status.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocDeploymentStatus { 5 | #[serde(rename = "Canary", skip_serializing_if = "Option::is_none")] 6 | pub canary: Option, 7 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 8 | pub healthy: Option, 9 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 10 | pub modify_index: Option, 11 | #[serde(rename = "Timestamp", skip_serializing_if = "Option::is_none")] 12 | pub timestamp: Option, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/acl_policy_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AclPolicyListStub { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Description", skip_serializing_if = "Option::is_none")] 8 | pub description: Option, 9 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 10 | pub modify_index: Option, 11 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 12 | pub name: Option, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/allocated_device_resource.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocatedDeviceResource { 5 | #[serde(rename = "DeviceIDs", skip_serializing_if = "Option::is_none")] 6 | pub device_ids: Option>, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 10 | pub _type: Option, 11 | #[serde(rename = "Vendor", skip_serializing_if = "Option::is_none")] 12 | pub vendor: Option, 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/models/consul_expose_path.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulExposePath { 5 | #[serde(rename = "ListenerPort", skip_serializing_if = "Option::is_none")] 6 | pub listener_port: Option, 7 | #[serde(rename = "LocalPathPort", skip_serializing_if = "Option::is_none")] 8 | pub local_path_port: Option, 9 | #[serde(rename = "Path", skip_serializing_if = "Option::is_none")] 10 | pub path: Option, 11 | #[serde(rename = "Protocol", skip_serializing_if = "Option::is_none")] 12 | pub protocol: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/quota_limit.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct QuotaLimit { 5 | #[serde(rename = "Hash", skip_serializing_if = "Option::is_none")] 6 | pub hash: Option, 7 | #[serde(rename = "Region", skip_serializing_if = "Option::is_none")] 8 | pub region: Option, 9 | #[serde(rename = "RegionLimit", skip_serializing_if = "Option::is_none")] 10 | pub region_limit: Option, 11 | #[serde(rename = "VariablesLimit", skip_serializing_if = "Option::is_none")] 12 | pub variables_limit: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/node_device.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeDevice { 5 | #[serde(rename = "HealthDescription", skip_serializing_if = "Option::is_none")] 6 | pub health_description: Option, 7 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 8 | pub healthy: Option, 9 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 10 | pub id: Option, 11 | #[serde(rename = "Locality", skip_serializing_if = "Option::is_none")] 12 | pub locality: Option, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/object_diff.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ObjectDiff { 5 | #[serde(rename = "Fields", skip_serializing_if = "Option::is_none")] 6 | pub fields: Option>, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | #[serde(rename = "Objects", skip_serializing_if = "Option::is_none")] 10 | pub objects: Option>, 11 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 12 | pub _type: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/volume_mount.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct VolumeMount { 5 | #[serde(rename = "Destination", skip_serializing_if = "Option::is_none")] 6 | pub destination: Option, 7 | #[serde(rename = "PropagationMode", skip_serializing_if = "Option::is_none")] 8 | pub propagation_mode: Option, 9 | #[serde(rename = "ReadOnly", skip_serializing_if = "Option::is_none")] 10 | pub read_only: Option, 11 | #[serde(rename = "Volume", skip_serializing_if = "Option::is_none")] 12 | pub volume: Option, 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/models/drain_strategy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DrainStrategy { 5 | #[serde(rename = "Deadline", skip_serializing_if = "Option::is_none")] 6 | pub deadline: Option, 7 | #[serde(rename = "ForceDeadline", skip_serializing_if = "Option::is_none")] 8 | pub force_deadline: Option, 9 | #[serde(rename = "IgnoreSystemJobs", skip_serializing_if = "Option::is_none")] 10 | pub ignore_system_jobs: Option, 11 | #[serde(rename = "StartedAt", skip_serializing_if = "Option::is_none")] 12 | pub started_at: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/migrate_strategy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct MigrateStrategy { 5 | #[serde(rename = "HealthCheck", skip_serializing_if = "Option::is_none")] 6 | pub health_check: Option, 7 | #[serde(rename = "HealthyDeadline", skip_serializing_if = "Option::is_none")] 8 | pub healthy_deadline: Option, 9 | #[serde(rename = "MaxParallel", skip_serializing_if = "Option::is_none")] 10 | pub max_parallel: Option, 11 | #[serde(rename = "MinHealthyTime", skip_serializing_if = "Option::is_none")] 12 | pub min_healthy_time: Option, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/multiregion_region.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct MultiregionRegion { 5 | #[serde(rename = "Count", skip_serializing_if = "Option::is_none")] 6 | pub count: Option, 7 | #[serde(rename = "Datacenters", skip_serializing_if = "Option::is_none")] 8 | pub datacenters: Option>, 9 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 10 | pub meta: Option<::std::collections::HashMap>, 11 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 12 | pub name: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/consul_gateway_tls_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulGatewayTlsConfig { 5 | #[serde(rename = "CipherSuites", skip_serializing_if = "Option::is_none")] 6 | pub cipher_suites: Option>, 7 | #[serde(rename = "Enabled", skip_serializing_if = "Option::is_none")] 8 | pub enabled: Option, 9 | #[serde(rename = "TLSMaxVersion", skip_serializing_if = "Option::is_none")] 10 | pub tls_max_version: Option, 11 | #[serde(rename = "TLSMinVersion", skip_serializing_if = "Option::is_none")] 12 | pub tls_min_version: Option, 13 | } -------------------------------------------------------------------------------- /src/models/consul_sidecar_service.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulSidecarService { 5 | #[serde(rename = "DisableDefaultTCPCheck", skip_serializing_if = "Option::is_none")] 6 | pub disable_default_tcp_check: Option, 7 | #[serde(rename = "Port", skip_serializing_if = "Option::is_none")] 8 | pub port: Option, 9 | #[serde(rename = "Proxy", skip_serializing_if = "Option::is_none")] 10 | pub proxy: Option, 11 | #[serde(rename = "Tags", skip_serializing_if = "Option::is_none")] 12 | pub tags: Option>, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/requested_device.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct RequestedDevice { 5 | #[serde(rename = "Affinities", skip_serializing_if = "Option::is_none")] 6 | pub affinities: Option>, 7 | #[serde(rename = "Constraints", skip_serializing_if = "Option::is_none")] 8 | pub constraints: Option>, 9 | #[serde(rename = "Count", skip_serializing_if = "Option::is_none")] 10 | pub count: Option, 11 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 12 | pub name: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/attribute.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Attribute { 5 | #[serde(rename = "Bool", skip_serializing_if = "Option::is_none")] 6 | pub bool: Option, 7 | #[serde(rename = "Float", skip_serializing_if = "Option::is_none")] 8 | pub float: Option, 9 | #[serde(rename = "Int", skip_serializing_if = "Option::is_none")] 10 | pub int: Option, 11 | #[serde(rename = "String", skip_serializing_if = "Option::is_none")] 12 | pub string: Option, 13 | #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")] 14 | pub unit: Option, 15 | } 16 | -------------------------------------------------------------------------------- /src/models/consul_connect.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulConnect { 5 | #[serde(rename = "Gateway", skip_serializing_if = "Option::is_none")] 6 | pub gateway: Option, 7 | #[serde(rename = "Native", skip_serializing_if = "Option::is_none")] 8 | pub native: Option, 9 | #[serde(rename = "SidecarService", skip_serializing_if = "Option::is_none")] 10 | pub sidecar_service: Option, 11 | #[serde(rename = "SidecarTask", skip_serializing_if = "Option::is_none")] 12 | pub sidecar_task: Option, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/field_diff.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct FieldDiff { 5 | #[serde(rename = "Annotations", skip_serializing_if = "Option::is_none")] 6 | pub annotations: Option>, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | #[serde(rename = "New", skip_serializing_if = "Option::is_none")] 10 | pub new: Option, 11 | #[serde(rename = "Old", skip_serializing_if = "Option::is_none")] 12 | pub old: Option, 13 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 14 | pub _type: Option, 15 | } 16 | -------------------------------------------------------------------------------- /src/models/consul_gateway.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulGateway { 5 | #[serde(rename = "Ingress", skip_serializing_if = "Option::is_none")] 6 | pub ingress: Option, 7 | #[serde(rename = "Mesh", skip_serializing_if = "Option::is_none")] 8 | pub mesh: Option, 9 | #[serde(rename = "Proxy", skip_serializing_if = "Option::is_none")] 10 | pub proxy: Option, 11 | #[serde(rename = "Terminating", skip_serializing_if = "Option::is_none")] 12 | pub terminating: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/consul_linked_service.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulLinkedService { 5 | #[serde(rename = "CAFile", skip_serializing_if = "Option::is_none")] 6 | pub ca_file: Option, 7 | #[serde(rename = "CertFile", skip_serializing_if = "Option::is_none")] 8 | pub cert_file: Option, 9 | #[serde(rename = "KeyFile", skip_serializing_if = "Option::is_none")] 10 | pub key_file: Option, 11 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 12 | pub name: Option, 13 | #[serde(rename = "SNI", skip_serializing_if = "Option::is_none")] 14 | pub sni: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/vault.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Vault { 5 | #[serde(rename = "ChangeMode", skip_serializing_if = "Option::is_none")] 6 | pub change_mode: Option, 7 | #[serde(rename = "ChangeSignal", skip_serializing_if = "Option::is_none")] 8 | pub change_signal: Option, 9 | #[serde(rename = "Env", skip_serializing_if = "Option::is_none")] 10 | pub env: Option, 11 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 12 | pub namespace: Option, 13 | #[serde(rename = "Policies", skip_serializing_if = "Option::is_none")] 14 | pub policies: Option>, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/allocated_task_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocatedTaskResources { 5 | #[serde(rename = "Cpu", skip_serializing_if = "Option::is_none")] 6 | pub cpu: Option, 7 | #[serde(rename = "Devices", skip_serializing_if = "Option::is_none")] 8 | pub devices: Option>, 9 | #[serde(rename = "Memory", skip_serializing_if = "Option::is_none")] 10 | pub memory: Option, 11 | #[serde(rename = "Networks", skip_serializing_if = "Option::is_none")] 12 | pub networks: Option>, 13 | } 14 | -------------------------------------------------------------------------------- /src/models/preemption_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct PreemptionConfig { 5 | #[serde(rename = "BatchSchedulerEnabled", skip_serializing_if = "Option::is_none")] 6 | pub batch_scheduler_enabled: Option, 7 | #[serde(rename = "ServiceSchedulerEnabled", skip_serializing_if = "Option::is_none")] 8 | pub service_scheduler_enabled: Option, 9 | #[serde(rename = "SysBatchSchedulerEnabled", skip_serializing_if = "Option::is_none")] 10 | pub sys_batch_scheduler_enabled: Option, 11 | #[serde(rename = "SystemSchedulerEnabled", skip_serializing_if = "Option::is_none")] 12 | pub system_scheduler_enabled: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/periodic_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct PeriodicConfig { 5 | #[serde(rename = "Enabled", skip_serializing_if = "Option::is_none")] 6 | pub enabled: Option, 7 | #[serde(rename = "ProhibitOverlap", skip_serializing_if = "Option::is_none")] 8 | pub prohibit_overlap: Option, 9 | #[serde(rename = "Spec", skip_serializing_if = "Option::is_none")] 10 | pub spec: Option, 11 | #[serde(rename = "SpecType", skip_serializing_if = "Option::is_none")] 12 | pub spec_type: Option, 13 | #[serde(rename = "TimeZone", skip_serializing_if = "Option::is_none")] 14 | pub time_zone: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/node_reserved_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeReservedResources { 5 | #[serde(rename = "Cpu", skip_serializing_if = "Option::is_none")] 6 | pub cpu: Option, 7 | #[serde(rename = "Disk", skip_serializing_if = "Option::is_none")] 8 | pub disk: Option, 9 | #[serde(rename = "Memory", skip_serializing_if = "Option::is_none")] 10 | pub memory: Option, 11 | #[serde(rename = "Networks", skip_serializing_if = "Option::is_none")] 12 | pub networks: Option, 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/models/quota_spec.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct QuotaSpec { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Description", skip_serializing_if = "Option::is_none")] 8 | pub description: Option, 9 | #[serde(rename = "Limits", skip_serializing_if = "Option::is_none")] 10 | pub limits: Option>, 11 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub modify_index: Option, 13 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 14 | pub name: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/task_diff.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskDiff { 5 | #[serde(rename = "Annotations", skip_serializing_if = "Option::is_none")] 6 | pub annotations: Option>, 7 | #[serde(rename = "Fields", skip_serializing_if = "Option::is_none")] 8 | pub fields: Option>, 9 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 10 | pub name: Option, 11 | #[serde(rename = "Objects", skip_serializing_if = "Option::is_none")] 12 | pub objects: Option>, 13 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 14 | pub _type: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/drain_metadata.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DrainMetadata { 5 | #[serde(rename = "AccessorID", skip_serializing_if = "Option::is_none")] 6 | pub accessor_id: Option, 7 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 8 | pub meta: Option<::std::collections::HashMap>, 9 | #[serde(rename = "StartedAt", skip_serializing_if = "Option::is_none")] 10 | pub started_at: Option, 11 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 12 | pub status: Option, 13 | #[serde(rename = "UpdatedAt", skip_serializing_if = "Option::is_none")] 14 | pub updated_at: Option, 15 | } 16 | 17 | -------------------------------------------------------------------------------- /src/models/job_diff.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct JobDiff { 5 | #[serde(rename = "Fields", skip_serializing_if = "Option::is_none")] 6 | pub fields: Option>, 7 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 8 | pub id: Option, 9 | #[serde(rename = "Objects", skip_serializing_if = "Option::is_none")] 10 | pub objects: Option>, 11 | #[serde(rename = "TaskGroups", skip_serializing_if = "Option::is_none")] 12 | pub task_groups: Option>, 13 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 14 | pub _type: Option, 15 | } 16 | -------------------------------------------------------------------------------- /src/models/one_time_token.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct OneTimeToken { 5 | #[serde(rename = "AccessorID", skip_serializing_if = "Option::is_none")] 6 | pub accessor_id: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "ExpiresAt", skip_serializing_if = "Option::is_none")] 10 | pub expires_at: Option, 11 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub modify_index: Option, 13 | #[serde(rename = "OneTimeSecretID", skip_serializing_if = "Option::is_none")] 14 | pub one_time_secret_id: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/task_csi_plugin_config.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskCsiPluginConfig { 5 | #[serde(rename = "HealthTimeout", skip_serializing_if = "Option::is_none")] 6 | pub health_timeout: Option, 7 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 8 | pub id: Option, 9 | #[serde(rename = "MountDir", skip_serializing_if = "Option::is_none")] 10 | pub mount_dir: Option, 11 | #[serde(rename = "StagePublishBaseDir", skip_serializing_if = "Option::is_none")] 12 | pub stage_publish_base_dir: Option, 13 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 14 | pub _type: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/node_event.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeEvent { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Details", skip_serializing_if = "Option::is_none")] 8 | pub details: Option<::std::collections::HashMap>, 9 | #[serde(rename = "Message", skip_serializing_if = "Option::is_none")] 10 | pub message: Option, 11 | #[serde(rename = "Subsystem", skip_serializing_if = "Option::is_none")] 12 | pub subsystem: Option, 13 | #[serde(rename = "Timestamp", skip_serializing_if = "Option::is_none")] 14 | pub timestamp: Option, 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/models/driver_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DriverInfo { 5 | #[serde(rename = "Attributes", skip_serializing_if = "Option::is_none")] 6 | pub attributes: Option<::std::collections::HashMap>, 7 | #[serde(rename = "Detected", skip_serializing_if = "Option::is_none")] 8 | pub detected: Option, 9 | #[serde(rename = "HealthDescription", skip_serializing_if = "Option::is_none")] 10 | pub health_description: Option, 11 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 12 | pub healthy: Option, 13 | #[serde(rename = "UpdateTime", skip_serializing_if = "Option::is_none")] 14 | pub update_time: Option, 15 | } 16 | -------------------------------------------------------------------------------- /src/models/node_device_resource.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeDeviceResource { 5 | #[serde(rename = "Attributes", skip_serializing_if = "Option::is_none")] 6 | pub attributes: Option<::std::collections::HashMap>, 7 | #[serde(rename = "Instances", skip_serializing_if = "Option::is_none")] 8 | pub instances: Option>, 9 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 10 | pub name: Option, 11 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 12 | pub _type: Option, 13 | #[serde(rename = "Vendor", skip_serializing_if = "Option::is_none")] 14 | pub vendor: Option, 15 | } 16 | -------------------------------------------------------------------------------- /src/models/alloc_file_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, Deserialize, Serialize)] 4 | pub struct AllocFileInfo { 5 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 6 | pub name: Option, 7 | #[serde(rename = "IsDir", skip_serializing_if = "Option::is_none")] 8 | pub is_dir: Option, 9 | #[serde(rename = "Size", skip_serializing_if = "Option::is_none")] 10 | pub size: Option, 11 | #[serde(rename = "FileMode", skip_serializing_if = "Option::is_none")] 12 | pub file_mode: Option, 13 | #[serde(rename = "ModTime", skip_serializing_if = "Option::is_none")] 14 | pub mod_time: Option, 15 | #[serde(rename = "ContentType", skip_serializing_if = "Option::is_none")] 16 | pub content_type: Option, 17 | } -------------------------------------------------------------------------------- /src/models/raft_server.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct RaftServer { 5 | #[serde(rename = "Address", skip_serializing_if = "Option::is_none")] 6 | pub address: Option, 7 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 8 | pub id: Option, 9 | #[serde(rename = "Leader", skip_serializing_if = "Option::is_none")] 10 | pub leader: Option, 11 | #[serde(rename = "Node", skip_serializing_if = "Option::is_none")] 12 | pub node: Option, 13 | #[serde(rename = "RaftProtocol", skip_serializing_if = "Option::is_none")] 14 | pub raft_protocol: Option, 15 | #[serde(rename = "Voter", skip_serializing_if = "Option::is_none")] 16 | pub voter: Option, 17 | } 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/models/metrics_summary.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct MetricsSummary { 5 | #[serde(rename = "Counters", skip_serializing_if = "Option::is_none")] 6 | pub counters: Option>, 7 | #[serde(rename = "Gauges", skip_serializing_if = "Option::is_none")] 8 | pub gauges: Option>, 9 | #[serde(rename = "Points", skip_serializing_if = "Option::is_none")] 10 | pub points: Option>, 11 | #[serde(rename = "Samples", skip_serializing_if = "Option::is_none")] 12 | pub samples: Option>, 13 | #[serde(rename = "Timestamp", skip_serializing_if = "Option::is_none")] 14 | pub timestamp: Option, 15 | } 16 | 17 | -------------------------------------------------------------------------------- /src/models/acl_policy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AclPolicy { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Description", skip_serializing_if = "Option::is_none")] 8 | pub description: Option, 9 | #[serde(rename = "JobACL", skip_serializing_if = "Option::is_none")] 10 | pub job_acl: Option, 11 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub modify_index: Option, 13 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 14 | pub name: Option, 15 | #[serde(rename = "Rules", skip_serializing_if = "Option::is_none")] 16 | pub rules: Option, 17 | } 18 | -------------------------------------------------------------------------------- /src/models/task_artifact.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskArtifact { 5 | #[serde(rename = "GetterHeaders", skip_serializing_if = "Option::is_none")] 6 | pub getter_headers: Option<::std::collections::HashMap>, 7 | #[serde(rename = "GetterMode", skip_serializing_if = "Option::is_none")] 8 | pub getter_mode: Option, 9 | #[serde(rename = "GetterOptions", skip_serializing_if = "Option::is_none")] 10 | pub getter_options: Option<::std::collections::HashMap>, 11 | #[serde(rename = "GetterSource", skip_serializing_if = "Option::is_none")] 12 | pub getter_source: Option, 13 | #[serde(rename = "RelativeDest", skip_serializing_if = "Option::is_none")] 14 | pub relative_dest: Option, 15 | } 16 | 17 | -------------------------------------------------------------------------------- /src/models/reschedule_policy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ReschedulePolicy { 5 | #[serde(rename = "Attempts", skip_serializing_if = "Option::is_none")] 6 | pub attempts: Option, 7 | #[serde(rename = "Delay", skip_serializing_if = "Option::is_none")] 8 | pub delay: Option, 9 | #[serde(rename = "DelayFunction", skip_serializing_if = "Option::is_none")] 10 | pub delay_function: Option, 11 | #[serde(rename = "Interval", skip_serializing_if = "Option::is_none")] 12 | pub interval: Option, 13 | #[serde(rename = "MaxDelay", skip_serializing_if = "Option::is_none")] 14 | pub max_delay: Option, 15 | #[serde(rename = "Unlimited", skip_serializing_if = "Option::is_none")] 16 | pub unlimited: Option, 17 | } 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/models/variable_metadata.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct VariableMetadata { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 8 | pub create_time: Option, 9 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 10 | pub modify_index: Option, 11 | #[serde(rename = "ModifyTime", skip_serializing_if = "Option::is_none")] 12 | pub modify_time: Option, 13 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 14 | pub namespace: Option, 15 | #[serde(rename = "Path", skip_serializing_if = "Option::is_none")] 16 | pub path: Option, 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/models/consul_proxy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulProxy { 5 | #[serde(rename = "Config", skip_serializing_if = "Option::is_none")] 6 | pub config: Option<::std::collections::HashMap>, 7 | #[serde(rename = "ExposeConfig", skip_serializing_if = "Option::is_none")] 8 | pub expose_config: Option, 9 | #[serde(rename = "LocalServiceAddress", skip_serializing_if = "Option::is_none")] 10 | pub local_service_address: Option, 11 | #[serde(rename = "LocalServicePort", skip_serializing_if = "Option::is_none")] 12 | pub local_service_port: Option, 13 | #[serde(rename = "Upstreams", skip_serializing_if = "Option::is_none")] 14 | pub upstreams: Option>, 15 | } 16 | -------------------------------------------------------------------------------- /src/models/task_group_scale_status.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskGroupScaleStatus { 5 | #[serde(rename = "Desired", skip_serializing_if = "Option::is_none")] 6 | pub desired: Option, 7 | #[serde(rename = "Events", skip_serializing_if = "Option::is_none")] 8 | pub events: Option>, 9 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 10 | pub healthy: Option, 11 | #[serde(rename = "Placed", skip_serializing_if = "Option::is_none")] 12 | pub placed: Option, 13 | #[serde(rename = "Running", skip_serializing_if = "Option::is_none")] 14 | pub running: Option, 15 | #[serde(rename = "Unhealthy", skip_serializing_if = "Option::is_none")] 16 | pub unhealthy: Option, 17 | } 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /src/models/scaling_policy_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ScalingPolicyListStub { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Enabled", skip_serializing_if = "Option::is_none")] 8 | pub enabled: Option, 9 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 10 | pub id: Option, 11 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub modify_index: Option, 13 | #[serde(rename = "Target", skip_serializing_if = "Option::is_none")] 14 | pub target: Option<::std::collections::HashMap>, 15 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 16 | pub _type: Option, 17 | } 18 | -------------------------------------------------------------------------------- /src/models/task_group_diff.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskGroupDiff { 5 | #[serde(rename = "Fields", skip_serializing_if = "Option::is_none")] 6 | pub fields: Option>, 7 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 8 | pub name: Option, 9 | #[serde(rename = "Objects", skip_serializing_if = "Option::is_none")] 10 | pub objects: Option>, 11 | #[serde(rename = "Tasks", skip_serializing_if = "Option::is_none")] 12 | pub tasks: Option>, 13 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 14 | pub _type: Option, 15 | #[serde(rename = "Updates", skip_serializing_if = "Option::is_none")] 16 | pub updates: Option<::std::collections::HashMap>, 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/models/job_summary.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct JobSummary { 5 | #[serde(rename = "Children", skip_serializing_if = "Option::is_none")] 6 | pub children: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 10 | pub job_id: Option, 11 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub modify_index: Option, 13 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 14 | pub namespace: Option, 15 | #[serde(rename = "Summary", skip_serializing_if = "Option::is_none")] 16 | pub summary: Option<::std::collections::HashMap>, 17 | } 18 | -------------------------------------------------------------------------------- /src/models/task_group_summary.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskGroupSummary { 5 | #[serde(rename = "Complete", skip_serializing_if = "Option::is_none")] 6 | pub complete: Option, 7 | #[serde(rename = "Failed", skip_serializing_if = "Option::is_none")] 8 | pub failed: Option, 9 | #[serde(rename = "Lost", skip_serializing_if = "Option::is_none")] 10 | pub lost: Option, 11 | #[serde(rename = "Queued", skip_serializing_if = "Option::is_none")] 12 | pub queued: Option, 13 | #[serde(rename = "Running", skip_serializing_if = "Option::is_none")] 14 | pub running: Option, 15 | #[serde(rename = "Starting", skip_serializing_if = "Option::is_none")] 16 | pub starting: Option, 17 | #[serde(rename = "Unknown", skip_serializing_if = "Option::is_none")] 18 | pub unknown: Option, 19 | } 20 | 21 | 22 | -------------------------------------------------------------------------------- /src/models/consul_upstream.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulUpstream { 5 | #[serde(rename = "Datacenter", skip_serializing_if = "Option::is_none")] 6 | pub datacenter: Option, 7 | #[serde(rename = "DestinationName", skip_serializing_if = "Option::is_none")] 8 | pub destination_name: Option, 9 | #[serde(rename = "DestinationNamespace", skip_serializing_if = "Option::is_none")] 10 | pub destination_namespace: Option, 11 | #[serde(rename = "LocalBindAddress", skip_serializing_if = "Option::is_none")] 12 | pub local_bind_address: Option, 13 | #[serde(rename = "LocalBindPort", skip_serializing_if = "Option::is_none")] 14 | pub local_bind_port: Option, 15 | #[serde(rename = "MeshGateway", skip_serializing_if = "Option::is_none")] 16 | pub mesh_gateway: Option, 17 | } 18 | -------------------------------------------------------------------------------- /src/models/variable.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Variable { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 8 | pub create_time: Option, 9 | #[serde(rename = "Items", skip_serializing_if = "Option::is_none")] 10 | pub items: Option<::std::collections::HashMap>, 11 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub modify_index: Option, 13 | #[serde(rename = "ModifyTime", skip_serializing_if = "Option::is_none")] 14 | pub modify_time: Option, 15 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 16 | pub namespace: Option, 17 | #[serde(rename = "Path", skip_serializing_if = "Option::is_none")] 18 | pub path: Option, 19 | } 20 | 21 | 22 | -------------------------------------------------------------------------------- /src/models/namespace.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Namespace { 5 | #[serde(rename = "Capabilities", skip_serializing_if = "Option::is_none")] 6 | pub capabilities: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "Description", skip_serializing_if = "Option::is_none")] 10 | pub description: Option, 11 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 12 | pub meta: Option<::std::collections::HashMap>, 13 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 14 | pub modify_index: Option, 15 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 16 | pub name: Option, 17 | #[serde(rename = "Quota", skip_serializing_if = "Option::is_none")] 18 | pub quota: Option, 19 | } 20 | -------------------------------------------------------------------------------- /src/models/csi_node_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiNodeInfo { 5 | #[serde(rename = "AccessibleTopology", skip_serializing_if = "Option::is_none")] 6 | pub accessible_topology: Option, 7 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 8 | pub id: Option, 9 | #[serde(rename = "MaxVolumes", skip_serializing_if = "Option::is_none")] 10 | pub max_volumes: Option, 11 | #[serde(rename = "RequiresNodeStageVolume", skip_serializing_if = "Option::is_none")] 12 | pub requires_node_stage_volume: Option, 13 | #[serde(rename = "SupportsCondition", skip_serializing_if = "Option::is_none")] 14 | pub supports_condition: Option, 15 | #[serde(rename = "SupportsExpand", skip_serializing_if = "Option::is_none")] 16 | pub supports_expand: Option, 17 | #[serde(rename = "SupportsStats", skip_serializing_if = "Option::is_none")] 18 | pub supports_stats: Option, 19 | } 20 | -------------------------------------------------------------------------------- /src/models/desired_updates.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DesiredUpdates { 5 | #[serde(rename = "Canary", skip_serializing_if = "Option::is_none")] 6 | pub canary: Option, 7 | #[serde(rename = "DestructiveUpdate", skip_serializing_if = "Option::is_none")] 8 | pub destructive_update: Option, 9 | #[serde(rename = "Ignore", skip_serializing_if = "Option::is_none")] 10 | pub ignore: Option, 11 | #[serde(rename = "InPlaceUpdate", skip_serializing_if = "Option::is_none")] 12 | pub in_place_update: Option, 13 | #[serde(rename = "Migrate", skip_serializing_if = "Option::is_none")] 14 | pub migrate: Option, 15 | #[serde(rename = "Place", skip_serializing_if = "Option::is_none")] 16 | pub place: Option, 17 | #[serde(rename = "Preemptions", skip_serializing_if = "Option::is_none")] 18 | pub preemptions: Option, 19 | #[serde(rename = "Stop", skip_serializing_if = "Option::is_none")] 20 | pub stop: Option, 21 | } 22 | 23 | 24 | -------------------------------------------------------------------------------- /src/models/resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Resources { 5 | #[serde(rename = "CPU", skip_serializing_if = "Option::is_none")] 6 | pub cpu: Option, 7 | #[serde(rename = "Cores", skip_serializing_if = "Option::is_none")] 8 | pub cores: Option, 9 | #[serde(rename = "Devices", skip_serializing_if = "Option::is_none")] 10 | pub devices: Option>, 11 | #[serde(rename = "DiskMB", skip_serializing_if = "Option::is_none")] 12 | pub disk_mb: Option, 13 | #[serde(rename = "IOPS", skip_serializing_if = "Option::is_none")] 14 | pub iops: Option, 15 | #[serde(rename = "MemoryMB", skip_serializing_if = "Option::is_none")] 16 | pub memory_mb: Option, 17 | #[serde(rename = "MemoryMaxMB", skip_serializing_if = "Option::is_none")] 18 | pub memory_max_mb: Option, 19 | #[serde(rename = "Networks", skip_serializing_if = "Option::is_none")] 20 | pub networks: Option>, 21 | } 22 | -------------------------------------------------------------------------------- /src/models/scaling_event.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ScalingEvent { 5 | #[serde(rename = "Count", skip_serializing_if = "Option::is_none")] 6 | pub count: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "Error", skip_serializing_if = "Option::is_none")] 10 | pub error: Option, 11 | #[serde(rename = "EvalID", skip_serializing_if = "Option::is_none")] 12 | pub eval_id: Option, 13 | #[serde(rename = "Message", skip_serializing_if = "Option::is_none")] 14 | pub message: Option, 15 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 16 | pub meta: Option<::std::collections::HashMap>, 17 | #[serde(rename = "PreviousCount", skip_serializing_if = "Option::is_none")] 18 | pub previous_count: Option, 19 | #[serde(rename = "Time", skip_serializing_if = "Option::is_none")] 20 | pub time: Option, 21 | } 22 | -------------------------------------------------------------------------------- /src/models/node_resources.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeResources { 5 | #[serde(rename = "Cpu", skip_serializing_if = "Option::is_none")] 6 | pub cpu: Option, 7 | #[serde(rename = "Devices", skip_serializing_if = "Option::is_none")] 8 | pub devices: Option>, 9 | #[serde(rename = "Disk", skip_serializing_if = "Option::is_none")] 10 | pub disk: Option, 11 | #[serde(rename = "MaxDynamicPort", skip_serializing_if = "Option::is_none")] 12 | pub max_dynamic_port: Option, 13 | #[serde(rename = "Memory", skip_serializing_if = "Option::is_none")] 14 | pub memory: Option, 15 | #[serde(rename = "MinDynamicPort", skip_serializing_if = "Option::is_none")] 16 | pub min_dynamic_port: Option, 17 | #[serde(rename = "Networks", skip_serializing_if = "Option::is_none")] 18 | pub networks: Option>, 19 | } 20 | -------------------------------------------------------------------------------- /src/models/volume_request.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] 4 | pub struct VolumeRequest { 5 | #[serde(rename = "AccessMode", skip_serializing_if = "Option::is_none")] 6 | pub access_mode: Option, 7 | #[serde(rename = "AttachmentMode", skip_serializing_if = "Option::is_none")] 8 | pub attachment_mode: Option, 9 | #[serde(rename = "MountOptions", skip_serializing_if = "Option::is_none")] 10 | pub mount_options: Option, 11 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 12 | pub name: Option, 13 | #[serde(rename = "PerAlloc", skip_serializing_if = "Option::is_none")] 14 | pub per_alloc: Option, 15 | #[serde(rename = "ReadOnly", skip_serializing_if = "Option::is_none")] 16 | pub read_only: Option, 17 | #[serde(rename = "Source", skip_serializing_if = "Option::is_none")] 18 | pub source: Option, 19 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 20 | pub _type: Option, 21 | } 22 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 BuildLine GmbH 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/models/task_state.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskState { 5 | #[serde(rename = "Events", skip_serializing_if = "Option::is_none")] 6 | pub events: Option>, 7 | #[serde(rename = "Failed", skip_serializing_if = "Option::is_none")] 8 | pub failed: Option, 9 | #[serde(rename = "FinishedAt", skip_serializing_if = "Option::is_none")] 10 | pub finished_at: Option, 11 | #[serde(rename = "LastRestart", skip_serializing_if = "Option::is_none")] 12 | pub last_restart: Option, 13 | #[serde(rename = "Restarts", skip_serializing_if = "Option::is_none")] 14 | pub restarts: Option, 15 | #[serde(rename = "StartedAt", skip_serializing_if = "Option::is_none")] 16 | pub started_at: Option, 17 | #[serde(rename = "State", skip_serializing_if = "Option::is_none")] 18 | pub state: Option, 19 | #[serde(rename = "TaskHandle", skip_serializing_if = "Option::is_none")] 20 | pub task_handle: Option, 21 | } 22 | 23 | 24 | -------------------------------------------------------------------------------- /src/models/consul_gateway_proxy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ConsulGatewayProxy { 5 | #[serde(rename = "Config", skip_serializing_if = "Option::is_none")] 6 | pub config: Option<::std::collections::HashMap>, 7 | #[serde(rename = "ConnectTimeout", skip_serializing_if = "Option::is_none")] 8 | pub connect_timeout: Option, 9 | #[serde(rename = "EnvoyDNSDiscoveryType", skip_serializing_if = "Option::is_none")] 10 | pub envoy_dns_discovery_type: Option, 11 | #[serde(rename = "EnvoyGatewayBindAddresses", skip_serializing_if = "Option::is_none")] 12 | pub envoy_gateway_bind_addresses: Option<::std::collections::HashMap>, 13 | #[serde(rename = "EnvoyGatewayBindTaggedAddresses", skip_serializing_if = "Option::is_none")] 14 | pub envoy_gateway_bind_tagged_addresses: Option, 15 | #[serde(rename = "EnvoyGatewayNoDefaultBind", skip_serializing_if = "Option::is_none")] 16 | pub envoy_gateway_no_default_bind: Option, 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/models/scheduler_configuration.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct SchedulerConfiguration { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "MemoryOversubscriptionEnabled", skip_serializing_if = "Option::is_none")] 8 | pub memory_oversubscription_enabled: Option, 9 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 10 | pub modify_index: Option, 11 | #[serde(rename = "PauseEvalBroker", skip_serializing_if = "Option::is_none")] 12 | pub pause_eval_broker: Option, 13 | #[serde(rename = "PreemptionConfig", skip_serializing_if = "Option::is_none")] 14 | pub preemption_config: Option, 15 | #[serde(rename = "RejectJobRegistration", skip_serializing_if = "Option::is_none")] 16 | pub reject_job_registration: Option, 17 | #[serde(rename = "SchedulerAlgorithm", skip_serializing_if = "Option::is_none")] 18 | pub scheduler_algorithm: Option, 19 | } 20 | 21 | -------------------------------------------------------------------------------- /src/models/sampled_value.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct SampledValue { 5 | #[serde(rename = "Count", skip_serializing_if = "Option::is_none")] 6 | pub count: Option, 7 | #[serde(rename = "Labels", skip_serializing_if = "Option::is_none")] 8 | pub labels: Option<::std::collections::HashMap>, 9 | #[serde(rename = "Max", skip_serializing_if = "Option::is_none")] 10 | pub max: Option, 11 | #[serde(rename = "Mean", skip_serializing_if = "Option::is_none")] 12 | pub mean: Option, 13 | #[serde(rename = "Min", skip_serializing_if = "Option::is_none")] 14 | pub min: Option, 15 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 16 | pub name: Option, 17 | #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")] 18 | pub rate: Option, 19 | #[serde(rename = "Stddev", skip_serializing_if = "Option::is_none")] 20 | pub stddev: Option, 21 | #[serde(rename = "Sum", skip_serializing_if = "Option::is_none")] 22 | pub sum: Option, 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /src/models/csi_volume_external_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiVolumeExternalStub { 5 | #[serde(rename = "CapacityBytes", skip_serializing_if = "Option::is_none")] 6 | pub capacity_bytes: Option, 7 | #[serde(rename = "CloneID", skip_serializing_if = "Option::is_none")] 8 | pub clone_id: Option, 9 | #[serde(rename = "ExternalID", skip_serializing_if = "Option::is_none")] 10 | pub external_id: Option, 11 | #[serde(rename = "IsAbnormal", skip_serializing_if = "Option::is_none")] 12 | pub is_abnormal: Option, 13 | #[serde(rename = "PublishedExternalNodeIDs", skip_serializing_if = "Option::is_none")] 14 | pub published_external_node_ids: Option>, 15 | #[serde(rename = "SnapshotID", skip_serializing_if = "Option::is_none")] 16 | pub snapshot_id: Option, 17 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 18 | pub status: Option, 19 | #[serde(rename = "VolumeContext", skip_serializing_if = "Option::is_none")] 20 | pub volume_context: Option<::std::collections::HashMap>, 21 | } 22 | 23 | 24 | -------------------------------------------------------------------------------- /src/models/network_resource.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NetworkResource { 5 | #[serde(rename = "CIDR", skip_serializing_if = "Option::is_none")] 6 | pub cidr: Option, 7 | #[serde(rename = "DNS", skip_serializing_if = "Option::is_none")] 8 | pub dns: Option, 9 | #[serde(rename = "Device", skip_serializing_if = "Option::is_none")] 10 | pub device: Option, 11 | #[serde(rename = "DynamicPorts", skip_serializing_if = "Option::is_none")] 12 | pub dynamic_ports: Option>, 13 | #[serde(rename = "Hostname", skip_serializing_if = "Option::is_none")] 14 | pub hostname: Option, 15 | #[serde(rename = "IP", skip_serializing_if = "Option::is_none")] 16 | pub ip: Option, 17 | #[serde(rename = "MBits", skip_serializing_if = "Option::is_none")] 18 | pub m_bits: Option, 19 | #[serde(rename = "Mode", skip_serializing_if = "Option::is_none")] 20 | pub mode: Option, 21 | #[serde(rename = "ReservedPorts", skip_serializing_if = "Option::is_none")] 22 | pub reserved_ports: Option>, 23 | } 24 | -------------------------------------------------------------------------------- /src/models/update_strategy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct UpdateStrategy { 5 | #[serde(rename = "AutoPromote", skip_serializing_if = "Option::is_none")] 6 | pub auto_promote: Option, 7 | #[serde(rename = "AutoRevert", skip_serializing_if = "Option::is_none")] 8 | pub auto_revert: Option, 9 | #[serde(rename = "Canary", skip_serializing_if = "Option::is_none")] 10 | pub canary: Option, 11 | #[serde(rename = "HealthCheck", skip_serializing_if = "Option::is_none")] 12 | pub health_check: Option, 13 | #[serde(rename = "HealthyDeadline", skip_serializing_if = "Option::is_none")] 14 | pub healthy_deadline: Option, 15 | #[serde(rename = "MaxParallel", skip_serializing_if = "Option::is_none")] 16 | pub max_parallel: Option, 17 | #[serde(rename = "MinHealthyTime", skip_serializing_if = "Option::is_none")] 18 | pub min_healthy_time: Option, 19 | #[serde(rename = "ProgressDeadline", skip_serializing_if = "Option::is_none")] 20 | pub progress_deadline: Option, 21 | #[serde(rename = "Stagger", skip_serializing_if = "Option::is_none")] 22 | pub stagger: Option, 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /src/models/csi_plugin_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiPluginListStub { 5 | #[serde(rename = "ControllerRequired", skip_serializing_if = "Option::is_none")] 6 | pub controller_required: Option, 7 | #[serde(rename = "ControllersExpected", skip_serializing_if = "Option::is_none")] 8 | pub controllers_expected: Option, 9 | #[serde(rename = "ControllersHealthy", skip_serializing_if = "Option::is_none")] 10 | pub controllers_healthy: Option, 11 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 12 | pub create_index: Option, 13 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 14 | pub id: Option, 15 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 16 | pub modify_index: Option, 17 | #[serde(rename = "NodesExpected", skip_serializing_if = "Option::is_none")] 18 | pub nodes_expected: Option, 19 | #[serde(rename = "NodesHealthy", skip_serializing_if = "Option::is_none")] 20 | pub nodes_healthy: Option, 21 | #[serde(rename = "Provider", skip_serializing_if = "Option::is_none")] 22 | pub provider: Option, 23 | } 24 | -------------------------------------------------------------------------------- /src/models/csi_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiInfo { 5 | #[serde(rename = "AllocID", skip_serializing_if = "Option::is_none")] 6 | pub alloc_id: Option, 7 | #[serde(rename = "ControllerInfo", skip_serializing_if = "Option::is_none")] 8 | pub controller_info: Option, 9 | #[serde(rename = "HealthDescription", skip_serializing_if = "Option::is_none")] 10 | pub health_description: Option, 11 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 12 | pub healthy: Option, 13 | #[serde(rename = "NodeInfo", skip_serializing_if = "Option::is_none")] 14 | pub node_info: Option, 15 | #[serde(rename = "PluginID", skip_serializing_if = "Option::is_none")] 16 | pub plugin_id: Option, 17 | #[serde(rename = "RequiresControllerPlugin", skip_serializing_if = "Option::is_none")] 18 | pub requires_controller_plugin: Option, 19 | #[serde(rename = "RequiresTopologies", skip_serializing_if = "Option::is_none")] 20 | pub requires_topologies: Option, 21 | #[serde(rename = "UpdateTime", skip_serializing_if = "Option::is_none")] 22 | pub update_time: Option, 23 | } 24 | -------------------------------------------------------------------------------- /src/models/scaling_policy.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ScalingPolicy { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Enabled", skip_serializing_if = "Option::is_none")] 8 | pub enabled: Option, 9 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 10 | pub id: Option, 11 | #[serde(rename = "Max", skip_serializing_if = "Option::is_none")] 12 | pub max: Option, 13 | #[serde(rename = "Min", skip_serializing_if = "Option::is_none")] 14 | pub min: Option, 15 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 16 | pub modify_index: Option, 17 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 18 | pub namespace: Option, 19 | #[serde(rename = "Policy", skip_serializing_if = "Option::is_none")] 20 | pub policy: Option<::std::collections::HashMap>, 21 | #[serde(rename = "Target", skip_serializing_if = "Option::is_none")] 22 | pub target: Option<::std::collections::HashMap>, 23 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 24 | pub _type: Option, 25 | } 26 | -------------------------------------------------------------------------------- /src/models/acl_token_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AclTokenListStub { 5 | #[serde(rename = "AccessorID", skip_serializing_if = "Option::is_none")] 6 | pub accessor_id: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 10 | pub create_time: Option, 11 | #[serde(rename = "Global", skip_serializing_if = "Option::is_none")] 12 | pub global: Option, 13 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 14 | pub modify_index: Option, 15 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 16 | pub name: Option, 17 | #[serde(rename = "Policies", skip_serializing_if = "Option::is_none")] 18 | pub policies: Option>, 19 | #[serde(rename = "Roles", skip_serializing_if = "Option::is_none")] 20 | pub roles: Option>, 21 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 22 | pub _type: Option, 23 | #[serde(rename = "expiration_time", skip_serializing_if = "Option::is_none")] 24 | pub expiration_time: Option, 25 | } 26 | -------------------------------------------------------------------------------- /src/models/csi_snapshot.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiSnapshot { 5 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 6 | pub create_time: Option, 7 | #[serde(rename = "ExternalSourceVolumeID", skip_serializing_if = "Option::is_none")] 8 | pub external_source_volume_id: Option, 9 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 10 | pub id: Option, 11 | #[serde(rename = "IsReady", skip_serializing_if = "Option::is_none")] 12 | pub is_ready: Option, 13 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 14 | pub name: Option, 15 | #[serde(rename = "Parameters", skip_serializing_if = "Option::is_none")] 16 | pub parameters: Option<::std::collections::HashMap>, 17 | #[serde(rename = "PluginID", skip_serializing_if = "Option::is_none")] 18 | pub plugin_id: Option, 19 | #[serde(rename = "Secrets", skip_serializing_if = "Option::is_none")] 20 | pub secrets: Option<::std::collections::HashMap>, 21 | #[serde(rename = "SizeBytes", skip_serializing_if = "Option::is_none")] 22 | pub size_bytes: Option, 23 | #[serde(rename = "SourceVolumeID", skip_serializing_if = "Option::is_none")] 24 | pub source_volume_id: Option, 25 | } 26 | -------------------------------------------------------------------------------- /src/models/deployment_state.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct DeploymentState { 5 | #[serde(rename = "AutoRevert", skip_serializing_if = "Option::is_none")] 6 | pub auto_revert: Option, 7 | #[serde(rename = "DesiredCanaries", skip_serializing_if = "Option::is_none")] 8 | pub desired_canaries: Option, 9 | #[serde(rename = "DesiredTotal", skip_serializing_if = "Option::is_none")] 10 | pub desired_total: Option, 11 | #[serde(rename = "HealthyAllocs", skip_serializing_if = "Option::is_none")] 12 | pub healthy_allocs: Option, 13 | #[serde(rename = "PlacedAllocs", skip_serializing_if = "Option::is_none")] 14 | pub placed_allocs: Option, 15 | #[serde(rename = "PlacedCanaries", skip_serializing_if = "Option::is_none")] 16 | pub placed_canaries: Option>, 17 | #[serde(rename = "ProgressDeadline", skip_serializing_if = "Option::is_none")] 18 | pub progress_deadline: Option, 19 | #[serde(rename = "Promoted", skip_serializing_if = "Option::is_none")] 20 | pub promoted: Option, 21 | #[serde(rename = "RequireProgressBy", skip_serializing_if = "Option::is_none")] 22 | pub require_progress_by: Option, 23 | #[serde(rename = "UnhealthyAllocs", skip_serializing_if = "Option::is_none")] 24 | pub unhealthy_allocs: Option, 25 | } 26 | -------------------------------------------------------------------------------- /src/models/autopilot_configuration.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AutopilotConfiguration { 5 | #[serde(rename = "CleanupDeadServers", skip_serializing_if = "Option::is_none")] 6 | pub cleanup_dead_servers: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "DisableUpgradeMigration", skip_serializing_if = "Option::is_none")] 10 | pub disable_upgrade_migration: Option, 11 | #[serde(rename = "EnableCustomUpgrades", skip_serializing_if = "Option::is_none")] 12 | pub enable_custom_upgrades: Option, 13 | #[serde(rename = "EnableRedundancyZones", skip_serializing_if = "Option::is_none")] 14 | pub enable_redundancy_zones: Option, 15 | #[serde(rename = "LastContactThreshold", skip_serializing_if = "Option::is_none")] 16 | pub last_contact_threshold: Option, 17 | #[serde(rename = "MaxTrailingLogs", skip_serializing_if = "Option::is_none")] 18 | pub max_trailing_logs: Option, 19 | #[serde(rename = "MinQuorum", skip_serializing_if = "Option::is_none")] 20 | pub min_quorum: Option, 21 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 22 | pub modify_index: Option, 23 | #[serde(rename = "ServerStabilizationTime", skip_serializing_if = "Option::is_none")] 24 | pub server_stabilization_time: Option, 25 | } 26 | -------------------------------------------------------------------------------- /src/models/server_health.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ServerHealth { 5 | #[serde(rename = "Address", skip_serializing_if = "Option::is_none")] 6 | pub address: Option, 7 | #[serde(rename = "Healthy", skip_serializing_if = "Option::is_none")] 8 | pub healthy: Option, 9 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 10 | pub id: Option, 11 | #[serde(rename = "LastContact", skip_serializing_if = "Option::is_none")] 12 | pub last_contact: Option, 13 | #[serde(rename = "LastIndex", skip_serializing_if = "Option::is_none")] 14 | pub last_index: Option, 15 | #[serde(rename = "LastTerm", skip_serializing_if = "Option::is_none")] 16 | pub last_term: Option, 17 | #[serde(rename = "Leader", skip_serializing_if = "Option::is_none")] 18 | pub leader: Option, 19 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 20 | pub name: Option, 21 | #[serde(rename = "SerfStatus", skip_serializing_if = "Option::is_none")] 22 | pub serf_status: Option, 23 | #[serde(rename = "StableSince", skip_serializing_if = "Option::is_none")] 24 | pub stable_since: Option, 25 | #[serde(rename = "Version", skip_serializing_if = "Option::is_none")] 26 | pub version: Option, 27 | #[serde(rename = "Voter", skip_serializing_if = "Option::is_none")] 28 | pub voter: Option, 29 | } 30 | -------------------------------------------------------------------------------- /src/models/service_registration.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ServiceRegistration { 5 | #[serde(rename = "Address", skip_serializing_if = "Option::is_none")] 6 | pub address: Option, 7 | #[serde(rename = "AllocID", skip_serializing_if = "Option::is_none")] 8 | pub alloc_id: Option, 9 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 10 | pub create_index: Option, 11 | #[serde(rename = "Datacenter", skip_serializing_if = "Option::is_none")] 12 | pub datacenter: Option, 13 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 14 | pub id: Option, 15 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 16 | pub job_id: Option, 17 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 18 | pub modify_index: Option, 19 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 20 | pub namespace: Option, 21 | #[serde(rename = "NodeID", skip_serializing_if = "Option::is_none")] 22 | pub node_id: Option, 23 | #[serde(rename = "Port", skip_serializing_if = "Option::is_none")] 24 | pub port: Option, 25 | #[serde(rename = "ServiceName", skip_serializing_if = "Option::is_none")] 26 | pub service_name: Option, 27 | #[serde(rename = "Tags", skip_serializing_if = "Option::is_none")] 28 | pub tags: Option>, 29 | } 30 | -------------------------------------------------------------------------------- /src/models/sidecar_task.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct SidecarTask { 5 | #[serde(rename = "Config", skip_serializing_if = "Option::is_none")] 6 | pub config: Option<::std::collections::HashMap>, 7 | #[serde(rename = "Driver", skip_serializing_if = "Option::is_none")] 8 | pub driver: Option, 9 | #[serde(rename = "Env", skip_serializing_if = "Option::is_none")] 10 | pub env: Option<::std::collections::HashMap>, 11 | #[serde(rename = "KillSignal", skip_serializing_if = "Option::is_none")] 12 | pub kill_signal: Option, 13 | #[serde(rename = "KillTimeout", skip_serializing_if = "Option::is_none")] 14 | pub kill_timeout: Option, 15 | #[serde(rename = "LogConfig", skip_serializing_if = "Option::is_none")] 16 | pub log_config: Option, 17 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 18 | pub meta: Option<::std::collections::HashMap>, 19 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 20 | pub name: Option, 21 | #[serde(rename = "Resources", skip_serializing_if = "Option::is_none")] 22 | pub resources: Option, 23 | #[serde(rename = "ShutdownDelay", skip_serializing_if = "Option::is_none")] 24 | pub shutdown_delay: Option, 25 | #[serde(rename = "User", skip_serializing_if = "Option::is_none")] 26 | pub user: Option, 27 | } 28 | -------------------------------------------------------------------------------- /src/models/acl_token.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AclToken { 5 | #[serde(rename = "AccessorID", skip_serializing_if = "Option::is_none")] 6 | pub accessor_id: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 10 | pub create_time: Option, 11 | #[serde(rename = "ExpirationTTL", skip_serializing_if = "Option::is_none")] 12 | pub expiration_ttl: Option, 13 | #[serde(rename = "ExpirationTime", skip_serializing_if = "Option::is_none")] 14 | pub expiration_time: Option, 15 | #[serde(rename = "Global", skip_serializing_if = "Option::is_none")] 16 | pub global: Option, 17 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 18 | pub modify_index: Option, 19 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 20 | pub name: Option, 21 | #[serde(rename = "Policies", skip_serializing_if = "Option::is_none")] 22 | pub policies: Option>, 23 | #[serde(rename = "Roles", skip_serializing_if = "Option::is_none")] 24 | pub roles: Option>, 25 | #[serde(rename = "SecretID", skip_serializing_if = "Option::is_none")] 26 | pub secret_id: Option, 27 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 28 | pub _type: Option, 29 | } -------------------------------------------------------------------------------- /src/models/deployment.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Deployment { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 8 | pub id: Option, 9 | #[serde(rename = "IsMultiregion", skip_serializing_if = "Option::is_none")] 10 | pub is_multiregion: Option, 11 | #[serde(rename = "JobCreateIndex", skip_serializing_if = "Option::is_none")] 12 | pub job_create_index: Option, 13 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 14 | pub job_id: Option, 15 | #[serde(rename = "JobModifyIndex", skip_serializing_if = "Option::is_none")] 16 | pub job_modify_index: Option, 17 | #[serde(rename = "JobSpecModifyIndex", skip_serializing_if = "Option::is_none")] 18 | pub job_spec_modify_index: Option, 19 | #[serde(rename = "JobVersion", skip_serializing_if = "Option::is_none")] 20 | pub job_version: Option, 21 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 22 | pub modify_index: Option, 23 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 24 | pub namespace: Option, 25 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 26 | pub status: Option, 27 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 28 | pub status_description: Option, 29 | #[serde(rename = "TaskGroups", skip_serializing_if = "Option::is_none")] 30 | pub task_groups: Option<::std::collections::HashMap>, 31 | } 32 | -------------------------------------------------------------------------------- /src/models/csi_controller_info.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiControllerInfo { 5 | #[serde(rename = "SupportsAttachDetach", skip_serializing_if = "Option::is_none")] 6 | pub supports_attach_detach: Option, 7 | #[serde(rename = "SupportsClone", skip_serializing_if = "Option::is_none")] 8 | pub supports_clone: Option, 9 | #[serde(rename = "SupportsCondition", skip_serializing_if = "Option::is_none")] 10 | pub supports_condition: Option, 11 | #[serde(rename = "SupportsCreateDelete", skip_serializing_if = "Option::is_none")] 12 | pub supports_create_delete: Option, 13 | #[serde(rename = "SupportsCreateDeleteSnapshot", skip_serializing_if = "Option::is_none")] 14 | pub supports_create_delete_snapshot: Option, 15 | #[serde(rename = "SupportsExpand", skip_serializing_if = "Option::is_none")] 16 | pub supports_expand: Option, 17 | #[serde(rename = "SupportsGet", skip_serializing_if = "Option::is_none")] 18 | pub supports_get: Option, 19 | #[serde(rename = "SupportsGetCapacity", skip_serializing_if = "Option::is_none")] 20 | pub supports_get_capacity: Option, 21 | #[serde(rename = "SupportsListSnapshots", skip_serializing_if = "Option::is_none")] 22 | pub supports_list_snapshots: Option, 23 | #[serde(rename = "SupportsListVolumes", skip_serializing_if = "Option::is_none")] 24 | pub supports_list_volumes: Option, 25 | #[serde(rename = "SupportsListVolumesAttachedNodes", skip_serializing_if = "Option::is_none")] 26 | pub supports_list_volumes_attached_nodes: Option, 27 | #[serde(rename = "SupportsReadOnlyAttach", skip_serializing_if = "Option::is_none")] 28 | pub supports_read_only_attach: Option, 29 | } 30 | -------------------------------------------------------------------------------- /src/models/csi_plugin.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiPlugin { 5 | #[serde(rename = "Allocations", skip_serializing_if = "Option::is_none")] 6 | pub allocations: Option>, 7 | #[serde(rename = "ControllerRequired", skip_serializing_if = "Option::is_none")] 8 | pub controller_required: Option, 9 | #[serde(rename = "Controllers", skip_serializing_if = "Option::is_none")] 10 | pub controllers: Option<::std::collections::HashMap>, 11 | #[serde(rename = "ControllersExpected", skip_serializing_if = "Option::is_none")] 12 | pub controllers_expected: Option, 13 | #[serde(rename = "ControllersHealthy", skip_serializing_if = "Option::is_none")] 14 | pub controllers_healthy: Option, 15 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 16 | pub create_index: Option, 17 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 18 | pub id: Option, 19 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 20 | pub modify_index: Option, 21 | #[serde(rename = "Nodes", skip_serializing_if = "Option::is_none")] 22 | pub nodes: Option<::std::collections::HashMap>, 23 | #[serde(rename = "NodesExpected", skip_serializing_if = "Option::is_none")] 24 | pub nodes_expected: Option, 25 | #[serde(rename = "NodesHealthy", skip_serializing_if = "Option::is_none")] 26 | pub nodes_healthy: Option, 27 | #[serde(rename = "Provider", skip_serializing_if = "Option::is_none")] 28 | pub provider: Option, 29 | #[serde(rename = "Version", skip_serializing_if = "Option::is_none")] 30 | pub version: Option, 31 | } 32 | -------------------------------------------------------------------------------- /src/models/template.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Template { 5 | #[serde(rename = "ChangeMode", skip_serializing_if = "Option::is_none")] 6 | pub change_mode: Option, 7 | #[serde(rename = "ChangeScript", skip_serializing_if = "Option::is_none")] 8 | pub change_script: Option, 9 | #[serde(rename = "ChangeSignal", skip_serializing_if = "Option::is_none")] 10 | pub change_signal: Option, 11 | #[serde(rename = "DestPath", skip_serializing_if = "Option::is_none")] 12 | pub dest_path: Option, 13 | #[serde(rename = "EmbeddedTmpl", skip_serializing_if = "Option::is_none")] 14 | pub embedded_tmpl: Option, 15 | #[serde(rename = "Envvars", skip_serializing_if = "Option::is_none")] 16 | pub envvars: Option, 17 | #[serde(rename = "Gid", skip_serializing_if = "Option::is_none")] 18 | pub gid: Option, 19 | #[serde(rename = "LeftDelim", skip_serializing_if = "Option::is_none")] 20 | pub left_delim: Option, 21 | #[serde(rename = "Perms", skip_serializing_if = "Option::is_none")] 22 | pub perms: Option, 23 | #[serde(rename = "RightDelim", skip_serializing_if = "Option::is_none")] 24 | pub right_delim: Option, 25 | #[serde(rename = "SourcePath", skip_serializing_if = "Option::is_none")] 26 | pub source_path: Option, 27 | #[serde(rename = "Splay", skip_serializing_if = "Option::is_none")] 28 | pub splay: Option, 29 | #[serde(rename = "Uid", skip_serializing_if = "Option::is_none")] 30 | pub uid: Option, 31 | #[serde(rename = "VaultGrace", skip_serializing_if = "Option::is_none")] 32 | pub vault_grace: Option, 33 | #[serde(rename = "Wait", skip_serializing_if = "Option::is_none")] 34 | pub wait: Option, 35 | } 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /src/models/job_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct JobListStub { 5 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 6 | pub create_index: Option, 7 | #[serde(rename = "Datacenters", skip_serializing_if = "Option::is_none")] 8 | pub datacenters: Option>, 9 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 10 | pub id: Option, 11 | #[serde(rename = "JobModifyIndex", skip_serializing_if = "Option::is_none")] 12 | pub job_modify_index: Option, 13 | #[serde(rename = "JobSummary", skip_serializing_if = "Option::is_none")] 14 | pub job_summary: Option, 15 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 16 | pub modify_index: Option, 17 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 18 | pub name: Option, 19 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 20 | pub namespace: Option, 21 | #[serde(rename = "ParameterizedJob", skip_serializing_if = "Option::is_none")] 22 | pub parameterized_job: Option, 23 | #[serde(rename = "ParentID", skip_serializing_if = "Option::is_none")] 24 | pub parent_id: Option, 25 | #[serde(rename = "Periodic", skip_serializing_if = "Option::is_none")] 26 | pub periodic: Option, 27 | #[serde(rename = "Priority", skip_serializing_if = "Option::is_none")] 28 | pub priority: Option, 29 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 30 | pub status: Option, 31 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 32 | pub status_description: Option, 33 | #[serde(rename = "Stop", skip_serializing_if = "Option::is_none")] 34 | pub stop: Option, 35 | #[serde(rename = "SubmitTime", skip_serializing_if = "Option::is_none")] 36 | pub submit_time: Option, 37 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 38 | pub _type: Option, 39 | } 40 | 41 | 42 | -------------------------------------------------------------------------------- /src/models/service.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Service { 5 | #[serde(rename = "Address", skip_serializing_if = "Option::is_none")] 6 | pub address: Option, 7 | #[serde(rename = "AddressMode", skip_serializing_if = "Option::is_none")] 8 | pub address_mode: Option, 9 | #[serde(rename = "CanaryMeta", skip_serializing_if = "Option::is_none")] 10 | pub canary_meta: Option<::std::collections::HashMap>, 11 | #[serde(rename = "CanaryTags", skip_serializing_if = "Option::is_none")] 12 | pub canary_tags: Option>, 13 | #[serde(rename = "CheckRestart", skip_serializing_if = "Option::is_none")] 14 | pub check_restart: Option, 15 | #[serde(rename = "Checks", skip_serializing_if = "Option::is_none")] 16 | pub checks: Option>, 17 | #[serde(rename = "Connect", skip_serializing_if = "Option::is_none")] 18 | pub connect: Option, 19 | #[serde(rename = "EnableTagOverride", skip_serializing_if = "Option::is_none")] 20 | pub enable_tag_override: Option, 21 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 22 | pub meta: Option<::std::collections::HashMap>, 23 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 24 | pub name: Option, 25 | #[serde(rename = "OnUpdate", skip_serializing_if = "Option::is_none")] 26 | pub on_update: Option, 27 | #[serde(rename = "PortLabel", skip_serializing_if = "Option::is_none")] 28 | pub port_label: Option, 29 | #[serde(rename = "Provider", skip_serializing_if = "Option::is_none")] 30 | pub provider: Option, 31 | #[serde(rename = "TaggedAddresses", skip_serializing_if = "Option::is_none")] 32 | pub tagged_addresses: Option<::std::collections::HashMap>, 33 | #[serde(rename = "Tags", skip_serializing_if = "Option::is_none")] 34 | pub tags: Option>, 35 | #[serde(rename = "TaskName", skip_serializing_if = "Option::is_none")] 36 | pub task_name: Option, 37 | } 38 | -------------------------------------------------------------------------------- /src/models/allocation_metric.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocationMetric { 5 | #[serde(rename = "AllocationTime", skip_serializing_if = "Option::is_none")] 6 | pub allocation_time: Option, 7 | #[serde(rename = "ClassExhausted", skip_serializing_if = "Option::is_none")] 8 | pub class_exhausted: Option<::std::collections::HashMap>, 9 | #[serde(rename = "ClassFiltered", skip_serializing_if = "Option::is_none")] 10 | pub class_filtered: Option<::std::collections::HashMap>, 11 | #[serde(rename = "CoalescedFailures", skip_serializing_if = "Option::is_none")] 12 | pub coalesced_failures: Option, 13 | #[serde(rename = "ConstraintFiltered", skip_serializing_if = "Option::is_none")] 14 | pub constraint_filtered: Option<::std::collections::HashMap>, 15 | #[serde(rename = "DimensionExhausted", skip_serializing_if = "Option::is_none")] 16 | pub dimension_exhausted: Option<::std::collections::HashMap>, 17 | #[serde(rename = "NodesAvailable", skip_serializing_if = "Option::is_none")] 18 | pub nodes_available: Option<::std::collections::HashMap>, 19 | #[serde(rename = "NodesEvaluated", skip_serializing_if = "Option::is_none")] 20 | pub nodes_evaluated: Option, 21 | #[serde(rename = "NodesExhausted", skip_serializing_if = "Option::is_none")] 22 | pub nodes_exhausted: Option, 23 | #[serde(rename = "NodesFiltered", skip_serializing_if = "Option::is_none")] 24 | pub nodes_filtered: Option, 25 | #[serde(rename = "QuotaExhausted", skip_serializing_if = "Option::is_none")] 26 | pub quota_exhausted: Option>, 27 | #[serde(rename = "ResourcesExhausted", skip_serializing_if = "Option::is_none")] 28 | pub resources_exhausted: Option<::std::collections::HashMap>, 29 | #[serde(rename = "ScoreMetaData", skip_serializing_if = "Option::is_none")] 30 | pub score_meta_data: Option>, 31 | #[serde(rename = "Scores", skip_serializing_if = "Option::is_none")] 32 | pub scores: Option<::std::collections::HashMap>, 33 | } 34 | 35 | 36 | -------------------------------------------------------------------------------- /src/models/evaluation_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct EvaluationStub { 5 | #[serde(rename = "BlockedEval", skip_serializing_if = "Option::is_none")] 6 | pub blocked_eval: Option, 7 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 8 | pub create_index: Option, 9 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 10 | pub create_time: Option, 11 | #[serde(rename = "DeploymentID", skip_serializing_if = "Option::is_none")] 12 | pub deployment_id: Option, 13 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 14 | pub id: Option, 15 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 16 | pub job_id: Option, 17 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 18 | pub modify_index: Option, 19 | #[serde(rename = "ModifyTime", skip_serializing_if = "Option::is_none")] 20 | pub modify_time: Option, 21 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 22 | pub namespace: Option, 23 | #[serde(rename = "NextEval", skip_serializing_if = "Option::is_none")] 24 | pub next_eval: Option, 25 | #[serde(rename = "NodeID", skip_serializing_if = "Option::is_none")] 26 | pub node_id: Option, 27 | #[serde(rename = "PreviousEval", skip_serializing_if = "Option::is_none")] 28 | pub previous_eval: Option, 29 | #[serde(rename = "Priority", skip_serializing_if = "Option::is_none")] 30 | pub priority: Option, 31 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 32 | pub status: Option, 33 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 34 | pub status_description: Option, 35 | #[serde(rename = "TriggeredBy", skip_serializing_if = "Option::is_none")] 36 | pub triggered_by: Option, 37 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 38 | pub _type: Option, 39 | #[serde(rename = "WaitUntil", skip_serializing_if = "Option::is_none")] 40 | pub wait_until: Option, 41 | } 42 | -------------------------------------------------------------------------------- /src/models/node_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct NodeListStub { 5 | #[serde(rename = "Address", skip_serializing_if = "Option::is_none")] 6 | pub address: Option, 7 | #[serde(rename = "Attributes", skip_serializing_if = "Option::is_none")] 8 | pub attributes: Option<::std::collections::HashMap>, 9 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 10 | pub create_index: Option, 11 | #[serde(rename = "Datacenter", skip_serializing_if = "Option::is_none")] 12 | pub datacenter: Option, 13 | #[serde(rename = "Drain", skip_serializing_if = "Option::is_none")] 14 | pub drain: Option, 15 | #[serde(rename = "Drivers", skip_serializing_if = "Option::is_none")] 16 | pub drivers: Option<::std::collections::HashMap>, 17 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 18 | pub id: Option, 19 | #[serde(rename = "LastDrain", skip_serializing_if = "Option::is_none")] 20 | pub last_drain: Option, 21 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 22 | pub modify_index: Option, 23 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 24 | pub name: Option, 25 | #[serde(rename = "NodeClass", skip_serializing_if = "Option::is_none")] 26 | pub node_class: Option, 27 | #[serde(rename = "NodeResources", skip_serializing_if = "Option::is_none")] 28 | pub node_resources: Option, 29 | #[serde(rename = "ReservedResources", skip_serializing_if = "Option::is_none")] 30 | pub reserved_resources: Option, 31 | #[serde(rename = "SchedulingEligibility", skip_serializing_if = "Option::is_none")] 32 | pub scheduling_eligibility: Option, 33 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 34 | pub status: Option, 35 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 36 | pub status_description: Option, 37 | #[serde(rename = "Version", skip_serializing_if = "Option::is_none")] 38 | pub version: Option, 39 | } 40 | -------------------------------------------------------------------------------- /src/models/event.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | use crate::models::allocation::Allocation; 4 | use crate::models::deployment::Deployment; 5 | use crate::models::evaluation::Evaluation; 6 | use crate::models::job::Job; 7 | use crate::models::node::Node; 8 | use crate::models::service::Service; 9 | 10 | #[derive(Clone, Debug, Default, Deserialize, Serialize)] 11 | #[serde(rename_all = "PascalCase")] 12 | pub struct EventCollection { 13 | #[serde(rename = "Index")] 14 | pub index: i32, 15 | #[serde(rename = "Events")] 16 | pub events: Vec, 17 | } 18 | 19 | #[derive(Clone, Debug, Default, Deserialize, Serialize)] 20 | #[serde(rename_all = "PascalCase")] 21 | pub struct Event { 22 | #[serde(rename = "Index")] 23 | pub index: i32, 24 | #[serde(rename = "Key")] 25 | pub key: String, 26 | #[serde(rename = "Namespace")] 27 | pub namespace: String, 28 | #[serde(rename = "Topic", skip_serializing_if = "Option::is_none")] 29 | pub topic: Option, 30 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 31 | pub _type: Option, 32 | #[serde(rename = "Payload", skip_serializing_if = "Option::is_none")] 33 | pub payload: Option, 34 | } 35 | 36 | #[derive(Clone, Debug, Deserialize, Serialize)] 37 | pub enum EventPayload { 38 | Allocation(Box), 39 | Deployment(Box), 40 | Evaluation(Box), 41 | Job(Box), 42 | Node(Box), 43 | Service(Box), 44 | } 45 | 46 | #[derive(Clone, Debug, Deserialize, Serialize)] 47 | pub enum EventTopic { 48 | ACLToken, 49 | ACLPolicy, 50 | ACLRole, 51 | Job, 52 | Allocation, 53 | Deployment, 54 | Evaluation, 55 | Node, 56 | Service, 57 | } 58 | 59 | #[derive(Clone, Debug, Deserialize, Serialize)] 60 | pub enum EventType { 61 | ACLTokenUpserted, 62 | ACLTokenDeleted, 63 | ACLPolicyUpserted, 64 | ACLPolicyDeleted, 65 | ACLRoleUpserted, 66 | ACLRoleDeleted, 67 | AllocationCreated, 68 | AllocationUpdated, 69 | AllocationUpdateDesiredStatus, 70 | DeploymentStatusUpdate, 71 | DeploymentPromotion, 72 | DeploymentAllocHealth, 73 | EvaluationUpdated, 74 | JobRegistered, 75 | JobDeregistered, 76 | JobBatchDeregistered, 77 | NodeRegistration, 78 | NodeDeregistration, 79 | NodeEligibility, 80 | NodeStreamEvent, 81 | NodeDrain, 82 | NodeEvent, 83 | PlanResult, 84 | ServiceRegistration, 85 | ServiceDeregistration, 86 | } -------------------------------------------------------------------------------- /src/models/csi_volume_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiVolumeListStub { 5 | #[serde(rename = "AccessMode", skip_serializing_if = "Option::is_none")] 6 | pub access_mode: Option, 7 | #[serde(rename = "AttachmentMode", skip_serializing_if = "Option::is_none")] 8 | pub attachment_mode: Option, 9 | #[serde(rename = "ControllerRequired", skip_serializing_if = "Option::is_none")] 10 | pub controller_required: Option, 11 | #[serde(rename = "ControllersExpected", skip_serializing_if = "Option::is_none")] 12 | pub controllers_expected: Option, 13 | #[serde(rename = "ControllersHealthy", skip_serializing_if = "Option::is_none")] 14 | pub controllers_healthy: Option, 15 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 16 | pub create_index: Option, 17 | #[serde(rename = "CurrentReaders", skip_serializing_if = "Option::is_none")] 18 | pub current_readers: Option, 19 | #[serde(rename = "CurrentWriters", skip_serializing_if = "Option::is_none")] 20 | pub current_writers: Option, 21 | #[serde(rename = "ExternalID", skip_serializing_if = "Option::is_none")] 22 | pub external_id: Option, 23 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 24 | pub id: Option, 25 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 26 | pub modify_index: Option, 27 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 28 | pub name: Option, 29 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 30 | pub namespace: Option, 31 | #[serde(rename = "NodesExpected", skip_serializing_if = "Option::is_none")] 32 | pub nodes_expected: Option, 33 | #[serde(rename = "NodesHealthy", skip_serializing_if = "Option::is_none")] 34 | pub nodes_healthy: Option, 35 | #[serde(rename = "PluginID", skip_serializing_if = "Option::is_none")] 36 | pub plugin_id: Option, 37 | #[serde(rename = "Provider", skip_serializing_if = "Option::is_none")] 38 | pub provider: Option, 39 | #[serde(rename = "ResourceExhausted", skip_serializing_if = "Option::is_none")] 40 | pub resource_exhausted: Option, 41 | #[serde(rename = "Schedulable", skip_serializing_if = "Option::is_none")] 42 | pub schedulable: Option, 43 | #[serde(rename = "Topologies", skip_serializing_if = "Option::is_none")] 44 | pub topologies: Option>, 45 | } 46 | -------------------------------------------------------------------------------- /src/models/task_group.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskGroup { 5 | #[serde(rename = "Affinities", skip_serializing_if = "Option::is_none")] 6 | pub affinities: Option>, 7 | #[serde(rename = "Constraints", skip_serializing_if = "Option::is_none")] 8 | pub constraints: Option>, 9 | #[serde(rename = "Consul", skip_serializing_if = "Option::is_none")] 10 | pub consul: Option, 11 | #[serde(rename = "Count", skip_serializing_if = "Option::is_none")] 12 | pub count: Option, 13 | #[serde(rename = "EphemeralDisk", skip_serializing_if = "Option::is_none")] 14 | pub ephemeral_disk: Option, 15 | #[serde(rename = "MaxClientDisconnect", skip_serializing_if = "Option::is_none")] 16 | pub max_client_disconnect: Option, 17 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 18 | pub meta: Option<::std::collections::HashMap>, 19 | #[serde(rename = "Migrate", skip_serializing_if = "Option::is_none")] 20 | pub migrate: Option, 21 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 22 | pub name: Option, 23 | #[serde(rename = "Networks", skip_serializing_if = "Option::is_none")] 24 | pub networks: Option>, 25 | #[serde(rename = "ReschedulePolicy", skip_serializing_if = "Option::is_none")] 26 | pub reschedule_policy: Option, 27 | #[serde(rename = "RestartPolicy", skip_serializing_if = "Option::is_none")] 28 | pub restart_policy: Option, 29 | #[serde(rename = "Scaling", skip_serializing_if = "Option::is_none")] 30 | pub scaling: Option, 31 | #[serde(rename = "Services", skip_serializing_if = "Option::is_none")] 32 | pub services: Option>, 33 | #[serde(rename = "ShutdownDelay", skip_serializing_if = "Option::is_none")] 34 | pub shutdown_delay: Option, 35 | #[serde(rename = "Spreads", skip_serializing_if = "Option::is_none")] 36 | pub spreads: Option>, 37 | #[serde(rename = "StopAfterClientDisconnect", skip_serializing_if = "Option::is_none")] 38 | pub stop_after_client_disconnect: Option, 39 | #[serde(rename = "Tasks", skip_serializing_if = "Option::is_none")] 40 | pub tasks: Option>, 41 | #[serde(rename = "Update", skip_serializing_if = "Option::is_none")] 42 | pub update: Option, 43 | #[serde(rename = "Volumes", skip_serializing_if = "Option::is_none")] 44 | pub volumes: Option<::std::collections::HashMap>, 45 | } 46 | 47 | 48 | -------------------------------------------------------------------------------- /src/models/service_check.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct ServiceCheck { 5 | #[serde(rename = "AddressMode", skip_serializing_if = "Option::is_none")] 6 | pub address_mode: Option, 7 | #[serde(rename = "Advertise", skip_serializing_if = "Option::is_none")] 8 | pub advertise: Option, 9 | #[serde(rename = "Args", skip_serializing_if = "Option::is_none")] 10 | pub args: Option>, 11 | #[serde(rename = "Body", skip_serializing_if = "Option::is_none")] 12 | pub body: Option, 13 | #[serde(rename = "CheckRestart", skip_serializing_if = "Option::is_none")] 14 | pub check_restart: Option, 15 | #[serde(rename = "Command", skip_serializing_if = "Option::is_none")] 16 | pub command: Option, 17 | #[serde(rename = "Expose", skip_serializing_if = "Option::is_none")] 18 | pub expose: Option, 19 | #[serde(rename = "FailuresBeforeCritical", skip_serializing_if = "Option::is_none")] 20 | pub failures_before_critical: Option, 21 | #[serde(rename = "GRPCService", skip_serializing_if = "Option::is_none")] 22 | pub grpc_service: Option, 23 | #[serde(rename = "GRPCUseTLS", skip_serializing_if = "Option::is_none")] 24 | pub grpc_use_tls: Option, 25 | #[serde(rename = "Header", skip_serializing_if = "Option::is_none")] 26 | pub header: Option<::std::collections::HashMap>>, 27 | #[serde(rename = "InitialStatus", skip_serializing_if = "Option::is_none")] 28 | pub initial_status: Option, 29 | #[serde(rename = "Interval", skip_serializing_if = "Option::is_none")] 30 | pub interval: Option, 31 | #[serde(rename = "Method", skip_serializing_if = "Option::is_none")] 32 | pub method: Option, 33 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 34 | pub name: Option, 35 | #[serde(rename = "OnUpdate", skip_serializing_if = "Option::is_none")] 36 | pub on_update: Option, 37 | #[serde(rename = "Path", skip_serializing_if = "Option::is_none")] 38 | pub path: Option, 39 | #[serde(rename = "PortLabel", skip_serializing_if = "Option::is_none")] 40 | pub port_label: Option, 41 | #[serde(rename = "Protocol", skip_serializing_if = "Option::is_none")] 42 | pub protocol: Option, 43 | #[serde(rename = "SuccessBeforePassing", skip_serializing_if = "Option::is_none")] 44 | pub success_before_passing: Option, 45 | #[serde(rename = "TLSSkipVerify", skip_serializing_if = "Option::is_none")] 46 | pub tls_skip_verify: Option, 47 | #[serde(rename = "TaskName", skip_serializing_if = "Option::is_none")] 48 | pub task_name: Option, 49 | #[serde(rename = "Timeout", skip_serializing_if = "Option::is_none")] 50 | pub timeout: Option, 51 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 52 | pub _type: Option, 53 | } 54 | -------------------------------------------------------------------------------- /src/models/task_event.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct TaskEvent { 5 | #[serde(rename = "Details", skip_serializing_if = "Option::is_none")] 6 | pub details: Option<::std::collections::HashMap>, 7 | #[serde(rename = "DiskLimit", skip_serializing_if = "Option::is_none")] 8 | pub disk_limit: Option, 9 | #[serde(rename = "DiskSize", skip_serializing_if = "Option::is_none")] 10 | pub disk_size: Option, 11 | #[serde(rename = "DisplayMessage", skip_serializing_if = "Option::is_none")] 12 | pub display_message: Option, 13 | #[serde(rename = "DownloadError", skip_serializing_if = "Option::is_none")] 14 | pub download_error: Option, 15 | #[serde(rename = "DriverError", skip_serializing_if = "Option::is_none")] 16 | pub driver_error: Option, 17 | #[serde(rename = "DriverMessage", skip_serializing_if = "Option::is_none")] 18 | pub driver_message: Option, 19 | #[serde(rename = "ExitCode", skip_serializing_if = "Option::is_none")] 20 | pub exit_code: Option, 21 | #[serde(rename = "FailedSibling", skip_serializing_if = "Option::is_none")] 22 | pub failed_sibling: Option, 23 | #[serde(rename = "FailsTask", skip_serializing_if = "Option::is_none")] 24 | pub fails_task: Option, 25 | #[serde(rename = "GenericSource", skip_serializing_if = "Option::is_none")] 26 | pub generic_source: Option, 27 | #[serde(rename = "KillError", skip_serializing_if = "Option::is_none")] 28 | pub kill_error: Option, 29 | #[serde(rename = "KillReason", skip_serializing_if = "Option::is_none")] 30 | pub kill_reason: Option, 31 | #[serde(rename = "KillTimeout", skip_serializing_if = "Option::is_none")] 32 | pub kill_timeout: Option, 33 | #[serde(rename = "Message", skip_serializing_if = "Option::is_none")] 34 | pub message: Option, 35 | #[serde(rename = "RestartReason", skip_serializing_if = "Option::is_none")] 36 | pub restart_reason: Option, 37 | #[serde(rename = "SetupError", skip_serializing_if = "Option::is_none")] 38 | pub setup_error: Option, 39 | #[serde(rename = "Signal", skip_serializing_if = "Option::is_none")] 40 | pub signal: Option, 41 | #[serde(rename = "StartDelay", skip_serializing_if = "Option::is_none")] 42 | pub start_delay: Option, 43 | #[serde(rename = "TaskSignal", skip_serializing_if = "Option::is_none")] 44 | pub task_signal: Option, 45 | #[serde(rename = "TaskSignalReason", skip_serializing_if = "Option::is_none")] 46 | pub task_signal_reason: Option, 47 | #[serde(rename = "Time", skip_serializing_if = "Option::is_none")] 48 | pub time: Option, 49 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 50 | pub _type: Option, 51 | #[serde(rename = "ValidationError", skip_serializing_if = "Option::is_none")] 52 | pub validation_error: Option, 53 | #[serde(rename = "VaultError", skip_serializing_if = "Option::is_none")] 54 | pub vault_error: Option, 55 | } 56 | 57 | 58 | 59 | -------------------------------------------------------------------------------- /src/models/allocation_list_stub.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct AllocationListStub { 5 | #[serde(rename = "AllocatedResources", skip_serializing_if = "Option::is_none")] 6 | pub allocated_resources: Option, 7 | #[serde(rename = "ClientDescription", skip_serializing_if = "Option::is_none")] 8 | pub client_description: Option, 9 | #[serde(rename = "ClientStatus", skip_serializing_if = "Option::is_none")] 10 | pub client_status: Option, 11 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 12 | pub create_index: Option, 13 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 14 | pub create_time: Option, 15 | #[serde(rename = "DeploymentStatus", skip_serializing_if = "Option::is_none")] 16 | pub deployment_status: Option, 17 | #[serde(rename = "DesiredDescription", skip_serializing_if = "Option::is_none")] 18 | pub desired_description: Option, 19 | #[serde(rename = "DesiredStatus", skip_serializing_if = "Option::is_none")] 20 | pub desired_status: Option, 21 | #[serde(rename = "EvalID", skip_serializing_if = "Option::is_none")] 22 | pub eval_id: Option, 23 | #[serde(rename = "FollowupEvalID", skip_serializing_if = "Option::is_none")] 24 | pub followup_eval_id: Option, 25 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 26 | pub id: Option, 27 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 28 | pub job_id: Option, 29 | #[serde(rename = "JobType", skip_serializing_if = "Option::is_none")] 30 | pub job_type: Option, 31 | #[serde(rename = "JobVersion", skip_serializing_if = "Option::is_none")] 32 | pub job_version: Option, 33 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 34 | pub modify_index: Option, 35 | #[serde(rename = "ModifyTime", skip_serializing_if = "Option::is_none")] 36 | pub modify_time: Option, 37 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 38 | pub name: Option, 39 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 40 | pub namespace: Option, 41 | #[serde(rename = "NodeID", skip_serializing_if = "Option::is_none")] 42 | pub node_id: Option, 43 | #[serde(rename = "NodeName", skip_serializing_if = "Option::is_none")] 44 | pub node_name: Option, 45 | #[serde(rename = "PreemptedAllocations", skip_serializing_if = "Option::is_none")] 46 | pub preempted_allocations: Option>, 47 | #[serde(rename = "PreemptedByAllocation", skip_serializing_if = "Option::is_none")] 48 | pub preempted_by_allocation: Option, 49 | #[serde(rename = "RescheduleTracker", skip_serializing_if = "Option::is_none")] 50 | pub reschedule_tracker: Option, 51 | #[serde(rename = "TaskGroup", skip_serializing_if = "Option::is_none")] 52 | pub task_group: Option, 53 | #[serde(rename = "TaskStates", skip_serializing_if = "Option::is_none")] 54 | pub task_states: Option<::std::collections::HashMap>, 55 | } 56 | -------------------------------------------------------------------------------- /src/models/task.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Task { 5 | #[serde(rename = "Affinities", skip_serializing_if = "Option::is_none")] 6 | pub affinities: Option>, 7 | #[serde(rename = "Artifacts", skip_serializing_if = "Option::is_none")] 8 | pub artifacts: Option>, 9 | #[serde(rename = "CSIPluginConfig", skip_serializing_if = "Option::is_none")] 10 | pub csi_plugin_config: Option, 11 | #[serde(rename = "Config", skip_serializing_if = "Option::is_none")] 12 | pub config: Option<::std::collections::HashMap>, 13 | #[serde(rename = "Constraints", skip_serializing_if = "Option::is_none")] 14 | pub constraints: Option>, 15 | #[serde(rename = "DispatchPayload", skip_serializing_if = "Option::is_none")] 16 | pub dispatch_payload: Option, 17 | #[serde(rename = "Driver", skip_serializing_if = "Option::is_none")] 18 | pub driver: Option, 19 | #[serde(rename = "Env", skip_serializing_if = "Option::is_none")] 20 | pub env: Option<::std::collections::HashMap>, 21 | #[serde(rename = "KillSignal", skip_serializing_if = "Option::is_none")] 22 | pub kill_signal: Option, 23 | #[serde(rename = "KillTimeout", skip_serializing_if = "Option::is_none")] 24 | pub kill_timeout: Option, 25 | #[serde(rename = "Kind", skip_serializing_if = "Option::is_none")] 26 | pub kind: Option, 27 | #[serde(rename = "Leader", skip_serializing_if = "Option::is_none")] 28 | pub leader: Option, 29 | #[serde(rename = "Lifecycle", skip_serializing_if = "Option::is_none")] 30 | pub lifecycle: Option, 31 | #[serde(rename = "LogConfig", skip_serializing_if = "Option::is_none")] 32 | pub log_config: Option, 33 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 34 | pub meta: Option<::std::collections::HashMap>, 35 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 36 | pub name: Option, 37 | #[serde(rename = "Resources", skip_serializing_if = "Option::is_none")] 38 | pub resources: Option, 39 | #[serde(rename = "RestartPolicy", skip_serializing_if = "Option::is_none")] 40 | pub restart_policy: Option, 41 | #[serde(rename = "ScalingPolicies", skip_serializing_if = "Option::is_none")] 42 | pub scaling_policies: Option>, 43 | #[serde(rename = "Services", skip_serializing_if = "Option::is_none")] 44 | pub services: Option>, 45 | #[serde(rename = "ShutdownDelay", skip_serializing_if = "Option::is_none")] 46 | pub shutdown_delay: Option, 47 | #[serde(rename = "Templates", skip_serializing_if = "Option::is_none")] 48 | pub templates: Option>, 49 | #[serde(rename = "User", skip_serializing_if = "Option::is_none")] 50 | pub user: Option, 51 | #[serde(rename = "Vault", skip_serializing_if = "Option::is_none")] 52 | pub vault: Option, 53 | #[serde(rename = "VolumeMounts", skip_serializing_if = "Option::is_none")] 54 | pub volume_mounts: Option>, 55 | } 56 | 57 | -------------------------------------------------------------------------------- /src/api/job.rs: -------------------------------------------------------------------------------- 1 | use models::{ 2 | JobCreateRequest, JobCreateResponse, JobListAllocationsParams, JobStopParams, JobStopResponse, 3 | }; 4 | use reqwest::Method; 5 | 6 | use crate::{ 7 | models::{Allocation, Job}, 8 | Nomad, NomadError, 9 | }; 10 | 11 | pub mod models { 12 | use serde::{Deserialize, Serialize}; 13 | 14 | use crate::models::job::Job; 15 | 16 | #[derive(Debug, Default, Serialize)] 17 | #[serde(rename_all = "PascalCase")] 18 | pub struct JobCreateRequest { 19 | pub enforce_index: Option, 20 | pub eval_priority: Option, 21 | pub job: Job, 22 | pub job_modify_index: Option, 23 | pub policy_override: Option, 24 | pub preserve_counts: Option, 25 | } 26 | 27 | #[derive(Debug, Deserialize)] 28 | #[serde(rename_all = "PascalCase")] 29 | pub struct JobCreateResponse { 30 | pub eval_create_index: Option, 31 | #[serde(rename = "EvalID")] 32 | pub eval_id: Option, 33 | pub index: Option, 34 | pub job_modify_index: Option, 35 | pub known_leader: Option, 36 | pub last_contact: Option, 37 | pub warnings: Option, 38 | } 39 | 40 | #[derive(Debug, Default, Serialize)] 41 | #[serde(rename_all = "camelCase")] 42 | pub struct JobListAllocationsParams { 43 | pub all: Option, 44 | } 45 | 46 | #[derive(Debug, Default, Serialize)] 47 | #[serde(rename_all = "camelCase")] 48 | pub struct JobStopParams { 49 | pub global: Option, 50 | pub purge: Option, 51 | pub namespace: Option, 52 | } 53 | 54 | #[derive(Debug, Deserialize)] 55 | #[serde(rename_all = "PascalCase")] 56 | pub struct JobStopResponse { 57 | #[serde(rename = "EvalID")] 58 | pub eval_id: Option, 59 | pub eval_create_index: Option, 60 | pub job_modify_index: Option, 61 | } 62 | } 63 | 64 | impl Nomad { 65 | /// https://developer.hashicorp.com/nomad/api-docs/jobs#create-job 66 | pub async fn job_create( 67 | &self, 68 | req: &JobCreateRequest, 69 | ) -> Result { 70 | let req = self.request(Method::POST, "jobs").json(req); 71 | 72 | self.send::(req).await 73 | } 74 | 75 | /// https://developer.hashicorp.com/nomad/api-docs/jobs#read-job 76 | pub async fn job_read(&self, job_id: &str) -> Result { 77 | let req = self.request(Method::GET, &format!("job/{}", job_id)); 78 | 79 | self.send::(req).await 80 | } 81 | 82 | pub async fn job_list_allocations( 83 | &self, 84 | job_id: &str, 85 | params: &JobListAllocationsParams, 86 | ) -> Result, NomadError> { 87 | let req = self 88 | .request(Method::GET, &format!("job/{}/allocations", job_id)) 89 | .query(¶ms); 90 | 91 | self.send::>(req).await 92 | } 93 | 94 | pub async fn job_stop( 95 | &self, 96 | job_id: &str, 97 | params: &JobStopParams, 98 | ) -> Result { 99 | let req = self 100 | .request(Method::DELETE, &format!("job/{}", job_id)) 101 | .query(¶ms); 102 | 103 | self.send::(req).await 104 | } 105 | } 106 | -------------------------------------------------------------------------------- /src/models/evaluation.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Evaluation { 5 | #[serde(rename = "AnnotatePlan", skip_serializing_if = "Option::is_none")] 6 | pub annotate_plan: Option, 7 | #[serde(rename = "BlockedEval", skip_serializing_if = "Option::is_none")] 8 | pub blocked_eval: Option, 9 | #[serde(rename = "ClassEligibility", skip_serializing_if = "Option::is_none")] 10 | pub class_eligibility: Option<::std::collections::HashMap>, 11 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 12 | pub create_index: Option, 13 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 14 | pub create_time: Option, 15 | #[serde(rename = "DeploymentID", skip_serializing_if = "Option::is_none")] 16 | pub deployment_id: Option, 17 | #[serde(rename = "EscapedComputedClass", skip_serializing_if = "Option::is_none")] 18 | pub escaped_computed_class: Option, 19 | #[serde(rename = "FailedTGAllocs", skip_serializing_if = "Option::is_none")] 20 | pub failed_tg_allocs: Option<::std::collections::HashMap>, 21 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 22 | pub id: Option, 23 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 24 | pub job_id: Option, 25 | #[serde(rename = "JobModifyIndex", skip_serializing_if = "Option::is_none")] 26 | pub job_modify_index: Option, 27 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 28 | pub modify_index: Option, 29 | #[serde(rename = "ModifyTime", skip_serializing_if = "Option::is_none")] 30 | pub modify_time: Option, 31 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 32 | pub namespace: Option, 33 | #[serde(rename = "NextEval", skip_serializing_if = "Option::is_none")] 34 | pub next_eval: Option, 35 | #[serde(rename = "NodeID", skip_serializing_if = "Option::is_none")] 36 | pub node_id: Option, 37 | #[serde(rename = "NodeModifyIndex", skip_serializing_if = "Option::is_none")] 38 | pub node_modify_index: Option, 39 | #[serde(rename = "PreviousEval", skip_serializing_if = "Option::is_none")] 40 | pub previous_eval: Option, 41 | #[serde(rename = "Priority", skip_serializing_if = "Option::is_none")] 42 | pub priority: Option, 43 | #[serde(rename = "QueuedAllocations", skip_serializing_if = "Option::is_none")] 44 | pub queued_allocations: Option<::std::collections::HashMap>, 45 | #[serde(rename = "QuotaLimitReached", skip_serializing_if = "Option::is_none")] 46 | pub quota_limit_reached: Option, 47 | #[serde(rename = "RelatedEvals", skip_serializing_if = "Option::is_none")] 48 | pub related_evals: Option>, 49 | #[serde(rename = "SnapshotIndex", skip_serializing_if = "Option::is_none")] 50 | pub snapshot_index: Option, 51 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 52 | pub status: Option, 53 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 54 | pub status_description: Option, 55 | #[serde(rename = "TriggeredBy", skip_serializing_if = "Option::is_none")] 56 | pub triggered_by: Option, 57 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 58 | pub _type: Option, 59 | #[serde(rename = "Wait", skip_serializing_if = "Option::is_none")] 60 | pub wait: Option, 61 | #[serde(rename = "WaitUntil", skip_serializing_if = "Option::is_none")] 62 | pub wait_until: Option, 63 | } 64 | -------------------------------------------------------------------------------- /src/models/node.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Node { 5 | #[serde(rename = "Attributes", skip_serializing_if = "Option::is_none")] 6 | pub attributes: Option<::std::collections::HashMap>, 7 | #[serde(rename = "CSIControllerPlugins", skip_serializing_if = "Option::is_none")] 8 | pub csi_controller_plugins: Option<::std::collections::HashMap>, 9 | #[serde(rename = "CSINodePlugins", skip_serializing_if = "Option::is_none")] 10 | pub csi_node_plugins: Option<::std::collections::HashMap>, 11 | #[serde(rename = "CgroupParent", skip_serializing_if = "Option::is_none")] 12 | pub cgroup_parent: Option, 13 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 14 | pub create_index: Option, 15 | #[serde(rename = "Datacenter", skip_serializing_if = "Option::is_none")] 16 | pub datacenter: Option, 17 | #[serde(rename = "Drain", skip_serializing_if = "Option::is_none")] 18 | pub drain: Option, 19 | #[serde(rename = "DrainStrategy", skip_serializing_if = "Option::is_none")] 20 | pub drain_strategy: Option, 21 | #[serde(rename = "Drivers", skip_serializing_if = "Option::is_none")] 22 | pub drivers: Option<::std::collections::HashMap>, 23 | #[serde(rename = "Events", skip_serializing_if = "Option::is_none")] 24 | pub events: Option>, 25 | #[serde(rename = "HTTPAddr", skip_serializing_if = "Option::is_none")] 26 | pub http_addr: Option, 27 | #[serde(rename = "HostNetworks", skip_serializing_if = "Option::is_none")] 28 | pub host_networks: Option<::std::collections::HashMap>, 29 | #[serde(rename = "HostVolumes", skip_serializing_if = "Option::is_none")] 30 | pub host_volumes: Option<::std::collections::HashMap>, 31 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 32 | pub id: Option, 33 | #[serde(rename = "LastDrain", skip_serializing_if = "Option::is_none")] 34 | pub last_drain: Option, 35 | #[serde(rename = "Links", skip_serializing_if = "Option::is_none")] 36 | pub links: Option<::std::collections::HashMap>, 37 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 38 | pub meta: Option<::std::collections::HashMap>, 39 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 40 | pub modify_index: Option, 41 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 42 | pub name: Option, 43 | #[serde(rename = "NodeClass", skip_serializing_if = "Option::is_none")] 44 | pub node_class: Option, 45 | #[serde(rename = "NodeResources", skip_serializing_if = "Option::is_none")] 46 | pub node_resources: Option, 47 | #[serde(rename = "Reserved", skip_serializing_if = "Option::is_none")] 48 | pub reserved: Option, 49 | #[serde(rename = "ReservedResources", skip_serializing_if = "Option::is_none")] 50 | pub reserved_resources: Option, 51 | #[serde(rename = "Resources", skip_serializing_if = "Option::is_none")] 52 | pub resources: Option, 53 | #[serde(rename = "SchedulingEligibility", skip_serializing_if = "Option::is_none")] 54 | pub scheduling_eligibility: Option, 55 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 56 | pub status: Option, 57 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 58 | pub status_description: Option, 59 | #[serde(rename = "StatusUpdatedAt", skip_serializing_if = "Option::is_none")] 60 | pub status_updated_at: Option, 61 | #[serde(rename = "TLSEnabled", skip_serializing_if = "Option::is_none")] 62 | pub tls_enabled: Option, 63 | } 64 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | 3 | use reqwest::{Client, Method, RequestBuilder}; 4 | use serde::de::DeserializeOwned; 5 | use thiserror::Error; 6 | 7 | pub mod api; 8 | pub mod models; 9 | 10 | #[derive(Debug, Error)] 11 | pub enum NomadError { 12 | #[error(transparent)] 13 | InvalidRequest(serde_json::error::Error), 14 | #[error(transparent)] 15 | RequestError(reqwest::Error), 16 | #[error(transparent)] 17 | ResponseError(reqwest::Error), 18 | #[error(transparent)] 19 | InvalidResponse(reqwest::Error), 20 | #[error("Status code: {0}, body: {1}")] 21 | UnexpectedResponseCode(reqwest::StatusCode, String), 22 | } 23 | 24 | #[derive(Clone, Debug)] 25 | pub struct Config { 26 | pub address: String, 27 | pub token: Option, 28 | } 29 | 30 | impl Config { 31 | pub fn from_env() -> Config { 32 | let addr = env::var("NOMAD_ADDR").unwrap_or_else(|_| "http://127.0.0.1:4646".to_string()); 33 | let token = env::var("NOMAD_TOKEN").unwrap_or_default(); 34 | 35 | Config { 36 | address: addr, 37 | token: Some(token), 38 | } 39 | } 40 | } 41 | 42 | #[derive(Clone, Debug)] 43 | pub struct Nomad { 44 | client: Client, 45 | config: Config, 46 | } 47 | 48 | impl Nomad { 49 | pub fn new(config: Config) -> Self { 50 | let builder = Client::builder().use_rustls_tls(); 51 | let client = builder.build().expect("HTTP client should be buildable"); 52 | 53 | Nomad { client, config } 54 | } 55 | 56 | pub fn get_endpoint(&self, endpoint: &str) -> String { 57 | format!("{}/v1/{}", self.config.address, endpoint) 58 | } 59 | 60 | pub fn request(&self, method: Method, endpoint: &str) -> RequestBuilder { 61 | self.client.request(method, self.get_endpoint(endpoint)) 62 | } 63 | 64 | async fn send( 65 | &self, 66 | mut builder: RequestBuilder, 67 | ) -> Result { 68 | if let Some(token) = self.config.token.as_ref() { 69 | builder = builder.header("X-Nomad-Token", token); 70 | } 71 | 72 | let request = builder.build().map_err(NomadError::RequestError)?; 73 | 74 | let response = self 75 | .client 76 | .execute(request) 77 | .await 78 | .map_err(NomadError::ResponseError)?; 79 | 80 | let status = response.status(); 81 | if !status.is_success() { 82 | let body = response 83 | .text() 84 | .await 85 | .map_err(|e| NomadError::UnexpectedResponseCode(status, e.to_string()))?; 86 | return Err(NomadError::UnexpectedResponseCode(status, body)); 87 | } 88 | 89 | match response.json::().await { 90 | Ok(body) => Ok(body), 91 | Err(e) => Err(NomadError::InvalidResponse(e)), 92 | } 93 | } 94 | 95 | async fn send_plain(&self, mut builder: RequestBuilder) -> Result { 96 | if let Some(token) = self.config.token.as_ref() { 97 | builder = builder.header("X-Nomad-Token", token); 98 | } 99 | 100 | let request = builder.build().map_err(NomadError::RequestError)?; 101 | 102 | let response = self 103 | .client 104 | .execute(request) 105 | .await 106 | .map_err(NomadError::ResponseError)?; 107 | 108 | let status = response.status(); 109 | if !status.is_success() { 110 | let body = response 111 | .text() 112 | .await 113 | .map_err(|e| NomadError::UnexpectedResponseCode(status, e.to_string()))?; 114 | return Err(NomadError::UnexpectedResponseCode(status, body)); 115 | } 116 | 117 | match response.text().await { 118 | Ok(body) => Ok(body), 119 | Err(e) => Err(NomadError::InvalidResponse(e)), 120 | } 121 | } 122 | } 123 | 124 | impl Default for Nomad { 125 | fn default() -> Self { 126 | Nomad::new(Config::from_env()) 127 | } 128 | } 129 | -------------------------------------------------------------------------------- /src/models/allocation.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Allocation { 5 | #[serde(rename = "AllocModifyIndex", skip_serializing_if = "Option::is_none")] 6 | pub alloc_modify_index: Option, 7 | #[serde(rename = "AllocatedResources", skip_serializing_if = "Option::is_none")] 8 | pub allocated_resources: Option, 9 | #[serde(rename = "ClientDescription", skip_serializing_if = "Option::is_none")] 10 | pub client_description: Option, 11 | #[serde(rename = "ClientStatus", skip_serializing_if = "Option::is_none")] 12 | pub client_status: Option, 13 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 14 | pub create_index: Option, 15 | #[serde(rename = "CreateTime", skip_serializing_if = "Option::is_none")] 16 | pub create_time: Option, 17 | #[serde(rename = "DeploymentID", skip_serializing_if = "Option::is_none")] 18 | pub deployment_id: Option, 19 | #[serde(rename = "DeploymentStatus", skip_serializing_if = "Option::is_none")] 20 | pub deployment_status: Option, 21 | #[serde(rename = "DesiredDescription", skip_serializing_if = "Option::is_none")] 22 | pub desired_description: Option, 23 | #[serde(rename = "DesiredStatus", skip_serializing_if = "Option::is_none")] 24 | pub desired_status: Option, 25 | #[serde(rename = "DesiredTransition", skip_serializing_if = "Option::is_none")] 26 | pub desired_transition: Option, 27 | #[serde(rename = "EvalID", skip_serializing_if = "Option::is_none")] 28 | pub eval_id: Option, 29 | #[serde(rename = "FollowupEvalID", skip_serializing_if = "Option::is_none")] 30 | pub followup_eval_id: Option, 31 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 32 | pub id: Option, 33 | #[serde(rename = "Job", skip_serializing_if = "Option::is_none")] 34 | pub job: Option, 35 | #[serde(rename = "JobID", skip_serializing_if = "Option::is_none")] 36 | pub job_id: Option, 37 | #[serde(rename = "Metrics", skip_serializing_if = "Option::is_none")] 38 | pub metrics: Option, 39 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 40 | pub modify_index: Option, 41 | #[serde(rename = "ModifyTime", skip_serializing_if = "Option::is_none")] 42 | pub modify_time: Option, 43 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 44 | pub name: Option, 45 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 46 | pub namespace: Option, 47 | #[serde(rename = "NextAllocation", skip_serializing_if = "Option::is_none")] 48 | pub next_allocation: Option, 49 | #[serde(rename = "NodeID", skip_serializing_if = "Option::is_none")] 50 | pub node_id: Option, 51 | #[serde(rename = "NodeName", skip_serializing_if = "Option::is_none")] 52 | pub node_name: Option, 53 | #[serde(rename = "PreemptedAllocations", skip_serializing_if = "Option::is_none")] 54 | pub preempted_allocations: Option>, 55 | #[serde(rename = "PreemptedByAllocation", skip_serializing_if = "Option::is_none")] 56 | pub preempted_by_allocation: Option, 57 | #[serde(rename = "PreviousAllocation", skip_serializing_if = "Option::is_none")] 58 | pub previous_allocation: Option, 59 | #[serde(rename = "RescheduleTracker", skip_serializing_if = "Option::is_none")] 60 | pub reschedule_tracker: Option, 61 | #[serde(rename = "Resources", skip_serializing_if = "Option::is_none")] 62 | pub resources: Option, 63 | #[serde(rename = "Services", skip_serializing_if = "Option::is_none")] 64 | pub services: Option<::std::collections::HashMap>, 65 | #[serde(rename = "TaskGroup", skip_serializing_if = "Option::is_none")] 66 | pub task_group: Option, 67 | #[serde(rename = "TaskResources", skip_serializing_if = "Option::is_none")] 68 | pub task_resources: Option<::std::collections::HashMap>, 69 | #[serde(rename = "TaskStates", skip_serializing_if = "Option::is_none")] 70 | pub task_states: Option<::std::collections::HashMap>, 71 | } 72 | -------------------------------------------------------------------------------- /src/models/csi_volume.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct CsiVolume { 5 | #[serde(rename = "AccessMode", skip_serializing_if = "Option::is_none")] 6 | pub access_mode: Option, 7 | #[serde(rename = "Allocations", skip_serializing_if = "Option::is_none")] 8 | pub allocations: Option>, 9 | #[serde(rename = "AttachmentMode", skip_serializing_if = "Option::is_none")] 10 | pub attachment_mode: Option, 11 | #[serde(rename = "Capacity", skip_serializing_if = "Option::is_none")] 12 | pub capacity: Option, 13 | #[serde(rename = "CloneID", skip_serializing_if = "Option::is_none")] 14 | pub clone_id: Option, 15 | #[serde(rename = "Context", skip_serializing_if = "Option::is_none")] 16 | pub context: Option<::std::collections::HashMap>, 17 | #[serde(rename = "ControllerRequired", skip_serializing_if = "Option::is_none")] 18 | pub controller_required: Option, 19 | #[serde(rename = "ControllersExpected", skip_serializing_if = "Option::is_none")] 20 | pub controllers_expected: Option, 21 | #[serde(rename = "ControllersHealthy", skip_serializing_if = "Option::is_none")] 22 | pub controllers_healthy: Option, 23 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 24 | pub create_index: Option, 25 | #[serde(rename = "ExternalID", skip_serializing_if = "Option::is_none")] 26 | pub external_id: Option, 27 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 28 | pub id: Option, 29 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 30 | pub modify_index: Option, 31 | #[serde(rename = "MountOptions", skip_serializing_if = "Option::is_none")] 32 | pub mount_options: Option, 33 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 34 | pub name: Option, 35 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 36 | pub namespace: Option, 37 | #[serde(rename = "NodesExpected", skip_serializing_if = "Option::is_none")] 38 | pub nodes_expected: Option, 39 | #[serde(rename = "NodesHealthy", skip_serializing_if = "Option::is_none")] 40 | pub nodes_healthy: Option, 41 | #[serde(rename = "Parameters", skip_serializing_if = "Option::is_none")] 42 | pub parameters: Option<::std::collections::HashMap>, 43 | #[serde(rename = "PluginID", skip_serializing_if = "Option::is_none")] 44 | pub plugin_id: Option, 45 | #[serde(rename = "Provider", skip_serializing_if = "Option::is_none")] 46 | pub provider: Option, 47 | #[serde(rename = "ProviderVersion", skip_serializing_if = "Option::is_none")] 48 | pub provider_version: Option, 49 | #[serde(rename = "ReadAllocs", skip_serializing_if = "Option::is_none")] 50 | pub read_allocs: Option<::std::collections::HashMap>, 51 | #[serde(rename = "RequestedCapabilities", skip_serializing_if = "Option::is_none")] 52 | pub requested_capabilities: Option>, 53 | #[serde(rename = "RequestedCapacityMax", skip_serializing_if = "Option::is_none")] 54 | pub requested_capacity_max: Option, 55 | #[serde(rename = "RequestedCapacityMin", skip_serializing_if = "Option::is_none")] 56 | pub requested_capacity_min: Option, 57 | #[serde(rename = "RequestedTopologies", skip_serializing_if = "Option::is_none")] 58 | pub requested_topologies: Option, 59 | #[serde(rename = "ResourceExhausted", skip_serializing_if = "Option::is_none")] 60 | pub resource_exhausted: Option, 61 | #[serde(rename = "Schedulable", skip_serializing_if = "Option::is_none")] 62 | pub schedulable: Option, 63 | #[serde(rename = "Secrets", skip_serializing_if = "Option::is_none")] 64 | pub secrets: Option<::std::collections::HashMap>, 65 | #[serde(rename = "SnapshotID", skip_serializing_if = "Option::is_none")] 66 | pub snapshot_id: Option, 67 | #[serde(rename = "Topologies", skip_serializing_if = "Option::is_none")] 68 | pub topologies: Option>, 69 | #[serde(rename = "WriteAllocs", skip_serializing_if = "Option::is_none")] 70 | pub write_allocs: Option<::std::collections::HashMap>, 71 | } 72 | -------------------------------------------------------------------------------- /src/models/job.rs: -------------------------------------------------------------------------------- 1 | use serde::{Deserialize, Serialize}; 2 | 3 | #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] 4 | pub struct Job { 5 | #[serde(rename = "Affinities", skip_serializing_if = "Option::is_none")] 6 | pub affinities: Option>, 7 | #[serde(rename = "AllAtOnce", skip_serializing_if = "Option::is_none")] 8 | pub all_at_once: Option, 9 | #[serde(rename = "Constraints", skip_serializing_if = "Option::is_none")] 10 | pub constraints: Option>, 11 | #[serde(rename = "ConsulNamespace", skip_serializing_if = "Option::is_none")] 12 | pub consul_namespace: Option, 13 | #[serde(rename = "ConsulToken", skip_serializing_if = "Option::is_none")] 14 | pub consul_token: Option, 15 | #[serde(rename = "CreateIndex", skip_serializing_if = "Option::is_none")] 16 | pub create_index: Option, 17 | #[serde(rename = "Datacenters", skip_serializing_if = "Option::is_none")] 18 | pub datacenters: Option>, 19 | #[serde(rename = "DispatchIdempotencyToken", skip_serializing_if = "Option::is_none")] 20 | pub dispatch_idempotency_token: Option, 21 | #[serde(rename = "Dispatched", skip_serializing_if = "Option::is_none")] 22 | pub dispatched: Option, 23 | #[serde(rename = "ID", skip_serializing_if = "Option::is_none")] 24 | pub id: Option, 25 | #[serde(rename = "JobModifyIndex", skip_serializing_if = "Option::is_none")] 26 | pub job_modify_index: Option, 27 | #[serde(rename = "Meta", skip_serializing_if = "Option::is_none")] 28 | pub meta: Option<::std::collections::HashMap>, 29 | #[serde(rename = "Migrate", skip_serializing_if = "Option::is_none")] 30 | pub migrate: Option, 31 | #[serde(rename = "ModifyIndex", skip_serializing_if = "Option::is_none")] 32 | pub modify_index: Option, 33 | #[serde(rename = "Multiregion", skip_serializing_if = "Option::is_none")] 34 | pub multiregion: Option, 35 | #[serde(rename = "Name", skip_serializing_if = "Option::is_none")] 36 | pub name: Option, 37 | #[serde(rename = "Namespace", skip_serializing_if = "Option::is_none")] 38 | pub namespace: Option, 39 | #[serde(rename = "NomadTokenID", skip_serializing_if = "Option::is_none")] 40 | pub nomad_token_id: Option, 41 | #[serde(rename = "ParameterizedJob", skip_serializing_if = "Option::is_none")] 42 | pub parameterized_job: Option, 43 | #[serde(rename = "ParentID", skip_serializing_if = "Option::is_none")] 44 | pub parent_id: Option, 45 | #[serde(rename = "Payload", skip_serializing_if = "Option::is_none")] 46 | pub payload: Option, 47 | #[serde(rename = "Periodic", skip_serializing_if = "Option::is_none")] 48 | pub periodic: Option, 49 | #[serde(rename = "Priority", skip_serializing_if = "Option::is_none")] 50 | pub priority: Option, 51 | #[serde(rename = "Region", skip_serializing_if = "Option::is_none")] 52 | pub region: Option, 53 | #[serde(rename = "Reschedule", skip_serializing_if = "Option::is_none")] 54 | pub reschedule: Option, 55 | #[serde(rename = "Spreads", skip_serializing_if = "Option::is_none")] 56 | pub spreads: Option>, 57 | #[serde(rename = "Stable", skip_serializing_if = "Option::is_none")] 58 | pub stable: Option, 59 | #[serde(rename = "Status", skip_serializing_if = "Option::is_none")] 60 | pub status: Option, 61 | #[serde(rename = "StatusDescription", skip_serializing_if = "Option::is_none")] 62 | pub status_description: Option, 63 | #[serde(rename = "Stop", skip_serializing_if = "Option::is_none")] 64 | pub stop: Option, 65 | #[serde(rename = "SubmitTime", skip_serializing_if = "Option::is_none")] 66 | pub submit_time: Option, 67 | #[serde(rename = "TaskGroups", skip_serializing_if = "Option::is_none")] 68 | pub task_groups: Option>, 69 | #[serde(rename = "Type", skip_serializing_if = "Option::is_none")] 70 | pub _type: Option, 71 | #[serde(rename = "Update", skip_serializing_if = "Option::is_none")] 72 | pub update: Option, 73 | #[serde(rename = "VaultNamespace", skip_serializing_if = "Option::is_none")] 74 | pub vault_namespace: Option, 75 | #[serde(rename = "VaultToken", skip_serializing_if = "Option::is_none")] 76 | pub vault_token: Option, 77 | #[serde(rename = "Version", skip_serializing_if = "Option::is_none")] 78 | pub version: Option, 79 | } 80 | -------------------------------------------------------------------------------- /src/models/mod.rs: -------------------------------------------------------------------------------- 1 | pub use self::acl_policy::AclPolicy; 2 | pub use self::acl_policy_list_stub::AclPolicyListStub; 3 | pub use self::acl_token::AclToken; 4 | pub use self::acl_token_list_stub::AclTokenListStub; 5 | pub use self::acl_token_role_link::AclTokenRoleLink; 6 | pub use self::affinity::Affinity; 7 | pub use self::alloc_deployment_status::AllocDeploymentStatus; 8 | pub use self::allocated_cpu_resources::AllocatedCpuResources; 9 | pub use self::allocated_device_resource::AllocatedDeviceResource; 10 | pub use self::allocated_memory_resources::AllocatedMemoryResources; 11 | pub use self::allocated_resources::AllocatedResources; 12 | pub use self::allocated_shared_resources::AllocatedSharedResources; 13 | pub use self::allocated_task_resources::AllocatedTaskResources; 14 | pub use self::allocation::Allocation; 15 | pub use self::allocation_list_stub::AllocationListStub; 16 | pub use self::allocation_metric::AllocationMetric; 17 | pub use self::attribute::Attribute; 18 | pub use self::autopilot_configuration::AutopilotConfiguration; 19 | pub use self::change_script::ChangeScript; 20 | pub use self::check_restart::CheckRestart; 21 | pub use self::constraint::Constraint; 22 | pub use self::consul::Consul; 23 | pub use self::consul_connect::ConsulConnect; 24 | pub use self::consul_expose_config::ConsulExposeConfig; 25 | pub use self::consul_expose_path::ConsulExposePath; 26 | pub use self::consul_gateway::ConsulGateway; 27 | pub use self::consul_gateway_bind_address::ConsulGatewayBindAddress; 28 | pub use self::consul_gateway_proxy::ConsulGatewayProxy; 29 | pub use self::consul_gateway_tls_config::ConsulGatewayTlsConfig; 30 | pub use self::consul_ingress_config_entry::ConsulIngressConfigEntry; 31 | pub use self::consul_ingress_listener::ConsulIngressListener; 32 | pub use self::consul_ingress_service::ConsulIngressService; 33 | pub use self::consul_linked_service::ConsulLinkedService; 34 | pub use self::consul_mesh_gateway::ConsulMeshGateway; 35 | pub use self::consul_proxy::ConsulProxy; 36 | pub use self::consul_sidecar_service::ConsulSidecarService; 37 | pub use self::consul_terminating_config_entry::ConsulTerminatingConfigEntry; 38 | pub use self::consul_upstream::ConsulUpstream; 39 | pub use self::csi_controller_info::CsiControllerInfo; 40 | pub use self::csi_info::CsiInfo; 41 | pub use self::csi_mount_options::CsiMountOptions; 42 | pub use self::csi_node_info::CsiNodeInfo; 43 | pub use self::csi_plugin::CsiPlugin; 44 | pub use self::csi_plugin_list_stub::CsiPluginListStub; 45 | pub use self::csi_snapshot::CsiSnapshot; 46 | pub use self::csi_topology::CsiTopology; 47 | pub use self::csi_topology_request::CsiTopologyRequest; 48 | pub use self::csi_volume::CsiVolume; 49 | pub use self::csi_volume_capability::CsiVolumeCapability; 50 | pub use self::csi_volume_external_stub::CsiVolumeExternalStub; 51 | pub use self::csi_volume_list_stub::CsiVolumeListStub; 52 | pub use self::deployment::Deployment; 53 | pub use self::deployment_state::DeploymentState; 54 | pub use self::desired_transition::DesiredTransition; 55 | pub use self::desired_updates::DesiredUpdates; 56 | pub use self::dispatch_payload_config::DispatchPayloadConfig; 57 | pub use self::dns_config::DnsConfig; 58 | pub use self::drain_metadata::DrainMetadata; 59 | pub use self::drain_spec::DrainSpec; 60 | pub use self::drain_strategy::DrainStrategy; 61 | pub use self::driver_info::DriverInfo; 62 | pub use self::ephemeral_disk::EphemeralDisk; 63 | pub use self::eval_options::EvalOptions; 64 | pub use self::evaluation::Evaluation; 65 | pub use self::evaluation_stub::EvaluationStub; 66 | pub use self::field_diff::FieldDiff; 67 | pub use self::fuzzy_match::FuzzyMatch; 68 | pub use self::gauge_value::GaugeValue; 69 | pub use self::host_network_info::HostNetworkInfo; 70 | pub use self::host_volume_info::HostVolumeInfo; 71 | pub use self::job::Job; 72 | pub use self::job_acl::JobAcl; 73 | pub use self::job_children_summary::JobChildrenSummary; 74 | pub use self::job_diff::JobDiff; 75 | pub use self::job_list_stub::JobListStub; 76 | pub use self::job_summary::JobSummary; 77 | pub use self::log_config::LogConfig; 78 | pub use self::metrics_summary::MetricsSummary; 79 | pub use self::migrate_strategy::MigrateStrategy; 80 | pub use self::multiregion::Multiregion; 81 | pub use self::multiregion_region::MultiregionRegion; 82 | pub use self::multiregion_strategy::MultiregionStrategy; 83 | pub use self::namespace::Namespace; 84 | pub use self::namespace_capabilities::NamespaceCapabilities; 85 | pub use self::network_resource::NetworkResource; 86 | pub use self::node::Node; 87 | pub use self::node_cpu_resources::NodeCpuResources; 88 | pub use self::node_device::NodeDevice; 89 | pub use self::node_device_locality::NodeDeviceLocality; 90 | pub use self::node_device_resource::NodeDeviceResource; 91 | pub use self::node_disk_resources::NodeDiskResources; 92 | pub use self::node_event::NodeEvent; 93 | pub use self::node_list_stub::NodeListStub; 94 | pub use self::node_memory_resources::NodeMemoryResources; 95 | pub use self::node_reserved_cpu_resources::NodeReservedCpuResources; 96 | pub use self::node_reserved_disk_resources::NodeReservedDiskResources; 97 | pub use self::node_reserved_memory_resources::NodeReservedMemoryResources; 98 | pub use self::node_reserved_network_resources::NodeReservedNetworkResources; 99 | pub use self::node_reserved_resources::NodeReservedResources; 100 | pub use self::node_resources::NodeResources; 101 | pub use self::node_score_meta::NodeScoreMeta; 102 | pub use self::object_diff::ObjectDiff; 103 | pub use self::one_time_token::OneTimeToken; 104 | pub use self::operator_health_reply::OperatorHealthReply; 105 | pub use self::parameterized_job_config::ParameterizedJobConfig; 106 | pub use self::periodic_config::PeriodicConfig; 107 | pub use self::plan_annotations::PlanAnnotations; 108 | pub use self::point_value::PointValue; 109 | pub use self::port::Port; 110 | pub use self::port_mapping::PortMapping; 111 | pub use self::preemption_config::PreemptionConfig; 112 | pub use self::quota_limit::QuotaLimit; 113 | pub use self::quota_spec::QuotaSpec; 114 | pub use self::raft_configuration::RaftConfiguration; 115 | pub use self::raft_server::RaftServer; 116 | pub use self::requested_device::RequestedDevice; 117 | pub use self::reschedule_event::RescheduleEvent; 118 | pub use self::reschedule_policy::ReschedulePolicy; 119 | pub use self::reschedule_tracker::RescheduleTracker; 120 | pub use self::resources::Resources; 121 | pub use self::restart_policy::RestartPolicy; 122 | pub use self::sampled_value::SampledValue; 123 | pub use self::scaling_event::ScalingEvent; 124 | pub use self::scaling_policy::ScalingPolicy; 125 | pub use self::scaling_policy_list_stub::ScalingPolicyListStub; 126 | pub use self::scheduler_configuration::SchedulerConfiguration; 127 | pub use self::server_health::ServerHealth; 128 | pub use self::service::Service; 129 | pub use self::service_check::ServiceCheck; 130 | pub use self::service_registration::ServiceRegistration; 131 | pub use self::sidecar_task::SidecarTask; 132 | pub use self::spread::Spread; 133 | pub use self::spread_target::SpreadTarget; 134 | pub use self::task::Task; 135 | pub use self::task_artifact::TaskArtifact; 136 | pub use self::task_csi_plugin_config::TaskCsiPluginConfig; 137 | pub use self::task_diff::TaskDiff; 138 | pub use self::task_event::TaskEvent; 139 | pub use self::task_group::TaskGroup; 140 | pub use self::task_group_diff::TaskGroupDiff; 141 | pub use self::task_group_scale_status::TaskGroupScaleStatus; 142 | pub use self::task_group_summary::TaskGroupSummary; 143 | pub use self::task_handle::TaskHandle; 144 | pub use self::task_lifecycle::TaskLifecycle; 145 | pub use self::task_state::TaskState; 146 | pub use self::template::Template; 147 | pub use self::update_strategy::UpdateStrategy; 148 | pub use self::variable::Variable; 149 | pub use self::variable_metadata::VariableMetadata; 150 | pub use self::vault::Vault; 151 | pub use self::volume_mount::VolumeMount; 152 | pub use self::volume_request::VolumeRequest; 153 | pub use self::wait_config::WaitConfig; 154 | 155 | pub mod acl_policy; 156 | pub mod acl_policy_list_stub; 157 | pub mod acl_token; 158 | pub mod acl_token_list_stub; 159 | pub mod acl_token_role_link; 160 | pub mod affinity; 161 | pub mod alloc_deployment_status; 162 | pub mod allocated_cpu_resources; 163 | pub mod allocated_device_resource; 164 | pub mod allocated_memory_resources; 165 | pub mod allocated_resources; 166 | pub mod allocated_shared_resources; 167 | pub mod allocated_task_resources; 168 | pub mod allocation; 169 | pub mod allocation_list_stub; 170 | pub mod allocation_metric; 171 | pub mod attribute; 172 | pub mod autopilot_configuration; 173 | pub mod change_script; 174 | pub mod check_restart; 175 | pub mod constraint; 176 | pub mod consul; 177 | pub mod consul_connect; 178 | pub mod consul_expose_config; 179 | pub mod consul_expose_path; 180 | pub mod consul_gateway; 181 | pub mod consul_gateway_bind_address; 182 | pub mod consul_gateway_proxy; 183 | pub mod consul_gateway_tls_config; 184 | pub mod consul_ingress_config_entry; 185 | pub mod consul_ingress_listener; 186 | pub mod consul_ingress_service; 187 | pub mod consul_linked_service; 188 | pub mod consul_mesh_gateway; 189 | pub mod consul_proxy; 190 | pub mod consul_sidecar_service; 191 | pub mod consul_terminating_config_entry; 192 | pub mod consul_upstream; 193 | pub mod csi_controller_info; 194 | pub mod csi_info; 195 | pub mod csi_mount_options; 196 | pub mod csi_node_info; 197 | pub mod csi_plugin; 198 | pub mod csi_plugin_list_stub; 199 | pub mod csi_snapshot; 200 | pub mod csi_topology; 201 | pub mod csi_volume; 202 | pub mod csi_volume_capability; 203 | pub mod csi_volume_external_stub; 204 | pub mod csi_volume_list_stub; 205 | pub mod deployment; 206 | pub mod deployment_state; 207 | pub mod desired_transition; 208 | pub mod desired_updates; 209 | pub mod dispatch_payload_config; 210 | pub mod dns_config; 211 | pub mod drain_metadata; 212 | pub mod drain_spec; 213 | pub mod drain_strategy; 214 | pub mod driver_info; 215 | pub mod ephemeral_disk; 216 | pub mod eval_options; 217 | pub mod evaluation; 218 | pub mod evaluation_stub; 219 | pub mod field_diff; 220 | pub mod fuzzy_match; 221 | pub mod gauge_value; 222 | pub mod host_network_info; 223 | pub mod host_volume_info; 224 | pub mod job; 225 | pub mod job_acl; 226 | pub mod job_children_summary; 227 | pub mod job_diff; 228 | pub mod job_list_stub; 229 | pub mod job_summary; 230 | pub mod log_config; 231 | pub mod metrics_summary; 232 | pub mod migrate_strategy; 233 | pub mod multiregion; 234 | pub mod multiregion_region; 235 | pub mod multiregion_strategy; 236 | pub mod namespace; 237 | pub mod namespace_capabilities; 238 | pub mod network_resource; 239 | pub mod node; 240 | pub mod node_cpu_resources; 241 | pub mod node_device; 242 | pub mod node_device_locality; 243 | pub mod node_device_resource; 244 | pub mod node_disk_resources; 245 | pub mod node_event; 246 | pub mod node_list_stub; 247 | pub mod node_memory_resources; 248 | pub mod node_reserved_cpu_resources; 249 | pub mod node_reserved_disk_resources; 250 | pub mod node_reserved_memory_resources; 251 | pub mod node_reserved_network_resources; 252 | pub mod node_reserved_resources; 253 | pub mod node_resources; 254 | pub mod node_score_meta; 255 | pub mod object_diff; 256 | pub mod one_time_token; 257 | pub mod operator_health_reply; 258 | pub mod parameterized_job_config; 259 | pub mod periodic_config; 260 | pub mod plan_annotations; 261 | pub mod point_value; 262 | pub mod port; 263 | pub mod port_mapping; 264 | pub mod preemption_config; 265 | pub mod quota_limit; 266 | pub mod quota_spec; 267 | pub mod raft_configuration; 268 | pub mod raft_server; 269 | pub mod requested_device; 270 | pub mod reschedule_event; 271 | pub mod reschedule_policy; 272 | pub mod reschedule_tracker; 273 | pub mod resources; 274 | pub mod restart_policy; 275 | pub mod sampled_value; 276 | pub mod scaling_event; 277 | pub mod scaling_policy; 278 | pub mod scaling_policy_list_stub; 279 | pub mod scheduler_configuration; 280 | pub mod server_health; 281 | pub mod service; 282 | pub mod service_check; 283 | pub mod service_registration; 284 | pub mod sidecar_task; 285 | pub mod spread; 286 | pub mod spread_target; 287 | pub mod task; 288 | pub mod task_artifact; 289 | pub mod task_csi_plugin_config; 290 | pub mod task_diff; 291 | pub mod task_event; 292 | pub mod task_group; 293 | pub mod task_group_diff; 294 | pub mod task_group_scale_status; 295 | pub mod task_group_summary; 296 | pub mod task_handle; 297 | pub mod task_lifecycle; 298 | pub mod task_state; 299 | pub mod template; 300 | pub mod update_strategy; 301 | pub mod variable; 302 | pub mod variable_metadata; 303 | pub mod vault; 304 | pub mod volume_mount; 305 | pub mod wait_config; 306 | pub mod alloc_file_info; 307 | pub mod event; 308 | pub mod volume_request; 309 | pub mod csi_topology_request; --------------------------------------------------------------------------------