2020-12-02 16:20:50 +01:00
|
|
|
use std::pin::Pin;
|
|
|
|
use std::task::{Poll, Context};
|
2020-12-01 10:21:39 +01:00
|
|
|
use std::future::Future;
|
2020-12-02 16:20:50 +01:00
|
|
|
use smol::{Task, Timer};
|
2020-12-01 09:44:18 +01:00
|
|
|
|
2020-12-02 16:20:50 +01:00
|
|
|
use futures::FutureExt;
|
|
|
|
use futures::future::BoxFuture;
|
|
|
|
|
|
|
|
use genawaiter::{sync::{Gen, GenBoxed, Co}, GeneratorState};
|
|
|
|
|
2020-12-07 12:11:07 +01:00
|
|
|
use futures_signals::signal::{Signal, Mutable, MutableSignalCloned};
|
2020-12-02 16:20:50 +01:00
|
|
|
use crate::machine::{Machine, ReturnToken};
|
|
|
|
use crate::db::machine::MachineState;
|
|
|
|
use crate::db::user::{User, UserId, UserData};
|
2020-12-01 16:06:39 +01:00
|
|
|
|
2020-12-02 17:12:25 +01:00
|
|
|
use crate::registries::sensors::Sensor;
|
|
|
|
|
2020-12-01 10:21:39 +01:00
|
|
|
use crate::error::Result;
|
|
|
|
|
2020-12-02 17:12:25 +01:00
|
|
|
pub struct Initiator<S: Sensor> {
|
2020-12-02 16:20:50 +01:00
|
|
|
signal: MutableSignalCloned<Option<Machine>>,
|
|
|
|
machine: Option<Machine>,
|
2020-12-02 17:15:25 +01:00
|
|
|
future: Option<BoxFuture<'static, (Option<User>, MachineState)>>,
|
2020-12-02 16:20:50 +01:00
|
|
|
token: Option<ReturnToken>,
|
2020-12-02 17:12:25 +01:00
|
|
|
sensor: Box<S>,
|
2020-12-01 10:21:39 +01:00
|
|
|
}
|
|
|
|
|
2020-12-02 17:12:25 +01:00
|
|
|
impl<S: Sensor> Initiator<S> {
|
|
|
|
pub fn new(sensor: Box<S>, signal: MutableSignalCloned<Option<Machine>>) -> Self {
|
2020-12-02 16:20:50 +01:00
|
|
|
Self {
|
|
|
|
signal: signal,
|
|
|
|
machine: None,
|
|
|
|
future: None,
|
|
|
|
token: None,
|
2020-12-02 17:12:25 +01:00
|
|
|
sensor: sensor,
|
2020-12-02 16:20:50 +01:00
|
|
|
}
|
|
|
|
}
|
2020-12-07 12:11:07 +01:00
|
|
|
|
|
|
|
pub fn wrap(sensor: Box<S>) -> (Mutable<Option<Machine>>, Self) {
|
|
|
|
let m = Mutable::new(None);
|
|
|
|
let s = m.signal_cloned();
|
|
|
|
|
|
|
|
(m, Self::new(sensor, s))
|
|
|
|
}
|
2020-12-02 16:20:50 +01:00
|
|
|
}
|
|
|
|
|
2020-12-02 17:12:25 +01:00
|
|
|
impl<S: Sensor> Future for Initiator<S> {
|
2020-12-02 16:20:50 +01:00
|
|
|
type Output = ();
|
|
|
|
|
|
|
|
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
|
|
|
|
let mut this = &mut *self;
|
|
|
|
|
|
|
|
// First of course, see what machine we should work with.
|
|
|
|
match Signal::poll_change(Pin::new(&mut this.signal), cx) {
|
|
|
|
Poll::Pending => { }
|
|
|
|
Poll::Ready(None) => return Poll::Ready(()),
|
|
|
|
// Keep in mind this is actually an Option<Machine>
|
|
|
|
Poll::Ready(Some(machine)) => this.machine = machine,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Do as much work as we can:
|
|
|
|
loop {
|
|
|
|
// If there is a future, poll it
|
|
|
|
match this.future.as_mut().map(|future| Future::poll(Pin::new(future), cx)) {
|
|
|
|
None => {
|
2020-12-02 17:15:25 +01:00
|
|
|
this.future = Some(this.sensor.run_sensor());
|
2020-12-02 16:20:50 +01:00
|
|
|
},
|
2020-12-02 17:15:25 +01:00
|
|
|
Some(Poll::Ready((user, state))) => {
|
2020-12-02 16:20:50 +01:00
|
|
|
this.future.take();
|
|
|
|
this.machine.as_mut().map(|machine| machine.request_state_change(user.as_ref(), state));
|
|
|
|
}
|
|
|
|
Some(Poll::Pending) => return Poll::Pending,
|
|
|
|
}
|
|
|
|
}
|
2020-12-01 10:21:39 +01:00
|
|
|
}
|
2020-12-01 09:44:18 +01:00
|
|
|
}
|
|
|
|
|
2020-12-07 12:11:07 +01:00
|
|
|
pub fn load() -> Result<(Mutable<Option<Machine>>, Initiator<Dummy>)> {
|
|
|
|
let d = Box::new(Dummy::new());
|
|
|
|
Ok(Initiator::wrap(d))
|
2020-12-01 09:44:18 +01:00
|
|
|
}
|
2020-12-02 17:12:25 +01:00
|
|
|
|
2020-12-02 17:15:25 +01:00
|
|
|
pub struct Dummy {
|
|
|
|
step: bool
|
|
|
|
}
|
2020-12-02 17:12:25 +01:00
|
|
|
|
2020-12-02 17:15:25 +01:00
|
|
|
impl Dummy {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self { step: false }
|
|
|
|
}
|
|
|
|
}
|
2020-12-02 17:12:25 +01:00
|
|
|
|
2020-12-02 17:15:25 +01:00
|
|
|
impl Sensor for Dummy {
|
|
|
|
fn run_sensor(&mut self)
|
|
|
|
-> BoxFuture<'static, (Option<User>, MachineState)>
|
2020-12-02 17:12:25 +01:00
|
|
|
{
|
2020-12-02 17:15:25 +01:00
|
|
|
let step = self.step;
|
|
|
|
self.step != self.step;
|
|
|
|
|
2020-12-02 17:12:25 +01:00
|
|
|
let f = async move {
|
|
|
|
Timer::after(std::time::Duration::from_secs(1)).await;
|
|
|
|
if step {
|
2020-12-02 17:15:25 +01:00
|
|
|
return (None, MachineState::free());
|
2020-12-02 17:12:25 +01:00
|
|
|
} else {
|
|
|
|
let user = User::new(
|
|
|
|
UserId::new("test".to_string(), None, None),
|
|
|
|
UserData::new(vec![], 0),
|
|
|
|
);
|
|
|
|
let p = user.data.priority;
|
|
|
|
let id = user.id.clone();
|
2020-12-02 17:15:25 +01:00
|
|
|
return (Some(user), MachineState::used(id, p));
|
2020-12-02 17:12:25 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
Box::pin(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|