Cargo.toml: upgrade rand and petname

Author: erikgrinaker

Cargo.lock

@@ -23,8 +23,8 @@ fs4 = "0.13"
 hdrhistogram = "7.5"
 itertools = "0.14"
 log = "0.4"
-petname = "2.0"
-rand = "0.8"
+petname = "3.0.0-alpha.2"
+rand = "0.9"
 regex = "1.10"
 rustyline = "17.0"
 rustyline-derive = "0.11"

Cargo.toml

@@ -18,7 +18,7 @@ use hdrhistogram::Histogram;
 use itertools::Itertools as _;
 use petname::Generator as _;
 use rand::SeedableRng as _;
-use rand::distributions::Distribution as _;
+use rand::distr::Distribution as _;
 use rand::rngs::StdRng;
 
 use toydb::error::Result;
@@ -128,7 +128,7 @@ impl Runner {
             // Spawn work generator.
             {
                 println!("Running workload {}...", workload);
-                let generator = workload.generate(rng).take(self.count);
+                let generator = workload.generate(rng)?.take(self.count);
                 s.spawn(move || -> Result<()> {
                     for item in generator {
                         work_tx.send(item)?;
@@ -189,7 +189,7 @@ trait Workload: std::fmt::Display {
     fn prepare(&self, client: &mut Client, rng: &mut StdRng) -> Result<()>;
 
     /// Generates work items as an iterator.
-    fn generate(&self, rng: StdRng) -> impl Iterator<Item = Self::Item> + Send + 'static;
+    fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::Item> + Send + 'static>;
 
     /// Executes a single work item. This will automatically be retried on
     /// certain errors, and must use a transaction where appropriate.
@@ -234,7 +234,7 @@ impl Workload for Read {
         client.execute(r#"DROP TABLE IF EXISTS "read""#)?;
         client.execute(r#"CREATE TABLE "read" (id INT PRIMARY KEY, value STRING NOT NULL)"#)?;
 
-        let chars = &mut rand::distributions::Alphanumeric.sample_iter(rng).map(|b| b as char);
+        let chars = &mut rand::distr::Alphanumeric.sample_iter(rng).map(|b| b as char);
         let rows = (1..=self.rows).map(|id| (id, chars.take(self.size).collect::<String>()));
         let chunks = rows.chunks(100);
         let queries = chunks.into_iter().map(|chunk| {
@@ -250,12 +250,12 @@ impl Workload for Read {
         Ok(())
     }
 
-    fn generate(&self, rng: StdRng) -> impl Iterator<Item = Self::Item> + 'static {
-        ReadGenerator {
+    fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::Item> + 'static> {
+        Ok(ReadGenerator {
             batch: self.batch,
-            dist: rand::distributions::Uniform::new(1, self.rows + 1),
+            dist: rand::distr::Uniform::new(1, self.rows + 1)?,
             rng,
-        }
+        })
     }
 
     fn execute(client: &mut Client, item: &Self::Item) -> Result<()> {
@@ -280,7 +280,7 @@ impl Workload for Read {
 struct ReadGenerator {
     batch: usize,
     rng: StdRng,
-    dist: rand::distributions::Uniform<u64>,
+    dist: rand::distr::Uniform<u64>,
 }
 
 impl Iterator for ReadGenerator {
@@ -331,8 +331,8 @@ impl Workload for Write {
         Ok(())
     }
 
-    fn generate(&self, rng: StdRng) -> impl Iterator<Item = Self::Item> + 'static {
-        WriteGenerator { next_id: 1, size: self.size, batch: self.batch, rng }
+    fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::Item> + 'static> {
+        Ok(WriteGenerator { next_id: 1, size: self.size, batch: self.batch, rng })
     }
 
     fn execute(client: &mut Client, item: &Self::Item) -> Result<()> {
@@ -369,8 +369,7 @@ impl Iterator for WriteGenerator {
     type Item = <Write as Workload>::Item;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let chars =
-            &mut rand::distributions::Alphanumeric.sample_iter(&mut self.rng).map(|b| b as char);
+        let chars = &mut rand::distr::Alphanumeric.sample_iter(&mut self.rng).map(|b| b as char);
         let mut rows = Vec::with_capacity(self.batch);
         while rows.len() < self.batch {
             rows.push((self.next_id, chars.take(self.size).collect()));
@@ -451,16 +450,16 @@ impl Workload for Bank {
         Ok(())
     }
 
-    fn generate(&self, rng: StdRng) -> impl Iterator<Item = Self::Item> + 'static {
+    fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::Item> + 'static> {
         let customers = self.customers;
         let max_transfer = self.max_transfer;
         // Generate random u64s, then pick random from,to,amount as the
         // remainder of the max customer and amount.
-        rand::distributions::Uniform::new_inclusive(0, u64::MAX)
+        Ok(rand::distr::Uniform::new_inclusive(0, u64::MAX)?
             .sample_iter(rng)
             .tuples()
             .map(move |(a, b, c)| (a % customers + 1, b % customers + 1, c % max_transfer + 1))
-            .filter(|(from, to, _)| from != to)
+            .filter(|(from, to, _)| from != to))
     }
 
     fn execute(client: &mut Client, item: &Self::Item) -> Result<()> {

src/bin/workload.rs

@@ -104,7 +104,7 @@ impl Client {
                     // to MAX_WAIT, but randomize the wait time in this interval
                     // to reduce the chance of collisions.
                     let mut wait = MAX_WAIT.min(MIN_WAIT * 2_u64.pow(retries));
-                    wait = rand::thread_rng().gen_range(MIN_WAIT..=wait);
+                    wait = rand::rng().random_range(MIN_WAIT..=wait);
                     std::thread::sleep(Duration::from_millis(wait));
                     retries += 1;
                 }

src/client.rs

@@ -163,6 +163,12 @@ impl From<log::SetLoggerError> for Error {
     }
 }
 
+impl From<rand::distr::uniform::Error> for Error {
+    fn from(err: rand::distr::uniform::Error) -> Self {
+        Error::InvalidInput(err.to_string())
+    }
+}
+
 impl From<regex::Error> for Error {
     fn from(err: regex::Error) -> Self {
         panic!("{err}") // faulty code

src/error.rs

@@ -214,7 +214,7 @@ impl<R: Role> RawNode<R> {
 
     /// Generates a random election timeout.
     fn random_election_timeout(&self) -> Ticks {
-        rand::thread_rng().gen_range(self.opts.election_timeout_range.clone())
+        rand::rng().random_range(self.opts.election_timeout_range.clone())
     }
 
     /// Sends a message to the given recipient.

src/raft/node.rs

@@ -69,7 +69,7 @@ impl TestCluster {
     /// toysql is too annoying, since we have to deal with rustyline, PTYs,
     /// echoing, multiline editing, etc.
     pub fn connect(&self) -> Result<Client, Box<dyn Error>> {
-        let id = rand::thread_rng().gen_range(1..=self.servers.len()) as NodeID;
+        let id = rand::rng().random_range(1..=self.servers.len()) as NodeID;
         self.servers.get(&id).unwrap().connect()
     }
 }