use std::collections::{BTreeMap, VecDeque};
use std::sync::mpsc;
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
use std::thread::JoinHandle;
use std::time::{Duration, Instant};
use crate::ctx::Ctx;
use crate::error::{Error, Result};
use crate::events::{EndInfo, EndReason, Event, Events, Protocol, ReceiverState, Started, Stats};
use crate::opts::Command;
use crate::session::GameIo;
use crate::util::stop::Stop;
const EVENT_QUEUE: usize = 256;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SessionState {
Connecting,
Streaming,
Ended,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct ReceiverInfo {
pub name: String,
pub protocol: Option<Protocol>,
pub state: ReceiverState,
pub error: Option<String>,
pub code: Option<String>,
}
#[derive(Clone)]
pub(crate) struct StateHandle(Arc<Shared>);
impl StateHandle {
pub(crate) fn connected(&self) -> bool {
let st = self.0.lock();
st.connected && !st.finished
}
}
pub type Callback = Box<dyn FnMut(&Event) + Send>;
#[derive(Default)]
struct State {
queue: VecDeque<Event>,
receivers: BTreeMap<String, ReceiverInfo>,
order: Vec<String>,
started: Option<Started>,
stats: Option<Stats>,
player_url: Option<String>,
share_url: Option<String>,
tunnel_urls: Vec<String>,
connected: bool,
end: Option<EndInfo>,
done: Option<Result<()>>,
finished: bool,
}
pub(crate) struct Shared {
state: Mutex<State>,
cv: Condvar,
}
impl Shared {
fn lock(&self) -> MutexGuard<'_, State> {
self.state.lock().unwrap_or_else(|e| e.into_inner())
}
fn record(&self, e: &Event) {
let mut st = self.lock();
match e {
Event::Receiver(r) => {
if !st.receivers.contains_key(&r.name) {
st.order.push(r.name.clone());
}
let protocol = r
.protocol
.or_else(|| st.receivers.get(&r.name).and_then(|i| i.protocol));
st.receivers.insert(
r.name.clone(),
ReceiverInfo {
name: r.name.clone(),
protocol,
state: r.state,
error: r.error.clone(),
code: r.code.clone(),
},
);
}
Event::Connected(_) => st.connected = true,
Event::Started(s) => st.started = Some(s.clone()),
Event::Stats(s) => st.stats = Some(s.clone()),
Event::Player(p) => {
st.player_url.get_or_insert_with(|| p.url.clone());
}
Event::SharePage(p) => st.share_url = Some(p.url.clone()),
Event::Tunnel(t) => st.tunnel_urls.push(t.url.clone()),
Event::End(e) => st.end = Some(e.clone()),
_ => {}
}
if st.queue.len() >= EVENT_QUEUE {
st.queue.pop_front();
}
st.queue.push_back(e.clone());
drop(st);
self.cv.notify_all();
}
}
pub struct Session {
shared: Arc<Shared>,
stop: Stop,
thread: Option<JoinHandle<()>>,
dispatcher: Option<JoinHandle<()>>,
}
impl std::fmt::Debug for Session {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Session")
.field("state", &self.state())
.finish_non_exhaustive()
}
}
#[derive(Clone, Debug)]
pub struct Stopper(Stop);
impl Stopper {
pub fn stop(&self) {
self.0.request();
}
pub fn stopped(&self) -> bool {
self.0.requested()
}
}
impl Session {
pub(crate) fn spawn(
cmd: Command,
mut ctx: Ctx,
io: GameIo,
mut callback: Option<Callback>,
) -> Result<Session> {
crate::util::timer::raise_resolution();
let shared = Arc::new(Shared {
state: Mutex::new(State::default()),
cv: Condvar::new(),
});
let (tx, rx) = mpsc::channel::<Event>();
let dispatcher = match callback.take() {
Some(mut f) => Some(
std::thread::Builder::new()
.name("tvpipe-events".into())
.spawn(move || {
while let Ok(e) = rx.recv() {
f(&e);
}
})
.map_err(|e| Error::io("spawn the event thread", e))?,
),
None => None,
};
let outer = ctx.events.clone();
let s = shared.clone();
let send = dispatcher.is_some().then_some(tx);
let send = send.map(Mutex::new);
ctx.events = Events::to(move |e| {
s.record(&e);
if let Some(tx) = &send {
let _ = tx.lock().unwrap_or_else(|e| e.into_inner()).send(e.clone());
}
outer.emit(e);
});
let stop = ctx.stop.clone();
let s = shared.clone();
let thread = std::thread::Builder::new()
.name("tvpipe-session".into())
.spawn(move || {
let rv = crate::session::run(cmd, &ctx, io);
drop(ctx);
let mut st = s.lock();
st.done = Some(rv);
st.finished = true;
drop(st);
s.cv.notify_all();
})
.map_err(|e| Error::io("spawn the session thread", e))?;
Ok(Session {
shared,
stop,
thread: Some(thread),
dispatcher,
})
}
pub(crate) fn wait_connected(&self) -> Result<()> {
let mut st = self.shared.lock();
loop {
if st.connected {
return Ok(());
}
if st.finished {
return match st.done.take() {
Some(Err(e)) => {
st.done = Some(Err(e.clone_lossy()));
Err(e)
}
_ => Err(Error::closed("the session ended before it connected")),
};
}
st = self.shared.cv.wait(st).unwrap_or_else(|e| e.into_inner());
}
}
pub(crate) fn state_handle(&self) -> StateHandle {
StateHandle(self.shared.clone())
}
pub fn state(&self) -> SessionState {
let st = self.shared.lock();
if st.finished || st.end.is_some() {
SessionState::Ended
} else if st.started.is_some() {
SessionState::Streaming
} else {
SessionState::Connecting
}
}
pub fn poll_events(&mut self) -> Vec<Event> {
self.shared.lock().queue.drain(..).collect()
}
pub fn next_event(&mut self, timeout: Duration) -> Option<Event> {
let until = Instant::now() + timeout;
let mut st = self.shared.lock();
loop {
if let Some(e) = st.queue.pop_front() {
return Some(e);
}
let now = Instant::now();
if st.finished || now >= until {
return None;
}
st = self
.shared
.cv
.wait_timeout(st, until - now)
.unwrap_or_else(|e| e.into_inner())
.0;
}
}
pub fn receivers(&self) -> Vec<ReceiverInfo> {
let st = self.shared.lock();
st.order
.iter()
.filter_map(|n| st.receivers.get(n).cloned())
.collect()
}
pub fn stats(&self) -> Option<Stats> {
self.shared.lock().stats.clone()
}
pub fn started(&self) -> Option<Started> {
self.shared.lock().started.clone()
}
pub fn player_url(&self) -> Option<String> {
self.shared.lock().player_url.clone()
}
pub fn share_url(&self) -> Option<String> {
self.shared.lock().share_url.clone()
}
pub fn tunnel_urls(&self) -> Vec<String> {
self.shared.lock().tunnel_urls.clone()
}
pub fn stopper(&self) -> Stopper {
Stopper(self.stop.clone())
}
pub fn stop(mut self) -> Result<EndInfo> {
self.stop.request();
self.join()
}
pub fn wait(mut self) -> Result<EndInfo> {
self.join()
}
pub fn wait_timeout(&self, timeout: Duration) -> bool {
let until = Instant::now() + timeout;
let mut st = self.shared.lock();
while !st.finished {
let now = Instant::now();
if now >= until {
return false;
}
st = self
.shared
.cv
.wait_timeout(st, until - now)
.unwrap_or_else(|e| e.into_inner())
.0;
}
true
}
fn join(&mut self) -> Result<EndInfo> {
if let Some(t) = self.thread.take() {
let _ = t.join();
}
if let Some(d) = self.dispatcher.take() {
let _ = d.join();
}
let mut st = self.shared.lock();
let end = st.end.clone();
match st.done.take() {
Some(Err(e)) => Err(e),
_ => Ok(end.unwrap_or_else(|| {
EndInfo::new(if self.stop.requested() {
EndReason::Stopped
} else {
EndReason::Done
})
})),
}
}
}
impl Drop for Session {
fn drop(&mut self) {
if self.thread.is_some() {
self.stop.request();
let _ = self.join();
}
}
}