Merge pull request #632 from swimos/example_app_join_value

Join value example app

Author: SirCipher

Cargo.toml

@@ -37,6 +37,7 @@ members = [
     "example_apps/tutorial_app",
     "example_apps/tutorial_app/model",
     "example_apps/tutorial_app/generator",
+    "example_apps/join_value",
 ]
 
 exclude = [

example_apps/join_value/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "join_value"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+swimos = { path = "../../swimos", features = ["server", "agent"] }
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+example-util = { path = "../example_util" }

example_apps/join_value/src/building.rs

@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+use swimos::agent::agent_lifecycle::utility::HandlerContext;
+use swimos::agent::event_handler::{EventHandler, HandlerActionExt};
+use swimos::agent::lanes::{CommandLane, JoinValueLane};
+use swimos::agent::projections;
+use swimos::agent::{lifecycle, AgentLaneModel};
+
+#[derive(AgentLaneModel)]
+#[projections]
+pub struct BuildingAgent {
+    lights: JoinValueLane<u64, bool>,
+    register_room: CommandLane<u64>,
+}
+
+#[derive(Clone)]
+pub struct BuildingLifecycle;
+
+#[lifecycle(BuildingAgent)]
+impl BuildingLifecycle {
+    #[on_start]
+    pub fn on_start(
+        &self,
+        context: HandlerContext<BuildingAgent>,
+    ) -> impl EventHandler<BuildingAgent> {
+        context
+            .get_agent_uri()
+            .and_then(move |uri| context.effect(move || println!("Starting agent at: {}", uri)))
+    }
+
+    #[on_stop]
+    pub fn on_stop(
+        &self,
+        context: HandlerContext<BuildingAgent>,
+    ) -> impl EventHandler<BuildingAgent> {
+        context
+            .get_agent_uri()
+            .and_then(move |uri| context.effect(move || println!("Stopping agent at: {}", uri)))
+    }
+
+    #[on_command(register_room)]
+    pub fn register_room(
+        &self,
+        context: HandlerContext<BuildingAgent>,
+        room_id: &u64,
+    ) -> impl EventHandler<BuildingAgent> {
+        let room_id = *room_id;
+        context
+            .get_parameter("name")
+            .and_then(move |building_name: Option<String>| {
+                let building_name = building_name.expect("Missing building name URI parameter");
+                context.add_downlink(
+                    BuildingAgent::LIGHTS,
+                    room_id,
+                    None,
+                    format!("/rooms/{building_name}/{room_id}").as_str(),
+                    "lights",
+                )
+            })
+            .followed_by(context.effect(move || println!("Registered room: {room_id}")))
+    }
+
+    #[on_update(lights)]
+    fn lights(
+        &self,
+        context: HandlerContext<BuildingAgent>,
+        _map: &HashMap<u64, bool>,
+        key: u64,
+        prev: Option<bool>,
+        new_value: &bool,
+    ) -> impl EventHandler<BuildingAgent> {
+        let new_value = *new_value;
+        context.effect(move || println!("Light {key} changed from {prev:?} to {new_value}"))
+    }
+}

example_apps/join_value/src/main.rs

@@ -0,0 +1,56 @@
+// Copyright 2015-2023 Swim Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::{error::Error, time::Duration};
+
+use crate::{
+    building::{BuildingAgent, BuildingLifecycle},
+    room::{RoomAgent, RoomLifecycle},
+};
+use example_util::{example_logging, manage_handle};
+use swimos::{
+    agent::agent_model::AgentModel, route::RoutePattern, server::Server, server::ServerBuilder,
+};
+
+mod building;
+mod room;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
+    example_logging()?;
+
+    let building_route = RoutePattern::parse_str("/buildings/:name")?;
+    let building_agent =
+        AgentModel::new(BuildingAgent::default, BuildingLifecycle.into_lifecycle());
+
+    let room_route = RoutePattern::parse_str("/rooms/:building/:room")?;
+    let room_agent = AgentModel::new(RoomAgent::default, RoomLifecycle.into_lifecycle());
+
+    let server = ServerBuilder::with_plane_name("Building Plane")
+        .add_route(building_route, building_agent)
+        .add_route(room_route, room_agent)
+        .update_config(|config| {
+            config.agent_runtime.inactive_timeout = Duration::from_secs(5 * 60);
+        })
+        .build()
+        .await?;
+
+    let (task, handle) = server.run();
+    let shutdown = manage_handle(handle);
+    let (_, result) = tokio::join!(shutdown, task);
+
+    result?;
+    println!("Server stopped successfully.");
+    Ok(())
+}

example_apps/join_value/src/room.rs

@@ -0,0 +1,52 @@
+use std::str::FromStr;
+use swimos::agent::agent_lifecycle::utility::HandlerContext;
+use swimos::agent::event_handler::{EventHandler, HandlerActionExt};
+use swimos::agent::lanes::ValueLane;
+use swimos::agent::projections;
+use swimos::agent::{lifecycle, AgentLaneModel};
+
+#[derive(AgentLaneModel)]
+#[projections]
+pub struct RoomAgent {
+    lights: ValueLane<bool>,
+}
+
+#[derive(Clone)]
+pub struct RoomLifecycle;
+
+#[lifecycle(RoomAgent)]
+impl RoomLifecycle {
+    #[on_start]
+    pub fn on_start(&self, context: HandlerContext<RoomAgent>) -> impl EventHandler<RoomAgent> {
+        context
+            .get_agent_uri()
+            .and_then(move |uri| context.effect(move || println!("Starting agent at: {}", uri)))
+            .followed_by(context.get_parameter("building").and_then(
+                move |building_name: Option<String>| {
+                    context
+                        .get_parameter("room")
+                        .and_then(move |room_id: Option<String>| {
+                            let building_name =
+                                building_name.expect("Missing building URI parameter");
+                            let room_id_str = room_id.expect("Missing room ID URI parameter");
+                            let room_id = u64::from_str(room_id_str.as_str())
+                                .expect("Expected a u64 room ID");
+
+                            context.send_command(
+                                None,
+                                format!("/buildings/{building_name}"),
+                                "register_room".to_string(),
+                                room_id,
+                            )
+                        })
+                },
+            ))
+    }
+
+    #[on_stop]
+    pub fn on_stop(&self, context: HandlerContext<RoomAgent>) -> impl EventHandler<RoomAgent> {
+        context
+            .get_agent_uri()
+            .and_then(move |uri| context.effect(move || println!("Starting agent at: {}", uri)))
+    }
+}