fix: add min count to autoscaler

fern/definition/admin/clusters/common.yml

@@ -18,6 +18,7 @@ types:
       pool_type: PoolType
       hardware: list<Hardware>
       desired_count: integer
+      min_count: integer
       max_count: integer
       drain_timeout: long
   Hardware:
@@ -44,4 +45,3 @@ types:
     properties:
       server_id: uuid
       public_ip: string
-

fern/definition/admin/clusters/datacenters.yml

@@ -49,6 +49,6 @@ types:
       pool_type: localCommons.PoolType
       hardware: list<localCommons.Hardware>
       desired_count: optional<integer>
+      min_count: optional<integer>
       max_count: optional<integer>
       drain_timeout: optional<long>
-

lib/bolt/cli/src/commands/cluster/datacenter.rs

@@ -100,6 +100,9 @@ pub enum SubCommand {
 		/// The desired count
 		#[clap(long)]
 		desired_count: Option<i32>,
+		/// The min count
+		#[clap(long)]
+		min_count: Option<i32>,
 		/// The max count
 		#[clap(long)]
 		max_count: Option<i32>,
@@ -192,6 +195,7 @@ impl SubCommand {
 				pool,
 				hardware,
 				desired_count,
+				min_count,
 				max_count,
 				drain_timeout,
 			} => {
@@ -234,6 +238,7 @@ impl SubCommand {
 								provider_hardware: hardware.clone(),
 							})
 							.collect(),
+						min_count,
 						max_count,
 						pool_type: pool.into(),
 					},

lib/bolt/config/src/ns.rs

@@ -669,6 +669,8 @@ pub enum ProvisioningBuildDeliveryMethod {
 pub struct ProvisioningDatacenterPool {
 	pub hardware: Vec<ProvisioningDatacenterHardware>,
 	pub desired_count: u32,
+	#[serde(default)]
+	pub min_count: u32,
 	pub max_count: u32,
 	/// Server drain time in ms.
 	pub drain_timeout: u64,

lib/bolt/core/src/context/project.rs

@@ -260,12 +260,18 @@ impl ProjectContextData {
 					panic!("invalid datacenter ({}): Missing ATS pool", name_id);
 				};
 
-				// Validate the build delivery method
 				assert!(
 					ats_pool.desired_count <= ats_pool.max_count,
 					"invalid datacenter ({}): ATS desired > max",
-					name_id
+					name_id,
+				);
+				assert!(
+					ats_pool.min_count <= ats_pool.desired_count,
+					"invalid datacenter ({}): ATS min > desired",
+					name_id,
 				);
+
+				// Validate the build delivery method
 				match datacenter.build_delivery_method {
 					config::ns::ProvisioningBuildDeliveryMethod::TrafficServer => {
 						assert_ne!(
@@ -296,7 +302,12 @@ impl ProjectContextData {
 				assert!(
 					gg_count <= gg_pool.unwrap().max_count,
 					"invalid datacenter ({}): GG desired > max",
-					name_id
+					name_id,
+				);
+				assert!(
+					gg_pool.unwrap().min_count <= gg_pool.unwrap().desired_count,
+					"invalid datacenter ({}): GG min > desired",
+					name_id,
 				);
 
 				let job_pool = datacenter
@@ -312,7 +323,12 @@ impl ProjectContextData {
 				assert!(
 					job_count <= job_pool.unwrap().max_count,
 					"invalid datacenter ({}): Job desired > max",
-					name_id
+					name_id,
+				);
+				assert!(
+					job_pool.unwrap().min_count <= job_pool.unwrap().desired_count,
+					"invalid datacenter ({}): Job min > desired",
+					name_id,
 				);
 			}
 		}

lib/convert/src/impls/admin.rs

@@ -108,6 +108,7 @@ impl ApiTryFrom<backend::cluster::Datacenter> for models::AdminClustersDatacente
 								})
 							})
 							.collect::<Result<Vec<models::AdminClustersHardware>, GlobalError>>()?,
+						min_count: unwrap!(p.min_count.try_into()),
 						max_count: unwrap!(p.max_count.try_into()),
 						pool_type: unwrap!(backend::cluster::PoolType::from_i32(p.pool_type))
 							.api_into(),

proto/backend/cluster.proto

@@ -37,6 +37,7 @@ message Pool {
     // See docs on failover (/docs/packages/cluster/SERVER_PROVISIONING.md#creating-a-new-server)
     repeated Hardware hardware = 2;
     uint32 desired_count = 3;
+    uint32 min_count = 6;
     uint32 max_count = 4;
     // Server drain timeout In ms
     uint64 drain_timeout = 5;

svc/api/admin/src/route/clusters/datacenters.rs

@@ -61,6 +61,7 @@ pub async fn create(
 				provider_hardware: "g6-nanode-1".to_string(),
 			}],
 			desired_count: 0,
+			min_count: 0,
 			max_count: 0,
 			drain_timeout,
 		},
@@ -70,6 +71,7 @@ pub async fn create(
 				provider_hardware: "g6-nanode-1".to_string(),
 			}],
 			desired_count: 0,
+			min_count: 0,
 			max_count: 0,
 			drain_timeout,
 		},
@@ -79,6 +81,7 @@ pub async fn create(
 				provider_hardware: "g6-nanode-1".to_string(),
 			}],
 			desired_count: 0,
+			min_count: 0,
 			max_count: 0,
 			drain_timeout,
 		},
@@ -136,6 +139,7 @@ pub async fn update(
 			})
 			.collect(),
 		desired_count: body.desired_count.map(|c| c as u32),
+		min_count: body.min_count.map(|c| c as u32),
 		max_count: body.max_count.map(|c| c as u32),
 		drain_timeout: body.drain_timeout.map(|d| d as u64),
 	}];

svc/pkg/cluster/standalone/default-update/src/lib.rs

@@ -39,6 +39,7 @@ impl From<Provider> for backend::cluster::Provider {
 struct Pool {
 	hardware: Vec<Hardware>,
 	desired_count: u32,
+	min_count: u32,
 	max_count: u32,
 	drain_timeout: u64,
 }
@@ -204,6 +205,7 @@ pub async fn run_from_env(use_autoscaler: bool) -> GlobalResult<()> {
 							.map(Into::into)
 							.collect::<Vec<_>>(),
 						desired_count,
+						min_count: Some(pool.min_count),
 						max_count: Some(pool.max_count),
 						drain_timeout: Some(pool.drain_timeout),
 					}
@@ -233,6 +235,7 @@ pub async fn run_from_env(use_autoscaler: bool) -> GlobalResult<()> {
 						pool_type: Into::<backend::cluster::PoolType>::into(pool_type) as i32,
 						hardware: pool.hardware.into_iter().map(Into::into).collect::<Vec<_>>(),
 						desired_count: pool.desired_count,
+						min_count: pool.min_count,
 						max_count: pool.max_count,
 						drain_timeout: pool.drain_timeout,
 					}