use std::error::Error;
use std::fmt;
use std::future::Future;
use std::pin::Pin;
use serde_json::Value;
use thiserror::Error;
use crate::fingerprint::FingerprintWarning;
use crate::msp::{InitializeParams, InitializeResult};
pub const INITIALIZE_METHOD: &str = "initialize";
pub const INITIALIZED_METHOD: &str = "initialized";
pub type HandshakeFuture<'a, T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'a>>;
pub trait HandshakeConnection {
type Error: Error + Send + Sync + 'static;
fn request<'a>(
&'a mut self,
method: &'static str,
params: Value,
) -> HandshakeFuture<'a, Value, Self::Error>;
fn notify<'a>(&'a mut self, method: &'static str) -> HandshakeFuture<'a, (), Self::Error>;
}
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum HandshakeError<E: Error + 'static> {
#[error("could not encode initialize params: {0}")]
Encode(#[source] serde_json::Error),
#[error("initialize transport failed: {0}")]
Transport(#[source] E),
#[error("initialize result did not match the generated MSP shape: {0}")]
InvalidResult(#[source] serde_json::Error),
}
#[non_exhaustive]
pub enum HandshakeRecoveryError<C, E: Error + 'static> {
Encode(serde_json::Error),
Transport(E),
InvalidResult(serde_json::Error),
InitializedNotify {
source: E,
connection: C,
},
}
impl<C, E: Error + 'static> HandshakeRecoveryError<C, E> {
#[must_use]
pub fn connection(&self) -> Option<&C> {
match self {
Self::InitializedNotify { connection, .. } => Some(connection),
Self::Encode(_) | Self::Transport(_) | Self::InvalidResult(_) => None,
}
}
#[must_use]
pub fn into_connection(self) -> Option<C> {
match self {
Self::InitializedNotify { connection, .. } => Some(connection),
Self::Encode(_) | Self::Transport(_) | Self::InvalidResult(_) => None,
}
}
#[must_use]
pub fn into_handshake_error(self) -> HandshakeError<E> {
match self {
Self::Encode(error) => HandshakeError::Encode(error),
Self::Transport(error) | Self::InitializedNotify { source: error, .. } => {
HandshakeError::Transport(error)
}
Self::InvalidResult(error) => HandshakeError::InvalidResult(error),
}
}
}
impl<C, E: Error + 'static> fmt::Debug for HandshakeRecoveryError<C, E> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Encode(error) => formatter.debug_tuple("Encode").field(error).finish(),
Self::Transport(source) => formatter.debug_tuple("Transport").field(source).finish(),
Self::InvalidResult(error) => {
formatter.debug_tuple("InvalidResult").field(error).finish()
}
Self::InitializedNotify { source, .. } => formatter
.debug_struct("InitializedNotify")
.field("source", source)
.field("connection", &"<preserved>")
.finish(),
}
}
}
impl<C, E: Error + 'static> fmt::Display for HandshakeRecoveryError<C, E> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Encode(error) => {
write!(formatter, "could not encode initialize params: {error}")
}
Self::Transport(source) => write!(formatter, "initialize transport failed: {source}"),
Self::InvalidResult(error) => write!(
formatter,
"initialize result did not match the generated MSP shape: {error}"
),
Self::InitializedNotify { source, .. } => write!(
formatter,
"initialized notification transport failed: {source}"
),
}
}
}
impl<C, E: Error + 'static> Error for HandshakeRecoveryError<C, E> {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Encode(error) | Self::InvalidResult(error) => Some(error),
Self::Transport(source) | Self::InitializedNotify { source, .. } => Some(source),
}
}
}
pub struct Handshake<C> {
connection: C,
}
impl<C> Handshake<C> {
#[must_use]
pub fn new(connection: C) -> Self {
Self { connection }
}
}
impl<C: HandshakeConnection> Handshake<C> {
pub async fn initialize(
self,
params: InitializeParams,
) -> Result<Initialized<C>, HandshakeError<C::Error>> {
self.initialize_preserving_connection(params)
.await
.map_err(HandshakeRecoveryError::into_handshake_error)
}
pub async fn initialize_preserving_connection(
mut self,
params: InitializeParams,
) -> Result<Initialized<C>, HandshakeRecoveryError<C, C::Error>> {
let params = serde_json::to_value(params).map_err(HandshakeRecoveryError::Encode)?;
let raw = self
.connection
.request(INITIALIZE_METHOD, params)
.await
.map_err(HandshakeRecoveryError::Transport)?;
let initialize_result: InitializeResult =
serde_json::from_value(raw).map_err(HandshakeRecoveryError::InvalidResult)?;
let fingerprint_warning =
FingerprintWarning::for_server(initialize_result.schema.fingerprint.clone());
if let Err(source) = self.connection.notify(INITIALIZED_METHOD).await {
return Err(HandshakeRecoveryError::InitializedNotify {
source,
connection: self.connection,
});
}
Ok(Initialized {
connection: self.connection,
initialize_result,
fingerprint_warning,
})
}
}
pub struct Initialized<C> {
connection: C,
pub initialize_result: InitializeResult,
pub fingerprint_warning: Option<FingerprintWarning>,
}
impl<C> Initialized<C> {
#[must_use]
pub fn connection(&self) -> &C {
&self.connection
}
#[must_use]
pub fn connection_mut(&mut self) -> &mut C {
&mut self.connection
}
#[must_use]
pub fn into_connection(self) -> C {
self.connection
}
}