feat: computing the graph for pods

This commit introduces the `ResourceGraph` trait
that allows a resource to compute the graph of its
references - both the owners and random things
that it refers to in the specification. It is
initially implemented for pods but the goal is to
have it be the detail screen for every resource
supported.feat: draw resource connections

Author: grampelberg

Cargo.lock

@@ -29,7 +29,7 @@ base64 = "0.22.1"
 bon = "2.3.0"
 cata = { version = "0.1.1" }
 chrono = { version = "0.4.38", features = ["serde"] }
-clap = { version = "4.5.17", features = ["derive", "env"] }
+clap = { version = "4.5.18", features = ["derive", "env"] }
 clap-verbosity-flag = "2.2.1"
 clio = { version = "0.3.5", features = ["clap", "clap-parse"] }
 color-eyre = "0.6.3"
@@ -53,6 +53,7 @@ lazy_static = "1.5.0"
 local-ip-address = "0.6.3"
 mio = "1.0.2"
 ndarray = "0.16.1"
+petgraph = "0.6.5"
 pkcs8 = "0.10.2"
 prometheus = "0.13.4"
 prometheus-static-metric = "0.5.1"
@@ -78,7 +79,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 syntect = "5.2.0"
 syntect-tui = "3.0.4"
-tachyonfx = "0.6.0"
+tachyonfx = "0.7.0"
 tokio = { version = "1.40.0", features = ["full", "tracing"] }
 tokio-util = { version = "0.7.12", features = ["io-util"] }
 tracing = "0.1.40"

Cargo.toml

@@ -1,6 +1,7 @@
 mod agent;
 mod authz;
 mod dashboard;
+mod graph;
 mod shell;
 mod stdin;
 
@@ -19,6 +20,7 @@ enum DevCmd {
     Agent(agent::Agent),
     Authz(authz::Authz),
     Dashboard(dashboard::Dashboard),
+    Graph(graph::Cmd),
     Shell(shell::Shell),
     Stdin(stdin::Stdin),
 }

src/cli/dev.rs

@@ -0,0 +1,44 @@
+use cata::{Command, Container};
+use clap::Parser;
+use eyre::Result;
+use k8s_openapi::api::core::v1::Pod;
+use kube::{api::ListParams, Api};
+use petgraph::dot::{Config, Dot};
+
+use crate::resources::ResourceGraph;
+
+#[derive(Parser, Container)]
+pub struct Cmd {}
+
+#[async_trait::async_trait]
+impl Command for Cmd {
+    async fn run(&self) -> Result<()> {
+        let client = kube::Client::try_default().await?;
+
+        let pods = Api::<Pod>::all(client.clone())
+            .list(&ListParams::default())
+            .await?;
+
+        for pod in pods.items {
+            let g = pod.graph(&client).await?;
+
+            let ng = g.map(
+                |_, n| {
+                    format!(
+                        "{}/{}",
+                        n.kind
+                            .as_ref()
+                            .unwrap_or(&"unknown".to_string())
+                            .to_lowercase(),
+                        n.name.as_ref().unwrap_or(&"unknown".to_string())
+                    )
+                },
+                |_, e| e,
+            );
+
+            println!("{:#?}", Dot::with_config(&ng, &[Config::EdgeNoLabel]));
+        }
+
+        Ok(())
+    }
+}

src/cli/dev/graph.rs

@@ -4,18 +4,24 @@ pub mod file;
 pub mod install;
 pub mod node;
 pub mod pod;
+pub mod refs;
 pub mod status;
 pub mod store;
 pub mod tunnel;
 
 use color_eyre::Section;
-use eyre::{eyre, Result};
+use eyre::{eyre, Report, Result};
 pub use file::File;
-use futures::StreamExt;
+use futures::{Stream, StreamExt};
 use itertools::Itertools;
 use json_value_merge::Merge;
-use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition;
+use k8s_openapi::{
+    api::core::v1::ObjectReference,
+    apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition,
+    apimachinery::pkg::apis::meta::v1::OwnerReference,
+};
 use kube::{
+    api,
     api::{
         Api, DynamicObject, GroupVersionKind, ObjectMeta, PartialObjectMetaExt, PatchParams,
         PostParams, ResourceExt,
@@ -24,6 +30,7 @@ use kube::{
     discovery::pinned_kind,
     CustomResourceExt, Resource,
 };
+use petgraph::Graph;
 use regex::Regex;
 use serde::Serialize;
 pub use tunnel::Tunnel;
@@ -131,6 +138,22 @@ pub trait Compare {
     fn cmp(&self, right: &Self) -> std::cmp::Ordering;
 }
 
+pub trait GetGv {
+    fn gv(&self) -> (String, String);
+}
+
+impl GetGv for String {
+    fn gv(&self) -> (String, String) {
+        let version: Vec<_> = self.splitn(2, '/').collect();
+
+        if version.len() == 1 {
+            (String::new(), version[0].to_string())
+        } else {
+            (version[0].to_string(), version[1].to_string())
+        }
+    }
+}
+
 pub trait GetGvk {
     fn gvk(&self) -> Result<GroupVersionKind>;
 }
@@ -141,13 +164,7 @@ impl GetGvk for DynamicObject {
             return Err(eyre!("no types found"));
         };
 
-        let version: Vec<_> = types.api_version.splitn(2, '/').collect();
-
-        let (group, version) = if version.len() == 1 {
-            (String::new(), version[0].to_string())
-        } else {
-            (version[0].to_string(), version[1].to_string())
-        };
+        let (group, version) = types.api_version.gv();
 
         Ok(GroupVersionKind {
             group,
@@ -157,22 +174,115 @@ impl GetGvk for DynamicObject {
     }
 }
 
+impl GetGvk for OwnerReference {
+    fn gvk(&self) -> Result<GroupVersionKind> {
+        let (group, version) = self.api_version.gv();
+
+        Ok(GroupVersionKind {
+            group,
+            version,
+            kind: self.kind.clone(),
+        })
+    }
+}
+
+pub trait ApiResource {
+    fn api_resource(&self) -> api::ApiResource;
+}
+
+impl ApiResource for DynamicObject {
+    fn api_resource(&self) -> api::ApiResource {
+        api::ApiResource::from_gvk(&self.gvk().unwrap())
+    }
+}
+
+async fn dynamic_client(
+    client: kube::Client,
+    namespace: &str,
+    gvk: &GroupVersionKind,
+) -> Result<Api<DynamicObject>> {
+    let (ar, caps) = pinned_kind(&client, gvk).await?;
+
+    if matches!(caps.scope, Scope::Namespaced) {
+        Ok(Api::namespaced_with(client, namespace, &ar))
+    } else {
+        Ok(Api::all_with(client, &ar))
+    }
+}
+
 pub trait DynamicClient {
     async fn dynamic(&self, client: kube::Client) -> Result<Api<DynamicObject>>;
 }
 
 impl DynamicClient for DynamicObject {
     async fn dynamic(&self, client: kube::Client) -> Result<Api<DynamicObject>> {
-        let (ar, caps) = pinned_kind(&client, &self.gvk()?).await?;
-
-        if matches!(caps.scope, Scope::Namespaced) {
-            Ok(Api::namespaced_with(
-                client,
-                self.namespace().unwrap_or_default().as_str(),
-                &ar,
-            ))
-        } else {
-            Ok(Api::all_with(client, &ar))
+        dynamic_client(
+            client,
+            self.namespace().unwrap_or_default().as_str(),
+            &self.gvk()?,
+        )
+        .await
+    }
+}
+
+#[async_trait::async_trait]
+pub(crate) trait GetOwners {
+    fn get_owners(&self, client: kube::Client) -> impl Stream<Item = Result<DynamicObject>>;
+}
+
+#[async_trait::async_trait]
+impl GetOwners for ObjectMeta {
+    fn get_owners(&self, client: kube::Client) -> impl Stream<Item = Result<DynamicObject>> {
+        futures::stream::iter(self.owner_references.clone().unwrap_or_default())
+            .map(move |reference| {
+                let client = client.clone();
+                let namespace = self.namespace.clone().unwrap_or_default();
+
+                async move {
+                    let resource = dynamic_client(client, namespace.as_str(), &reference.gvk()?)
+                        .await?
+                        .get(reference.name.as_str())
+                        .await?;
+
+                    Ok::<DynamicObject, Report>(resource)
+                }
+            })
+            .buffered(100)
+    }
+}
+
+pub(crate) trait NamedReference {
+    fn named_ref<N, NS>(name: N, namespace: Option<NS>) -> ObjectReference
+    where
+        N: Into<String>,
+        NS: Into<String>;
+}
+
+impl<K> NamedReference for K
+where
+    K: Resource,
+    <K as Resource>::DynamicType: Default,
+{
+    fn named_ref<N, NS>(name: N, namespace: Option<NS>) -> ObjectReference
+    where
+        N: Into<String>,
+        NS: Into<String>,
+    {
+        let namespace = namespace.map(Into::into);
+
+        ObjectReference {
+            api_version: Some(K::api_version(&K::DynamicType::default()).to_string()),
+            field_path: None,
+            kind: Some(K::kind(&K::DynamicType::default()).to_string()),
+            name: Some(name.into()),
+            namespace,
+            resource_version: None,
+            uid: None,
         }
     }
 }
+
+#[async_trait::async_trait]
+pub(crate) trait ResourceGraph {
+    async fn graph(&self, client: &kube::Client) -> Result<Graph<ObjectReference, ()>>;
+}

src/resources.rs

@@ -1,3 +1,4 @@
+pub mod graph;
 pub mod proc;
 
 use std::{borrow::Borrow, cmp::Ordering, net::IpAddr, sync::Arc};