validator: adjust services IPs to support multiple VS nodes

Move ScyllaDB nodes IP last octets from 2-254 to 1-127.
Move Vector Store node IP last octets from 1 to 128-254.
This setup supports adding more ScyllaDB and Vector Store
nodes in testing if needed.

Changed `VS_NAME` to a list of available DNS names for Vector Store
nodes. Now the names are `vs1`, `vs2`, `vs3`, and more if needed.

Renamed `get_default_vs_url` function to `get_default_vs_urls`
and adjusted it to return URLs of three default Vector Store nodes.

Added `get_default_vs_ips` function to return vector of three
default Vector Store node IPs (not to confuse with DNS names).

Adjusted `get_default_node_configs` so that now the default nodes
does support one primary Vector Store node and two secondary ones.

Author: QuerthDP

crates/validator-tests/src/common.rs

@@ -26,23 +26,32 @@ pub use vector_store::httproutes::IndexStatus;
 
 pub const DEFAULT_TEST_TIMEOUT: Duration = Duration::from_secs(120);
 
-pub const VS_NAME: &str = "vs";
+pub const VS_NAMES: [&str; 3] = ["vs1", "vs2", "vs3"];
 
 pub const VS_PORT: u16 = 6080;
 pub const DB_PORT: u16 = 9042;
 
-pub const VS_OCTET: u8 = 1;
-pub const DB_OCTET_1: u8 = 2;
-pub const DB_OCTET_2: u8 = 3;
-pub const DB_OCTET_3: u8 = 4;
-
-pub async fn get_default_vs_url(actors: &TestActors) -> String {
-    format!(
-        "http://{}.{}:{}",
-        VS_NAME,
-        actors.dns.domain().await,
-        VS_PORT
-    )
+pub const DB_OCTET_1: u8 = 1;
+pub const DB_OCTET_2: u8 = 2;
+pub const DB_OCTET_3: u8 = 3;
+pub const VS_OCTET_1: u8 = 128;
+pub const VS_OCTET_2: u8 = 129;
+pub const VS_OCTET_3: u8 = 130;
+
+pub async fn get_default_vs_urls(actors: &TestActors) -> Vec<String> {
+    let domain = actors.dns.domain().await;
+    VS_NAMES
+        .iter()
+        .map(|name| format!("http://{}.{}:{}", name, domain, VS_PORT))
+        .collect()
+}
+
+pub fn get_default_vs_ips(actors: &TestActors) -> Vec<Ipv4Addr> {
+    vec![
+        actors.services_subnet.ip(VS_OCTET_1),
+        actors.services_subnet.ip(VS_OCTET_2),
+        actors.services_subnet.ip(VS_OCTET_3),
+    ]
 }
 
 pub fn get_default_db_ips(actors: &TestActors) -> Vec<Ipv4Addr> {
@@ -54,23 +63,28 @@ pub fn get_default_db_ips(actors: &TestActors) -> Vec<Ipv4Addr> {
 }
 
 pub async fn get_default_node_configs(actors: &TestActors) -> Vec<ScyllaNodeConfig> {
-    let vs_url = get_default_vs_url(actors).await;
+    let vs_urls = get_default_vs_urls(actors).await;
     get_default_db_ips(actors)
         .iter()
-        .map(|&ip| ScyllaNodeConfig {
-            db_ip: ip,
-            primary_vs_uris: vec![vs_url.clone()],
-            secondary_vs_uris: vec![],
+        .enumerate()
+        .map(|(i, &ip)| {
+            let mut vs_urls = vs_urls.clone();
+            ScyllaNodeConfig {
+                db_ip: ip,
+                primary_vs_uris: vec![vs_urls.remove(i)],
+                secondary_vs_uris: vs_urls,
+            }
         })
         .collect()
 }
 
 pub async fn init(actors: TestActors) {
     info!("started");
 
-    let vs_ip = actors.services_subnet.ip(VS_OCTET);
-
-    actors.dns.upsert(VS_NAME.to_string(), vs_ip).await;
+    let vs_ips = get_default_vs_ips(&actors);
+    for (name, ip) in VS_NAMES.iter().zip(vs_ips.iter()) {
+        actors.dns.upsert(name.to_string(), *ip).await;
+    }
 
     let node_configs: Vec<ScyllaNodeConfig> = get_default_node_configs(&actors).await;
     let db_ip = node_configs.first().unwrap().db_ip; // Use the first DB node for vector store connection
@@ -80,7 +94,7 @@ pub async fn init(actors: TestActors) {
     actors
         .vs
         .start(
-            (vs_ip, VS_PORT).into(),
+            (vs_ips[0], VS_PORT).into(),
             (db_ip, DB_PORT).into(),
             HashMap::new(),
         )
@@ -92,7 +106,9 @@ pub async fn init(actors: TestActors) {
 
 pub async fn cleanup(actors: TestActors) {
     info!("started");
-    actors.dns.remove(VS_NAME.to_string()).await;
+    for name in VS_NAMES.iter() {
+        actors.dns.remove(name.to_string()).await;
+    }
     actors.vs.stop().await;
     actors.db.stop().await;
     info!("finished");
@@ -106,7 +122,7 @@ pub async fn prepare_connection(actors: &TestActors) -> (Arc<Session>, HttpClien
             .await
             .expect("failed to create session"),
     );
-    let client = HttpClient::new((actors.services_subnet.ip(VS_OCTET), VS_PORT).into());
+    let client = HttpClient::new((actors.services_subnet.ip(VS_OCTET_1), VS_PORT).into());
     (session, client)
 }
 

crates/validator-vector-store/src/high_availability.rs

@@ -19,10 +19,11 @@ pub(crate) async fn new() -> TestCase {
 }
 
 async fn init_one_primary_two_secondary(actors: TestActors) {
-    let vs_ip = actors.services_subnet.ip(VS_OCTET);
-    actors.dns.upsert(VS_NAME.to_string(), vs_ip).await;
+    let vs_ip = actors.services_subnet.ip(VS_OCTET_1);
+    actors.dns.upsert(VS_NAMES[0].to_string(), vs_ip).await;
 
-    let vs_url = get_default_vs_url(&actors).await;
+    let vs_urls = get_default_vs_urls(&actors).await;
+    let vs_url = &vs_urls[0];
 
     let node_configs: Vec<ScyllaNodeConfig> = vec![
         ScyllaNodeConfig {

crates/validator-vector-store/src/memory_limit.rs

@@ -35,8 +35,11 @@ async fn memory_limit_during_index_build(actors: TestActors) {
     info!("started");
 
     // Start DB
-    let vs_ip = actors.services_subnet.ip(common::VS_OCTET);
-    actors.dns.upsert(common::VS_NAME.to_string(), vs_ip).await;
+    let vs_ip = actors.services_subnet.ip(common::VS_OCTET_1);
+    actors
+        .dns
+        .upsert(common::VS_NAMES[0].to_string(), vs_ip)
+        .await;
     let node_configs = common::get_default_node_configs(&actors).await;
     let db_ip = node_configs.first().unwrap().db_ip;
     actors.db.start(node_configs.clone(), None).await;
@@ -104,8 +107,13 @@ async fn memory_limit_during_index_build(actors: TestActors) {
     assert!(actors.vs.wait_for_ready().await);
 
     // Create index
-    let client =
-        HttpClient::new((actors.services_subnet.ip(common::VS_OCTET), common::VS_PORT).into());
+    let client = HttpClient::new(
+        (
+            actors.services_subnet.ip(common::VS_OCTET_1),
+            common::VS_PORT,
+        )
+            .into(),
+    );
 
     let index = common::create_index(&session, &client, &table, "v").await;