use std::sync::Arc;
use std::time::Duration;
#[derive(Clone)]
#[non_exhaustive]
pub struct ClientConfig {
pub server_url: String,
pub namespace: String,
pub timeout: Duration,
pub identity: String,
pub use_payload_format: bool,
pub data_converter: Option<crate::client::client::DataConverterType>,
pub codec_chain: Option<Arc<orcher_sdk_core::codec::CodecChain>>,
pub api_key: Option<String>,
pub organization_id: Option<String>,
pub tls: Option<ClientTlsConfig>,
}
#[derive(Clone, Default)]
#[non_exhaustive]
pub struct ClientTlsConfig {
pub ca_cert: Option<Vec<u8>>,
pub client_cert: Option<Vec<u8>>,
pub client_key: Option<Vec<u8>>,
pub domain_name: Option<String>,
}
impl Default for ClientConfig {
fn default() -> Self {
Self {
server_url: "http://localhost:50051".to_string(),
namespace: "default".to_string(),
timeout: Duration::from_secs(30),
identity: format!("orcher-client-{}", uuid::Uuid::new_v4()),
use_payload_format: true,
data_converter: None, codec_chain: None, api_key: None, organization_id: None, tls: None, }
}
}
impl ClientConfig {
pub fn new(server_url: impl Into<String>) -> Self {
Self {
server_url: server_url.into(),
..Self::default()
}
}
pub fn with_server_url(mut self, server_url: impl Into<String>) -> Self {
self.server_url = server_url.into();
self
}
pub fn with_namespace(mut self, namespace: impl Into<String>) -> Self {
self.namespace = namespace.into();
self
}
pub fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub fn with_identity(mut self, identity: impl Into<String>) -> Self {
self.identity = identity.into();
self
}
pub fn with_payload_format(mut self, use_payload_format: bool) -> Self {
self.use_payload_format = use_payload_format;
self
}
pub fn with_data_converter(
mut self,
data_converter: crate::client::client::DataConverterType,
) -> Self {
self.data_converter = Some(data_converter);
self
}
pub fn with_codec_chain(
mut self,
codec_chain: Arc<orcher_sdk_core::codec::CodecChain>,
) -> Self {
self.codec_chain = Some(codec_chain);
self
}
pub fn with_api_key(mut self, api_key: impl Into<String>) -> Self {
self.api_key = Some(api_key.into());
self
}
pub fn with_organization_id(mut self, organization_id: impl Into<String>) -> Self {
self.organization_id = Some(organization_id.into());
self
}
pub fn with_tls(mut self, tls: ClientTlsConfig) -> Self {
self.tls = Some(tls);
self
}
}
impl ClientTlsConfig {
pub fn new() -> Self {
Self::default()
}
pub fn with_ca_cert(mut self, ca_cert: impl Into<Vec<u8>>) -> Self {
self.ca_cert = Some(ca_cert.into());
self
}
pub fn with_client_identity(
mut self,
client_cert: impl Into<Vec<u8>>,
client_key: impl Into<Vec<u8>>,
) -> Self {
self.client_cert = Some(client_cert.into());
self.client_key = Some(client_key.into());
self
}
pub fn with_domain_name(mut self, domain_name: impl Into<String>) -> Self {
self.domain_name = Some(domain_name.into());
self
}
}
impl std::fmt::Debug for ClientConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ClientConfig")
.field("server_url", &self.server_url)
.field("namespace", &self.namespace)
.field("timeout", &self.timeout)
.field("identity", &self.identity)
.field("use_payload_format", &self.use_payload_format)
.field("data_converter", &"<DataConverter>")
.field(
"codec_chain",
&if self.codec_chain.is_some() {
"<CodecChain>"
} else {
"None"
},
)
.field(
"api_key",
&if self.api_key.is_some() {
"<redacted>"
} else {
"None"
},
)
.field("organization_id", &self.organization_id)
.field(
"tls",
&if self.tls.is_some() {
"<configured>"
} else {
"None"
},
)
.finish()
}
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct StartWorkflowOptions {
pub workflow_id: Option<String>,
pub task_queue: String,
pub workflow_execution_timeout: Option<Duration>,
pub workflow_run_timeout: Option<Duration>,
pub workflow_task_timeout: Option<Duration>,
pub namespace: Option<String>,
pub idempotency_key: Option<String>,
pub cron_schedule: Option<String>,
pub retry_policy: Option<crate::task::RetryPolicy>,
pub id_reuse_policy: Option<WorkflowIdReusePolicy>,
}
impl StartWorkflowOptions {
pub fn new(task_queue: impl Into<String>) -> Self {
Self {
task_queue: task_queue.into(),
..Self::default()
}
}
pub fn with_workflow_id(mut self, workflow_id: impl Into<String>) -> Self {
self.workflow_id = Some(workflow_id.into());
self
}
pub fn with_task_queue(mut self, task_queue: impl Into<String>) -> Self {
self.task_queue = task_queue.into();
self
}
pub fn with_workflow_execution_timeout(mut self, timeout: Duration) -> Self {
self.workflow_execution_timeout = Some(timeout);
self
}
pub fn with_workflow_run_timeout(mut self, timeout: Duration) -> Self {
self.workflow_run_timeout = Some(timeout);
self
}
pub fn with_workflow_task_timeout(mut self, timeout: Duration) -> Self {
self.workflow_task_timeout = Some(timeout);
self
}
pub fn with_namespace(mut self, namespace: impl Into<String>) -> Self {
self.namespace = Some(namespace.into());
self
}
pub fn with_idempotency_key(mut self, key: impl Into<String>) -> Self {
self.idempotency_key = Some(key.into());
self
}
pub fn with_cron_schedule(mut self, cron_schedule: impl Into<String>) -> Self {
self.cron_schedule = Some(cron_schedule.into());
self
}
pub fn with_retry_policy(mut self, retry_policy: crate::task::RetryPolicy) -> Self {
self.retry_policy = Some(retry_policy);
self
}
pub fn with_id_reuse_policy(mut self, policy: WorkflowIdReusePolicy) -> Self {
self.id_reuse_policy = Some(policy);
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum WorkflowIdReusePolicy {
AllowDuplicate,
AllowDuplicateFailedOnly,
RejectDuplicate,
TerminateIfRunning,
}
impl WorkflowIdReusePolicy {
pub(crate) fn to_proto(self) -> orcher_sdk_core::proto::orcher::v1::WorkflowIdReusePolicy {
use orcher_sdk_core::proto::orcher::v1::WorkflowIdReusePolicy as Proto;
match self {
Self::AllowDuplicate => Proto::AllowDuplicate,
Self::AllowDuplicateFailedOnly => Proto::AllowDuplicateFailedOnly,
Self::RejectDuplicate => Proto::RejectDuplicate,
Self::TerminateIfRunning => Proto::TerminateIfRunning,
}
}
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct QueryOptions {
pub timeout: Option<Duration>,
pub reject_condition: Option<QueryRejectCondition>,
}
impl QueryOptions {
pub fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn with_reject_condition(mut self, condition: QueryRejectCondition) -> Self {
self.reject_condition = Some(condition);
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum QueryRejectCondition {
NotOpen,
NotCompleted,
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct EventOptions {
pub timeout: Option<Duration>,
}
impl EventOptions {
pub fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_client_config_defaults() {
let config = ClientConfig::default();
assert_eq!(config.server_url, "http://localhost:50051");
assert_eq!(config.namespace, "default");
assert_eq!(config.timeout, Duration::from_secs(30));
assert!(config.identity.starts_with("orcher-client-"));
assert!(config.use_payload_format);
assert!(config.data_converter.is_none());
}
#[test]
fn test_client_config_with_payload_format_disabled() {
let config = ClientConfig {
use_payload_format: false,
..Default::default()
};
assert!(!config.use_payload_format);
}
#[test]
fn test_client_config_debug() {
let config = ClientConfig::default();
let debug_str = format!("{:?}", config);
assert!(debug_str.contains("use_payload_format"));
assert!(debug_str.contains("data_converter"));
}
#[test]
fn test_start_workflow_options_defaults() {
let options = StartWorkflowOptions::default();
assert!(options.workflow_id.is_none());
assert_eq!(options.task_queue, "");
assert!(options.workflow_execution_timeout.is_none());
assert!(options.namespace.is_none());
}
#[test]
fn test_query_options_defaults() {
let options = QueryOptions::default();
assert!(options.timeout.is_none());
assert!(options.reject_condition.is_none());
}
#[test]
fn test_query_reject_condition() {
assert_eq!(QueryRejectCondition::NotOpen, QueryRejectCondition::NotOpen);
assert_ne!(
QueryRejectCondition::NotOpen,
QueryRejectCondition::NotCompleted
);
}
#[test]
fn test_event_options_defaults() {
let options = EventOptions::default();
assert!(options.timeout.is_none());
}
}