113 lines
3.5 KiB
Rust
113 lines
3.5 KiB
Rust
use super::{Control, Publisher, SessionError, Subscriber};
|
|
use crate::{cache::broadcast, setup};
|
|
|
|
use webtransport_quinn::{RecvStream, SendStream, Session};
|
|
|
|
/// An endpoint that accepts connections, publishing and/or consuming live streams.
|
|
pub struct Server {}
|
|
|
|
impl Server {
|
|
/// Accept an established Webtransport session, performing the MoQ handshake.
|
|
///
|
|
/// This returns a [Request] half-way through the handshake that allows the application to accept or deny the session.
|
|
pub async fn accept(session: Session) -> Result<Request, SessionError> {
|
|
let mut control = session.accept_bi().await?;
|
|
|
|
let mut client = setup::Client::decode(&mut control.1).await?;
|
|
|
|
if client.versions.contains(&setup::Version::DRAFT_01) {
|
|
// We always require subscriber ID.
|
|
client.extensions.require_subscriber_id()?;
|
|
|
|
// We require OBJECT_EXPIRES for publishers only.
|
|
if client.role.is_publisher() {
|
|
client.extensions.require_object_expires()?;
|
|
}
|
|
|
|
// We don't require SUBSCRIBE_SPLIT since it's easy enough to support, but it's clearly an oversight.
|
|
// client.extensions.require(&Extension::SUBSCRIBE_SPLIT)?;
|
|
} else if client.versions.contains(&setup::Version::KIXEL_01) {
|
|
// Extensions didn't exist in KIXEL_01, so we set them manually.
|
|
client.extensions = setup::Extensions {
|
|
object_expires: true,
|
|
subscriber_id: true,
|
|
subscribe_split: true,
|
|
};
|
|
} else {
|
|
return Err(SessionError::Version(
|
|
client.versions,
|
|
[setup::Version::DRAFT_01, setup::Version::KIXEL_01].into(),
|
|
));
|
|
}
|
|
|
|
Ok(Request {
|
|
session,
|
|
client,
|
|
control,
|
|
})
|
|
}
|
|
}
|
|
|
|
/// A partially complete MoQ Transport handshake.
|
|
pub struct Request {
|
|
session: Session,
|
|
client: setup::Client,
|
|
control: (SendStream, RecvStream),
|
|
}
|
|
|
|
impl Request {
|
|
/// Accept the session as a publisher, using the provided broadcast to serve subscriptions.
|
|
pub async fn publisher(mut self, source: broadcast::Subscriber) -> Result<Publisher, SessionError> {
|
|
let setup = self.setup(setup::Role::Publisher)?;
|
|
setup.encode(&mut self.control.0).await?;
|
|
|
|
let control = Control::new(self.control.0, self.control.1, setup.extensions);
|
|
let publisher = Publisher::new(self.session, control, source);
|
|
Ok(publisher)
|
|
}
|
|
|
|
/// Accept the session as a subscriber only.
|
|
pub async fn subscriber(mut self, source: broadcast::Publisher) -> Result<Subscriber, SessionError> {
|
|
let setup = self.setup(setup::Role::Subscriber)?;
|
|
setup.encode(&mut self.control.0).await?;
|
|
|
|
let control = Control::new(self.control.0, self.control.1, setup.extensions);
|
|
let subscriber = Subscriber::new(self.session, control, source);
|
|
Ok(subscriber)
|
|
}
|
|
|
|
// TODO Accept the session and perform both roles.
|
|
/*
|
|
pub async fn accept(self) -> anyhow::Result<(Publisher, Subscriber)> {
|
|
self.ok(setup::Role::Both).await
|
|
}
|
|
*/
|
|
|
|
fn setup(&mut self, role: setup::Role) -> Result<setup::Server, SessionError> {
|
|
let server = setup::Server {
|
|
role,
|
|
version: setup::Version::DRAFT_01,
|
|
extensions: self.client.extensions.clone(),
|
|
params: Default::default(),
|
|
};
|
|
|
|
// We need to sure we support the opposite of the client's role.
|
|
// ex. if the client is a publisher, we must be a subscriber ONLY.
|
|
if !self.client.role.is_compatible(server.role) {
|
|
return Err(SessionError::RoleIncompatible(self.client.role, server.role));
|
|
}
|
|
|
|
Ok(server)
|
|
}
|
|
|
|
/// Reject the request, closing the Webtransport session.
|
|
pub fn reject(self, code: u32) {
|
|
self.session.close(code, b"")
|
|
}
|
|
|
|
/// The role advertised by the client.
|
|
pub fn role(&self) -> setup::Role {
|
|
self.client.role
|
|
}
|
|
}
|