orign 0.2.3

A globally distributed container orchestrator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::entities::buffer;
use crate::entities::human;
use crate::entities::llm;
use crate::entities::model_deployment;
use crate::entities::training_job;
use sea_orm::*;

pub struct Mutation;

impl Mutation {
    pub async fn create_buffer(
        db: &DatabaseConnection,
        form_data: buffer::ActiveModel,
    ) -> Result<buffer::Model, DbErr> {
        form_data.insert(db).await
    }

    pub async fn delete_buffer(db: &DatabaseConnection, id: &str) -> Result<DeleteResult, DbErr> {
        buffer::Entity::delete_by_id(id).exec(db).await
    }

    // src/mutation.rs
    pub async fn update_buffer(
        db: &DatabaseConnection,
        form_data: &buffer::ActiveModel,
    ) -> Result<buffer::Model, DbErr> {
        form_data.clone().update(db).await
    }

    pub async fn create_deployment(
        db: &DatabaseConnection,
        form_data: model_deployment::ActiveModel,
    ) -> Result<model_deployment::Model, DbErr> {
        form_data.insert(db).await
    }

    pub async fn delete_deployment(
        db: &DatabaseConnection,
        id: &str,
    ) -> Result<DeleteResult, DbErr> {
        model_deployment::Entity::delete_by_id(id).exec(db).await
    }

    pub async fn update_deployment_status(
        db: &DatabaseConnection,
        id: &str,
        status: String,
    ) -> Result<model_deployment::Model, DbErr> {
        let mut deployment: model_deployment::ActiveModel =
            model_deployment::Entity::find_by_id(id)
                .one(db)
                .await?
                .ok_or(DbErr::Custom("Deployment not found".to_string()))?
                .into();

        deployment.status = Set(Some(status));
        deployment.updated_at = Set(chrono::Utc::now().into());

        deployment.update(db).await
    }

    pub async fn update_training_job_status(
        db: &DatabaseConnection,
        id: &str,
        new_status: &str,
    ) -> Result<training_job::Model, DbErr> {
        let Some(job) = training_job::Entity::find_by_id(id).one(db).await? else {
            return Err(DbErr::Custom(format!("Training job not found: {}", id)));
        };

        let mut active_model: training_job::ActiveModel = job.into();

        active_model.status = Set(Some(new_status.to_string()));
        active_model.updated_at = Set(chrono::Utc::now().into());

        active_model.update(db).await
    }

    pub async fn create_training_job(
        db: &DatabaseConnection,
        form_data: training_job::ActiveModel,
    ) -> Result<training_job::Model, DbErr> {
        form_data.insert(db).await
    }

    pub async fn delete_llm_by_name_namespace_and_owners(
        db: &DatabaseConnection,
        name: &str,
        namespace: &str,
        owner_ids: &[&str],
    ) -> Result<u64, DbErr> {
        let delete_result = llm::Entity::delete_many()
            .filter(llm::Column::Name.eq(name))
            .filter(llm::Column::Namespace.eq(namespace))
            .filter(llm::Column::OwnerId.is_in(owner_ids.iter().copied()))
            .exec(db)
            .await?;

        // Returns the count of rows deleted
        Ok(delete_result.rows_affected)
    }

    pub async fn delete_human_by_name_namespace_and_owners(
        db: &DatabaseConnection,
        name: &str,
        namespace: &str,
        owner_ids: &[&str],
    ) -> Result<u64, DbErr> {
        Ok(human::Entity::delete_many()
            .filter(human::Column::Name.eq(name))
            .filter(human::Column::Namespace.eq(namespace))
            .filter(human::Column::OwnerId.is_in(owner_ids.iter().copied()))
            .exec(db)
            .await?
            .rows_affected)
    }

    /// Update an existing LLM record using an `llm::ActiveModel`.
    pub async fn update_llm(
        db: &DatabaseConnection,
        form_data: &llm::ActiveModel,
    ) -> Result<llm::Model, DbErr> {
        form_data.clone().update(db).await
    }
}