use crate::error::{Error, Result, WorkflowError};
use crate::task::IntoTaskName;
use crate::workflow::command::{ScheduleTaskCommand, WorkflowCommand};
use crate::workflow::WorkflowContext;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use std::time::Duration;
pub const SESSION_CREATE_TASK: &str = "__orcher_create_session";
pub const SESSION_COMPLETE_TASK: &str = "__orcher_complete_session";
pub const SESSION_QUEUE_SEPARATOR: &str = "__session__";
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SessionOptions {
#[serde(with = "humantime_serde_compat")]
pub creation_timeout: Duration,
#[serde(with = "humantime_serde_compat")]
pub execution_timeout: Duration,
pub max_concurrent_tasks: usize,
#[serde(with = "humantime_serde_compat")]
pub heartbeat_interval: Duration,
}
impl Default for SessionOptions {
fn default() -> Self {
Self {
creation_timeout: Duration::from_secs(30),
execution_timeout: Duration::from_secs(600),
max_concurrent_tasks: 1,
heartbeat_interval: Duration::from_secs(5),
}
}
}
impl SessionOptions {
pub fn with_creation_timeout(mut self, timeout: Duration) -> Self {
self.creation_timeout = timeout;
self
}
pub fn with_execution_timeout(mut self, timeout: Duration) -> Self {
self.execution_timeout = timeout;
self
}
pub fn with_max_concurrent_tasks(mut self, max: usize) -> Self {
self.max_concurrent_tasks = max;
self
}
pub fn with_heartbeat_interval(mut self, interval: Duration) -> Self {
self.heartbeat_interval = interval;
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SessionState {
Open,
Closed,
Failed,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionInfo {
pub session_id: String,
pub session_queue: String,
pub worker_identity: String,
pub state: SessionState,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateSessionInput {
pub session_id: String,
pub creation_timeout_ms: u64,
pub execution_timeout_ms: u64,
pub max_concurrent_tasks: usize,
pub heartbeat_interval_ms: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompleteSessionInput {
pub session_id: String,
}
pub struct SessionContext<'a> {
ctx: &'a WorkflowContext,
info: SessionInfo,
}
impl<'a> SessionContext<'a> {
pub(crate) fn new(ctx: &'a WorkflowContext, info: SessionInfo) -> Self {
Self { ctx, info }
}
pub async fn execute_task<T, I, O>(&self, task: T, input: I) -> Result<O>
where
T: IntoTaskName,
I: Serialize + Send + Sync + 'static,
O: DeserializeOwned + Send + Sync + 'static,
{
if self.info.state != SessionState::Open {
return Err(Error::Workflow(WorkflowError::InvalidState(format!(
"Cannot execute task on session '{}': state is {:?}",
self.info.session_id, self.info.state
))));
}
{
let mut state = self.ctx.state.lock().unwrap();
state.task_queue_override = Some(self.info.session_queue.clone());
}
self.ctx.execute_task(task, input).await
}
pub fn complete(&mut self) {
if self.info.state != SessionState::Open {
tracing::warn!(
session_id = %self.info.session_id,
state = ?self.info.state,
"Attempted to complete session that is not open"
);
return;
}
self.info.state = SessionState::Closed;
let input = CompleteSessionInput {
session_id: self.info.session_id.clone(),
};
let input_bytes = serde_json::to_vec(&input).unwrap_or_default();
let sequence = self.ctx.next_sequence();
let task_id = self.ctx.step_id(
orcher_sdk_core::kernel::step_ids::StepKind::Task,
sequence,
|| format!("{}_{}", SESSION_COMPLETE_TASK, sequence),
);
self.ctx
.reach_step(crate::workflow::StepKind::Task, &task_id);
let command = ScheduleTaskCommand {
sequence,
task_id,
task_type: SESSION_COMPLETE_TASK.to_string(),
task_queue: self.info.session_queue.clone(),
input: input_bytes,
timeout: Duration::from_secs(30),
heartbeat_timeout: None,
queue_timeout: None,
retry_policy: None,
headers: vec![],
};
self.ctx.add_command(WorkflowCommand::ScheduleTask(command));
tracing::debug!(
session_id = %self.info.session_id,
session_queue = %self.info.session_queue,
"Session completion scheduled"
);
}
pub fn info(&self) -> &SessionInfo {
&self.info
}
pub fn is_open(&self) -> bool {
self.info.state == SessionState::Open
}
pub fn session_id(&self) -> &str {
&self.info.session_id
}
pub fn worker_identity(&self) -> &str {
&self.info.worker_identity
}
pub fn session_queue(&self) -> &str {
&self.info.session_queue
}
}
pub fn build_session_queue(original_queue: &str, worker_resource_id: &str) -> String {
format!(
"{}{}{}",
original_queue, SESSION_QUEUE_SEPARATOR, worker_resource_id
)
}
pub fn is_session_queue(queue: &str) -> bool {
queue.contains(SESSION_QUEUE_SEPARATOR)
}
pub fn original_queue_from_session(session_queue: &str) -> Option<&str> {
session_queue.split(SESSION_QUEUE_SEPARATOR).next()
}
mod humantime_serde_compat {
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::time::Duration;
pub fn serialize<S: Serializer>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error> {
duration.as_millis().serialize(serializer)
}
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Duration, D::Error> {
let ms = u64::deserialize(deserializer)?;
Ok(Duration::from_millis(ms))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_session_options_defaults() {
let opts = SessionOptions::default();
assert_eq!(opts.creation_timeout, Duration::from_secs(30));
assert_eq!(opts.execution_timeout, Duration::from_secs(600));
assert_eq!(opts.max_concurrent_tasks, 1);
assert_eq!(opts.heartbeat_interval, Duration::from_secs(5));
}
#[test]
fn test_session_options_builder() {
let opts = SessionOptions::default()
.with_creation_timeout(Duration::from_secs(60))
.with_execution_timeout(Duration::from_secs(1200))
.with_max_concurrent_tasks(4)
.with_heartbeat_interval(Duration::from_secs(10));
assert_eq!(opts.creation_timeout, Duration::from_secs(60));
assert_eq!(opts.execution_timeout, Duration::from_secs(1200));
assert_eq!(opts.max_concurrent_tasks, 4);
assert_eq!(opts.heartbeat_interval, Duration::from_secs(10));
}
#[test]
fn test_build_session_queue() {
let queue = build_session_queue("default", "worker_abc123");
assert_eq!(queue, "default__session__worker_abc123");
}
#[test]
fn test_is_session_queue() {
assert!(is_session_queue("default__session__worker_abc123"));
assert!(!is_session_queue("default"));
assert!(!is_session_queue("my-queue"));
}
#[test]
fn test_original_queue_from_session() {
assert_eq!(
original_queue_from_session("default__session__worker_abc123"),
Some("default")
);
assert_eq!(original_queue_from_session("default"), Some("default"));
}
#[test]
fn test_session_state_transitions() {
let info = SessionInfo {
session_id: "session_1".to_string(),
session_queue: "default__session__worker_abc".to_string(),
worker_identity: "worker-1".to_string(),
state: SessionState::Open,
};
assert_eq!(info.state, SessionState::Open);
}
#[test]
fn test_create_session_input_serialization() {
let input = CreateSessionInput {
session_id: "session_1".to_string(),
creation_timeout_ms: 30000,
execution_timeout_ms: 600000,
max_concurrent_tasks: 4,
heartbeat_interval_ms: 5000,
};
let json = serde_json::to_string(&input).unwrap();
let decoded: CreateSessionInput = serde_json::from_str(&json).unwrap();
assert_eq!(decoded.session_id, "session_1");
assert_eq!(decoded.max_concurrent_tasks, 4);
}
#[test]
fn test_session_options_serialization() {
let opts = SessionOptions::default();
let json = serde_json::to_string(&opts).unwrap();
let decoded: SessionOptions = serde_json::from_str(&json).unwrap();
assert_eq!(decoded.creation_timeout, opts.creation_timeout);
assert_eq!(decoded.execution_timeout, opts.execution_timeout);
}
}