claviron-php-embed 0.2.0-alpha.19

Managed in-process PHP execution, application hosting, and native extensions for Claviron
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Runtime presence and immutable identity from the embedding AppState.

use std::sync::OnceLock;

use claviron_runtime::AppState;
use ext_php_rs::exception::PhpException;
use ext_php_rs::types::Zval;
use ext_php_rs::zend::{ExecuteData, SapiGlobals};

use crate::engine::{ClavironContext, PhpExecution, ProgramModel};
use crate::sapi::ServerContext;

static APP_NAME: OnceLock<Box<str>> = OnceLock::new();
static ENVIRONMENT: OnceLock<Box<str>> = OnceLock::new();
static HOST_PREPARED: OnceLock<()> = OnceLock::new();

pub(crate) fn mark_prepared() {
    let _ = HOST_PREPARED.set(());
}

pub(crate) fn configure_from_state(state: &AppState) {
    APP_NAME.get_or_init(|| state.name().into());
    ENVIRONMENT.get_or_init(|| state.environment().into());
}

/// Registered through the shared SAPI startup path in every PHP execution model.
pub(super) extern "C" fn available(
    _ex: &mut ExecuteData,
    retval: &mut Zval,
) {
    ext_php_rs::zend::run_handler(std::panic::AssertUnwindSafe(|| {
        retval.set_bool(true);
    }));
}

/// Prepared host bindings are independent from native engine presence.
pub(super) extern "C" fn configured(
    _ex: &mut ExecuteData,
    retval: &mut Zval,
) {
    ext_php_rs::zend::run_handler(std::panic::AssertUnwindSafe(|| {
        retval.set_bool(HOST_PREPARED.get().is_some());
    }));
}

/// Embedding application identity, not the PHP program or routed application name.
pub(super) extern "C" fn app_name(
    _ex: &mut ExecuteData,
    retval: &mut Zval,
) {
    ext_php_rs::zend::run_handler(std::panic::AssertUnwindSafe(|| {
        let result = APP_NAME
            .get()
            .ok_or_else(|| {
                "Claviron runtime identity is not configured".to_string()
            })
            .and_then(|name| {
                retval
                    .set_string(name, false)
                    .map_err(|error| error.to_string())
            });
        if let Err(error) = result {
            PhpException::from_message(error).throw();
        }
    }));
}

/// The environment the process runs under: `production`, `local`, or the
/// one its launch named. A worker reports its master's.
pub(super) extern "C" fn environment(
    _ex: &mut ExecuteData,
    retval: &mut Zval,
) {
    ext_php_rs::zend::run_handler(std::panic::AssertUnwindSafe(|| {
        let result = ENVIRONMENT
            .get()
            .ok_or_else(|| {
                "Claviron runtime environment is not configured".to_string()
            })
            .and_then(|environment| {
                retval
                    .set_string(environment, false)
                    .map_err(|error| error.to_string())
            });
        if let Err(error) = result {
            PhpException::from_message(error).throw();
        }
    }));
}

/// Named PHP application currently executing, or null outside that model.
pub(super) extern "C" fn application_name(
    _ex: &mut ExecuteData,
    retval: &mut Zval,
) {
    ext_php_rs::zend::run_handler(std::panic::AssertUnwindSafe(|| {
        let globals = SapiGlobals::get();
        if globals.server_context.is_null() {
            retval.set_null();
            return;
        }
        let context =
            ClavironContext::from_server_context(globals.server_context);
        match &context.execution {
            PhpExecution::Program(program)
                if program.model == ProgramModel::Application =>
            {
                if let Err(error) = retval.set_string(&program.name, false) {
                    PhpException::from_message(error.to_string()).throw();
                }
            }
            _ => retval.set_null(),
        }
    }));
}