Deployment and lifecycle management for Nix
feat: make daemon its own
+52
-19
+3
-3
client/src/main.rs
+3
-3
client/src/main.rs
···
50
50
#[command(subcommand)]
51
51
action: TreeCommands,
52
52
},
53
+
54
+
Daemon {},
53
55
}
54
56
55
57
#[derive(Debug, Subcommand)]
···
74
76
subcommand_help_heading = "Tree commands"
75
77
)]
76
78
enum TreeCommands {
77
-
Daemon {},
78
-
79
79
Info {},
80
80
81
81
Reboot {
···
181
181
182
182
match &cli.action {
183
183
Actions::Daemon {} => {
184
-
let mut daemon = Daemon::new(tree).expect("Failed to initialize daemon");
184
+
let mut daemon = Daemon::new(&config).await;
185
185
daemon.run().await.unwrap()
186
186
}
187
187
+49
-16
client/src/sower/daemon.rs
+49
-16
client/src/sower/daemon.rs
···
1
-
use super::Tree;
1
+
use super::{Config, Tree};
2
2
3
+
use std::sync::Arc;
3
4
use std::time::Duration;
4
5
5
6
use phoenix_channels_client::url::Url;
6
7
use serde_json::json;
8
+
use tracing::info;
7
9
8
-
use phoenix_channels_client::{Event, EventPayload, EventsError, Payload, Socket, Topic, JSON};
10
+
use phoenix_channels_client::{
11
+
Channel, Event, EventPayload, EventsError, Payload, Socket, Topic, JSON,
12
+
};
13
+
14
+
pub struct Daemon {
15
+
tree: Tree,
16
+
socket: Arc<Socket>,
17
+
lobby_channel: Arc<Channel>,
18
+
lobby_topic: Arc<Topic>,
19
+
}
20
+
21
+
impl Daemon {
22
+
pub async fn new(config: &Config) -> Self {
23
+
let tree = Tree::new(config).await.expect("Failed to load tree");
9
24
10
-
impl Tree {
11
-
pub async fn daemon(&mut self) -> Result<(), std::io::Error> {
12
-
let url = Url::parse(&self.sower.clone().unwrap().channels_url).unwrap();
25
+
info!("Connecting to sower");
26
+
let url = Url::parse(&tree.sower.clone().unwrap().channels_url).unwrap();
13
27
let socket = Socket::spawn(url, None).unwrap();
14
28
socket.connect(Duration::from_secs(10)).await.unwrap();
15
29
30
+
info!("Joining lobby tree:all");
16
31
let topic = Topic::from_string("tree:all".to_string());
17
32
let channel = socket.channel(topic.clone(), None).await.unwrap();
18
-
let events = channel.events();
19
33
channel.join(Duration::from_secs(15)).await.unwrap();
20
34
21
-
let Payload::JSONPayload { json } = channel
35
+
Self {
36
+
lobby_channel: channel,
37
+
lobby_topic: topic,
38
+
socket,
39
+
tree,
40
+
}
41
+
}
42
+
43
+
pub async fn login(&mut self) {
44
+
info!("Registering with sower");
45
+
let Payload::JSONPayload { json } = self
46
+
.lobby_channel
22
47
.call(
23
48
Event::from_string("register".to_string()),
24
49
Payload::json_from_serialized(
25
-
json!({ "name": &self.name, "type": &self.seed_type}).to_string(),
50
+
json!({ "name": &self.tree.name, "type": &self.tree.seed_type}).to_string(),
26
51
)
27
52
.unwrap(),
28
53
Duration::from_secs(5),
···
33
58
panic!("unable to register")
34
59
};
35
60
36
-
self.id = if let JSON::Str { string, .. } = &json {
61
+
self.tree.id = if let JSON::Str { string, .. } = &json {
62
+
info!("Received tree id {}", string);
37
63
Some(string.to_string())
38
64
} else {
39
65
panic!("unable to parse registration response")
40
66
};
67
+
}
41
68
69
+
pub async fn run(&mut self) -> Result<(), std::io::Error> {
70
+
self.login().await;
71
+
72
+
let events = self.lobby_channel.events();
42
73
tokio::select! {
43
74
_ = async {
75
+
info!("Listening for events");
44
76
loop {
45
77
match events.event().await {
46
78
Ok(EventPayload { event, payload }) => match event {
···
48
80
user: user_event_name,
49
81
} => println!(
50
82
"channel {} event {} sent with payload {:#?}",
51
-
topic, user_event_name, payload
83
+
self.lobby_topic, user_event_name, payload
52
84
),
53
-
Event::Phoenix { phoenix } => println!("channel {} {}", topic, phoenix),
85
+
Event::Phoenix { phoenix } => println!("channel {} {}", self.lobby_topic, phoenix),
54
86
},
55
87
Err(events_error) => match events_error {
56
88
EventsError::NoMoreEvents => break,
57
89
EventsError::MissedEvents { missed_event_count } => {
58
-
eprintln!("{} events missed on channel {}", missed_event_count, topic);
90
+
eprintln!("{} events missed on channel {}", missed_event_count, self.lobby_topic);
59
91
}
60
92
},
61
93
}
···
63
95
} => {}
64
96
}
65
97
66
-
// Leave the channel
67
-
channel.leave().await.unwrap();
98
+
info!("Leaving the lobby");
99
+
self.lobby_channel.leave().await.unwrap();
68
100
69
-
// Disconnect the socket
70
-
socket.disconnect().await.unwrap();
101
+
info!("Closing socket");
102
+
self.socket.disconnect().await.unwrap();
71
103
104
+
info!("Shutdown");
72
105
Ok(())
73
106
}
74
107
}