Introduce multiple addresses for connection

Author: farost

Cargo.lock

@@ -46,7 +46,7 @@ features = {}
 
 	[dependencies.typedb-driver]
 		features = []
-		rev = "59547fa99650030c449697b74fbc30ce63264104"
+		rev = "f1bf3d9e327344fe7a67084c13da4eb0fb5ca2be"
 		git = "https://github.com/typedb/typedb-driver"
 		default-features = false
 

Cargo.toml

@@ -13,10 +13,14 @@ def typedb_dependencies():
 
 def typedb_driver():
     # TODO: Return typedb
+#    native.local_repository(
+#        name = "typedb_driver",
+#        path = "../typedb-driver",
+#    )
     git_repository(
         name = "typedb_driver",
         remote = "https://github.com/farost/typedb-driver",
-        commit = "59547fa99650030c449697b74fbc30ce63264104",  # sync-marker: do not remove this comment, this is used for sync-dependencies by @typedb_driver
+        commit = "f1bf3d9e327344fe7a67084c13da4eb0fb5ca2be",  # sync-marker: do not remove this comment, this is used for sync-dependencies by @typedb_driver
     )
 #    git_repository(
 #        name = "typedb_driver",

dependencies/typedb/repositories.bzl

@@ -21,9 +21,27 @@ pub struct Args {
     #[arg(long, value_name = "path to script file")]
     pub script: Vec<String>,
 
-    /// TypeDB address to connect to. If using TLS encryption, this must start with "https://"
-    #[arg(long, value_name = "host:port")]
-    pub address: String,
+    /// TypeDB address to connect to (host:port). If using TLS encryption, this must start with "https://".
+    #[arg(long, value_name = "host:port", conflicts_with_all = ["addresses", "address_translation"])]
+    pub address: Option<String>,
+
+    /// A comma-separated list of TypeDB replica addresses of a single cluster to connect to.
+    #[arg(long, value_name = "host1:port1,host2:port2", conflicts_with_all = ["address", "address_translation"])]
+    pub addresses: Option<String>,
+
+    /// A comma-separated list of public=private address pairs. Public addresses are the user-facing
+    /// addresses of the replicas, and private addresses are the addresses used for the server-side
+    /// connection between replicas.
+    #[arg(long, value_name = "public=private,...", conflicts_with_all = ["address", "addresses"])]
+    pub address_translation: Option<String>,
+
+    /// If used in a cluster environment, disables attempts to redirect requests to server replicas,
+    /// limiting Console to communicate only with the single address specified in the `address`
+    /// argument.
+    /// Use for administrative / debug purposes to test a specific replica only: this option will
+    /// lower the success rate of Console's operations in production.
+    #[arg(long = "replication-disabled", default_value = "false")]
+    pub replication_disabled: bool,
 
     /// Username for authentication
     #[arg(long, value_name = "username")]
@@ -45,8 +63,8 @@ pub struct Args {
 
     /// Disable error reporting. Error reporting helps TypeDB improve by reporting
     /// errors and crashes to the development team.
-    #[arg(long = "diagnostics-disable", default_value = "false")]
-    pub diagnostics_disable: bool,
+    #[arg(long = "diagnostics-disabled", default_value = "false")]
+    pub diagnostics_disabled: bool,
 
     /// Print the Console binary version
     #[arg(long = "version")]

src/cli.rs

@@ -17,7 +17,7 @@ use std::{
     rc::Rc,
     sync::Arc,
 };
-
+use std::collections::HashMap;
 use clap::Parser;
 use home::home_dir;
 use rustyline::error::ReadlineError;
@@ -99,10 +99,11 @@ fn main() {
     if args.password.is_none() {
         args.password = Some(LineReaderHidden::new().readline(&format!("password for '{}': ", args.username)));
     }
-    if !args.diagnostics_disable {
+    if !args.diagnostics_disabled {
         init_diagnostics()
     }
-    if !args.tls_disabled && !args.address.starts_with("https:") {
+    let address_info = parse_addresses(&args);
+    if !args.tls_disabled && !address_info.only_https {
         println!(
             "\
             TLS connections can only be enabled when connecting to HTTPS endpoints, for example using 'https://<ip>:port'. \
@@ -113,10 +114,11 @@ fn main() {
     }
     let runtime = BackgroundRuntime::new();
     let tls_root_ca_path = args.tls_root_ca.as_ref().map(|value| Path::new(value));
+    let driver_options = DriverOptions::new().use_replication(!args.replication_disabled).is_tls_enabled(!args.tls_disabled).tls_root_ca(tls_root_ca_path).unwrap();
     let driver = match runtime.run(TypeDBDriver::new(
-        Addresses::try_from_address_str(args.address).unwrap(),
+        address_info.addresses,
         Credentials::new(&args.username, args.password.as_ref().unwrap()),
-        DriverOptions::new().is_tls_enabled(!args.tls_disabled).tls_root_ca(tls_root_ca_path).unwrap(),
+        driver_options,
     )) {
         Ok(driver) => Arc::new(driver),
         Err(err) => {
@@ -425,6 +427,40 @@ fn transaction_type_str(transaction_type: TransactionType) -> &'static str {
     }
 }
 
+struct AddressInfo {
+    only_https: bool,
+    addresses: Addresses,
+}
+
+fn parse_addresses(args: &Args) -> AddressInfo {
+    if let Some(address) = &args.address {
+        AddressInfo {only_https: is_https_address(address), addresses: Addresses::try_from_address_str(address).unwrap() }
+    } else if let Some(addresses) = &args.addresses {
+        let split = addresses.split(',').map(str::to_string).collect::<Vec<_>>();
+        println!("Split: {split:?}");
+        let only_https = split.iter().all(|address| is_https_address(address));
+        AddressInfo {only_https, addresses: Addresses::try_from_addresses_str(split).unwrap() }
+    } else if let Some(translation) = &args.address_translation {
+        let mut map = HashMap::new();
+        let mut only_https = true;
+        for pair in translation.split(',') {
+            let (public_address, private_address) = pair
+                .split_once('=')
+                .unwrap_or_else(|| panic!("Invalid address pair: {pair}. Must be of form public=private"));
+            only_https = only_https && is_https_address(public_address);
+            map.insert(public_address.to_string(), private_address.to_string());
+        }
+        println!("Translation map:: {map:?}");
+        AddressInfo {only_https, addresses: Addresses::try_from_translation_str(map).unwrap() }
+    } else {
+        panic!("At least one of --address, --addresses, or --address-translation must be provided.");
+    }
+}
+
+fn is_https_address(address: &str) -> bool {
+    address.starts_with("https:")
+}
+
 fn init_diagnostics() {
     let _ = sentry::init((
         DIAGNOSTICS_REPORTING_URI,