Unsafe Cells and Multithreading

[FaunuX]

I need some way to pass an &PyAny into a thread. While I understand that it is unsafe, I can clone the PyAny for each thread. How can I do this? Sorry if this isn't the right place for such a question.

Here is my code

lib.rs

use std::sync::{ Arc, Mutex };

use pyo3::prelude::*; 
use pyo3::types::PyType; 

mod net;
use net::run;

mod http;
use http::{Request, Response};

#[pyfunction]
fn serve<'a>(py: Python<'a>, port: u16, app: &'a PyAny) -> PyResult<&'a PyAny> {
    let class: &PyType = app.get_type();
    py.allow_threads(
        pyo3_asyncio::tokio::future_into_py(py, async move {
            run(&port, |req: Request| { 
                println!("{:?}", class); 
                Response {
                    status_code: 200,
                    reason: "OK".to_string(),
                    content_type: "application/json".to_string(),
                    body: "{}".to_string(),
                }
            }).await?;
            Ok(Python::with_gil(|py| py.None()))
        })
    )
}

#[pymodule]
#[pyo3(name="granola")]
fn granola(py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(serve, m)?)?;
    Ok(())
}

net.rs

use pyo3::prelude::*; 

use crate::http;

use std::convert::Infallible;
use std::net::SocketAddr;

use http_body_util::Full;
use hyper::body::Bytes;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use tokio::net::TcpListener;

pub async fn run<F>(port: &u16, app: F) -> PyResult<()> 
    where
        F: FnOnce(http::Request) -> http::Response {
    async fn hello(_: Request<hyper::body::Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
        Ok(Response::new(Full::new(Bytes::from("Hello, World!"))))
    }
    let addr = SocketAddr::from(([127, 0, 0, 1], port.to_owned()));

    let listener = TcpListener::bind(addr).await?;

    loop {
        let (stream, _) = listener.accept().await?;

        tokio::task::spawn(async move {
            if let Err(err) = http1::Builder::new()
                .serve_connection(stream, service_fn(hello))
                    .await
                    {
                        println!("Error serving connection: {:?}", err);
                    }
        });
    }
}

I really don't know what to do, any help would be greatly appreciated.

[adamreichold]

So for the short and possibly wrong answer but I am pressed on time right now: Generally, if you want to store &PyAny for a indefinite amount of time or pass it to other threads, you need to turn it into Py<PyAny> a.k.a. PyObject which is Send + Sync using e.g. the ToPyObject or IntoPy traits.

[FaunuX]

But I was hoping to be able to call methods and such. Is this impossible?

[davidhewitt]

You can use Py::as_ref to associate the Py<PyAny> with a Python thread and get a &PyAny to call all the normal methods on.