Method connect

src/sql-server-util/src/lib.rs:62–114

Connect to the specified SQL Server instance, returning a [`Client`] that can be used to query it and a [`Connection`] that must be polled to send and receive results. TODO(sql_server2): Maybe return a `ClientBuilder` here that implements IntoFuture and does the default good thing of moving the `Connection` into a tokio task? And a `.raw()` option that will instead return both the Client and Conn

(config: Config)

    /// into a tokio task? And a `.raw()` option that will instead return both
    /// the Client and Connection for manual polling.
    pub async fn connect(config: Config) -> Result<Self, SqlServerError> {
        // Setup our tunnelling and return any resources that need to be kept
        // alive for the duration of the connection.
        let (tcp, resources): (_, Option<Box<dyn Any + Send + Sync>>) = match &config.tunnel {
            TunnelConfig::Direct { resolved_addresses } => {
                let tcp = if resolved_addresses.is_empty() {
                    TcpStream::connect(config.inner.get_addr()).await
                } else {
                    TcpStream::connect(resolved_addresses.as_ref()).await
                }
                .context("direct")?;
                (tcp, None)
            }
            TunnelConfig::Ssh {
                config: ssh_config,
                manager,
                timeout,
                host,
                port,
            } => {
                // N.B. If this tunnel is dropped it will close so we need to
                // keep it alive for the duration of the connection.
                let tunnel = manager
                    .connect(ssh_config.clone(), host, *port, *timeout, config.in_task)
                    .await?;
                let tcp = TcpStream::connect(tunnel.local_addr())
                    .await
                    .context("ssh tunnel")?;

                (tcp, Some(Box::new(tunnel)))
            }
            TunnelConfig::AwsPrivatelink {
                connection_id,
                port,
            } => {
                let privatelink_host = mz_cloud_resources::vpc_endpoint_name(*connection_id);
                let tcp = TcpStream::connect((privatelink_host.as_str(), *port))
                    .await
                    .context(format!("aws privatelink {:?}", privatelink_host))?;

                (tcp, None)
            }
        };

        tcp.set_nodelay(true)?;

        let (client, connection) = Self::connect_raw(config, tcp, resources).await?;
        mz_ore::task::spawn(|| "sql-server-client-connection", async move {
            connection.await
        });

        Ok(client)
    }

    /// Create a new Client instance with the same configuration that created
    /// this configuration.