Struct Worker

pub struct Worker {
    pub kind: String,
    pub version: String,
    pub metadata: Metadata,
    pub spec: WorkerSpec,
    pub status: Option<WorkerStatus>,
}

Represents a complete worker definition with metadata, specification and status

Examples

Creating a basic worker:

use crate::models::Worker;
CoreUnit
let worker = serde_json::from_str::<Worker>(r#"{
    "kind": "Worker",
    "version": "v0",
    "metadata": {
        "name": "worker-1",
        "tags": ["compute"]
    },
    "spec": {
        "cpus": "8 cores",
        "gpus": "1 gpu",
        "memory": "16 GiB",
        "disk": "100 GiB"
    }
}"#).unwrap();

Converting from protobuf:

use crate::proto::gevulot::gevulot;
use crate::models::Worker;

let proto_worker = gevulot::Worker {
    metadata: Some(gevulot::Metadata {
        name: "worker-1".to_string(),
        ..Default::default()
    }),
    spec: Some(gevulot::WorkerSpec {
        cpus: 8,
        gpus: 1,
        memory: 16000000000,
        disk: 100000000000,
    }),
    ..Default::default()
};

let worker = Worker::from(proto_worker);

Fields

kind: String

version: String

metadata: Metadata

spec: WorkerSpec

status: Option<WorkerStatus>

Trait Implementations

impl Debug for Worker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Worker

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Worker> for Worker

fn from(proto: Worker) -> Self

Converts to this type from the input type.

impl Serialize for Worker

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.