Enable user-defined context structs for async UDFs

[jbeisen]

Define an async trait UdfContext that users can implement in their UDF definition. The struct can store shared resources used by each invocation of the UDF, like a database connection. An Arc pointer to the context is passed as the first argument to the UDF.

Here's how the example async udf from #483 can be modified to use the context:

/*
[dependencies]
tokio = { version = "1", features = ["full"] }
tokio-postgres = "0.7"
async-trait = "0.1.68"

[udfs]
async_results_ordered = true
async_max_concurrency = 10
async_timeout_seconds = 5
*/

use tokio_postgres::{NoTls, Error, Client};
use async_trait::async_trait;
use arroyo_types::UdfContext;
use std::sync::Arc;
use tokio::sync::RwLock;

pub struct Context {
    client: RwLock<Option<Client>>,
}

impl Context {
    pub fn new() -> Self {
        Self {
            client: RwLock::new(None),
        }
    }
}

#[async_trait]
impl UdfContext for Context {
    async fn init(&self) {
        let conn_str = "host=localhost user=arroyo password=arroyo dbname=my_db";

        let (client, connection) = tokio_postgres::connect(conn_str, NoTls).await.unwrap();

        let mut c = self.client.write().await;
        *c = Some(client);

        tokio::spawn(async move {
            if let Err(e) = connection.await {
                println!("connection error: {}", e);
            }
        });
    }
}

pub async fn user_name_from_id(context: Arc<Context>, id: i64) -> String {
    let client = context.client.read().await;
    let rows = client
        .as_ref()
        .unwrap()
        .query("SELECT name FROM users WHERE id = $1", &[&id])
        .await
        .unwrap();

    return if let Some(row) = rows.get(0) {
        row.get(0)
    } else {
        format!("Unknown-{}", id)
    };
}

Note that the struct that implements UdfContext must be called Context. I considered making this flexible but didn't think of a good reason to do so.