chore(deps): update rust crate serde to v1.0.216

Reviewed-on: #4

.drone.yml

@@ -0,0 +1,2 @@
+kind: template
+load: cuddle-rust-cli-plan.yaml

CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2024-04-06
+
+### Added
+- update
+- update
+- update stuff
+- update
+- with drone
+- with agent db
+- with sled db and capnp
+- with sled db
+- with basic changelog
+- with basic package
+- with publish
+- with monitoring
+- with monitor
+- with extra churning repl thingy
+- with enroll
+- add initial churn
+- add simple health check
+
+### Docs
+- add notes
+
+### Other
+- *(test)* test commit
+- *(test)* test commit
+- *(test)* test commit
+- *(test)* test commit
+- Merge pull request 'chore(deps): update all dependencies' (#2) from renovate/all into main
+
+Reviewed-on: https://git.front.kjuulh.io/kjuulh/churn/pulls/2
+
+- *(deps)* update all dependencies
+- change to byte slice
+- fmt
+- fmt
+- Add renovate.json
+
+- Release churn-server v0.1.0
+
+- Release churn-agent v0.1.0
+
+- Release churn v0.1.0
+
+- Release churn v0.1.0
+
+- Release churn-domain v0.1.0, churn v0.1.0
+
+- with changelog
+- Release churn-domain v0.1.0, churn v0.1.0
+

Cargo.toml

@@ -16,17 +16,22 @@ publish = true
 churn = { path = "crates/churn" }
 churn-agent = { path = "crates/churn-agent" }
 churn-server = { path = "crates/churn-server" }
-churn-domain = { path = "crates/churn-domain" }
+churn-domain = { path = "crates/churn-domain", version = "0.1.0" }
+churn-capnp = { path = "crates/churn-capnp", version = "0.1.0" }
 
-anyhow = { version = "1.0.71" }
+anyhow = { version = "1.0.86" }
 tokio = { version = "1", features = ["full"] }
 tracing = { version = "0.1", features = ["log"] }
-tracing-subscriber = { version = "0.3.17" }
-clap = { version = "4.3.4", features = ["derive", "env"] }
+tracing-subscriber = { version = "0.3.18" }
+clap = { version = "4.5.4", features = ["derive", "env"] }
 dotenv = { version = "0.15.0" }
-axum = { version = "0.6.18", features = ["macros"] }
+axum = { version = "0.7.5", features = ["macros"] }
 async-trait = "*"
 serde = {version = "1", features = ["derive"]}
 serde_json = "1"
-reqwest = {version = "0.11.20", features = ["json"]}
-uuid = {version = "1.4.1", features = ["v4", "serde"]}
+reqwest = {version = "0.12.4", features = ["json"]}
+uuid = {version = "1.8.0", features = ["v4", "serde"]}
+itertools = {version = "0.13.0"}
+
+sled = "0.34.7"
+chrono = {version = "0.4.38", features = ["serde"]}

NOTES.md

@@ -0,0 +1,6 @@
+# Notes
+
+- Building a ringbuffer like structure for sliding window logs in the server.
+  - Move logs to cold storage in rocksdb, after they're expelled from the ringbuffer
+
+- Implement rocksdb in the agents to support settings and whatnot

crates/churn-agent/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## v0.1.0 (2023-08-26)
+
+### New Features
+
+ - <csr-id-8f8c5fd41aaa82a495dd0933060f0a3a095bbaf1/> with basic package
+ - <csr-id-821e14fb1256957a107220c6c775565f5abc58c4/> with publish
+ - <csr-id-569f5272e667deeef9f269db5eaf3dec57e2df1c/> with monitor
+ - <csr-id-97978df287ee42f523f509ac686a13fa0400a026/> add initial churn
+ - <csr-id-f61d0bbf120607e59145a80b65985ab93c938522/> add simple health check
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 5 commits contributed to the release over the course of 2 calendar days.
+ - 5 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - With basic package (8f8c5fd)
+    - With publish (821e14f)
+    - With monitor (569f527)
+    - Add initial churn (97978df)
+    - Add simple health check (f61d0bb)
+</details>
+

crates/churn-agent/Cargo.toml

@@ -3,7 +3,7 @@ name = "churn-agent"
 description.workspace = true
 authors.workspace = true
 license-file.workspace = true
-version.workspace = true
+version= "0.1.0"
 edition.workspace = true
 publish.workspace = true
 

crates/churn-agent/src/agent.rs

@@ -1,16 +1,7 @@
-
-
 use std::sync::Arc;
 
-
-
-
-
-
-use axum::{async_trait};
-use churn_domain::{ServerEnrollReq};
-
-
+use axum::async_trait;
+use churn_domain::ServerEnrollReq;
 
 use tokio::sync::Mutex;
 
@@ -37,8 +28,6 @@ struct DefaultAgentService {
     leases: Arc<Mutex<Vec<String>>>,
 }
 
-
-
 #[async_trait]
 pub trait AgentServiceTrait {
     async fn enroll(&self, agent_name: &str, server: &str, lease: &str) -> anyhow::Result<()>;

crates/churn-agent/src/main.rs

@@ -14,6 +14,7 @@ use axum::{
 use churn_domain::AgentEnrollReq;
 use clap::{Parser, Subcommand};
 use serde_json::json;
+use tokio::net::TcpListener;
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None, subcommand_required = true)]
@@ -42,14 +43,11 @@ enum Commands {
     },
 }
 
-#[derive(Clone)]
-#[derive(Default)]
+#[derive(Clone, Default)]
 struct AppState {
     agent: AgentService,
 }
 
-
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenv::dotenv().ok();
@@ -73,8 +71,8 @@ async fn handle_command(cmd: Command) -> anyhow::Result<()> {
                 .with_state(AppState::default());
 
             tracing::info!("churn server listening on {}", host);
-            axum::Server::bind(&host)
-                .serve(app.into_make_service())
+            let listener = TcpListener::bind(&host).await?;
+            axum::serve(listener, app.into_make_service())
                 .await
                 .unwrap();
 

crates/churn-capnp/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "churn-capnp"
+repository.workspace = true
+description.workspace = true
+readme.workspace = true
+license-file.workspace = true
+authors.workspace = true
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+churn-domain.workspace = true
+
+uuid.workspace = true
+anyhow.workspace = true
+chrono.workspace = true
+
+capnp = "0.19.5"
+
+
+[build-dependencies]
+capnpc = "0.19.0"

crates/churn-capnp/build.rs

@@ -0,0 +1,10 @@
+extern crate capnpc;
+
+fn main() {
+    capnpc::CompilerCommand::new()
+        .output_path("src/")
+        .src_prefix("schemas/")
+        .file("schemas/models.capnp")
+        .run()
+        .unwrap();
+}

crates/churn-capnp/schemas/models.capnp

@@ -0,0 +1,17 @@
+@0xf23adf24ffd8aca4;
+
+struct LogEvent {
+  id @0 :Text;
+  author @1 :Text;
+  content @2 :Text;
+  datetime @3 :Int64;
+}
+
+struct Agent {
+  name @0 :Text;
+}
+
+struct Lease {
+  id @0 :Text;
+  lease @1 :Text;
+}

crates/churn-capnp/src/lib.rs

@@ -0,0 +1,105 @@
+use capnp::message::{Builder, HeapAllocator};
+use capnp::message::{ReaderOptions, TypedReader};
+use capnp::serialize::{self, BufferSegments};
+
+use capnp::traits::Owned;
+use churn_domain::{Agent, Lease, LogEvent};
+
+mod models_capnp;
+
+pub trait CapnpPackExt {
+    type Return;
+
+    fn serialize_capnp(&self) -> Vec<u8>;
+    fn deserialize_capnp(content: &[u8]) -> anyhow::Result<Self::Return>;
+
+    fn capnp_to_string(builder: &Builder<HeapAllocator>) -> Vec<u8> {
+        serialize::write_message_to_words(builder)
+    }
+
+    fn string_to_capnp<S>(mut content: &[u8]) -> TypedReader<BufferSegments<&[u8]>, S>
+    where
+        S: Owned,
+    {
+        let log_event =
+            serialize::read_message_from_flat_slice(&mut content, ReaderOptions::new()).unwrap();
+
+        log_event.into_typed::<S>()
+    }
+}
+
+impl CapnpPackExt for LogEvent {
+    type Return = Self;
+
+    fn serialize_capnp(&self) -> Vec<u8> {
+        let mut builder = Builder::new_default();
+        let mut log_event = builder.init_root::<models_capnp::log_event::Builder>();
+        log_event.set_id(&self.id.to_string());
+        log_event.set_author(&self.author);
+        log_event.set_content(&self.content);
+        log_event.set_datetime(self.timestamp.timestamp());
+
+        Self::capnp_to_string(&builder)
+    }
+
+    fn deserialize_capnp(content: &[u8]) -> anyhow::Result<Self> {
+        let log_event = Self::string_to_capnp::<models_capnp::log_event::Owned>(content);
+        let log_event = log_event.get()?;
+
+        Ok(Self {
+            id: uuid::Uuid::parse_str(log_event.get_id()?.to_str()?)?,
+            author: log_event.get_author()?.to_string()?,
+            content: log_event.get_content()?.to_string()?,
+            timestamp: chrono::DateTime::<chrono::Utc>::from_utc(
+                chrono::NaiveDateTime::from_timestamp_opt(log_event.get_datetime(), 0).unwrap(),
+                chrono::Utc,
+            ),
+        })
+    }
+}
+
+impl CapnpPackExt for Agent {
+    type Return = Self;
+
+    fn serialize_capnp(&self) -> Vec<u8> {
+        let mut builder = Builder::new_default();
+        let mut item = builder.init_root::<models_capnp::agent::Builder>();
+
+        item.set_name(&self.name);
+
+        Self::capnp_to_string(&builder)
+    }
+
+    fn deserialize_capnp(content: &[u8]) -> anyhow::Result<Self::Return> {
+        let item = Self::string_to_capnp::<models_capnp::agent::Owned>(content);
+        let item = item.get()?;
+
+        Ok(Self {
+            name: item.get_name()?.to_string()?,
+        })
+    }
+}
+
+impl CapnpPackExt for Lease {
+    type Return = Self;
+
+    fn serialize_capnp(&self) -> Vec<u8> {
+        let mut builder = Builder::new_default();
+        let mut item = builder.init_root::<models_capnp::lease::Builder>();
+
+        item.set_id(&self.id.to_string());
+        item.set_lease(&self.lease.to_string());
+
+        Self::capnp_to_string(&builder)
+    }
+
+    fn deserialize_capnp(content: &[u8]) -> anyhow::Result<Self::Return> {
+        let item = Self::string_to_capnp::<models_capnp::lease::Owned>(content);
+        let item = item.get()?;
+
+        Ok(Self {
+            id: uuid::Uuid::parse_str(item.get_id()?.to_str()?)?,
+            lease: uuid::Uuid::parse_str(item.get_lease()?.to_str()?)?,
+        })
+    }
+}

crates/churn-capnp/src/models_capnp.rs

@@ -0,0 +1,771 @@
+// @generated by the capnpc-rust plugin to the Cap'n Proto schema compiler.
+// DO NOT EDIT.
+// source: models.capnp
+
+
+pub mod log_event {
+  #[derive(Copy, Clone)]
+  pub struct Owned(());
+  impl ::capnp::introspect::Introspect for Owned { fn introspect() -> ::capnp::introspect::Type { ::capnp::introspect::TypeVariant::Struct(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types, annotation_types: _private::get_annotation_types }).into() } }
+  impl ::capnp::traits::Owned for Owned { type Reader<'a> = Reader<'a>; type Builder<'a> = Builder<'a>; }
+  impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a> = Reader<'a>; type Builder<'a> = Builder<'a>; }
+  impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; }
+
+  pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> }
+  impl <'a,> ::core::marker::Copy for Reader<'a,>  {}
+  impl <'a,> ::core::clone::Clone for Reader<'a,>  {
+    fn clone(&self) -> Self { *self }
+  }
+
+  impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,>  {
+    const TYPE_ID: u64 = _private::TYPE_ID;
+  }
+  impl <'a,> ::core::convert::From<::capnp::private::layout::StructReader<'a>> for Reader<'a,>  {
+    fn from(reader: ::capnp::private::layout::StructReader<'a>) -> Self {
+      Self { reader,  }
+    }
+  }
+
+  impl <'a,> ::core::convert::From<Reader<'a,>> for ::capnp::dynamic_value::Reader<'a>  {
+    fn from(reader: Reader<'a,>) -> Self {
+      Self::Struct(::capnp::dynamic_struct::Reader::new(reader.reader, ::capnp::schema::StructSchema::new(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types::<>, annotation_types: _private::get_annotation_types::<>})))
+    }
+  }
+
+  impl <'a,> ::core::fmt::Debug for Reader<'a,>  {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::result::Result<(), ::core::fmt::Error> {
+      core::fmt::Debug::fmt(&::core::convert::Into::<::capnp::dynamic_value::Reader<'_>>::into(*self), f)
+    }
+  }
+
+  impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,>  {
+    fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: ::core::option::Option<&'a [::capnp::Word]>) -> ::capnp::Result<Self> {
+      ::core::result::Result::Ok(reader.get_struct(default)?.into())
+    }
+  }
+
+  impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,>  {
+    fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
+      self.reader
+    }
+  }
+
+  impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,>  {
+    fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
+      self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
+    }
+  }
+
+  impl <'a,> Reader<'a,>  {
+    pub fn reborrow(&self) -> Reader<'_,> {
+      Self { .. *self }
+    }
+
+    pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
+      self.reader.total_size()
+    }
+    #[inline]
+    pub fn get_id(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
+      ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn has_id(&self) -> bool {
+      !self.reader.get_pointer_field(0).is_null()
+    }
+    #[inline]
+    pub fn get_author(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
+      ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn has_author(&self) -> bool {
+      !self.reader.get_pointer_field(1).is_null()
+    }
+    #[inline]
+    pub fn get_content(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
+      ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(2), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn has_content(&self) -> bool {
+      !self.reader.get_pointer_field(2).is_null()
+    }
+    #[inline]
+    pub fn get_datetime(self) -> i64 {
+      self.reader.get_data_field::<i64>(0)
+    }
+  }
+
+  pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> }
+  impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,>  {
+    const STRUCT_SIZE: ::capnp::private::layout::StructSize = ::capnp::private::layout::StructSize { data: 1, pointers: 3 };
+  }
+  impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,>  {
+    const TYPE_ID: u64 = _private::TYPE_ID;
+  }
+  impl <'a,> ::core::convert::From<::capnp::private::layout::StructBuilder<'a>> for Builder<'a,>  {
+    fn from(builder: ::capnp::private::layout::StructBuilder<'a>) -> Self {
+      Self { builder,  }
+    }
+  }
+
+  impl <'a,> ::core::convert::From<Builder<'a,>> for ::capnp::dynamic_value::Builder<'a>  {
+    fn from(builder: Builder<'a,>) -> Self {
+      Self::Struct(::capnp::dynamic_struct::Builder::new(builder.builder, ::capnp::schema::StructSchema::new(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types::<>, annotation_types: _private::get_annotation_types::<>})))
+    }
+  }
+
+  impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,>  {
+    fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
+      self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
+    }
+  }
+
+  impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,>  {
+    fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Self {
+      builder.init_struct(<Self as ::capnp::traits::HasStructSize>::STRUCT_SIZE).into()
+    }
+    fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: ::core::option::Option<&'a [::capnp::Word]>) -> ::capnp::Result<Self> {
+      ::core::result::Result::Ok(builder.get_struct(<Self as ::capnp::traits::HasStructSize>::STRUCT_SIZE, default)?.into())
+    }
+  }
+
+  impl <'a,> ::capnp::traits::SetterInput<Owned<>> for Reader<'a,>  {
+    fn set_pointer_builder(mut pointer: ::capnp::private::layout::PointerBuilder<'_>, value: Self, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) }
+  }
+
+  impl <'a,> Builder<'a,>  {
+    pub fn into_reader(self) -> Reader<'a,> {
+      self.builder.into_reader().into()
+    }
+    pub fn reborrow(&mut self) -> Builder<'_,> {
+      Builder { builder: self.builder.reborrow() }
+    }
+    pub fn reborrow_as_reader(&self) -> Reader<'_,> {
+      self.builder.as_reader().into()
+    }
+
+    pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
+      self.builder.as_reader().total_size()
+    }
+    #[inline]
+    pub fn get_id(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
+      ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn set_id(&mut self, value: impl ::capnp::traits::SetterInput<::capnp::text::Owned>)  {
+      ::capnp::traits::SetterInput::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false).unwrap()
+    }
+    #[inline]
+    pub fn init_id(self, size: u32) -> ::capnp::text::Builder<'a> {
+      self.builder.get_pointer_field(0).init_text(size)
+    }
+    #[inline]
+    pub fn has_id(&self) -> bool {
+      !self.builder.is_pointer_field_null(0)
+    }
+    #[inline]
+    pub fn get_author(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
+      ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn set_author(&mut self, value: impl ::capnp::traits::SetterInput<::capnp::text::Owned>)  {
+      ::capnp::traits::SetterInput::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false).unwrap()
+    }
+    #[inline]
+    pub fn init_author(self, size: u32) -> ::capnp::text::Builder<'a> {
+      self.builder.get_pointer_field(1).init_text(size)
+    }
+    #[inline]
+    pub fn has_author(&self) -> bool {
+      !self.builder.is_pointer_field_null(1)
+    }
+    #[inline]
+    pub fn get_content(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
+      ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn set_content(&mut self, value: impl ::capnp::traits::SetterInput<::capnp::text::Owned>)  {
+      ::capnp::traits::SetterInput::set_pointer_builder(self.builder.reborrow().get_pointer_field(2), value, false).unwrap()
+    }
+    #[inline]
+    pub fn init_content(self, size: u32) -> ::capnp::text::Builder<'a> {
+      self.builder.get_pointer_field(2).init_text(size)
+    }
+    #[inline]
+    pub fn has_content(&self) -> bool {
+      !self.builder.is_pointer_field_null(2)
+    }
+    #[inline]
+    pub fn get_datetime(self) -> i64 {
+      self.builder.get_data_field::<i64>(0)
+    }
+    #[inline]
+    pub fn set_datetime(&mut self, value: i64)  {
+      self.builder.set_data_field::<i64>(0, value);
+    }
+  }
+
+  pub struct Pipeline { _typeless: ::capnp::any_pointer::Pipeline }
+  impl ::capnp::capability::FromTypelessPipeline for Pipeline {
+    fn new(typeless: ::capnp::any_pointer::Pipeline) -> Self {
+      Self { _typeless: typeless,  }
+    }
+  }
+  impl Pipeline  {
+  }
+  mod _private {
+    pub static ENCODED_NODE: [::capnp::Word; 78] = [
+      ::capnp::word(0, 0, 0, 0, 5, 0, 6, 0),
+      ::capnp::word(50, 25, 14, 89, 91, 12, 143, 231),
+      ::capnp::word(13, 0, 0, 0, 1, 0, 1, 0),
+      ::capnp::word(164, 172, 216, 255, 36, 223, 58, 242),
+      ::capnp::word(3, 0, 7, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(21, 0, 0, 0, 178, 0, 0, 0),
+      ::capnp::word(29, 0, 0, 0, 7, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(25, 0, 0, 0, 231, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(109, 111, 100, 101, 108, 115, 46, 99),
+      ::capnp::word(97, 112, 110, 112, 58, 76, 111, 103),
+      ::capnp::word(69, 118, 101, 110, 116, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 1, 0, 1, 0),
+      ::capnp::word(16, 0, 0, 0, 3, 0, 4, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(97, 0, 0, 0, 26, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(92, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(104, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(1, 0, 0, 0, 1, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 1, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(101, 0, 0, 0, 58, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(96, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(108, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(2, 0, 0, 0, 2, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 2, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(105, 0, 0, 0, 66, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(100, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(112, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(3, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 3, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(109, 0, 0, 0, 74, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(108, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(120, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(105, 100, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(97, 117, 116, 104, 111, 114, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(99, 111, 110, 116, 101, 110, 116, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(100, 97, 116, 101, 116, 105, 109, 101),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(5, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(5, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+    ];
+    pub fn get_field_types(index: u16) -> ::capnp::introspect::Type {
+      match index {
+        0 => <::capnp::text::Owned as ::capnp::introspect::Introspect>::introspect(),
+        1 => <::capnp::text::Owned as ::capnp::introspect::Introspect>::introspect(),
+        2 => <::capnp::text::Owned as ::capnp::introspect::Introspect>::introspect(),
+        3 => <i64 as ::capnp::introspect::Introspect>::introspect(),
+        _ => panic!("invalid field index {}", index),
+      }
+    }
+    pub fn get_annotation_types(child_index: Option<u16>, index: u32) -> ::capnp::introspect::Type {
+      panic!("invalid annotation indices ({:?}, {}) ", child_index, index)
+    }
+    pub static RAW_SCHEMA: ::capnp::introspect::RawStructSchema = ::capnp::introspect::RawStructSchema {
+      encoded_node: &ENCODED_NODE,
+      nonunion_members: NONUNION_MEMBERS,
+      members_by_discriminant: MEMBERS_BY_DISCRIMINANT,
+      members_by_name: MEMBERS_BY_NAME,
+    };
+    pub static NONUNION_MEMBERS : &[u16] = &[0,1,2,3];
+    pub static MEMBERS_BY_DISCRIMINANT : &[u16] = &[];
+    pub static MEMBERS_BY_NAME : &[u16] = &[1,2,3,0];
+    pub const TYPE_ID: u64 = 0xe78f_0c5b_590e_1932;
+  }
+}
+
+pub mod agent {
+  #[derive(Copy, Clone)]
+  pub struct Owned(());
+  impl ::capnp::introspect::Introspect for Owned { fn introspect() -> ::capnp::introspect::Type { ::capnp::introspect::TypeVariant::Struct(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types, annotation_types: _private::get_annotation_types }).into() } }
+  impl ::capnp::traits::Owned for Owned { type Reader<'a> = Reader<'a>; type Builder<'a> = Builder<'a>; }
+  impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a> = Reader<'a>; type Builder<'a> = Builder<'a>; }
+  impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; }
+
+  pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> }
+  impl <'a,> ::core::marker::Copy for Reader<'a,>  {}
+  impl <'a,> ::core::clone::Clone for Reader<'a,>  {
+    fn clone(&self) -> Self { *self }
+  }
+
+  impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,>  {
+    const TYPE_ID: u64 = _private::TYPE_ID;
+  }
+  impl <'a,> ::core::convert::From<::capnp::private::layout::StructReader<'a>> for Reader<'a,>  {
+    fn from(reader: ::capnp::private::layout::StructReader<'a>) -> Self {
+      Self { reader,  }
+    }
+  }
+
+  impl <'a,> ::core::convert::From<Reader<'a,>> for ::capnp::dynamic_value::Reader<'a>  {
+    fn from(reader: Reader<'a,>) -> Self {
+      Self::Struct(::capnp::dynamic_struct::Reader::new(reader.reader, ::capnp::schema::StructSchema::new(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types::<>, annotation_types: _private::get_annotation_types::<>})))
+    }
+  }
+
+  impl <'a,> ::core::fmt::Debug for Reader<'a,>  {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::result::Result<(), ::core::fmt::Error> {
+      core::fmt::Debug::fmt(&::core::convert::Into::<::capnp::dynamic_value::Reader<'_>>::into(*self), f)
+    }
+  }
+
+  impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,>  {
+    fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: ::core::option::Option<&'a [::capnp::Word]>) -> ::capnp::Result<Self> {
+      ::core::result::Result::Ok(reader.get_struct(default)?.into())
+    }
+  }
+
+  impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,>  {
+    fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
+      self.reader
+    }
+  }
+
+  impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,>  {
+    fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
+      self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
+    }
+  }
+
+  impl <'a,> Reader<'a,>  {
+    pub fn reborrow(&self) -> Reader<'_,> {
+      Self { .. *self }
+    }
+
+    pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
+      self.reader.total_size()
+    }
+    #[inline]
+    pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
+      ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn has_name(&self) -> bool {
+      !self.reader.get_pointer_field(0).is_null()
+    }
+  }
+
+  pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> }
+  impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,>  {
+    const STRUCT_SIZE: ::capnp::private::layout::StructSize = ::capnp::private::layout::StructSize { data: 0, pointers: 1 };
+  }
+  impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,>  {
+    const TYPE_ID: u64 = _private::TYPE_ID;
+  }
+  impl <'a,> ::core::convert::From<::capnp::private::layout::StructBuilder<'a>> for Builder<'a,>  {
+    fn from(builder: ::capnp::private::layout::StructBuilder<'a>) -> Self {
+      Self { builder,  }
+    }
+  }
+
+  impl <'a,> ::core::convert::From<Builder<'a,>> for ::capnp::dynamic_value::Builder<'a>  {
+    fn from(builder: Builder<'a,>) -> Self {
+      Self::Struct(::capnp::dynamic_struct::Builder::new(builder.builder, ::capnp::schema::StructSchema::new(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types::<>, annotation_types: _private::get_annotation_types::<>})))
+    }
+  }
+
+  impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,>  {
+    fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
+      self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
+    }
+  }
+
+  impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,>  {
+    fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Self {
+      builder.init_struct(<Self as ::capnp::traits::HasStructSize>::STRUCT_SIZE).into()
+    }
+    fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: ::core::option::Option<&'a [::capnp::Word]>) -> ::capnp::Result<Self> {
+      ::core::result::Result::Ok(builder.get_struct(<Self as ::capnp::traits::HasStructSize>::STRUCT_SIZE, default)?.into())
+    }
+  }
+
+  impl <'a,> ::capnp::traits::SetterInput<Owned<>> for Reader<'a,>  {
+    fn set_pointer_builder(mut pointer: ::capnp::private::layout::PointerBuilder<'_>, value: Self, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) }
+  }
+
+  impl <'a,> Builder<'a,>  {
+    pub fn into_reader(self) -> Reader<'a,> {
+      self.builder.into_reader().into()
+    }
+    pub fn reborrow(&mut self) -> Builder<'_,> {
+      Builder { builder: self.builder.reborrow() }
+    }
+    pub fn reborrow_as_reader(&self) -> Reader<'_,> {
+      self.builder.as_reader().into()
+    }
+
+    pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
+      self.builder.as_reader().total_size()
+    }
+    #[inline]
+    pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
+      ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn set_name(&mut self, value: impl ::capnp::traits::SetterInput<::capnp::text::Owned>)  {
+      ::capnp::traits::SetterInput::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false).unwrap()
+    }
+    #[inline]
+    pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> {
+      self.builder.get_pointer_field(0).init_text(size)
+    }
+    #[inline]
+    pub fn has_name(&self) -> bool {
+      !self.builder.is_pointer_field_null(0)
+    }
+  }
+
+  pub struct Pipeline { _typeless: ::capnp::any_pointer::Pipeline }
+  impl ::capnp::capability::FromTypelessPipeline for Pipeline {
+    fn new(typeless: ::capnp::any_pointer::Pipeline) -> Self {
+      Self { _typeless: typeless,  }
+    }
+  }
+  impl Pipeline  {
+  }
+  mod _private {
+    pub static ENCODED_NODE: [::capnp::Word; 32] = [
+      ::capnp::word(0, 0, 0, 0, 5, 0, 6, 0),
+      ::capnp::word(160, 129, 44, 52, 151, 203, 164, 244),
+      ::capnp::word(13, 0, 0, 0, 1, 0, 0, 0),
+      ::capnp::word(164, 172, 216, 255, 36, 223, 58, 242),
+      ::capnp::word(1, 0, 7, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(21, 0, 0, 0, 154, 0, 0, 0),
+      ::capnp::word(29, 0, 0, 0, 7, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(25, 0, 0, 0, 63, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(109, 111, 100, 101, 108, 115, 46, 99),
+      ::capnp::word(97, 112, 110, 112, 58, 65, 103, 101),
+      ::capnp::word(110, 116, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 1, 0, 1, 0),
+      ::capnp::word(4, 0, 0, 0, 3, 0, 4, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(13, 0, 0, 0, 42, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(8, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(20, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(110, 97, 109, 101, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+    ];
+    pub fn get_field_types(index: u16) -> ::capnp::introspect::Type {
+      match index {
+        0 => <::capnp::text::Owned as ::capnp::introspect::Introspect>::introspect(),
+        _ => panic!("invalid field index {}", index),
+      }
+    }
+    pub fn get_annotation_types(child_index: Option<u16>, index: u32) -> ::capnp::introspect::Type {
+      panic!("invalid annotation indices ({:?}, {}) ", child_index, index)
+    }
+    pub static RAW_SCHEMA: ::capnp::introspect::RawStructSchema = ::capnp::introspect::RawStructSchema {
+      encoded_node: &ENCODED_NODE,
+      nonunion_members: NONUNION_MEMBERS,
+      members_by_discriminant: MEMBERS_BY_DISCRIMINANT,
+      members_by_name: MEMBERS_BY_NAME,
+    };
+    pub static NONUNION_MEMBERS : &[u16] = &[0];
+    pub static MEMBERS_BY_DISCRIMINANT : &[u16] = &[];
+    pub static MEMBERS_BY_NAME : &[u16] = &[0];
+    pub const TYPE_ID: u64 = 0xf4a4_cb97_342c_81a0;
+  }
+}
+
+pub mod lease {
+  #[derive(Copy, Clone)]
+  pub struct Owned(());
+  impl ::capnp::introspect::Introspect for Owned { fn introspect() -> ::capnp::introspect::Type { ::capnp::introspect::TypeVariant::Struct(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types, annotation_types: _private::get_annotation_types }).into() } }
+  impl ::capnp::traits::Owned for Owned { type Reader<'a> = Reader<'a>; type Builder<'a> = Builder<'a>; }
+  impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a> = Reader<'a>; type Builder<'a> = Builder<'a>; }
+  impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; }
+
+  pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> }
+  impl <'a,> ::core::marker::Copy for Reader<'a,>  {}
+  impl <'a,> ::core::clone::Clone for Reader<'a,>  {
+    fn clone(&self) -> Self { *self }
+  }
+
+  impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,>  {
+    const TYPE_ID: u64 = _private::TYPE_ID;
+  }
+  impl <'a,> ::core::convert::From<::capnp::private::layout::StructReader<'a>> for Reader<'a,>  {
+    fn from(reader: ::capnp::private::layout::StructReader<'a>) -> Self {
+      Self { reader,  }
+    }
+  }
+
+  impl <'a,> ::core::convert::From<Reader<'a,>> for ::capnp::dynamic_value::Reader<'a>  {
+    fn from(reader: Reader<'a,>) -> Self {
+      Self::Struct(::capnp::dynamic_struct::Reader::new(reader.reader, ::capnp::schema::StructSchema::new(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types::<>, annotation_types: _private::get_annotation_types::<>})))
+    }
+  }
+
+  impl <'a,> ::core::fmt::Debug for Reader<'a,>  {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::result::Result<(), ::core::fmt::Error> {
+      core::fmt::Debug::fmt(&::core::convert::Into::<::capnp::dynamic_value::Reader<'_>>::into(*self), f)
+    }
+  }
+
+  impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,>  {
+    fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: ::core::option::Option<&'a [::capnp::Word]>) -> ::capnp::Result<Self> {
+      ::core::result::Result::Ok(reader.get_struct(default)?.into())
+    }
+  }
+
+  impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,>  {
+    fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
+      self.reader
+    }
+  }
+
+  impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,>  {
+    fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
+      self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
+    }
+  }
+
+  impl <'a,> Reader<'a,>  {
+    pub fn reborrow(&self) -> Reader<'_,> {
+      Self { .. *self }
+    }
+
+    pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
+      self.reader.total_size()
+    }
+    #[inline]
+    pub fn get_id(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
+      ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn has_id(&self) -> bool {
+      !self.reader.get_pointer_field(0).is_null()
+    }
+    #[inline]
+    pub fn get_lease(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
+      ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn has_lease(&self) -> bool {
+      !self.reader.get_pointer_field(1).is_null()
+    }
+  }
+
+  pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> }
+  impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,>  {
+    const STRUCT_SIZE: ::capnp::private::layout::StructSize = ::capnp::private::layout::StructSize { data: 0, pointers: 2 };
+  }
+  impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,>  {
+    const TYPE_ID: u64 = _private::TYPE_ID;
+  }
+  impl <'a,> ::core::convert::From<::capnp::private::layout::StructBuilder<'a>> for Builder<'a,>  {
+    fn from(builder: ::capnp::private::layout::StructBuilder<'a>) -> Self {
+      Self { builder,  }
+    }
+  }
+
+  impl <'a,> ::core::convert::From<Builder<'a,>> for ::capnp::dynamic_value::Builder<'a>  {
+    fn from(builder: Builder<'a,>) -> Self {
+      Self::Struct(::capnp::dynamic_struct::Builder::new(builder.builder, ::capnp::schema::StructSchema::new(::capnp::introspect::RawBrandedStructSchema { generic: &_private::RAW_SCHEMA, field_types: _private::get_field_types::<>, annotation_types: _private::get_annotation_types::<>})))
+    }
+  }
+
+  impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,>  {
+    fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
+      self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
+    }
+  }
+
+  impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,>  {
+    fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Self {
+      builder.init_struct(<Self as ::capnp::traits::HasStructSize>::STRUCT_SIZE).into()
+    }
+    fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: ::core::option::Option<&'a [::capnp::Word]>) -> ::capnp::Result<Self> {
+      ::core::result::Result::Ok(builder.get_struct(<Self as ::capnp::traits::HasStructSize>::STRUCT_SIZE, default)?.into())
+    }
+  }
+
+  impl <'a,> ::capnp::traits::SetterInput<Owned<>> for Reader<'a,>  {
+    fn set_pointer_builder(mut pointer: ::capnp::private::layout::PointerBuilder<'_>, value: Self, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) }
+  }
+
+  impl <'a,> Builder<'a,>  {
+    pub fn into_reader(self) -> Reader<'a,> {
+      self.builder.into_reader().into()
+    }
+    pub fn reborrow(&mut self) -> Builder<'_,> {
+      Builder { builder: self.builder.reborrow() }
+    }
+    pub fn reborrow_as_reader(&self) -> Reader<'_,> {
+      self.builder.as_reader().into()
+    }
+
+    pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
+      self.builder.as_reader().total_size()
+    }
+    #[inline]
+    pub fn get_id(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
+      ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn set_id(&mut self, value: impl ::capnp::traits::SetterInput<::capnp::text::Owned>)  {
+      ::capnp::traits::SetterInput::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false).unwrap()
+    }
+    #[inline]
+    pub fn init_id(self, size: u32) -> ::capnp::text::Builder<'a> {
+      self.builder.get_pointer_field(0).init_text(size)
+    }
+    #[inline]
+    pub fn has_id(&self) -> bool {
+      !self.builder.is_pointer_field_null(0)
+    }
+    #[inline]
+    pub fn get_lease(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
+      ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None)
+    }
+    #[inline]
+    pub fn set_lease(&mut self, value: impl ::capnp::traits::SetterInput<::capnp::text::Owned>)  {
+      ::capnp::traits::SetterInput::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false).unwrap()
+    }
+    #[inline]
+    pub fn init_lease(self, size: u32) -> ::capnp::text::Builder<'a> {
+      self.builder.get_pointer_field(1).init_text(size)
+    }
+    #[inline]
+    pub fn has_lease(&self) -> bool {
+      !self.builder.is_pointer_field_null(1)
+    }
+  }
+
+  pub struct Pipeline { _typeless: ::capnp::any_pointer::Pipeline }
+  impl ::capnp::capability::FromTypelessPipeline for Pipeline {
+    fn new(typeless: ::capnp::any_pointer::Pipeline) -> Self {
+      Self { _typeless: typeless,  }
+    }
+  }
+  impl Pipeline  {
+  }
+  mod _private {
+    pub static ENCODED_NODE: [::capnp::Word; 47] = [
+      ::capnp::word(0, 0, 0, 0, 5, 0, 6, 0),
+      ::capnp::word(98, 86, 14, 197, 84, 8, 214, 176),
+      ::capnp::word(13, 0, 0, 0, 1, 0, 0, 0),
+      ::capnp::word(164, 172, 216, 255, 36, 223, 58, 242),
+      ::capnp::word(2, 0, 7, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(21, 0, 0, 0, 154, 0, 0, 0),
+      ::capnp::word(29, 0, 0, 0, 7, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(25, 0, 0, 0, 119, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(109, 111, 100, 101, 108, 115, 46, 99),
+      ::capnp::word(97, 112, 110, 112, 58, 76, 101, 97),
+      ::capnp::word(115, 101, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 1, 0, 1, 0),
+      ::capnp::word(8, 0, 0, 0, 3, 0, 4, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(41, 0, 0, 0, 26, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(36, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(48, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(1, 0, 0, 0, 1, 0, 0, 0),
+      ::capnp::word(0, 0, 1, 0, 1, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(45, 0, 0, 0, 50, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(40, 0, 0, 0, 3, 0, 1, 0),
+      ::capnp::word(52, 0, 0, 0, 2, 0, 1, 0),
+      ::capnp::word(105, 100, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(108, 101, 97, 115, 101, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(12, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+      ::capnp::word(0, 0, 0, 0, 0, 0, 0, 0),
+    ];
+    pub fn get_field_types(index: u16) -> ::capnp::introspect::Type {
+      match index {
+        0 => <::capnp::text::Owned as ::capnp::introspect::Introspect>::introspect(),
+        1 => <::capnp::text::Owned as ::capnp::introspect::Introspect>::introspect(),
+        _ => panic!("invalid field index {}", index),
+      }
+    }
+    pub fn get_annotation_types(child_index: Option<u16>, index: u32) -> ::capnp::introspect::Type {
+      panic!("invalid annotation indices ({:?}, {}) ", child_index, index)
+    }
+    pub static RAW_SCHEMA: ::capnp::introspect::RawStructSchema = ::capnp::introspect::RawStructSchema {
+      encoded_node: &ENCODED_NODE,
+      nonunion_members: NONUNION_MEMBERS,
+      members_by_discriminant: MEMBERS_BY_DISCRIMINANT,
+      members_by_name: MEMBERS_BY_NAME,
+    };
+    pub static NONUNION_MEMBERS : &[u16] = &[0,1];
+    pub static MEMBERS_BY_DISCRIMINANT : &[u16] = &[];
+    pub static MEMBERS_BY_NAME : &[u16] = &[0,1];
+    pub const TYPE_ID: u64 = 0xb0d6_0854_c50e_5662;
+  }
+}

crates/churn-domain/Cargo.toml

@@ -20,3 +20,4 @@ axum.workspace = true
 reqwest.workspace = true
 serde.workspace = true
 uuid.workspace = true
+chrono.workspace = true

crates/churn-domain/src/lib.rs

@@ -23,3 +23,33 @@ pub struct ServerMonitorResp {
     pub cursor: Option<uuid::Uuid>,
     pub logs: Vec<String>,
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct LogEvent {
+    pub id: uuid::Uuid,
+    pub author: String,
+    pub content: String,
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+}
+
+impl LogEvent {
+    pub fn new(author: impl Into<String>, content: impl Into<String>) -> Self {
+        Self {
+            id: uuid::Uuid::new_v4(),
+            author: author.into(),
+            content: content.into(),
+            timestamp: chrono::Utc::now(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Agent {
+    pub name: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Lease {
+    pub id: uuid::Uuid,
+    pub lease: uuid::Uuid,
+}

crates/churn-server/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## v0.1.0 (2023-08-26)
+
+### New Features
+
+ - <csr-id-8f8c5fd41aaa82a495dd0933060f0a3a095bbaf1/> with basic package
+ - <csr-id-821e14fb1256957a107220c6c775565f5abc58c4/> with publish
+ - <csr-id-e0545c726c44dccfb8ea179266c1da93389c07e4/> with monitoring
+ - <csr-id-569f5272e667deeef9f269db5eaf3dec57e2df1c/> with monitor
+ - <csr-id-8c41e1004c11bc3018d36a72be6e38b2e410c362/> with enroll
+ - <csr-id-97978df287ee42f523f509ac686a13fa0400a026/> add initial churn
+ - <csr-id-f61d0bbf120607e59145a80b65985ab93c938522/> add simple health check
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 8 commits contributed to the release over the course of 2 calendar days.
+ - 7 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Release churn-domain v0.1.0, churn v0.1.0 (34bc81e)
+    - With basic package (8f8c5fd)
+    - With publish (821e14f)
+    - With monitoring (e0545c7)
+    - With monitor (569f527)
+    - With enroll (8c41e10)
+    - Add initial churn (97978df)
+    - Add simple health check (f61d0bb)
+</details>
+

crates/churn-server/Cargo.toml

@@ -3,7 +3,7 @@ name = "churn-server"
 authors.workspace = true
 description.workspace = true
 license-file.workspace = true
-version.workspace = true
+version= "0.1.0"
 edition.workspace = true
 publish.workspace = true
 
@@ -11,6 +11,7 @@ publish.workspace = true
 
 [dependencies]
 churn-domain.workspace = true
+churn-capnp.workspace = true
 
 anyhow.workspace = true
 tokio.workspace = true
@@ -22,3 +23,7 @@ axum.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 uuid.workspace = true
+async-trait.workspace = true
+itertools.workspace = true
+
+sled.workspace = true

crates/churn-server/src/agent.rs

@@ -1,17 +1,21 @@
-use std::collections::HashMap;
-
 use std::sync::Arc;
 
 use axum::async_trait;
 
-use churn_domain::ServerEnrollReq;
-use tokio::sync::Mutex;
+use churn_capnp::CapnpPackExt;
+use churn_domain::{Agent, ServerEnrollReq};
 
-use crate::Agent;
+use crate::db::Db;
 
 #[derive(Clone)]
 pub struct AgentService(Arc<dyn AgentServiceTrait + Send + Sync + 'static>);
 
+impl AgentService {
+    pub fn new(db: Db) -> Self {
+        Self(Arc::new(DefaultAgentService::new(db)))
+    }
+}
+
 impl std::ops::Deref for AgentService {
     type Target = Arc<dyn AgentServiceTrait + Send + Sync + 'static>;
 
@@ -20,15 +24,14 @@ impl std::ops::Deref for AgentService {
     }
 }
 
-impl Default for AgentService {
-    fn default() -> Self {
-        Self(Arc::new(DefaultAgentService::default()))
-    }
+struct DefaultAgentService {
+    agents: Db,
 }
 
-#[derive(Default)]
-struct DefaultAgentService {
-    agents: Arc<Mutex<HashMap<String, Agent>>>,
+impl DefaultAgentService {
+    pub fn new(db: Db) -> Self {
+        Self { agents: db }
+    }
 }
 
 #[async_trait]
@@ -41,24 +44,17 @@ impl AgentServiceTrait for DefaultAgentService {
     async fn enroll(&self, req: ServerEnrollReq) -> anyhow::Result<String> {
         let agent_name = req.agent_name;
 
-        let mut agents = self.agents.lock().await;
+        self.agents
+            .insert(
+                "agents",
+                &agent_name,
+                &Agent {
+                    name: agent_name.clone(),
+                }
+                .serialize_capnp(),
+            )
+            .await?;
 
-        match agents.insert(
-            agent_name.clone(),
-            Agent {
-                name: agent_name.clone(),
-            },
-        ) {
-            Some(_) => {
-                tracing::debug!("agents store already contained agent, replaced existing");
-
-                Ok(agent_name)
-            }
-            None => {
-                tracing::debug!("agents store didn't contain agent, inserted");
-
-                Ok(agent_name)
-            }
-        }
+        Ok(agent_name)
     }
 }

crates/churn-server/src/db.rs

@@ -0,0 +1,64 @@
+use core::slice::SlicePattern;
+
+use std::path::{Path};
+use std::sync::Arc;
+
+use async_trait::async_trait;
+
+#[derive(Clone)]
+pub struct Db(Arc<dyn DbTrait + Send + Sync + 'static>);
+
+impl Db {
+    pub fn new_sled(path: &Path) -> Self {
+        Self(Arc::new(DefaultDb::new(path)))
+    }
+}
+
+impl std::ops::Deref for Db {
+    type Target = Arc<dyn DbTrait + Send + Sync + 'static>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+struct DefaultDb {
+    db: sled::Db,
+}
+
+impl DefaultDb {
+    pub fn new(path: &Path) -> Self {
+        Self {
+            db: sled::open(path).expect("to be able open a sled path"),
+        }
+    }
+}
+
+#[async_trait]
+pub trait DbTrait {
+    async fn insert(&self, namespace: &str, key: &str, value: &[u8]) -> anyhow::Result<()>;
+    async fn get_all(&self, namespace: &str) -> anyhow::Result<Vec<Vec<u8>>>;
+}
+
+#[async_trait]
+impl DbTrait for DefaultDb {
+    async fn insert(&self, namespace: &str, key: &str, value: &[u8]) -> anyhow::Result<()> {
+        let tree = self.db.open_tree(namespace)?;
+
+        tree.insert(key, value)?;
+
+        //tree.flush_async().await?;
+
+        Ok(())
+    }
+
+    async fn get_all(&self, namespace: &str) -> anyhow::Result<Vec<Vec<u8>>> {
+        let tree = self.db.open_tree(namespace)?;
+
+        Ok(tree
+            .iter()
+            .flatten()
+            .map(|(_, val)| val.as_slice().to_vec())
+            .collect::<Vec<_>>())
+    }
+}

crates/churn-server/src/event.rs

@@ -1,16 +1,23 @@
-use std::collections::HashMap;
-
 use std::sync::Arc;
 
 use axum::async_trait;
 
-use churn_domain::ServerEnrollReq;
-use serde::{ser::SerializeStruct, Deserialize, Serialize};
-use tokio::sync::{Mutex, RwLock};
+use churn_domain::LogEvent;
+use itertools::Itertools;
+
+use churn_capnp::CapnpPackExt;
+
+use crate::db::Db;
 
 #[derive(Clone)]
 pub struct EventService(Arc<dyn EventServiceTrait + Send + Sync + 'static>);
 
+impl EventService {
+    pub fn new(db: Db) -> Self {
+        Self(Arc::new(DefaultEventService::new(db)))
+    }
+}
+
 impl std::ops::Deref for EventService {
     type Target = Arc<dyn EventServiceTrait + Send + Sync + 'static>;
 
@@ -19,31 +26,13 @@ impl std::ops::Deref for EventService {
     }
 }
 
-impl Default for EventService {
-    fn default() -> Self {
-        Self(Arc::new(DefaultEventService::default()))
-    }
-}
-
-#[derive(Default)]
 struct DefaultEventService {
-    agents: Arc<RwLock<Vec<LogEvent>>>,
+    db: Db,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct LogEvent {
-    pub id: uuid::Uuid,
-    pub author: String,
-    pub content: String,
-}
-
-impl LogEvent {
-    pub fn new(author: impl Into<String>, content: impl Into<String>) -> Self {
-        Self {
-            id: uuid::Uuid::new_v4(),
-            author: author.into(),
-            content: content.into(),
-        }
+impl DefaultEventService {
+    pub fn new(db: Db) -> Self {
+        Self { db }
     }
 }
 
@@ -52,27 +41,68 @@ pub trait EventServiceTrait {
     async fn append(&self, req: LogEvent) -> anyhow::Result<()>;
     async fn get_from_cursor(&self, cursor: uuid::Uuid) -> anyhow::Result<Vec<LogEvent>>;
     async fn get_from_beginning(&self) -> anyhow::Result<Vec<LogEvent>>;
+    async fn get_latest_cursor(&self) -> anyhow::Result<uuid::Uuid>;
 }
 
 #[async_trait]
 impl EventServiceTrait for DefaultEventService {
     async fn append(&self, req: LogEvent) -> anyhow::Result<()> {
-        let mut events = self.agents.write().await;
-        events.push(req);
+        self.db
+            .insert("events_log", &req.id.to_string(), &req.serialize_capnp())
+            .await?;
+
         Ok(())
     }
     async fn get_from_cursor(&self, cursor: uuid::Uuid) -> anyhow::Result<Vec<LogEvent>> {
-        let events = self.agents.read().await;
-        let items = events
+        let events = self.db.get_all("events_log").await?;
+
+        let events = events
             .iter()
+            .flat_map(|e| match LogEvent::deserialize_capnp(e) {
+                Ok(o) => Ok(o),
+                Err(e) => {
+                    tracing::error!("failed to deserialize capnp: {e}");
+                    Err(e)
+                }
+            })
+            .sorted_by_key(|i| i.timestamp)
             .skip_while(|item| item.id != cursor)
             .skip(1)
-            .cloned()
-            .collect::<Vec<_>>();
-        Ok(items)
+            .collect();
+
+        Ok(events)
     }
     async fn get_from_beginning(&self) -> anyhow::Result<Vec<LogEvent>> {
-        let events = self.agents.read().await;
-        Ok(events.iter().cloned().collect())
+        let events = self.db.get_all("events_log").await?;
+
+        let events = events
+            .iter()
+            .map(|x| x.as_slice())
+            .flat_map(LogEvent::deserialize_capnp)
+            .sorted_by_key(|i| i.timestamp)
+            .collect();
+
+        Ok(events)
+    }
+
+    async fn get_latest_cursor(&self) -> anyhow::Result<uuid::Uuid> {
+        let events = self.db.get_all("events_log").await?;
+
+        let event = events
+            .iter()
+            .flat_map(|e| match LogEvent::deserialize_capnp(e) {
+                Ok(o) => Ok(o),
+                Err(e) => {
+                    tracing::error!("failed to deserialize capnp: {e}");
+                    Err(e)
+                }
+            })
+            .sorted_by_key(|i| i.timestamp)
+            .last();
+
+        match event {
+            Some(x) => Ok(x.id),
+            None => anyhow::bail!("no events found"),
+        }
     }
 }

crates/churn-server/src/lease.rs

@@ -1,22 +1,22 @@
-
-
 use std::sync::Arc;
 
+use axum::async_trait;
+
+use churn_capnp::CapnpPackExt;
+use churn_domain::Lease;
 
 
-
-
-
-use axum::{async_trait};
-
-
-
-
-use tokio::sync::Mutex;
+use crate::db::Db;
 
 #[derive(Clone)]
 pub struct LeaseService(Arc<dyn LeaseServiceTrait + Send + Sync + 'static>);
 
+impl LeaseService {
+    pub fn new(db: Db) -> Self {
+        Self(Arc::new(DefaultLeaseService::new(db)))
+    }
+}
+
 impl std::ops::Deref for LeaseService {
     type Target = Arc<dyn LeaseServiceTrait + Send + Sync + 'static>;
 
@@ -25,19 +25,16 @@ impl std::ops::Deref for LeaseService {
     }
 }
 
-impl Default for LeaseService {
-    fn default() -> Self {
-        Self(Arc::new(DefaultLeaseService::default()))
+struct DefaultLeaseService {
+    db: Db,
+}
+
+impl DefaultLeaseService {
+    pub fn new(db: Db) -> Self {
+        Self { db }
     }
 }
 
-#[derive(Default)]
-struct DefaultLeaseService {
-    leases: Arc<Mutex<Vec<String>>>,
-}
-
-
-
 #[async_trait]
 pub trait LeaseServiceTrait {
     async fn create_lease(&self) -> anyhow::Result<String>;
@@ -46,12 +43,17 @@ pub trait LeaseServiceTrait {
 #[async_trait]
 impl LeaseServiceTrait for DefaultLeaseService {
     async fn create_lease(&self) -> anyhow::Result<String> {
-        let mut leases = self.leases.lock().await;
+        let lease = uuid::Uuid::new_v4();
+        let id = uuid::Uuid::new_v4();
 
-        let lease = uuid::Uuid::new_v4().to_string();
+        self.db
+            .insert(
+                "lease",
+                &lease.to_string(),
+                &Lease { id, lease }.serialize_capnp(),
+            )
+            .await?;
 
-        leases.push(lease.clone());
-
-        Ok(lease)
+        Ok(lease.to_string())
     }
 }

crates/churn-server/src/main.rs

@@ -1,8 +1,12 @@
+#![feature(slice_pattern)]
+
 mod agent;
+mod db;
 mod event;
 mod lease;
 
 use std::net::SocketAddr;
+use std::path::PathBuf;
 
 use agent::AgentService;
 use anyhow::Error;
@@ -11,18 +15,38 @@ use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use axum::routing::{get, post};
 use axum::{Json, Router};
-use churn_domain::{LeaseResp, ServerEnrollReq, ServerMonitorResp};
-use clap::{Parser, Subcommand};
-use event::{EventService, LogEvent};
+use churn_domain::{Agent, LeaseResp, LogEvent, ServerEnrollReq, ServerMonitorResp};
+use clap::{Args, Parser, Subcommand, ValueEnum};
+use event::EventService;
 use lease::LeaseService;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serde_json::json;
+use tokio::net::TcpListener;
+
+use crate::db::Db;
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None, subcommand_required = true)]
 struct Command {
     #[command(subcommand)]
     command: Option<Commands>,
+
+    #[clap(flatten)]
+    global: GlobalArgs,
+}
+
+#[derive(Args)]
+struct GlobalArgs {
+    #[arg(env = "CHURN_DATABASE", long, default_value = "sled")]
+    database: DatabaseType,
+
+    #[arg(env = "CHURN_SLED_PATH", long, default_value = "churn-server.sled")]
+    sled_path: PathBuf,
+}
+
+#[derive(ValueEnum, Clone)]
+enum DatabaseType {
+    Sled,
 }
 
 #[derive(Subcommand)]
@@ -33,11 +57,6 @@ enum Commands {
     },
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
-struct Agent {
-    pub name: String,
-}
-
 #[derive(Clone)]
 struct AppState {
     agent: AgentService,
@@ -52,34 +71,34 @@ async fn main() -> anyhow::Result<()> {
 
     let cli = Command::parse();
 
-    match cli.command {
-        Some(Commands::Serve { host }) => {
-            tracing::info!("Starting churn server");
+    if let Some(Commands::Serve { host }) = cli.command {
+        tracing::info!("Starting churn server");
+        let db = match cli.global.database {
+            DatabaseType::Sled => Db::new_sled(&cli.global.sled_path),
+        };
 
-            let app = Router::new()
-                .route("/ping", get(ping))
-                .route("/logs", get(logs))
-                .nest(
-                    "/agent",
-                    Router::new()
-                        .route("/enroll", post(enroll))
-                        .route("/ping", post(agent_ping))
-                        .route("/events", post(get_tasks))
-                        .route("/lease", post(agent_lease)),
-                )
-                .with_state(AppState {
-                    agent: AgentService::default(),
-                    leases: LeaseService::default(),
-                    events: EventService::default(),
-                });
+        let app = Router::new()
+            .route("/ping", get(ping))
+            .route("/logs", get(logs))
+            .nest(
+                "/agent",
+                Router::new()
+                    .route("/enroll", post(enroll))
+                    .route("/ping", post(agent_ping))
+                    .route("/events", post(get_tasks))
+                    .route("/lease", post(agent_lease)),
+            )
+            .with_state(AppState {
+                agent: AgentService::new(db.clone()),
+                leases: LeaseService::new(db.clone()),
+                events: EventService::new(db.clone()),
+            });
 
-            tracing::info!("churn server listening on {}", host);
-            axum::Server::bind(&host)
-                .serve(app.into_make_service())
-                .await
-                .unwrap();
-        }
-        None => {}
+        tracing::info!("churn server listening on {}", host);
+        let listener = TcpListener::bind(&host).await?;
+        axum::serve(listener, app.into_make_service())
+            .await
+            .unwrap();
     }
 
     Ok(())
@@ -180,31 +199,40 @@ async fn logs(
 
     match cursor.cursor {
         Some(cursor) => {
-            tracing::trace!("finding logs from cursor: {}", cursor);
+            tracing::debug!("finding logs from cursor: {}", cursor);
         }
         None => {
-            tracing::trace!("finding logs from beginning");
+            tracing::debug!("finding logs from beginning");
         }
     }
 
-    let events = match cursor.cursor {
-        Some(c) => state.events.get_from_cursor(c).await,
-        None => state.events.get_from_beginning().await,
-    }
-    .map_err(AppError::Internal)?;
+    match cursor.cursor {
+        Some(c) => {
+            let events = state
+                .events
+                .get_from_cursor(c)
+                .await
+                .map_err(AppError::Internal)?;
 
-    if events.is_empty() {
-        return Ok(Json(ServerMonitorResp {
-            cursor: cursor.cursor.clone(),
-            logs: Vec::new(),
-        }));
-    }
+            Ok(Json(ServerMonitorResp {
+                cursor: events.last().map(|e| e.id),
+                logs: events
+                    .iter()
+                    .map(|e| format!("{}: {}", e.author, e.content))
+                    .collect(),
+            }))
+        }
+        None => {
+            let cursor = state
+                .events
+                .get_latest_cursor()
+                .await
+                .map_err(AppError::Internal)?;
 
-    Ok(Json(ServerMonitorResp {
-        cursor: events.last().map(|e| e.id),
-        logs: events
-            .iter()
-            .map(|e| format!("{}: {}", e.author, e.content))
-            .collect(),
-    }))
+            Ok(Json(ServerMonitorResp {
+                cursor: Some(cursor),
+                logs: Vec::new(),
+            }))
+        }
+    }
 }

crates/churn/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## v0.1.0 (2023-08-26)
 
+<csr-id-1ae70ac5258ae9f8f5471923fefd3e8ab02f46c1/>
+
 ### Chore
 
  - <csr-id-1ae70ac5258ae9f8f5471923fefd3e8ab02f46c1/> with changelog
@@ -25,7 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 9 commits contributed to the release over the course of 2 calendar days.
+ - 11 commits contributed to the release over the course of 2 calendar days.
  - 8 commits were understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
 
@@ -36,6 +38,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release churn v0.1.0 (d5212f0)
+    - Release churn-domain v0.1.0, churn v0.1.0 (e4e05bc)
     - With changelog (1ae70ac)
     - Release churn-domain v0.1.0, churn v0.1.0 (34bc81e)
     - With basic package (8f8c5fd)

crates/churn/src/main.rs

@@ -109,7 +109,7 @@ async fn handle_command(cmd: Command) -> anyhow::Result<()> {
             } => todo!(),
             Commands::Monitor {
                 server,
-                server_token,
+                server_token: _,
             } => {
                 tracing::info!("monitoring server: {}", server);
 
@@ -146,8 +146,6 @@ async fn handle_command(cmd: Command) -> anyhow::Result<()> {
                     }
                     tokio::time::sleep(std::time::Duration::from_secs(1)).await;
                 }
-
-                Ok(())
             }
         }
     } else {

crates/churning/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-dagger-sdk = "0.2.2"
-dagger-rust = "0.2.0"
+dagger-sdk = "0.11.0"
+dagger-rust = {git = "https://git.front.kjuulh.io/kjuulh/dagger-components.git", ref = "main"}
 tokio.workspace = true
 eyre = "*"

crates/churning/src/main.rs

@@ -1,13 +1,13 @@
 use std::{path::PathBuf, sync::Arc};
 
 use dagger_rust::build::{RustVersion, SlimImage};
-use dagger_sdk::{Config, Query};
+use dagger_sdk::Query;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
-    let mut config = Config::default();
-    config.logger = None;
+    // let mut config = Config::default();
+    // config.logger = None;
 
     println!("Building churning...");
 
@@ -17,20 +17,24 @@ async fn main() -> eyre::Result<()> {
     let cli = build_container(client.clone(), "churn").await?;
     let server = build_container(client.clone(), "churn-server").await?;
     let server = server
+        .with_env_variable("CHURN_DATABASE", "sled")
+        .with_env_variable("CHURN_SLED_PATH", "/mnt/sled")
+        .with_mounted_cache("/mnt/sled", client.cache_volume("sled"))
         .with_exec(vec!["churn-server", "serve", "--host", "0.0.0.0:3000"])
         .with_exposed_port(3000);
 
-    let server_id = server.id().await?;
+    let server_service = server.as_service();
 
     let agent = build_container(client.clone(), "churn-agent").await?;
     let agent = agent
-        .with_service_binding("churn-server", server_id.clone())
+        .with_service_binding("churn-server", server_service.clone())
         .with_exec(vec!["churn-agent", "daemon", "--host", "0.0.0.0:3000"])
         .with_exposed_port(3000);
+    let agent_service = agent.as_service();
 
     let churning = cli
-        .with_service_binding("churn-agent", agent.id().await?)
-        .with_service_binding("churn-server", server_id)
+        .with_service_binding("churn-agent", agent_service)
+        .with_service_binding("churn-server", server_service)
         .with_env_variable("CHURN_SERVER", "http://churn-server:3000")
         .with_env_variable("CHURN_SERVER_TOKEN", "something")
         .with_env_variable("CHURN_AGENT", "http://churn-agent:3000")
@@ -49,7 +53,7 @@ async fn main() -> eyre::Result<()> {
     let stderr = churning.stderr().await?;
     println!("{stderr}");
 
-    churning.exit_code().await?;
+    churning.sync().await?;
     println!("Finished building churning...");
 
     repl(churning).await?; //.with_entrypoint(vec!["churn"])).await?;
@@ -58,8 +62,6 @@ async fn main() -> eyre::Result<()> {
 }
 
 async fn repl(container: dagger_sdk::Container) -> eyre::Result<()> {
-    let mut container = container;
-
     loop {
         let stdin = tokio::io::stdin();
         let mut stdout = tokio::io::stdout();
@@ -78,7 +80,7 @@ async fn repl(container: dagger_sdk::Container) -> eyre::Result<()> {
             break;
         }
 
-        container = container.with_exec(input.split(' ').collect());
+        let container = container.with_exec(input.split(' ').collect());
 
         match container.stdout().await {
             Ok(stdout) => {
@@ -88,16 +90,8 @@ async fn repl(container: dagger_sdk::Container) -> eyre::Result<()> {
                 eprintln!("{}", e);
             }
         }
-        // match container.stderr().await {
-        //     Ok(stderr) => {
-        //         println!("{stderr}");
-        //     }
-        //     Err(e) => {
-        //         eprintln!("{}", e);
-        //     }
-        // }
 
-        match container.exit_code().await {
+        match container.sync().await {
             Ok(_) => {}
             Err(_e) => {
                 //eprintln!("encountred error: {}", e);
@@ -108,12 +102,16 @@ async fn repl(container: dagger_sdk::Container) -> eyre::Result<()> {
     Ok(())
 }
 
-async fn build_container(
-    client: Arc<Query>,
-    bin_name: &str,
-) -> eyre::Result<dagger_sdk::Container> {
+async fn build_container(client: Query, bin_name: &str) -> eyre::Result<dagger_sdk::Container> {
     let crates = &["crates/*", "ci"];
-    let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];
+    let debian_deps = &[
+        "libssl-dev",
+        "pkg-config",
+        "openssl",
+        "git",
+        "jq",
+        "capnproto",
+    ];
     let debian_image = "debian:bullseye".to_string();
 
     let images = dagger_rust::build::RustBuild::new(client.clone())

cuddle.yaml

@@ -1,7 +1,24 @@
 # yaml-language-server: $schema=https://git.front.kjuulh.io/kjuulh/cuddle/raw/branch/main/schemas/base.json
 
-base: "git@git.front.kjuulh.io:kjuulh/cuddle-base.git"
+base: "git@git.front.kjuulh.io:kjuulh/cuddle-rust-cli-plan.git"
 
 vars:
   service: "churn"
   registry: kasperhermansen
+
+please:
+  project:
+    owner: kjuulh
+    repository: churn
+    branch: main
+  settings:
+    api_url: https://git.front.kjuulh.io  
+
+components:
+  packages:
+    debian:
+      dev:
+        - capnproto
+      release:
+        - capnproto
+        

renovate.json

@@ -0,0 +1,3 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json"
+}