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

// src/entities/buffer.rs

use crate::resources::v1::buffers::models::{V1ReplayBuffer, V1ReplayBufferStatus};
use nebulous::models::V1ResourceMeta;
use sea_orm::entity::prelude::*;
use serde::{Deserialize, Serialize};
use serde_json::Value as Json;

#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]
#[sea_orm(table_name = "buffers")]
pub struct Model {
    #[sea_orm(primary_key, column_type = "Text", auto_increment = false)]
    pub id: String,
    pub namespace: String,
    pub name: String,
    #[sea_orm(unique)]
    pub full_name: String,
    pub owner_id: String,
    pub train_every: Option<i32>,
    pub sample_n: i32,
    pub sample_strategy: String,
    pub train_job: Option<Json>,
    pub num_epochs: i32,
    pub status: Option<Json>,
    pub num_records: Option<i32>,
    pub train_idx: Option<i32>,
    pub labels: Option<Json>,
    pub epoch_idx: Option<i32>,
    pub updated_at: DateTimeWithTimeZone,
    pub created_at: DateTimeWithTimeZone,
    pub created_by: Option<String>,
}

// The Relation enum is required, even if empty.
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}

// The ActiveModelBehavior is required, even if empty.
impl ActiveModelBehavior for ActiveModel {}

/// Try parsing the JSON fields; if parsing fails, default to an empty struct.
impl V1ReplayBuffer {
    pub fn from_model(model: &Model) -> Self {
        // Attempt to parse the train_job JSON into a V1ContainerRequest
        let parsed_train_job = model
            .train_job
            .as_ref()
            .and_then(|tj| serde_json::from_value(tj.clone()).ok())
            .unwrap_or_default();

        // Build the V1ReplayBufferStatus from DB fields
        let parsed_status = model
            .status
            .as_ref()
            .and_then(|st| serde_json::from_value(st.clone()).ok())
            .unwrap_or_else(|| {
                // or build it from the known fields
                V1ReplayBufferStatus {
                    num_records: model.num_records,
                    train_idx: model.train_idx,
                    num_train_jobs: None,
                    last_train_job: None,
                    // We can carry over num_epochs if you want it here too
                    num_epochs: Some(model.num_epochs),
                }
            });

        V1ReplayBuffer {
            // Build the metadata from model fields
            metadata: V1ResourceMeta {
                name: model.name.clone(),
                namespace: model.namespace.clone(),
                // If your V1ResourceMeta has owner references or labels, set them here
                // Also possible: uid, resourceVersion, etc.
                ..Default::default()
            },
            train_every: model.train_every,
            sample_n: model.sample_n,
            sample_strategy: model.sample_strategy.clone(),
            status: parsed_status,
            train_job: parsed_train_job,
            num_epochs: model.num_epochs,
        }
    }
}