use serde::{Deserialize, Serialize};
use crate::presentation::{
PresentationDeclaration, default_declarations, external_protocol_declaration,
};
mod ids;
pub use ids::{NodeKey, RouteViewId};
pub use document_session_api::engine_ids::*;
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SurfaceTargetId(pub String);
impl SurfaceTargetId {
pub fn new(value: impl Into<String>) -> Self {
Self(value.into())
}
pub fn as_str(&self) -> &str {
&self.0
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct WorkspaceRouteId(pub String);
impl WorkspaceRouteId {
pub fn new(value: impl Into<String>) -> Self {
Self(value.into())
}
pub fn as_str(&self) -> &str {
&self.0
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EngineRouteRequest {
pub workspace_id: WorkspaceRouteId,
pub view: Option<RouteViewId>,
pub node: Option<NodeKey>,
pub address: String,
#[serde(default)]
pub content_type: Option<String>,
#[serde(default)]
pub pinned_engine: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EngineRouteDecision {
pub engine_id: String,
pub surface_contract: SurfaceContract,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EngineRoutePolicy {
pub rules: Vec<EngineRouteRule>,
pub fallback: EngineRouteRule,
#[serde(default)]
pub per_host_overrides: std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EngineRouteRule {
pub schemes: Vec<String>,
#[serde(default)]
pub content_types: Vec<String>,
pub engine_id: String,
pub mode: SurfaceContractMode,
}
impl EngineRoutePolicy {
pub fn route(&self, request: &EngineRouteRequest) -> EngineRouteDecision {
self.route_filtered(request, |_| true)
}
pub fn route_filtered(
&self,
request: &EngineRouteRequest,
is_available: impl Fn(&str) -> bool,
) -> EngineRouteDecision {
let scheme = address_scheme(&request.address);
if let Some(pin) = request.pinned_engine.as_deref()
&& is_available(pin)
{
return EngineRouteDecision {
engine_id: pin.to_string(),
surface_contract: SurfaceContract {
target: surface_target_for_request(request, scheme),
mode: SurfaceContractMode::CompositedTexture,
},
};
}
let by_content_type = request.content_type.as_deref().and_then(|ct| {
self.rules
.iter()
.find(|rule| rule.matches_content_type(ct) && is_available(&rule.engine_id))
});
let by_host = host_from_address(&request.address).and_then(|host| {
let host_lower = host.to_ascii_lowercase();
self.per_host_overrides
.iter()
.find(|(domain, engine_id)| {
domain.eq_ignore_ascii_case(&host_lower) && is_available(engine_id)
})
.map(|(_, engine_id)| engine_id.as_str())
});
let by_scheme = scheme.and_then(|scheme| {
self.rules
.iter()
.find(|rule| rule.matches_scheme(scheme) && is_available(&rule.engine_id))
});
if let Some(rule) = by_content_type {
return EngineRouteDecision {
engine_id: rule.engine_id.clone(),
surface_contract: SurfaceContract {
target: surface_target_for_request(request, scheme),
mode: rule.mode,
},
};
}
if let Some(host_engine) = by_host {
return EngineRouteDecision {
engine_id: host_engine.to_string(),
surface_contract: SurfaceContract {
target: surface_target_for_request(request, scheme),
mode: SurfaceContractMode::CompositedTexture,
},
};
}
let rule = by_scheme.unwrap_or(&self.fallback);
EngineRouteDecision {
engine_id: rule.engine_id.clone(),
surface_contract: SurfaceContract {
target: surface_target_for_request(request, scheme),
mode: rule.mode,
},
}
}
}
impl Default for EngineRoutePolicy {
fn default() -> Self {
Self::from_declarations(&default_declarations(), &external_protocol_declaration())
}
}
impl EngineRoutePolicy {
pub fn from_declarations<'a>(
declarations: impl IntoIterator<Item = &'a PresentationDeclaration>,
fallback: &PresentationDeclaration,
) -> Self {
Self {
rules: declarations
.into_iter()
.map(EngineRouteRule::from_declaration)
.collect(),
fallback: EngineRouteRule::from_declaration(fallback),
per_host_overrides: std::collections::HashMap::new(),
}
}
}
impl EngineRouteRule {
pub fn from_declaration(declaration: &PresentationDeclaration) -> Self {
Self {
schemes: declaration.presents.schemes.clone(),
content_types: declaration.presents.content_types.clone(),
engine_id: declaration.id.clone(),
mode: declaration.reaches.mode,
}
}
pub fn new(
schemes: impl IntoIterator<Item = impl Into<String>>,
engine_id: impl Into<String>,
mode: SurfaceContractMode,
) -> Self {
Self {
schemes: schemes.into_iter().map(Into::into).collect(),
content_types: Vec::new(),
engine_id: engine_id.into(),
mode,
}
}
pub fn content_type(
types: impl IntoIterator<Item = impl Into<String>>,
engine_id: impl Into<String>,
mode: SurfaceContractMode,
) -> Self {
Self {
schemes: Vec::new(),
content_types: types.into_iter().map(Into::into).collect(),
engine_id: engine_id.into(),
mode,
}
}
pub fn matches_scheme(&self, scheme: &str) -> bool {
self.schemes
.iter()
.any(|candidate| candidate.eq_ignore_ascii_case(scheme))
}
pub fn matches_content_type(&self, content_type: &str) -> bool {
let primary = content_type
.split(';')
.next()
.unwrap_or(content_type)
.trim();
self.content_types
.iter()
.any(|candidate| candidate.eq_ignore_ascii_case(primary))
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SurfaceContract {
pub target: SurfaceTargetId,
pub mode: SurfaceContractMode,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum SurfaceContractMode {
CompositedTexture,
NativeOverlay,
EmbeddedHost,
Headless,
}
pub fn host_from_address(address: &str) -> Option<&str> {
let after_scheme = address.split_once("://")?.1;
let authority = after_scheme
.split(['/', '?', '#'])
.next()
.unwrap_or(after_scheme);
let host_with_port = authority.rsplit('@').next().unwrap_or(authority);
let host = host_with_port.split(':').next().unwrap_or(host_with_port);
if host.is_empty() { None } else { Some(host) }
}
pub fn address_scheme(address: &str) -> Option<&str> {
let (scheme, _) = address.split_once(':')?;
let first = scheme.as_bytes().first()?;
if !first.is_ascii_alphabetic() {
return None;
}
if scheme
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'-' | b'.'))
{
Some(scheme)
} else {
None
}
}
fn surface_target_for_request(
request: &EngineRouteRequest,
scheme: Option<&str>,
) -> SurfaceTargetId {
if let Some(node) = request.node {
return SurfaceTargetId::new(format!("node:{}", node.index()));
}
if let Some(view) = request.view {
return SurfaceTargetId::new(format!("view:{}", view.as_uuid()));
}
SurfaceTargetId::new(format!(
"workspace:{}:{}",
request.workspace_id.as_str(),
scheme.unwrap_or("unknown")
))
}
#[cfg(test)]
mod tests;