Add hint when authentication fails, rv interactive

src/connect.rs

@@ -8,7 +8,7 @@
 use tokio::time::sleep;
 use tokio_stream::Stream;
 
-use edgedb_errors::{Error, ErrorKind, ResultExt};
+use edgedb_errors::{Error, ErrorKind, ResultExt, AuthenticationError};
 use edgedb_errors::{NoDataError, ProtocolEncodingError, ClientError};
 use edgedb_protocol::QueryResult;
 use edgedb_protocol::client_message::{State, CompilationOptions};
@@ -151,18 +151,14 @@
         self
     }
     pub async fn connect(&self) -> Result<Connection, anyhow::Error> {
-        self._connect(false).await
+        self._connect().await
     }
 
-    pub async fn connect_interactive(&self) -> Result<Connection, anyhow::Error> {
-        self._connect(true).await
-    }
-
-    async fn _connect(&self, interactive: bool) -> Result<Connection, anyhow::Error> {
+    async fn _connect(&self) -> Result<Connection, anyhow::Error> {
         let cfg = self.config.as_ref().map_err(Clone::clone)?;
         let conn = tokio::select!(
             conn = Connection::connect(&cfg) => conn?,
-            _ = self.print_warning(cfg, interactive) => unreachable!(),
+            _ = self.print_warning(cfg) => unreachable!(),
         );
         Ok(conn)
     }
@@ -176,19 +172,20 @@
             _ =>
                 format!("EdgeDB instance at {}", cfg.display_addr())
         };
-        format!("Connecting to {}...", desc)
+        let wait = cfg.wait_until_available();
+        let wait_msg = match wait.as_secs() {
+            seconds if seconds < 1 => format!("{}ms", wait.as_millis()),
+            seconds => format!("{seconds}s")
+        };
+        format!("Connecting to {desc} (will try up to {wait_msg})...")
     }
 
-    async fn print_warning(&self, cfg: &Config, interactive: bool)
+    async fn print_warning(&self, cfg: &Config)
         -> Result<Connection, Error>
     {
         sleep(Duration::new(1, 0)).await;
         let msg = self.warning_msg(cfg);
-        if interactive {
-            eprint!("{}", msg);
-        } else {
-            eprintln!("{}", msg);
-        }
+        eprintln!("{}", msg);
         pending().await
     }
     pub fn get(&self) -> anyhow::Result<&Config, ArcError> {
@@ -198,8 +195,20 @@
 
 impl Connection {
     pub async fn connect(cfg: &Config) -> Result<Connection, Error> {
+        let connection = match raw::Connection::connect(&cfg).await {
+            Ok(conn) => conn,
+            Err(err) => {
+                if err.is::<AuthenticationError>() {
+                    eprintln!("Failed to authenticate.\
+                        \nHint: Use `edgedb info` to find and check the config for this instance");
+                    return Err(err)
+                } else {
+                    return Err(err)
+                }
+            }
+        };
         Ok(Connection {
-            inner: raw::Connection::connect(&cfg).await?,
+            inner: connection,
             state: State::empty(),
             server_version: None,
             config: cfg.clone(),

src/options.rs

@@ -647,7 +647,10 @@ impl Options {
                 }
             );
 
+        let extra_help = "Hint: Setting RUST_LOG to `info`, `debug`, or `trace` can provide extra debugging info when encountering an issue.\n";
+
         let app = clap::Command::new("edgedb")
+                    .after_help(extra_help)
                     .term_width(term_width())
                     .args(deglobalized);
 

src/repl.rs

@@ -155,7 +155,7 @@ impl State {
     pub async fn try_connect(&mut self, database: &str) -> anyhow::Result<()> {
         let mut params = self.conn_params.clone();
         params.database(database)?;
-        let mut conn = params.connect_interactive().await?;
+        let mut conn = params.connect().await?;
         let fetched_version = conn.get_version().await?;
         if self.last_version.as_ref() != Some(&fetched_version) {
             self.print_banner(&fetched_version)?;