py03 sharing Juniper GraphQL request module (sharing state between dependencies)

Question

Thanks in advance to @brunorijsman for his excellent self answered example of callbacks between rust and python using py03 How to pass a Rust function as a callback to Python using pyo3, which my code is heavily influenced by.

I'm trying to interrupt a GraphQL request using callbacks to a python file which is importing from rust using py03.

I've been able to use a Mutex to store shared state, but i'm stuck at how to store or share with Juniper a callback. I'm planning to eventually await the callbacks on both sides with async and futures, but at the moment I can't find a way to make the callback in rust callable from a Juniper resolver once its been registered...

GQLwrapper rust module lib.rs:

#[macro_use]
extern crate lazy_static;
use actix_cors::Cors;
use actix_web::{
    middleware, route,
    web::{self, Data},
    App, HttpResponse, HttpServer, Responder,
};
use juniper::http::{GraphQLRequest};
use juniper::{EmptySubscription, FieldResult, RootNode, EmptyMutation};
use pyo3::prelude::*;
use std::thread;
use std::{io, sync::Arc};
mod schema;
use crate::schema::{Model, Params};
pub struct QueryRoot;

#[juniper::graphql_object]
impl QueryRoot {
    fn model<'mdl>(&self, _params: Params) -> FieldResult<Model> {
        // I WANT TO BE ABLE TO CALL THE CALLBACK HERE WITH MY GRAPHQLDATA!
        Ok(Model {
            prompt: _params.prompt.to_owned(),
        })
    }
}

type Schema = RootNode<'static, QueryRoot, EmptyMutation, EmptySubscription>;
fn create_schema() -> Schema {
    Schema::new(QueryRoot {}, EmptyMutation::new(), EmptySubscription::new())
}

/// GraphQL endpoint
#[route("/graphql", method = "GET", method = "POST")]
async fn graphql(st: web::Data<Schema>, data: web::Json<GraphQLRequest>) -> impl Responder {
    let user = data.execute(&st, &()).await;
    HttpResponse::Ok().json(user)
}

#[actix_web::main]
async fn main() -> io::Result<()> {
    std::env::set_var("RUST_LOG", "actix_web=info");
    env_logger::init();
    let schema = Arc::new(create_schema());
    HttpServer::new(move || {
        #[pyfunction]
        fn init() -> PyResult<String> {
            thread::spawn(move || main());
            Ok("GQL server started...".to_string())
        }

        #[pyclass]
        struct Callback {
            #[allow(dead_code)]
            callback_function: Box<dyn Fn(&PyAny) -> PyResult<()> + Send>,
        }

        #[pymethods]
        impl Callback {
            fn __call__(&self, python_api: &PyAny) -> PyResult<()> {
                (self.callback_function)(python_api)
            }
        }

        #[pyfunction]
        fn rust_register_callback(python_api: &PyAny) -> PyResult<()> {
            // this registers a python callback which will in turn be used to send rust_callback
            // along with a message when a request is recieved.
            Python::with_gil(|py| {
                // THIS IS THE CALLBACK I WANT TO BE ABLE TO CALL FROM THE RESOLVER...
                let callback = Box::new(Callback {
                    callback_function: Box::new(move |python_api| {
                        rust_callback(python_api)
                    }),
                });
                println!("Rust: register callback");
                python_api
                .getattr("set_response_callback")?
                .call1((callback.into_py(py),"data piped from request".to_string()))?;
                Ok(())
            })
        }

        fn rust_callback(message: &PyAny) -> PyResult<()> {
            // This callback will return a message from python and add to the GraphQL response.
            // I need to be able to ultimately await this and use it to set state that will be passed back
            println!("Rust: rust_callback");
            println!("Rust: Message={}", message);
            Ok(())
        }

        #[pymodule]
        #[pyo3(name = "GQLwrapper")]
        fn GQLwrapper(_py: Python, m: &PyModule) -> PyResult<()> {
            m.add_function(wrap_pyfunction!(init, m)?)?;
            m.add_function(wrap_pyfunction!(rust_register_callback, m)?)?;
            m.add_class::<Callback>()?;
            Ok(())
        }
        App::new()
            .app_data(Data::from(schema.clone()))
            .service(graphql)
            .wrap(Cors::permissive())
            .wrap(middleware::Logger::default())
    })
    .workers(2)
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Python main.py:

from lib.wrapper import graphql_wrapper
import time

def runner():
    print("Python: doing some work")
    graphql_wrapper.call_response_callback()

graphql_wrapper.set_fn_to_call(runner)
time.sleep(5000)

python wrapper.py:

import GQLwrapper

class PythonApi:

    def __init__(self):
        self.response_callback = None
        self.python_callback = None
        GQLwrapper.init()
    def set_response_callback(self, callback, data):
        self.response_callback = callback
        print(f'Python: Message={data}')
        self.python_callback()
    def call_response_callback(self):
        assert self.response_callback is not None
        self.response_callback("data to add back into response")
    def set_fn_to_call(self, callback):
        self.python_callback = callback
        GQLwrapper.rust_register_callback(self)

graphql_wrapper = PythonApi()

py03 sharing Juniper GraphQL request module (sharing state between dependencies)

0 Answers0