use super::signals::SessionEndReason;
use super::stored::{
StoredSession, clear_stored_session, is_token_expired, session_key, stored_session,
};
use super::{renew_when_due, token_expiry};
use crate::client::SemiontClient;
use crate::errors::{
SemiontError, SessionError, SessionErrorCode, SignInError, SignInErrorCode, TransportErrorCode,
};
use crate::locked;
use crate::retry::{REFRESH, RetryFacts, equal_jitter};
use crate::state::{Held, Tasks};
use crate::state_unit::StateUnit;
use crate::storage::{SessionStorage, StorageSubscription};
use crate::timing::{MAX_RECONNECT, RECONNECT};
use crate::transport::{BoxFuture, ConnectionState, Failures};
use crate::types::{KbTarget, UserResponse};
use rand_core::Rng;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, Weak};
use std::time::SystemTime;
use tokio::sync::watch;
pub type Refresh = Arc<
dyn Fn(
Option<String>,
)
-> BoxFuture<'static, Result<Option<String>, Arc<dyn std::error::Error + Send + Sync>>>
+ Send
+ Sync,
>;
pub type Validate =
Arc<dyn Fn(String) -> BoxFuture<'static, Result<UserResponse, SemiontError>> + Send + Sync>;
pub type OnAuthFailed = Arc<dyn Fn(SessionEndReason) + Send + Sync>;
pub type OnSessionError = Arc<dyn Fn(SessionError) + Send + Sync>;
fn not_renewed(failure: Option<&(dyn std::error::Error + Send + Sync)>) -> String {
match failure {
Some(failure) => format!("Token refresh failed: {failure}"),
None => "Token refresh failed".to_owned(),
}
}
fn refused(failure: &(dyn std::error::Error + Send + Sync + 'static)) -> bool {
failure
.downcast_ref::<SignInError>()
.is_some_and(|failure| {
failure.code == SignInErrorCode::Exchange
&& failure.status.is_some()
&& !REFRESH.retryable(&RetryFacts {
status: failure.status,
method: Some("POST"),
keyed: false,
})
})
}
fn not_forgotten(why: String, forgotten: &(dyn std::error::Error + Send + Sync)) -> String {
format!("{why}; and the sign-in could not be forgotten: {forgotten}")
}
pub struct SemiontSessionConfig {
pub kb: KbTarget,
pub storage: Arc<dyn SessionStorage>,
pub client: Arc<SemiontClient>,
pub token: watch::Sender<Option<String>>,
pub refresh: Option<Refresh>,
pub validate: Option<Validate>,
pub on_auth_failed: Option<OnAuthFailed>,
pub on_error: Option<OnSessionError>,
pub random: Option<Arc<Mutex<dyn Rng + Send>>>,
}
struct Shared {
id: String,
kb: KbTarget,
client: Arc<SemiontClient>,
storage: Arc<dyn SessionStorage>,
token: Held<Option<String>>,
user: Held<Option<UserResponse>>,
ready: Held<bool>,
unanswered: Held<bool>,
refresh: Option<Refresh>,
validate: Option<Validate>,
on_auth_failed: Option<OnAuthFailed>,
on_error: Option<OnSessionError>,
random: Option<Arc<Mutex<dyn Rng + Send>>>,
tasks: Tasks,
storage_changes: Mutex<Option<StorageSubscription>>,
closed: AtomicBool,
answering: tokio::sync::Mutex<()>,
}
pub struct SemiontSession {
shared: Arc<Shared>,
}
impl SemiontSession {
pub fn new(config: SemiontSessionConfig) -> SemiontSession {
let shared = Arc::new(Shared {
id: format!("session-{}", uuid::Uuid::new_v4()),
kb: config.kb,
client: config.client,
storage: config.storage,
token: Held::of(config.token),
user: Held::new(None),
ready: Held::new(false),
unanswered: Held::new(false),
refresh: config.refresh,
validate: config.validate,
on_auth_failed: config.on_auth_failed,
on_error: config.on_error,
random: config.random,
tasks: Tasks::new(),
storage_changes: Mutex::new(None),
closed: AtomicBool::new(false),
answering: tokio::sync::Mutex::new(()),
});
let stored = stored_session(shared.storage.as_ref(), &shared.kb.id);
if let Some(stored) = &stored
&& !is_token_expired(&stored.access, SystemTime::now())
&& shared.token.now().is_none()
{
shared.token.set(Some(stored.access.clone()));
}
let renewing = shared.clone();
shared
.tasks
.spawn(renew_when_due(shared.token.read(), move || {
let shared = renewing.clone();
async move {
shared.renew().await;
}
}));
let retrying = shared.clone();
shared
.tasks
.spawn(async move { retrying.renew_when_unanswered().await });
let heard = Arc::downgrade(&shared);
*locked(&shared.storage_changes) = shared.storage.subscribe(Arc::new(move |key, value| {
if let Some(shared) = heard.upgrade() {
shared.written_elsewhere(key, value);
}
}));
let starting = shared.clone();
shared.tasks.spawn(async move {
starting.validate(stored).await;
starting.ready.set(true);
});
SemiontSession { shared }
}
pub fn id(&self) -> &str {
&self.shared.id
}
pub fn kb(&self) -> &KbTarget {
&self.shared.kb
}
pub fn client(&self) -> &Arc<SemiontClient> {
&self.shared.client
}
pub fn token(&self) -> watch::Receiver<Option<String>> {
self.shared.token.read()
}
pub fn user(&self) -> watch::Receiver<Option<UserResponse>> {
self.shared.user.read()
}
pub fn stream_state(&self) -> watch::Receiver<ConnectionState> {
self.shared.client.state()
}
pub fn errors(&self) -> Failures {
self.shared.client.transport().failures()
}
pub async fn ready(&self) {
let mut ready = self.shared.ready.read();
let _ = ready.wait_for(|ready| *ready).await;
}
pub fn expires_at(&self) -> Option<SystemTime> {
token_expiry(&self.shared.token.now()?)
}
pub async fn refresh(&self, refused: Option<&str>) -> Option<String> {
self.shared.refused(refused).await
}
pub fn renewer(&self) -> SessionRenewer {
SessionRenewer {
shared: Arc::downgrade(&self.shared),
}
}
}
impl StateUnit for SemiontSession {
fn dispose(&self) {
self.shared.end();
}
}
pub struct OpenedSession {
session: SemiontSession,
}
impl OpenedSession {
pub fn new(session: SemiontSession) -> OpenedSession {
OpenedSession { session }
}
pub fn session(&self) -> &SemiontSession {
&self.session
}
pub async fn close(&self) {
self.session.dispose();
self.session.client().close().await;
}
}
#[derive(Clone)]
pub struct SessionRenewer {
shared: Weak<Shared>,
}
impl SessionRenewer {
pub async fn refresh(&self, refused: Option<&str>) -> Option<String> {
match self.shared.upgrade() {
Some(shared) => shared.refused(refused).await,
None => None,
}
}
}
impl Drop for SemiontSession {
fn drop(&mut self) {
self.shared.end();
}
}
impl Shared {
fn closed(&self) -> bool {
self.closed.load(Ordering::SeqCst)
}
fn end(&self) {
if self.closed.swap(true, Ordering::SeqCst) {
return;
}
self.tasks.stop();
*locked(&self.storage_changes) = None;
self.token.end();
self.user.end();
self.ready.end();
self.unanswered.end();
}
async fn try_refresh(
&self,
) -> (
Option<String>,
Option<Arc<dyn std::error::Error + Send + Sync>>,
) {
match &self.refresh {
None => (None, None),
Some(refresh) => match refresh(self.token.now()).await {
Ok(token) => (token, None),
Err(failure) => (None, Some(failure)),
},
}
}
async fn renew(&self) -> Option<String> {
if self.closed() || self.refresh.is_none() {
return None;
}
let (renewed, failure) = self.try_refresh().await;
if self.closed() {
return None;
}
if let Some(token) = renewed {
self.unanswered.set(false);
self.token.set(Some(token.clone()));
return Some(token);
}
self.token.set(None);
if stored_session(self.storage.as_ref(), &self.kb.id).is_none() {
self.unanswered.set(false);
return None;
}
self.unrenewed(failure);
None
}
async fn renew_when_unanswered(&self) {
let mut owed = self.unanswered.read();
loop {
if owed.wait_for(|owed| *owed).await.is_err() {
return;
}
let mut step = RECONNECT;
while self.unanswered.now() {
tokio::time::sleep(equal_jitter(step, self.random.as_deref())).await;
if self.token.now().is_some() {
self.unanswered.set(false);
} else if self.unanswered.now() {
if self.user.now().is_none() {
self.refused(None).await;
} else {
self.renew().await;
}
}
step = (step * 2).min(MAX_RECONNECT);
}
}
}
fn unrenewed(&self, failure: Option<Arc<dyn std::error::Error + Send + Sync>>) {
self.token.set(None);
let why = not_renewed(failure.as_deref());
match failure {
Some(failure) if !refused(failure.as_ref()) => {
self.unanswered.set(true);
self.failed(SessionErrorCode::RefreshExhausted, why);
}
_ => self.signed_out(
SessionEndReason::Expired,
SessionErrorCode::RefreshExhausted,
why,
),
}
}
async fn refused(&self, refused: Option<&str>) -> Option<String> {
let _answering = self.answering.lock().await;
let held = self.token.now();
if held.as_deref() != refused {
return held;
}
let renewed = self.renew().await?;
let Some(validate) = &self.validate else {
return Some(renewed);
};
if !self.ready.now() {
return Some(renewed);
}
let answer = validate(renewed.clone()).await;
if self.closed() {
return None;
}
if self.token.now().as_deref() == Some(renewed.as_str()) {
match answer {
Ok(user) => self.user.set(Some(user)),
Err(SemiontError::Transport(refusal))
if refusal.code == TransportErrorCode::Unauthorized =>
{
self.signed_out(
SessionEndReason::Refused,
SessionErrorCode::CredentialRefused,
"The gateway refused a token its issuer had just issued".to_owned(),
);
}
Err(_) => {}
}
}
self.token.now()
}
fn signed_out(&self, told: SessionEndReason, code: SessionErrorCode, why: String) {
self.unanswered.set(false);
self.token.set(None);
let why = match clear_stored_session(self.storage.as_ref(), &self.kb.id) {
Ok(()) => why,
Err(forgotten) => not_forgotten(why, forgotten.as_ref()),
};
if let Some(on_auth_failed) = &self.on_auth_failed {
on_auth_failed(told);
}
self.failed(code, why);
}
fn failed(&self, code: SessionErrorCode, message: String) {
if let Some(on_error) = &self.on_error {
on_error(SessionError::new(code, message, &self.kb.id));
}
}
async fn validate(&self, stored: Option<StoredSession>) {
let Some(stored) = stored else { return };
let expired = is_token_expired(&stored.access, SystemTime::now());
let mut token = if expired {
match self.try_refresh().await {
(Some(renewed), _) => renewed,
(None, Some(failure)) if !refused(failure.as_ref()) => {
self.unanswered.set(true);
self.failed(
SessionErrorCode::AuthFailed,
not_renewed(Some(failure.as_ref())),
);
return;
}
(None, failure) => {
if let Err(forgotten) = clear_stored_session(self.storage.as_ref(), &self.kb.id)
{
self.failed(
SessionErrorCode::RefreshExhausted,
not_forgotten(not_renewed(failure.as_deref()), forgotten.as_ref()),
);
}
return;
}
}
} else {
stored.access.clone()
};
if token != stored.access {
self.token.set(Some(token.clone()));
}
let Some(validate) = &self.validate else {
return;
};
let mut just_issued = expired;
loop {
if self.closed() {
return;
}
let answer = validate(token.clone()).await;
if self.closed() {
return;
}
match answer {
Ok(user) => {
self.user.set(Some(user));
return;
}
Err(SemiontError::Transport(refusal))
if refusal.code == TransportErrorCode::Unauthorized =>
{
if just_issued {
self.signed_out(
SessionEndReason::Refused,
SessionErrorCode::CredentialRefused,
"The gateway refused a token its issuer had just issued".to_owned(),
);
return;
}
let current = self.token.now();
if current.as_deref() != Some(token.as_str()) {
let Some(current) = current else { return };
token = current;
just_issued = true;
continue;
}
let (renewed, failure) = self.try_refresh().await;
if self.closed() {
return;
}
match renewed {
Some(renewed) => {
self.token.set(Some(renewed.clone()));
token = renewed;
just_issued = true;
}
None => {
self.unrenewed(failure);
return;
}
}
}
Err(other) => {
self.failed(SessionErrorCode::AuthFailed, other.to_string());
return;
}
}
}
}
fn written_elsewhere(&self, key: &str, value: Option<&str>) {
if self.closed() || key != session_key(&self.kb.id) {
return;
}
match value {
None => {
self.token.set(None);
self.user.set(None);
}
Some(written) => {
if let Some(session) = StoredSession::read(written) {
self.token.set(Some(session.access));
}
}
}
}
}