Improve scheduler actor

.zed/debug.json

@@ -0,0 +1,14 @@
+[
+  {
+    "label": "Run manager agent",
+    "build": {
+      "command": "cargo",
+      "args": ["build"]
+    },
+    "sourceLanguages": ["rust"],
+    "program": "$ZED_WORKTREE_ROOT/target/debug/odorobo",
+    "args": ["--manager-enabled"],
+    "request": "launch",
+    "adapter": "CodeLLDB"
+  }
+]

odorobo/src/actors/agent_actor.rs

@@ -316,6 +316,7 @@ impl Message<GetAgentStatus> for AgentActor {
             vms: self.vms.keys().copied().collect(),
             used_vcpus: vcpus_used_by_vms + self.config.get_reserved_vcpus(),
             used_ram: ByteSize::b(ram_used_by_vms),
+            metadata: self.metadata.clone(),
         }
     }
 }

odorobo/src/actors/ip_management_actor.rs

@@ -1,6 +1,3 @@
-use kameo::prelude::*;
-use stable_eyre::{Report, Result};
-
 // idk if we ever agreed upon an OUI for fyra, but im reserving `FYR` for this
 // -cappy
 pub const FYRA_OUI: [u8; 3] = [0x46, 0x59, 0x52];
@@ -21,18 +18,3 @@ fn test_calculate_mac_address() {
     let mac = calculate_mac_address(ip);
     assert_eq!(mac, [0x46, 0x59, 0x52, 168, 0x01, 0x01]);
 }
-
-/// HTTP REST API service
-#[derive(RemoteActor)]
-pub struct IPManagementActor;
-
-impl Actor for IPManagementActor {
-    type Args = ();
-    type Error = Report;
-
-    async fn on_start(_state: Self::Args, _actor_ref: ActorRef<Self>) -> Result<Self, Self::Error> {
-        // if we need to like prep the router stuff
-
-        Ok(Self)
-    }
-}

odorobo/src/ch_driver/actor.rs

@@ -30,17 +30,22 @@ pub struct VMActor {
     /// path to the Cloud Hypervisor socket, in /run/odorobo/vms/<VMID>/ch.sock
     pub vm_instance: VMInstance,
     pub migration_state: Option<MigrationState>,
+    pub manifest: Option<VirtualMachine>,
 }
 
 impl Actor for VMActor {
-    // tuple of VM ID and optional config
+    // tuple of VM ID and manifest
     type Args = (ulid::Ulid, Option<VirtualMachine>);
     type Error = Report;
 
     #[tracing::instrument(skip_all)]
     async fn on_start((vmid, vm_config): Self::Args, actor_ref: ActorRef<Self>) -> Result<Self> {
-        let mut vminstance =
-            VMInstance::spawn(&vmid.to_string(), vm_config.map(VmConfig::from), None).await?;
+        let mut vminstance = VMInstance::spawn(
+            &vmid.to_string(),
+            vm_config.clone().map(VmConfig::from),
+            None,
+        )
+        .await?;
 
         // Take the child process out so we can watch for unexpected death.
         // destroy() handles a missing child_process gracefully.
@@ -72,6 +77,7 @@ impl Actor for VMActor {
             vmid,
             vm_instance: vminstance,
             migration_state: None,
+            manifest: vm_config,
         })
     }
 
@@ -159,7 +165,7 @@ impl Message<GetVMInfo> for VMActor {
     ) -> Self::Reply {
         GetVMInfoReply {
             vmid: self.vmid,
-            config: self.vm_instance.vm_config.clone(),
+            config: self.manifest.clone(), // we likely dont want to send the entire manifest on every update, but some of this data is required and this is easier for now.
         }
     }
 }

odorobo/src/messages/agent.rs

@@ -3,6 +3,8 @@ use kameo::Reply;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
+use crate::types::ObjectMetadata;
+
 #[derive(Serialize, Deserialize)]
 pub struct GetAgentStatus;
 
@@ -16,4 +18,5 @@ pub struct AgentStatus {
     pub used_vcpus: u32,
     pub used_ram: ByteSize,
     pub vms: Vec<Ulid>,
+    pub metadata: ObjectMetadata,
 }

odorobo/src/messages/vm.rs

@@ -99,5 +99,5 @@ pub struct GetVMInfo {
 #[derive(Serialize, Deserialize, Reply, Debug, Clone)]
 pub struct GetVMInfoReply {
     pub vmid: Ulid,
-    pub config: Option<VmConfig>,
+    pub config: Option<VirtualMachine>,
 }

odorobo/src/types.rs

@@ -165,20 +165,23 @@ pub struct VirtualMachine {
     /// Metadata
     pub metadata: Option<ObjectMetadata>,
 
-    /// List of Affinity rules for scheduling. These are ANDed / summed together depending on the strictness.
+    /// List of Affinity rules for scheduling.
+    /// Affinity rules are ANDed or summed based on strictness
     pub affinity: Option<Vec<AffinityRule>>,
 }
 
 #[derive(Serialize, Deserialize, Debug, JsonSchema, Clone)]
 pub struct AffinityRule {
     pub strictness: AffinityStrictness,
     pub affinity_type: AffinityType,
-    pub direction: AffinityDirection,
+    /// if true, the outcome of the requirements is inverted
+    #[serde(default)]
+    pub inverse: bool,
     /// ORed together
     pub requirements: Vec<AffinityRequirement>,
 }
 
-#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone)]
+#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone, Copy)]
 pub enum AffinityStrictness {
     Required,
     Preferred { weight: i64 },
@@ -190,12 +193,8 @@ pub enum AffinityType {
     Agent,
 }
 
-#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone)]
-pub enum AffinityDirection {
-    Normal,
-    Anti,
-}
-
+/// if there are several metadata tables, their results will be ANDed together
+/// EX: if a requirement is checked against several VMs, it must pass all VMs for the requirement to be fulfilled.
 #[derive(Serialize, Deserialize, Debug, JsonSchema, Clone)]
 pub struct AffinityRequirement {
     pub key: String,
@@ -210,8 +209,7 @@ pub enum MetadataTable {
     Annotation,
 }
 
-// todo: possibly replace with std::ops
-#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone)]
+#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone, PartialEq)]
 pub enum Operator {
     In,
     NotIn,

odorobo/src/utils/mod.rs

@@ -1,4 +1,3 @@
-pub mod actor_cache;
 pub mod actor_names;
 
 use aide::OperationIo;

odoroboctl/src/cli.rs

@@ -1,6 +1,11 @@
+use std::collections::BTreeMap;
+
 use bytesize::ByteSize;
 use clap::{Parser, Subcommand};
-use odorobo::types::{CreateVMRequest, VMData, VirtualMachine};
+use odorobo::types::{
+    AffinityRequirement, AffinityRule, AffinityStrictness, AffinityType, CreateVMRequest,
+    MetadataTable, ObjectMetadata, Operator, VMData, VirtualMachine,
+};
 use reqwest::{Client, Response};
 use serde::Deserialize;
 use stable_eyre::Result;
@@ -105,9 +110,27 @@ pub async fn run_command(cli: Cli) -> Result<()> {
                     vcpus: 4,
                     max_vcpus: None,
                     memory: ByteSize::gib(4),
-                    image: "/var/lib/odorobo/f43.raw".to_string(),
+                    image: "/var/lib/odorobo/f43-1.raw".to_string(),
                     ..Default::default()
                 },
+                metadata: Some(ObjectMetadata {
+                    labels: BTreeMap::new(),
+                    annotations: BTreeMap::from([(
+                        String::from("distribution"),
+                        String::from("different"),
+                    )]),
+                }),
+                affinity: Some(vec![AffinityRule {
+                    strictness: AffinityStrictness::Required,
+                    affinity_type: AffinityType::VirtualMachine,
+                    inverse: false,
+                    requirements: vec![AffinityRequirement {
+                        key: String::from("distribution"),
+                        table: MetadataTable::Annotation,
+                        operator: Operator::NotIn,
+                        values: vec![String::from("different")],
+                    }],
+                }]),
                 ..Default::default()
             };