session and seat management daemon
match session to seat by id instead of name
+37
-31
+3
daemon/src/ecs/components.rs
+3
daemon/src/ecs/components.rs
···
32
32
pub struct SeatName(pub String);
33
33
component!(SeatName, seat_name_components);
34
34
35
+
pub struct SeatEntity(pub super::Entity);
36
+
component!(SeatEntity, seat_entity_components);
37
+
35
38
pub struct Timestamp(pub time::SystemTime);
36
39
component!(Timestamp, timestamp_components);
37
40
+6
daemon/src/ecs/mod.rs
+6
daemon/src/ecs/mod.rs
···
18
18
username_components: Vec<Option<Username>>,
19
19
vt_components: Vec<Option<Vt>>,
20
20
seat_name_components: Vec<Option<SeatName>>,
21
+
seat_entity_components: Vec<Option<SeatEntity>>,
21
22
timestamp_components: Vec<Option<Timestamp>>,
22
23
leader_id_components: Vec<Option<LeaderId>>,
23
24
session_objects_components: Vec<Option<SessionObjects>>,
···
63
64
username: String,
64
65
vt: u32,
65
66
seat: Option<String>,
67
+
seat_entity: Option<Entity>,
66
68
timestamp: time::SystemTime,
67
69
leader_id: i32,
68
70
objects: Vec<session_core_session::SessionCoreSession>,
···
75
77
self.insert(entity, Vt(vt));
76
78
if let Some(seat) = seat {
77
79
self.insert(entity, SeatName(seat));
80
+
}
81
+
if let Some(seat_entity) = seat_entity {
82
+
self.insert(entity, SeatEntity(seat_entity));
78
83
}
79
84
self.insert(entity, Timestamp(timestamp));
80
85
self.insert(entity, LeaderId(leader_id));
···
159
164
clear_component(&mut self.username_components, entity);
160
165
clear_component(&mut self.vt_components, entity);
161
166
clear_component(&mut self.seat_name_components, entity);
167
+
clear_component(&mut self.seat_entity_components, entity);
162
168
clear_component(&mut self.timestamp_components, entity);
163
169
clear_component(&mut self.leader_id_components, entity);
164
170
clear_component(&mut self.session_objects_components, entity);
+19
-14
daemon/src/main.rs
+19
-14
daemon/src/main.rs
···
161
161
162
162
seat::refresh_current_vts(&mut self.world, &self.seat_entities);
163
163
164
-
let mut session_seat = self.seat_entities.first().and_then(|seat_entity| {
164
+
let mut session_seat_entity = self.seat_entities.first().copied();
165
+
let mut session_seat = session_seat_entity.and_then(|seat_entity| {
165
166
self.world
166
-
.get::<ecs::SeatName>(*seat_entity)
167
+
.get::<ecs::SeatName>(seat_entity)
167
168
.map(|seat| seat.0.clone())
168
169
.filter(|seat| !seat.is_empty())
169
170
});
···
184
185
log::error!(uid, error = e.to_string().as_str(); "failed to chmod runtime dir");
185
186
}
186
187
187
-
if let Some(seat) = self.seat_entities.iter().copied().find_map(|seat_entity| {
188
-
let mode = self.world.get::<ecs::SeatMode>(seat_entity)?;
189
-
if mode.0 != ecs::SeatKind::VtBound {
190
-
return None;
191
-
}
192
-
let current_vt = self.world.get::<ecs::CurrentVt>(seat_entity)?.0;
193
-
(current_vt == vt).then(|| {
194
-
self.world
195
-
.get::<ecs::SeatName>(seat_entity)
196
-
.map(|seat| seat.0.clone())
197
-
})?
198
-
}) {
188
+
if let Some((seat_entity, seat)) =
189
+
self.seat_entities.iter().copied().find_map(|seat_entity| {
190
+
let mode = self.world.get::<ecs::SeatMode>(seat_entity)?;
191
+
if mode.0 != ecs::SeatKind::VtBound {
192
+
return None;
193
+
}
194
+
let current_vt = self.world.get::<ecs::CurrentVt>(seat_entity)?.0;
195
+
(current_vt == vt).then(|| {
196
+
self.world
197
+
.get::<ecs::SeatName>(seat_entity)
198
+
.map(|seat| (seat_entity, seat.0.clone()))
199
+
})?
200
+
})
201
+
{
202
+
session_seat_entity = Some(seat_entity);
199
203
session_seat = Some(seat);
200
204
active_state = session_core_v1::ActiveState::Active;
201
205
}
···
206
210
username,
207
211
vt,
208
212
session_seat.clone(),
213
+
session_seat_entity,
209
214
time::SystemTime::now(),
210
215
leader_id,
211
216
Vec::new(),
+9
-17
daemon/src/seat.rs
+9
-17
daemon/src/seat.rs
···
15
15
Closed,
16
16
}
17
17
18
-
pub fn entity(world: &ecs::World, entities: &[ecs::Entity], name: &str) -> Option<ecs::Entity> {
19
-
entities.iter().copied().find(|entity| {
20
-
world
21
-
.get::<ecs::SeatName>(*entity)
22
-
.is_some_and(|seat| seat.0 == name)
23
-
})
24
-
}
25
-
26
18
pub fn client_entity_by_seat_object(
27
19
world: &ecs::World,
28
20
entities: &[ecs::Entity],
···
134
126
}
135
127
136
128
world.insert(client_entity, ecs::SeatName(seat_name.clone()));
129
+
world.insert(client_entity, ecs::SeatEntity(seat_entity));
137
130
world.insert(client_entity, ecs::Session(session_id));
138
131
world.insert(client_entity, ecs::SeatState(SeatState::Enabled));
139
132
if let Some(clients) = world.get_mut::<ecs::SeatClients>(seat_entity) {
···
415
408
416
409
world.insert(client_entity, ecs::SeatState(SeatState::Closed));
417
410
let _ = world.remove::<ecs::SeatName>(client_entity);
411
+
let _ = world.remove::<ecs::SeatEntity>(client_entity);
418
412
let _ = world.remove::<ecs::Session>(client_entity);
419
413
world.remove_entity(client_entity);
420
414
···
933
927
{
934
928
if self
935
929
.world
936
-
.get::<ecs::SeatName>(entity)
937
-
.is_none_or(|seat| seat.0.as_str() != seat_name.as_str())
930
+
.get::<ecs::SeatEntity>(entity)
931
+
.is_none_or(|seat| seat.0 != seat_entity)
938
932
{
939
933
log::info!(session_id = session_id.as_raw(), seat = seat_name.as_str(); "session seat changed");
940
934
self.world.insert(entity, ecs::SeatName(seat_name.clone()));
935
+
self.world.insert(entity, ecs::SeatEntity(seat_entity));
941
936
}
942
937
if let Some(objects) = self.world.get::<ecs::SessionObjects>(entity) {
943
938
for object in &objects.0 {
···
961
956
else {
962
957
return;
963
958
};
964
-
let Some(seat_name) = self
959
+
let Some(seat_entity) = self
965
960
.world
966
-
.get::<ecs::SeatName>(client_entity)
967
-
.map(|seat| seat.0.clone())
961
+
.get::<ecs::SeatEntity>(client_entity)
962
+
.map(|seat| seat.0)
968
963
else {
969
-
return;
970
-
};
971
-
let Some(seat_entity) = entity(&self.world, &self.seat_entities, &seat_name) else {
972
-
log::error!("No shared seat found for {seat_name}");
964
+
log::error!("Seat client has no seat entity");
973
965
return;
974
966
};
975
967