Method new

lib-engine/src/environment/models/database.rs:191–285

(
        context: &Context,
        long_id: Uuid,
        action: Action,
        name: &str,
        kube_name: String,
        version: VersionsNumber,
        created_at: DateTime<Utc>,
        f

impl<C: CloudProvider, M: DatabaseMode, T: DatabaseType<C, M>> Database<C, M, T> {
    pub fn new(
        context: &Context,
        long_id: Uuid,
        action: Action,
        name: &str,
        kube_name: String,
        version: VersionsNumber,
        created_at: DateTime<Utc>,
        fqdn: &str,
        fqdn_id: &str,
        cpu_request: KubernetesCpuResourceUnit,
        cpu_limit: KubernetesCpuResourceUnit,
        ram_request: KubernetesMemoryResourceUnit,
        ram_limit: KubernetesMemoryResourceUnit,
        total_disk_size_in_gb: u32, // TODO(benjaminch): introduce a Kubernetes Volume Size resource unit
        database_instance_type: Option<Box<dyn DatabaseInstanceType>>,
        publicly_accessible: bool,
        private_port: u16,
        options: T::DatabaseOptions,
        mk_event_details: impl Fn(Transmitter) -> EventDetails,
        annotations_groups: Vec<AnnotationsGroup>,
        additionnal_annotations: Vec<Annotation>,
        labels_groups: Vec<LabelsGroup>,
    ) -> Result<Self, DatabaseError> {
        // TODO: Implement domain constraint logic

        // check instance type is matching database cloud provider
        database_instance_type
            .as_ref()
            .map_or(Ok(()), |i| Self::check_instance_type_validity(i.as_ref(), C::cloud_provider()))?;

        let workspace_directory = crate::fs::workspace_directory(
            context.workspace_root_dir(),
            context.execution_id(),
            format!("databases/{long_id}"),
        )
        .map_err(|_| DatabaseError::InvalidConfig("Can't create workspace directory".to_string()))?;

        // Check memory settings only for container databases, as managed db are using an instance type
        if M::is_container() {
            if cpu_request.to_millicpu() > cpu_limit.to_millicpu() {
                return Err(DatabaseError::InvalidConfig(
                    "cpu_request_in_milli must be less or equal to cpu_limit_in_milli".to_string(),
                ));
            }

            if cpu_request.to_millicpu() == 0 {
                return Err(DatabaseError::InvalidConfig(
                    "cpu_request_in_milli must be greater than 0".to_string(),
                ));
            }

            if ram_request.to_mebibyte() > ram_limit.to_mebibyte() {
                return Err(DatabaseError::InvalidConfig(
                    "ram_request_in_mib must be less or equal to ram_limit_in_mib".to_string(),
                ));
            }