Struct aws_smithy_http_server_python::PyApp

pub struct PyApp {
    pub handlers: PyHandlers,
    pub context: Option<Arc<PyObject>>,
    pub workers: Mutex<Vec<PyObject>>,
    pub router: Option<PyRouter>,
}

Python application definition, holding the handlers map, the optional Python context object, the list of workers and the PyRouter.

Fields

handlers: PyHandlers

context: Option<Arc<PyObject>>

workers: Mutex<Vec<PyObject>>

router: Option<PyRouter>

Implementations

impl PyApp

pub fn context(&mut self, _py: Python<'_>, context: PyObject)

Register a new context object inside the Rust state.

pub fn start_worker(
    &mut self,
    py: Python<'_>,
    socket: &PyCell<PySocket>,
    worker_number: isize
) -> PyResult<()>

Start a single worker with its own Tokio and Python async runtime and provided shared socket.

Python asynchronous loop needs to be started and handled during the lifetime of the process. First of all we install uvloop as the main Python event loop. Thanks to libuv, uvloop performs ~20% better than Python standard event loop in most benchmarks, while being 100% compatible. We retrieve the Python context object, if setup by the user calling PyApp::context method, generate the PyState structure and build the aws_smithy_http_server::Router, filling it with the functions generated by PythonServerOperationHandlerGenerator.kt. At last we get a cloned reference to the underlying socket2::Socket.

Now that all the setup is done, we can start the two runtimes and run the hyper server. We spawn a thread with a new tokio::runtime, setup the middlewares and finally block the thread on hyper::serve. The main process continues and at the end it is blocked on Python loop.run_forever().

pub fn register_operation(
    &mut self,
    py: Python<'_>,
    name: &str,
    func: PyObject
) -> PyResult<()>

Register a new operation in the handlers map.

The operation registered in the map are used inside the code-generated router() method and passed to the aws_smithy_http_server::Router as part of the operation handlers call.

pub fn run(
    &mut self,
    py: Python<'_>,
    address: Option<String>,
    port: Option<i32>,
    backlog: Option<i32>,
    workers: Option<usize>
) -> PyResult<()>

Main entrypoint: start the server on multiple workers.

The multiprocessing server is achieved using the ability of a Python interpreter to clone and start itself as a new process. The shared sockets is created and Using the multiprocessing::Process module, multiple workers with the method self.start_worker() as target are started.

Trait Implementations

impl Clone for PyApp

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PyApp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PyApp

fn default() -> PyApp

Returns the “default value” for a type.

impl IntoPy<Py<PyAny>> for PyApp

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for PyApp

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

impl PyClassImpl for PyApp

const DOC: &'static str = _

Class doc string

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

type Layout = PyCell<PyApp>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<PyApp>

This handles following two situations:

fn for_all_items(visitor: &mut dyn FnMut(&PyClassItems))

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyMethods<PyApp> for PyClassImplCollector<PyApp>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyApp

type AsRefTarget = PyCell<PyApp>

Utility type to make Py::as_ref work.

const NAME: &'static str = _

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

PyTypeObject instance for this type.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.