use crate::error::{Error, Result};
use crate::workflow::session::{
build_session_queue, CompleteSessionInput, CreateSessionInput, SessionInfo, SessionState,
};
use dashmap::DashMap;
pub use orcher_sdk_core::poller::SessionQueueChange;
use std::sync::Arc;
use tokio::sync::{mpsc, Semaphore};
use tracing::{debug, info, warn};
pub struct SessionManager {
resource_id: String,
max_sessions: usize,
session_slots: Arc<Semaphore>,
active_sessions: Arc<DashMap<String, SessionEntry>>,
queue_change_tx: mpsc::UnboundedSender<SessionQueueChange>,
}
#[derive(Debug, Clone)]
pub struct SessionEntry {
pub session_id: String,
pub session_queue: String,
pub original_queue: String,
pub cancel: tokio_util::sync::CancellationToken,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct SessionManagerConfig {
pub max_sessions: usize,
}
impl Default for SessionManagerConfig {
fn default() -> Self {
Self { max_sessions: 10 }
}
}
impl SessionManager {
pub fn new(
config: SessionManagerConfig,
queue_change_tx: mpsc::UnboundedSender<SessionQueueChange>,
) -> Self {
let resource_id = uuid::Uuid::new_v4().to_string();
info!(
resource_id = %resource_id,
max_sessions = config.max_sessions,
"SessionManager created"
);
Self {
resource_id,
max_sessions: config.max_sessions,
session_slots: Arc::new(Semaphore::new(config.max_sessions)),
active_sessions: Arc::new(DashMap::new()),
queue_change_tx,
}
}
pub fn resource_id(&self) -> &str {
&self.resource_id
}
pub fn active_session_count(&self) -> usize {
self.active_sessions.len()
}
pub fn available_slots(&self) -> usize {
self.session_slots.available_permits()
}
pub async fn handle_create_session(
&self,
input: CreateSessionInput,
task_queue: &str,
heartbeat_tx: Option<mpsc::UnboundedSender<HeartbeatRequest>>,
) -> Result<SessionInfo> {
let permit = self
.session_slots
.clone()
.try_acquire_owned()
.map_err(|_| {
Error::Worker(crate::error::WorkerError::ResourceExhausted {
resource: format!(
"session slots ({}/{} in use)",
self.max_sessions - self.session_slots.available_permits(),
self.max_sessions,
),
})
})?;
let session_queue = build_session_queue(task_queue, &self.resource_id);
let cancel = tokio_util::sync::CancellationToken::new();
let entry = SessionEntry {
session_id: input.session_id.clone(),
session_queue: session_queue.clone(),
original_queue: task_queue.to_string(),
cancel: cancel.clone(),
};
self.active_sessions.insert(input.session_id.clone(), entry);
if let Err(e) = self
.queue_change_tx
.send(SessionQueueChange::Add(session_queue.clone()))
{
warn!(
session_id = %input.session_id,
error = %e,
"Failed to notify TaskDriver of new session queue"
);
}
info!(
session_id = %input.session_id,
session_queue = %session_queue,
resource_id = %self.resource_id,
available_slots = self.session_slots.available_permits(),
"Session created"
);
if let Some(hb_tx) = heartbeat_tx {
let session_id = input.session_id.clone();
let interval_ms = input.heartbeat_interval_ms;
let cancel_clone = cancel.clone();
tokio::spawn(async move {
let interval = std::time::Duration::from_millis(interval_ms);
loop {
tokio::select! {
_ = cancel_clone.cancelled() => {
debug!(session_id = %session_id, "Session heartbeat loop stopped");
break;
}
_ = tokio::time::sleep(interval) => {
if hb_tx.send(HeartbeatRequest {
session_id: session_id.clone(),
}).is_err() {
warn!(session_id = %session_id, "Heartbeat channel closed");
break;
}
}
}
}
});
}
let cancel_for_permit = cancel.clone();
tokio::spawn(async move {
cancel_for_permit.cancelled().await;
drop(permit);
});
Ok(SessionInfo {
session_id: input.session_id,
session_queue,
worker_identity: self.resource_id.clone(),
state: SessionState::Open,
})
}
pub async fn handle_complete_session(&self, input: CompleteSessionInput) -> Result<()> {
if let Some((_, entry)) = self.active_sessions.remove(&input.session_id) {
entry.cancel.cancel();
if let Err(e) = self
.queue_change_tx
.send(SessionQueueChange::Remove(entry.session_queue.clone()))
{
warn!(
session_id = %input.session_id,
error = %e,
"Failed to notify TaskDriver to remove session queue"
);
}
info!(
session_id = %input.session_id,
session_queue = %entry.session_queue,
available_slots = self.session_slots.available_permits() + 1,
"Session completed"
);
} else {
warn!(
session_id = %input.session_id,
"Attempted to complete unknown session"
);
}
Ok(())
}
pub fn is_session_active(&self, session_id: &str) -> bool {
self.active_sessions.contains_key(session_id)
}
pub fn get_session(&self, session_id: &str) -> Option<SessionEntry> {
self.active_sessions.get(session_id).map(|e| e.clone())
}
pub fn close_all_sessions(&self) {
let sessions: Vec<_> = self
.active_sessions
.iter()
.map(|e| e.value().clone())
.collect();
for entry in &sessions {
entry.cancel.cancel();
let _ = self
.queue_change_tx
.send(SessionQueueChange::Remove(entry.session_queue.clone()));
}
self.active_sessions.clear();
if !sessions.is_empty() {
info!(
count = sessions.len(),
"Force-closed all active sessions during shutdown"
);
}
}
}
impl Drop for SessionManager {
fn drop(&mut self) {
for entry in self.active_sessions.iter() {
entry.value().cancel.cancel();
}
}
}
#[derive(Debug, Clone)]
pub struct HeartbeatRequest {
pub session_id: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_session_manager_create_and_complete() {
let (tx, mut rx) = mpsc::unbounded_channel();
let manager = SessionManager::new(SessionManagerConfig { max_sessions: 2 }, tx);
assert_eq!(manager.available_slots(), 2);
assert_eq!(manager.active_session_count(), 0);
let input = CreateSessionInput {
session_id: "session_1".to_string(),
creation_timeout_ms: 30000,
execution_timeout_ms: 600000,
max_concurrent_tasks: 1,
heartbeat_interval_ms: 5000,
};
let info = manager
.handle_create_session(input, "default", None)
.await
.unwrap();
assert_eq!(info.session_id, "session_1");
assert!(info.session_queue.contains("__session__"));
assert_eq!(info.state, SessionState::Open);
assert_eq!(manager.active_session_count(), 1);
let change = rx.recv().await.unwrap();
match change {
SessionQueueChange::Add(queue) => assert_eq!(queue, info.session_queue),
_ => panic!("Expected Add"),
}
let complete_input = CompleteSessionInput {
session_id: "session_1".to_string(),
};
manager
.handle_complete_session(complete_input)
.await
.unwrap();
assert_eq!(manager.active_session_count(), 0);
let change = rx.recv().await.unwrap();
match change {
SessionQueueChange::Remove(queue) => assert_eq!(queue, info.session_queue),
_ => panic!("Expected Remove"),
}
}
#[tokio::test]
async fn test_session_manager_slot_exhaustion() {
let (tx, _rx) = mpsc::unbounded_channel();
let manager = SessionManager::new(SessionManagerConfig { max_sessions: 1 }, tx);
let input1 = CreateSessionInput {
session_id: "session_1".to_string(),
creation_timeout_ms: 30000,
execution_timeout_ms: 600000,
max_concurrent_tasks: 1,
heartbeat_interval_ms: 5000,
};
manager
.handle_create_session(input1, "default", None)
.await
.unwrap();
let input2 = CreateSessionInput {
session_id: "session_2".to_string(),
creation_timeout_ms: 30000,
execution_timeout_ms: 600000,
max_concurrent_tasks: 1,
heartbeat_interval_ms: 5000,
};
let result = manager.handle_create_session(input2, "default", None).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_session_manager_close_all() {
let (tx, _rx) = mpsc::unbounded_channel();
let manager = SessionManager::new(SessionManagerConfig { max_sessions: 5 }, tx);
for i in 0..3 {
let input = CreateSessionInput {
session_id: format!("session_{}", i),
creation_timeout_ms: 30000,
execution_timeout_ms: 600000,
max_concurrent_tasks: 1,
heartbeat_interval_ms: 5000,
};
manager
.handle_create_session(input, "default", None)
.await
.unwrap();
}
assert_eq!(manager.active_session_count(), 3);
manager.close_all_sessions();
assert_eq!(manager.active_session_count(), 0);
}
#[test]
fn test_session_queue_naming() {
let resource_id = "abc123";
let queue = build_session_queue("my-queue", resource_id);
assert_eq!(queue, "my-queue__session__abc123");
}
}