use orcher_sdk_core::kernel::random::RunRandom;
use rand::distributions::uniform::SampleUniform;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use uuid::Uuid;
#[derive(Debug, Clone)]
pub struct WorkflowRand {
source: Source,
step_counter: Arc<AtomicU64>,
}
#[derive(Debug, Clone)]
enum Source {
Own {
workflow_id: String,
},
Kernel(Arc<Mutex<RunRandom>>),
}
fn own_seed(workflow_id: &str, counter: u64) -> u64 {
let mut hasher = DefaultHasher::new();
workflow_id.hash(&mut hasher);
counter.hash(&mut hasher);
hasher.finish()
}
enum Drawn<'a> {
Own(Box<StdRng>),
Kernel(MutexGuard<'a, RunRandom>),
}
struct KernelRng<'a>(&'a mut RunRandom);
impl rand::RngCore for KernelRng<'_> {
fn next_u32(&mut self) -> u32 {
(self.0.next_u64() >> 32) as u32
}
fn next_u64(&mut self) -> u64 {
self.0.next_u64()
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
for chunk in dest.chunks_mut(8) {
let bytes = self.0.next_u64().to_le_bytes();
chunk.copy_from_slice(&bytes[..chunk.len()]);
}
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
self.fill_bytes(dest);
Ok(())
}
}
impl WorkflowRand {
pub fn new(workflow_id: impl Into<String>) -> Self {
Self {
source: Source::Own {
workflow_id: workflow_id.into(),
},
step_counter: Arc::new(AtomicU64::new(0)),
}
}
pub(crate) fn from_kernel_seed(seed: [u8; 32]) -> Self {
Self {
source: Source::Kernel(Arc::new(Mutex::new(RunRandom::from_seed(seed)))),
step_counter: Arc::new(AtomicU64::new(0)),
}
}
fn next_rng(&self) -> Drawn<'_> {
let counter = self.step_counter.fetch_add(1, Ordering::SeqCst);
match &self.source {
Source::Own { workflow_id } => Drawn::Own(Box::new(StdRng::seed_from_u64(own_seed(
workflow_id,
counter,
)))),
Source::Kernel(random) => Drawn::Kernel(
random
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()),
),
}
}
pub fn uuid(&self) -> Uuid {
match self.next_rng() {
Drawn::Own(mut rng) => Uuid::from_u128(rng.gen()),
Drawn::Kernel(mut random) => Uuid::from_bytes(random.uuid_bytes()),
}
}
pub fn random(&self) -> f64 {
match self.next_rng() {
Drawn::Own(mut rng) => rng.gen(),
Drawn::Kernel(mut random) => random.next_f64(),
}
}
pub fn random_range<T, R>(&self, range: R) -> T
where
T: SampleUniform,
R: rand::distributions::uniform::SampleRange<T>,
{
match self.next_rng() {
Drawn::Own(mut rng) => rng.gen_range(range),
Drawn::Kernel(mut random) => KernelRng(&mut random).gen_range(range),
}
}
pub fn bool(&self) -> bool {
match self.next_rng() {
Drawn::Own(mut rng) => rng.gen(),
Drawn::Kernel(mut random) => random.next_bool(),
}
}
pub fn choose<'a, T>(&self, items: &'a [T]) -> Option<&'a T> {
if items.is_empty() {
return None;
}
let index = match self.next_rng() {
Drawn::Own(mut rng) => rng.gen_range(0..items.len()),
Drawn::Kernel(mut random) => random.below(items.len() as u64) as usize,
};
Some(&items[index])
}
pub fn shuffle<T>(&self, items: &mut [T]) {
use rand::seq::SliceRandom;
match self.next_rng() {
Drawn::Own(mut rng) => items.shuffle(&mut *rng),
Drawn::Kernel(mut random) => random.shuffle(items),
}
}
pub fn choose_multiple<T: Clone>(&self, items: &[T], count: usize) -> Vec<T> {
use rand::seq::SliceRandom;
if items.is_empty() {
return vec![];
}
let actual_count = count.min(items.len());
match self.next_rng() {
Drawn::Own(mut rng) => items
.choose_multiple(&mut *rng, actual_count)
.cloned()
.collect(),
Drawn::Kernel(mut random) => random
.sample(items.len(), actual_count)
.into_iter()
.map(|index| items[index].clone())
.collect(),
}
}
pub fn step_count(&self) -> u64 {
self.step_counter.load(Ordering::SeqCst)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_workflow_rand_uuid_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let uuid1 = rand1.uuid();
let uuid2 = rand2.uuid();
assert_eq!(uuid1, uuid2);
}
#[test]
fn test_workflow_rand_uuid_different_workflows() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-456");
let uuid1 = rand1.uuid();
let uuid2 = rand2.uuid();
assert_ne!(uuid1, uuid2);
}
#[test]
fn test_workflow_rand_uuid_sequence() {
let rand = WorkflowRand::new("wf-123");
let uuid1 = rand.uuid();
let uuid2 = rand.uuid();
let uuid3 = rand.uuid();
assert_ne!(uuid1, uuid2);
assert_ne!(uuid2, uuid3);
assert_ne!(uuid1, uuid3);
}
#[test]
fn test_workflow_rand_random_in_range() {
let rand = WorkflowRand::new("wf-123");
for _ in 0..100 {
let value = rand.random();
assert!((0.0..1.0).contains(&value));
}
}
#[test]
fn test_workflow_rand_random_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let value1 = rand1.random();
let value2 = rand2.random();
assert_eq!(value1, value2);
}
#[test]
fn test_workflow_rand_random_range() {
let rand = WorkflowRand::new("wf-123");
for _ in 0..100 {
let value = rand.random_range(10..20);
assert!((10..20).contains(&value));
}
}
#[test]
fn test_workflow_rand_random_range_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let value1 = rand1.random_range(5..15);
let value2 = rand2.random_range(5..15);
assert_eq!(value1, value2);
}
#[test]
fn test_workflow_rand_bool() {
let rand = WorkflowRand::new("wf-123");
let mut true_count = 0;
let mut false_count = 0;
for _ in 0..100 {
if rand.bool() {
true_count += 1;
} else {
false_count += 1;
}
}
assert!(true_count > 0);
assert!(false_count > 0);
}
#[test]
fn test_workflow_rand_bool_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let value1 = rand1.bool();
let value2 = rand2.bool();
assert_eq!(value1, value2);
}
#[test]
fn test_workflow_rand_choose() {
let rand = WorkflowRand::new("wf-123");
let items = vec!["a", "b", "c"];
let choice = rand.choose(&items);
assert!(choice.is_some());
assert!(items.contains(choice.unwrap()));
}
#[test]
fn test_workflow_rand_choose_empty() {
let rand = WorkflowRand::new("wf-123");
let items: Vec<&str> = vec![];
let choice = rand.choose(&items);
assert!(choice.is_none());
}
#[test]
fn test_workflow_rand_choose_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let items = vec!["a", "b", "c"];
let choice1 = rand1.choose(&items);
let choice2 = rand2.choose(&items);
assert_eq!(choice1, choice2);
}
#[test]
fn test_workflow_rand_shuffle() {
let rand = WorkflowRand::new("wf-123");
let mut items1 = vec![1, 2, 3, 4, 5];
let items2 = items1.clone();
rand.shuffle(&mut items1);
let same_order = items1.iter().zip(items2.iter()).all(|(a, b)| a == b);
assert!(!same_order || items1.len() <= 1);
}
#[test]
fn test_workflow_rand_shuffle_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let mut items1 = vec![1, 2, 3, 4, 5];
let mut items2 = vec![1, 2, 3, 4, 5];
rand1.shuffle(&mut items1);
rand2.shuffle(&mut items2);
assert_eq!(items1, items2);
}
#[test]
fn test_workflow_rand_shuffle_empty() {
let rand = WorkflowRand::new("wf-123");
let mut items: Vec<i32> = vec![];
rand.shuffle(&mut items);
assert_eq!(items.len(), 0);
}
#[test]
fn test_workflow_rand_shuffle_single() {
let rand = WorkflowRand::new("wf-123");
let mut items = vec![42];
rand.shuffle(&mut items);
assert_eq!(items, vec![42]);
}
#[test]
fn test_workflow_rand_choose_multiple() {
let rand = WorkflowRand::new("wf-123");
let items = vec![1, 2, 3, 4, 5];
let chosen = rand.choose_multiple(&items, 3);
assert_eq!(chosen.len(), 3);
for item in &chosen {
assert!(items.contains(item));
}
let mut sorted = chosen.clone();
sorted.sort();
sorted.dedup();
assert_eq!(sorted.len(), chosen.len());
}
#[test]
fn test_workflow_rand_choose_multiple_more_than_available() {
let rand = WorkflowRand::new("wf-123");
let items = vec![1, 2, 3];
let chosen = rand.choose_multiple(&items, 10);
assert_eq!(chosen.len(), 3); }
#[test]
fn test_workflow_rand_choose_multiple_empty() {
let rand = WorkflowRand::new("wf-123");
let items: Vec<i32> = vec![];
let chosen = rand.choose_multiple(&items, 5);
assert_eq!(chosen.len(), 0);
}
#[test]
fn test_workflow_rand_clone() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = rand1.clone();
let uuid1 = rand1.uuid();
let uuid2 = rand2.uuid();
assert_ne!(uuid1, uuid2);
let rand3 = WorkflowRand::new("wf-123");
let rand4 = WorkflowRand::new("wf-123");
let uuid3 = rand3.uuid();
let uuid4 = rand4.uuid();
assert_eq!(uuid3, uuid4);
}
#[test]
fn test_workflow_rand_compute_seed_consistency() {
let seed1 = own_seed("wf-123", 0);
let seed2 = own_seed("wf-123", 0);
assert_eq!(seed1, seed2);
}
#[test]
fn test_workflow_rand_compute_seed_different_counters() {
let seed1 = own_seed("wf-123", 0);
let seed2 = own_seed("wf-123", 1);
assert_ne!(seed1, seed2);
}
#[test]
fn test_workflow_rand_step_count() {
let rand = WorkflowRand::new("wf-123");
assert_eq!(rand.step_count(), 0);
rand.uuid();
assert_eq!(rand.step_count(), 1);
rand.random();
assert_eq!(rand.step_count(), 2);
rand.random_range(1..10);
assert_eq!(rand.step_count(), 3);
rand.bool();
assert_eq!(rand.step_count(), 4);
}
}