Method on_startup

crates/pg/src/pg_server.rs:217–311

(&self, client: &mut C, message: PgWireFrontendMessage)

    for PgSpacetimeDB<T>
{
    async fn on_startup<C>(&self, client: &mut C, message: PgWireFrontendMessage) -> PgWireResult<()>
    where
        C: ClientInfo + Sink<PgWireBackendMessage> + Unpin + Send,
        C::Error: Debug,
        PgWireError: From<<C as Sink<PgWireBackendMessage>>::Error>,
    {
        match message {
            PgWireFrontendMessage::Startup(ref startup) => {
                protocol_negotiation(client, startup).await?;
                save_startup_parameters_to_metadata(client, startup);
                client.set_state(PgWireConnectionState::AuthenticationInProgress);

                let login_info = LoginInfo::from_client_info(client);

                if login_info.database().is_none() {
                    return Err(PgError::DatabaseNameRequired.into());
                }

                client
                    .send(PgWireBackendMessage::Authentication(Authentication::CleartextPassword))
                    .await?;
            }
            PgWireFrontendMessage::PasswordMessageFamily(pwd) => {
                let params = client.metadata();
                let param = |param: &str| {
                    params
                        .get(param)
                        .map(String::from)
                        .ok_or_else(|| PgError::MetadataError(anyhow::anyhow!("Missing parameter: {param}")))
                };

                // We don't support `METADATA_USER` because we don't have a user management system.
                let database = param(METADATA_DATABASE)?;
                let pwd = pwd.into_password()?;
                match param("application_name") {
                    Ok(application_name) => {
                        log::info!("PG: Connecting to database: {database}, by {application_name}",);
                    }
                    _ => {
                        log::info!("PG: Connecting to database: {database}");
                    }
                }

                let name = database::NameOrIdentity::Name(DatabaseName(database.clone()));
                match response(name.resolve(&self.ctx).await, &database).await {
                    Ok(identity) => identity,
                    Err(PgError::Pg(PgWireError::UserError(err))) => {
                        return close_client(client, *err).await;
                    }
                    Err(err) => {
                        return Err(err.into());
                    }
                };

                let claims = match validate_token(&self.ctx, &pwd.password).await {
                    Ok(claims) => claims,
                    Err(err) => {
                        log::error!(