Fix usage of deprecated parts of rand

Author: Henrik Gustafsson

examples/custom_load_balancing_policy.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use rand::thread_rng;
+use rand::rng;
 use rand::Rng;
 use scylla::client::execution_profile::ExecutionProfile;
 use scylla::client::session::Session;
@@ -23,7 +23,7 @@ fn with_random_shard(node: NodeRef) -> (NodeRef, Option<Shard>) {
         .sharder()
         .map(|sharder| sharder.nr_shards.get())
         .unwrap_or(1);
-    (node, Some(thread_rng().gen_range(0..nr_shards) as Shard))
+    (node, Some(rng().random_range(0..nr_shards) as Shard))
 }
 
 impl LoadBalancingPolicy for CustomLoadBalancingPolicy {

scylla-proxy/src/actions.rs

@@ -105,7 +105,7 @@ impl Condition {
                 })
                 .unwrap_or(false),
             Condition::RandomWithProbability(probability) => {
-                rand::thread_rng().gen_bool(*probability)
+                rand::rng().random_bool(*probability)
             }
 
             Condition::TrueForLimitedTimes(times) => {
@@ -592,7 +592,7 @@ impl ResponseForger {
             || example_db_errors::other(2137),
         ];
         RequestReaction::forge_with_error_lazy_delay(
-            Box::new(|| ERRORS[rand::thread_rng().next_u32() as usize % ERRORS.len()]()),
+            Box::new(|| ERRORS[rand::rng().next_u32() as usize % ERRORS.len()]()),
             delay,
         )
     }

scylla-proxy/src/proxy.rs

@@ -1315,7 +1315,7 @@ mod tests {
     fn random_body() -> Bytes {
         let body_len = (rand::random::<u32>() % 1000) as usize;
         let mut body = BytesMut::zeroed(body_len);
-        rand::thread_rng().fill_bytes(body.as_mut());
+        rand::rng().fill_bytes(body.as_mut());
         body.freeze()
     }
 

scylla/src/cluster/metadata.rs

@@ -33,8 +33,8 @@ use crate::utils::pretty::{CommaSeparatedDisplayer, DisplayUsingDebug};
 use futures::future::{self, FutureExt};
 use futures::stream::{self, StreamExt, TryStreamExt};
 use futures::Stream;
-use rand::seq::SliceRandom;
-use rand::{thread_rng, Rng};
+use rand::seq::{IndexedRandom, SliceRandom};
+use rand::{rng, Rng};
 use scylla_macros::DeserializeRow;
 use std::borrow::BorrowMut;
 use std::cell::Cell;
@@ -416,7 +416,7 @@ impl MetadataReader {
 
         let control_connection_endpoint = UntranslatedEndpoint::ContactPoint(
             initial_peers
-                .choose(&mut thread_rng())
+                .choose(&mut rng())
                 .expect("Tried to initialize MetadataReader with empty initial_known_nodes list!")
                 .clone(),
         );
@@ -469,7 +469,7 @@ impl MetadataReader {
         // Therefore, we try to fetch metadata from other known peers, in order.
 
         // shuffle known_peers to iterate through them in random order later
-        self.known_peers.shuffle(&mut thread_rng());
+        self.known_peers.shuffle(&mut rng());
         debug!(
             "Known peers: {}",
             CommaSeparatedDisplayer(self.known_peers.iter().map(DisplayUsingDebug))
@@ -641,7 +641,7 @@ impl MetadataReader {
                 if !self.known_peers.is_empty() {
                     self.control_connection_endpoint = self
                         .known_peers
-                        .choose(&mut thread_rng())
+                        .choose(&mut rng())
                         .expect("known_peers is empty - should be impossible")
                         .clone();
 
@@ -856,7 +856,7 @@ async fn create_peer_from_row(
             // Also, we could implement support for Cassandra's other standard partitioners
             // like RandomPartitioner or ByteOrderedPartitioner.
             trace!("Couldn't parse tokens as 64-bit integers: {}, proceeding with a dummy token. If you're using a partitioner with different token size, consider migrating to murmur3", e);
-            vec![Token::new(rand::thread_rng().gen::<i64>())]
+            vec![Token::new(rand::rng().random::<i64>())]
         }
     };
 

scylla/src/network/connection_pool.rs

@@ -284,7 +284,7 @@ impl NodeConnectionPool {
                 sharder,
                 connections,
             } => {
-                let shard: u16 = rand::thread_rng().gen_range(0..sharder.nr_shards.get());
+                let shard: u16 = rand::rng().random_range(0..sharder.nr_shards.get());
                 Self::connection_for_shard_helper(shard, sharder.nr_shards, connections.as_slice())
             }
         })
@@ -308,7 +308,7 @@ impl NodeConnectionPool {
 
         let orig_shard = shard;
         while !shards_to_try.is_empty() {
-            let idx = rand::thread_rng().gen_range(0..shards_to_try.len());
+            let idx = rand::rng().random_range(0..shards_to_try.len());
             let shard = shards_to_try.swap_remove(idx);
 
             if let Some(conn) =
@@ -381,7 +381,7 @@ impl NodeConnectionPool {
         } else if v.len() == 1 {
             Some(v[0].clone())
         } else {
-            let idx = rand::thread_rng().gen_range(0..v.len());
+            let idx = rand::rng().random_range(0..v.len());
             Some(v[idx].clone())
         }
     }

scylla/src/policies/load_balancing/default.rs

@@ -11,7 +11,7 @@ use crate::{
     routing::{Shard, Token},
 };
 use itertools::{Either, Itertools};
-use rand::{prelude::SliceRandom, thread_rng, Rng};
+use rand::{prelude::SliceRandom, rng, Rng};
 use rand_pcg::Pcg32;
 use scylla_cql::frame::response::result::TableSpec;
 use scylla_cql::frame::types::SerialConsistency;
@@ -815,7 +815,7 @@ impl DefaultPolicy {
             let mut gen = Pcg32::new(fixed, 0);
             replica_set.choose_filtered(&mut gen, |(node, shard)| predicate(node, *shard))
         } else {
-            replica_set.choose_filtered(&mut thread_rng(), |(node, shard)| predicate(node, *shard))
+            replica_set.choose_filtered(&mut rng(), |(node, shard)| predicate(node, *shard))
         }
     }
 
@@ -853,7 +853,7 @@ impl DefaultPolicy {
         // Create a randomly rotated slice view
         let nodes_len = nodes.len();
         if nodes_len > 0 {
-            let index = rand::thread_rng().gen_range(0..nodes_len); // gen_range() panics when range is empty!
+            let index = rng().random_range(0..nodes_len); // gen_range() panics when range is empty!
             Either::Left(
                 nodes[index..]
                     .iter()
@@ -896,7 +896,7 @@ impl DefaultPolicy {
             let mut gen = Pcg32::new(fixed, 0);
             vec.shuffle(&mut gen);
         } else {
-            vec.shuffle(&mut thread_rng());
+            vec.shuffle(&mut rng());
         }
 
         vec.into_iter()

scylla/src/policies/load_balancing/plan.rs

@@ -1,4 +1,4 @@
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 use tracing::error;
 
 use super::{FallbackPlan, LoadBalancingPolicy, NodeRef, RoutingInfo};
@@ -98,7 +98,7 @@ impl<'a> Plan<'a> {
                     .sharder()
                     .map(|sharder| sharder.nr_shards.get())
                     .unwrap_or(1);
-                thread_rng().gen_range(0..nr_shards).into()
+                rng().random_range(0..nr_shards).into()
             }),
         )
     }

scylla/src/routing/locator/mod.rs

@@ -364,7 +364,7 @@ impl<'a> ReplicaSet<'a> {
     {
         let len = self.len();
         if len > 0 {
-            let index = rng.gen_range(0..len);
+            let index = rng.random_range(0..len);
 
             match &self.inner {
                 ReplicaSetInner::Plain(replicas) => replicas

scylla/src/routing/partitioner.rs

@@ -433,7 +433,7 @@ mod tests {
                 partitioner.write(data);
             } else {
                 let pivot = if !data.is_empty() {
-                    randgen.gen_range(0..data.len())
+                    randgen.random_range(0..data.len())
                 } else {
                     0
                 };

scylla/src/routing/sharding.rs

@@ -66,8 +66,8 @@ impl Sharder {
     /// Randomly choose a source port `p` such that `shard == shard_of_source_port(p)`.
     pub fn draw_source_port_for_shard(&self, shard: Shard) -> u16 {
         assert!(shard < self.nr_shards.get() as u32);
-        rand::thread_rng()
-            .gen_range((49152 + self.nr_shards.get() - 1)..(65535 - self.nr_shards.get() + 1))
+        rand::rng()
+            .random_range((49152 + self.nr_shards.get() - 1)..(65535 - self.nr_shards.get() + 1))
             / self.nr_shards.get()
             * self.nr_shards.get()
             + shard as u16