Minimum `Orchestrator` trait

[eywalker]

enum ImageKind {
    Published(String),
    Tarball(PathBuf),
}

trait Orchestrator {
    fn start(&self, pod_job: &PodJob) -> Result<PodRun>;
    fn start_with_altimage(&self, pod_job: &PodJob, image: &ImageKind) -> Result<PodRun>;
    fn list(&self) -> Result<Vec<PodRun>>;
    fn delete(&self, pod_run: &PodRun) -> Result<()>;
}

[guzman-raphael]

Summary from 11/23/24 - 11/27/24 meetings:

• PodJob will capture the user provided image as-is without any translation to capture the intended user input.
• There will be a way to manually override the image specification in a PodJob to start with an alternative image e.g. orchestrator.start_with_altimage(pod_job: PodJob, image: ImageKind). This provides a means to develop and iterate quickly but meant to be intentionally somewhat painful to motivate user to eventually clean up PodJob once the computation is more stable.
• ImageKind would be:

  enum ImageKind {
    Published(String),  // e.g. alpine:latest
    Tarball(String, String)  // e.g. alpine:local_dev, path/in/default/data/store/image.tar.gz
  }

• There with be an internal, private method called orchestrator.load(image: String, image_tarball_path: String) to provide an API that can be implemented on an orchestrator that defines how tarballs are loaded into available images locally. For the LocalDockerOrchestrator, this will simply be the command docker load -i [tarball/path] # plus tag appropriately. Later with Kubernetes we could use this to create our own image lookup/load driver. This will be used exclusively by .start_with_altimage(...) when it was called with a tarball.

[guzman-raphael]

// orchestrator/mod.rs
struct RunInfo {
    name: String,
    image: String,
    created: i64,
    entrypoint: String,
    command: String,
    state: String,
    mounts: Vec<String>,
    nano_cpu_limit: i64,
    memory_limit: i64,
}

struct PodRun<'orch, T> {
    pod_job_model_id: ModelID,
    orchestrator: &'orch T,
    container_id: u128, // millisecond=.as_millis(), nanosecond=.as_nanos()
}

trait PodRunAPI<T> {
    fn new(
        pod_job_model_id: ModelID,
        orchestrator: &T,
        container_id: Option<u128>,
    ) -> Result<PodRun<T>> ;
    fn get_info(&self) -> Result<Option<ContainerInfo>>;
}

trait API {
    type PodRun<'orch>;
    /// How to start containers.
    ///
    /// # Errors
    ///
    /// Will return `Err` if there is an issue starting container.
    fn start(&self, pod_job: &PodJob) -> Result<Self::PodRun<'_>>;
    /// How to query containers.
    ///
    /// # Errors
    ///
    /// Will return `Err` if there is an issue querying metadata from containers.
    fn list(&self) -> Result<Vec<Self::PodRun<'_>>>;
    /// How to delete containers.
    ///
    /// # Errors
    ///
    /// Will return `Err` if there is an issue deleting a container.
    fn delete(&self, pod_run: &Self::PodRun<'_>) -> Result<()>;
}

pub mod docker;

// orchestrator/docker.rs

fn parse_name(name: &str) -> Result<(ModelID, u128)> {}
fn make_name(model_id: &ModelID, container_id: u128) -> String {
    match model_id {
        ModelID::Hash(hash) => format!("{hash}_{container_id}"),
        ModelID::Annotation(name, version) => format!("{name}_{version}_{container_id}"),
    }
}

struct LocalDockerOrchestrator {
    pub data_directory: PathBuf,
    api: Docker,
    async_driver: Runtime,
}

trait LocalDockerOrchestratorAPI: Sized {
    fn new(data_directory: impl AsRef<Path>) -> Result<Self>;
    fn get_async_driver(&self) -> &Runtime;
    fn get_api(&self) -> &Docker;
}

impl LocalDockerOrchestratorAPI for LocalDockerOrchestrator {}
impl orchestrator::API for LocalDockerOrchestrator {
    type PodRun<'orch> = PodRun<'orch, Self>;
}
impl<'orch, T> PodRunAPI<T> for PodRun<'orch, T>
where
    T: LocalDockerOrchestratorAPI,
{}

[Synicix]

Daniel ver of pod run:

// Pod Run
/// Struct to store the active run in memory, does not get saved to store
pub struct PodRun {
    /// UID of the run which is hash of ``pod_job`` hash + date time)
    pub hash: String,
    /// Info about the pod job
    pub pod_job: PodJob,
    /// Status of the ``PodRun``
    pub status: Status,
    /// Current most up to date metrics of the job
    pub metrics: RunMetrics,
}

// Pod Result
/// Output of Pod Run once it is completed
#[derive(Deserialize, Debug, PartialEq, Default)]
pub struct PodResult {
    /// UID of the run which is hash of ``pod_job`` hash + date time)
    #[serde(skip)]
    pub hash: String,
    /// Image used
    pub image_used: String,
    /// Output logs of the system
    pub logs: String,
    /// Historical logs of resource usage
    pub metrics: RunMetrics,
    /// Depending on the status, there may or may not be an output
    pub output: Option<PodOutput>,
    /// Info about the pod job
    #[serde(skip)]
    pub pod_job: PodJob,
    /// Status of the current run
    pub status: Status,
}

/// Metrics storage for the run
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Default)]
pub struct RunMetrics {
    /// Time that the job was queued
    pub queued_time: NaiveDateTime,
    /// Time that the job began execution
    pub start_time: NaiveDateTime,
    /// Time that the job completed or failed
    pub completed_time: NaiveDateTime,
    /// History of cpu usage of the process or entire host (Have to figure out total cpu usage of only container)
    pub cpu_usage_history: Vec<(NaiveDateTime, u16)>,
    /// History of memory usage by the container
    pub mem_usage_history: Vec<(NaiveDateTime, u16)>,
}

[eywalker]

TODO: update the description here to minimum orchestrator trait and open a new issue of the advanced features including logging