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

use crate::resources::v1::buffers::models::{
    V1ReplayBuffer, V1ReplayBufferRequest, V1UpdateReplayBufferRequest,
};
use nebulous::models::V1ResourceMeta;
use nebulous::models::V1ResourceMetaRequest;
use nebulous::resources::v1::containers::models::{
    V1Container, V1ContainerRequest, V1UpdateContainer,
};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Clone, Debug)]
pub struct V1OnlineLLMRequest {
    pub metadata: V1ResourceMetaRequest,
    pub model: String,
    pub buffer: V1BufferOptionRequest,
    pub server: V1ServerOptionRequest,
    pub chat_schema: Option<String>,
}

#[derive(Deserialize, Serialize, Clone, Debug)]
pub struct V1UpdateOnlineLLMRequest {
    pub model: Option<String>,
    pub buffer: Option<V1UpdateBufferOption>,
    pub server: Option<V1UpdateServerOption>,
    pub chat_schema: Option<String>,
    pub no_delete: Option<bool>,
}

#[derive(Deserialize, Serialize, Clone, Default)]
pub struct V1OnlineLLMStatus {
    pub is_online: Option<bool>,
    pub endpoint: Option<String>,
    pub last_error: Option<String>,
}

#[derive(Deserialize, Serialize, Clone, Default)]
pub struct V1OnlineLLM {
    pub metadata: V1ResourceMeta,
    pub model: String,
    pub buffer: V1ReplayBuffer,
    pub server: V1Container,
    pub chat_schema: Option<String>,
    pub status: V1OnlineLLMStatus,
}

#[derive(Deserialize, Serialize, Clone, Default)]
pub struct V1OnlineLLMs {
    pub llms: Vec<V1OnlineLLM>,
}

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum V1BufferOption {
    Id(String),
    Buffer(V1ReplayBuffer),
}

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum V1UpdateBufferOption {
    Id(String),
    Buffer(V1UpdateReplayBufferRequest),
}

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum V1BufferOptionRequest {
    Id(String),
    Buffer(V1ReplayBufferRequest),
}

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum V1ServerOption {
    Ref(V1ResourceReference),
    Server(V1Container),
}

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum V1UpdateServerOption {
    Ref(V1ResourceReference),
    Server(V1UpdateContainer),
}

#[derive(Deserialize, Serialize, Clone, Debug)]
pub struct V1ResourceReference {
    pub kind: String,
    pub name: String,
    pub namespace: String,
}

impl V1ResourceReference {
    /// Convert a `V1ResourceReference` to a string, encoded as `name.namespace.kind`.
    pub fn to_string_encoded(&self) -> String {
        format!("{}.{}.{}", self.name, self.namespace, self.kind)
    }

    /// Parse a `V1ResourceReference` from a string in the format `name.namespace.kind`.
    pub fn from_str_encoded(encoded: &str) -> Result<Self, String> {
        let parts: Vec<&str> = encoded.split('.').collect();
        if parts.len() != 3 {
            return Err(format!(
                "Invalid reference string: expected 3 parts, got {}",
                parts.len()
            ));
        }
        Ok(Self {
            name: parts[0].to_string(),
            namespace: parts[1].to_string(),
            kind: parts[2].to_string(),
        })
    }
}

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum V1ServerOptionRequest {
    Ref(V1ResourceReference),
    Server(V1ContainerRequest),
}