use super::{AttemptId, ClientId, CycleId, SessionId};
use crate::error::{ErrorKind, ErrorStage};
use crate::{BoxError, HeaderMap, Metadata, NetError, Result};
use std::fmt;
use std::future::Future;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use tokio::sync::{oneshot, Semaphore};
type ProviderOutput = std::result::Result<HandshakeHeaders, BoxError>;
type ProviderFuture = Pin<Box<dyn Future<Output = ProviderOutput> + Send + 'static>>;
type AsyncProvider = dyn Fn(HandshakeAttempt) -> Result<ProviderFuture> + Send + Sync;
type BlockingProvider = dyn Fn(HandshakeAttempt) -> Result<HandshakeHeaders> + Send + Sync;
#[derive(Clone)]
pub struct HandshakeProvider {
inner: ProviderKind,
}
#[derive(Clone)]
enum ProviderKind {
Async(
Arc<AsyncProvider>,
),
Blocking(
Arc<BlockingProvider>,
),
}
impl HandshakeProvider {
pub fn new<F, Fut>(provider: F) -> Self
where
F: Fn(HandshakeAttempt) -> Fut + Send + Sync + 'static,
Fut: Future<Output = ProviderOutput> + Send + 'static,
{
let callback = Owned::new(provider);
Self {
inner: ProviderKind::Async(Arc::new(move |attempt| {
let provider = callback.value.as_ref().ok_or_else(internal_failure)?;
caught(catch_unwind(AssertUnwindSafe(|| provider(attempt))))
.map(|future| Box::pin(future) as ProviderFuture)
})),
}
}
pub fn blocking<F>(provider: F) -> Self
where
F: Fn(HandshakeAttempt) -> ProviderOutput + Send + Sync + 'static,
{
let callback = Owned::new(provider);
Self {
inner: ProviderKind::Blocking(Arc::new(move |attempt| {
let provider = callback.value.as_ref().ok_or_else(internal_failure)?;
resolve_provider_outcome(catch_unwind(AssertUnwindSafe(|| provider(attempt))))
})),
}
}
#[cfg(test)]
pub(crate) async fn provide(
&self,
attempt: HandshakeAttempt,
slots: Arc<Semaphore>,
) -> Result<HandshakeHeaders> {
self.provide_with_threads(
attempt,
slots,
Arc::new(crate::common::retirement::ThreadRegistry::new()),
)
.await
}
pub(crate) async fn provide_with_threads(
&self,
attempt: HandshakeAttempt,
slots: Arc<Semaphore>,
threads: Arc<crate::common::retirement::ThreadRegistry>,
) -> Result<HandshakeHeaders> {
let identity = (attempt.client_id, attempt.session_id, attempt.attempt_id);
let result = match &self.inner {
ProviderKind::Async(provider) => {
let provided = {
let _scope = crate::common::retirement::ExecutionScope::enter();
provider(attempt)
};
match provided {
Ok(future) => GuardedFuture::new(future).await,
Err(error) => Err(error),
}
}
ProviderKind::Blocking(provider) => {
run_blocking_with_spawn(provider.clone(), attempt, slots, |job| {
threads.spawn("open-net-ws-context-provider", job)
})
.await
}
};
result.map_err(|error| {
let mut context = error.context().clone();
context.client_id = Some(identity.0);
context.session_id = Some(identity.1);
context.attempt_id = Some(identity.2);
error.with_context(context)
})
}
}
impl fmt::Debug for HandshakeProvider {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let mode = match self.inner {
ProviderKind::Async(_) => "async",
ProviderKind::Blocking(_) => "blocking",
};
formatter
.debug_struct("HandshakeProvider")
.field("mode", &mode)
.finish_non_exhaustive()
}
}
#[derive(Clone)]
pub struct HandshakeAttempt {
pub client_id: ClientId,
pub session_id: SessionId,
pub cycle_id: CycleId,
pub attempt_id: AttemptId,
pub metadata: Arc<Metadata>,
}
impl fmt::Debug for HandshakeAttempt {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HandshakeAttempt")
.field("client_id", &self.client_id)
.field("session_id", &self.session_id)
.field("cycle_id", &self.cycle_id)
.field("attempt_id", &self.attempt_id)
.field("metadata_count", &self.metadata.len())
.finish()
}
}
#[derive(Clone)]
pub struct HandshakeHeaders {
pub headers: HeaderMap,
pub credential_version: Option<String>,
}
impl HandshakeHeaders {
pub fn new(headers: HeaderMap) -> Self {
Self {
headers,
credential_version: None,
}
}
}
impl fmt::Debug for HandshakeHeaders {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HandshakeHeaders")
.field("header_count", &self.headers.len())
.field(
"credential_version_bytes",
&self.credential_version.as_ref().map(String::len),
)
.finish()
}
}
pub(crate) fn validate_headers(headers: &HeaderMap) -> Result<()> {
use http::header::{CONNECTION, HOST, SEC_WEBSOCKET_KEY, SEC_WEBSOCKET_VERSION, UPGRADE};
if [
HOST,
CONNECTION,
UPGRADE,
SEC_WEBSOCKET_KEY,
SEC_WEBSOCKET_VERSION,
]
.iter()
.any(|name| headers.contains_key(name))
{
return Err(NetError::input(
"headers",
"must not override SDK-managed WebSocket handshake headers",
));
}
Ok(())
}
struct Owned<T> {
value: Option<T>,
}
impl<T> Owned<T> {
fn new(value: T) -> Self {
Self { value: Some(value) }
}
fn take(&mut self) -> Result<T> {
self.value.take().ok_or_else(internal_failure)
}
}
impl<T> Drop for Owned<T> {
fn drop(&mut self) {
retire(self.value.take());
}
}
fn retire<T>(value: T) -> bool {
match catch_unwind(AssertUnwindSafe(|| drop(value))) {
Ok(()) => false,
Err(payload) => {
crate::log_e!(crate::common::log::log_def::LogType::WSC;
"ws.handshake.retire", "arg_value|stage|error", "redacted", "provider", "user_value_cleanup_panicked");
dispose_payload(payload);
true
}
}
}
fn dispose_payload(payload: Box<dyn std::any::Any + Send>) {
if let Err(secondary) = catch_unwind(AssertUnwindSafe(|| drop(payload))) {
crate::log_e!(crate::common::log::log_def::LogType::WSC;
"ws.handshake.dispose_payload", "arg_payload|stage|error", "redacted", "provider", "panic_payload_cleanup_panicked");
std::mem::forget(secondary);
}
}
fn internal_failure() -> NetError {
NetError::from(ErrorKind::Internal).with_stage(ErrorStage::Provider)
}
fn callback_failure() -> NetError {
NetError::from(ErrorKind::CallbackPanicked).with_stage(ErrorStage::Provider)
}
fn caught<T>(outcome: std::thread::Result<T>) -> Result<T> {
outcome.map_err(|payload| {
dispose_payload(payload);
callback_failure()
})
}
fn resolve_provider_outcome(
outcome: std::thread::Result<ProviderOutput>,
) -> Result<HandshakeHeaders> {
resolve_provider_output(caught(outcome)?)
}
fn resolve_provider_output(output: ProviderOutput) -> Result<HandshakeHeaders> {
let mut headers = Owned::new(output.map_err(NetError::provider)?);
if let Some(version) = headers
.value
.as_ref()
.and_then(|headers| headers.credential_version.as_deref())
{
super::value_limits::validate_credential_version(version)
.map_err(|error| error.with_stage(ErrorStage::Provider))?;
}
headers.take()
}
struct GuardedFuture {
future: Owned<ProviderFuture>,
}
impl GuardedFuture {
fn new(future: ProviderFuture) -> Self {
Self {
future: Owned::new(future),
}
}
fn complete_poll(
&mut self,
outcome: std::thread::Result<Poll<ProviderOutput>>,
) -> Poll<Result<HandshakeHeaders>> {
match caught(outcome) {
Ok(Poll::Pending) => Poll::Pending,
Ok(Poll::Ready(output)) => {
let mut output = Owned::new(output);
if retire(self.future.value.take()) {
return Poll::Ready(Err(callback_failure()));
}
Poll::Ready(output.take().and_then(resolve_provider_output))
}
Err(error) => {
retire(self.future.value.take());
Poll::Ready(Err(error))
}
}
}
}
impl Future for GuardedFuture {
type Output = Result<HandshakeHeaders>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let _scope = crate::common::retirement::ExecutionScope::enter();
let Some(future) = self.future.value.as_mut() else {
return Poll::Ready(Err(internal_failure()));
};
let outcome = catch_unwind(AssertUnwindSafe(|| future.as_mut().poll(cx)));
self.complete_poll(outcome)
}
}
impl Drop for GuardedFuture {
fn drop(&mut self) {
let _scope = crate::common::retirement::ExecutionScope::enter();
retire(self.future.value.take());
}
}
async fn run_blocking_with_spawn(
provider: Arc<BlockingProvider>,
attempt: HandshakeAttempt,
slots: Arc<Semaphore>,
spawn: impl FnOnce(Box<dyn FnOnce() + Send + 'static>) -> std::io::Result<()>,
) -> Result<HandshakeHeaders> {
let permit = slots.try_acquire_owned().map_err(|error| {
NetError::with_source(ErrorKind::ResourceExhausted, error).with_stage(ErrorStage::Provider)
})?;
let (sent, received) = oneshot::channel();
let job = Box::new(move || {
let _permit = permit;
let result = provider(attempt);
retire(provider);
if let Err(result) = sent.send(Owned::new(result)) {
drop(result);
}
});
spawn(job).map_err(|error| {
NetError::with_source(ErrorKind::RuntimeUnavailable, error).with_stage(ErrorStage::Provider)
})?;
let mut output = received.await.map_err(|error| {
NetError::with_source(ErrorKind::RuntimeUnavailable, error).with_stage(ErrorStage::Provider)
})?;
output.take()?
}
#[cfg(test)]
#[path = "handshake_tests.rs"]
mod tests;