Working on example http-server.

jmjoy · jmjoy · commit 56d3429876d0 · 2021-06-05T17:52:15.000+08:00
diff --git a/examples/http-server/src/lib.rs b/examples/http-server/src/lib.rs
@@ -1,9 +1,14 @@
-use crate::{errors::make_exception_class, server::make_server_class};
+use crate::{
+    errors::make_exception_class, request::make_request_class, response::make_response_class,
+    server::make_server_class,
+};
 use phper::{modules::Module, php_get_module};
 use std::{mem::forget, sync::Arc};
 use tokio::runtime;
 
 pub mod errors;
+pub mod request;
+pub mod response;
 pub mod server;
 pub mod utils;
 
@@ -27,11 +32,12 @@ pub fn get_module() -> Module {
         forget(guard);
         true
     });
-
     module.on_module_shutdown(move |_| true);
 
     module.add_class(make_exception_class());
     module.add_class(make_server_class());
+    module.add_class(make_request_class());
+    module.add_class(make_response_class());
 
     module
 }
diff --git a/examples/http-server/src/request.rs b/examples/http-server/src/request.rs
@@ -0,0 +1,29 @@
+use crate::errors::HttpServerError;
+use phper::{
+    classes::{DynamicClass, Visibility},
+    values::Val,
+};
+
+pub const HTTP_REQUEST_CLASS_NAME: &'static str = "HttpServer\\HttpRequest";
+
+pub fn make_request_class() -> DynamicClass<()> {
+    let mut class = DynamicClass::new(HTTP_REQUEST_CLASS_NAME);
+
+    class.add_property("header", Visibility::Public, ());
+    class.add_property("server", Visibility::Public, ());
+    class.add_property("data", Visibility::Private, ());
+
+    class.add_method(
+        "getData",
+        Visibility::Public,
+        |this, _| {
+            if this.get_property("data").get_type().is_null() {
+                this.set_property("data", Val::new("Some data here"));
+            }
+            Ok::<_, HttpServerError>(this.duplicate_property("data"))
+        },
+        vec![],
+    );
+
+    class
+}
diff --git a/examples/http-server/src/response.rs b/examples/http-server/src/response.rs
@@ -0,0 +1,24 @@
+use hyper::{Body, Response};
+use phper::{
+    classes::{DynamicClass, Visibility},
+    functions::Argument,
+};
+
+pub const HTTP_RESPONSE_CLASS_NAME: &'static str = "HttpServer\\HttpResponse";
+
+pub fn make_response_class() -> DynamicClass<Response<Body>> {
+    let mut class = DynamicClass::new_with_default(HTTP_RESPONSE_CLASS_NAME);
+
+    class.add_method(
+        "end",
+        Visibility::Public,
+        |this, arguments| {
+            let response: &mut Response<Body> = this.as_mut_state();
+            *response.body_mut() = arguments[0].as_string()?.into();
+            Ok::<_, phper::Error>(())
+        },
+        vec![Argument::by_val("data")],
+    );
+
+    class
+}
diff --git a/examples/http-server/src/server.rs b/examples/http-server/src/server.rs
@@ -1,16 +1,19 @@
-use crate::errors::HttpServerError;
+use crate::{
+    errors::HttpServerError, request::HTTP_REQUEST_CLASS_NAME, response::HTTP_RESPONSE_CLASS_NAME,
+    utils::replace_and_get,
+};
 use hyper::{
     server::{conn::AddrIncoming, Builder},
     service::{make_service_fn, service_fn},
     Body, Request, Response, Server,
 };
 use phper::{
-    classes::{DynamicClass, Visibility},
+    classes::{ClassEntry, DynamicClass, StatelessClassEntry, Visibility},
     functions::Argument,
     values::Val,
 };
-use std::{convert::Infallible, mem::replace, net::SocketAddr};
-use tokio::runtime::Handle;
+use std::{convert::Infallible, mem::replace, net::SocketAddr, sync::Arc};
+use tokio::{runtime::Handle, sync::Mutex};
 
 const HTTP_SERVER_CLASS_NAME: &'static str = "HttpServer\\HttpServer";
 
@@ -52,9 +55,45 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
         Visibility::Public,
         |this, _| {
             let builder = replace(this.as_mut_state(), None).unwrap();
+            let handle = this
+                .duplicate_property("onRequestHandle")
+                .map_err(phper::Error::NotRefCountedType)?;
+            let handle = Arc::new(Mutex::new(handle));
+
+            let make_svc = make_service_fn(move |_conn| {
+                let handle = handle.clone();
+
+                async move {
+                    Ok::<_, Infallible>(service_fn(move |_: Request<Body>| {
+                        let handle = handle.clone();
+                        async move {
+                            let handle = handle.lock().await;
 
-            let make_svc =
-                make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle)) });
+                            let request =
+                                StatelessClassEntry::from_globals(HTTP_REQUEST_CLASS_NAME)
+                                    .unwrap()
+                                    .new_object([])
+                                    .unwrap();
+                            let request = Val::new(request);
+                            let mut response = ClassEntry::<Response<Body>>::from_globals(
+                                HTTP_RESPONSE_CLASS_NAME,
+                            )
+                            .unwrap()
+                            .new_object([])
+                            .unwrap();
+                            let response_val = response.duplicate();
+                            let response_val = Val::new(response_val);
+                            handle
+                                .call([request, response_val])
+                                .map_err(phper::Error::CallFunction)
+                                .unwrap();
+
+                            let response = replace_and_get(response.as_mut_state());
+                            Ok::<Response<Body>, Infallible>(response)
+                        }
+                    }))
+                }
+            });
 
             let server = builder.serve(make_svc);
             Handle::current().block_on(server)?;
@@ -66,7 +105,3 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
 
     class
 }
-
-async fn handle(_: Request<Body>) -> Result<Response<Body>, Infallible> {
-    Ok(Response::new("Hello, World!".into()))
-}
diff --git a/examples/http-server/tests/php/test.php b/examples/http-server/tests/php/test.php
@@ -8,7 +8,7 @@
 
 $server = new HttpServer("127.0.0.1", 9000);
 $server->onRequest(function ($request, $response) {
-    $response->header('Content-Type', 'text/plain');
+//     $response->header('Content-Type', 'text/plain');
     $response->end("Hello World\n");
 });
-// $server->start();
+$server->start();
diff --git a/phper-alloc/src/lib.rs b/phper-alloc/src/lib.rs
@@ -81,3 +81,5 @@ impl<T: EAllocatable> Drop for EBox<T> {
         <T>::free(self.ptr);
     }
 }
+
+unsafe impl<T: EAllocatable> Send for EBox<T> {}
diff --git a/phper/src/classes.rs b/phper/src/classes.rs
@@ -222,7 +222,7 @@ impl<T: 'static> ClassEntry<T> {
     }
 
     /// Create the object from class and call `__construct` with arguments.
-    pub fn new_object(&self, arguments: &mut [Val]) -> crate::Result<EBox<Object<T>>> {
+    pub fn new_object(&self, arguments: impl AsMut<[Val]>) -> crate::Result<EBox<Object<T>>> {
         let mut object = self.init_object()?;
         object.call_construct(arguments)?;
         Ok(object)
diff --git a/phper/src/functions.rs b/phper/src/functions.rs
@@ -238,9 +238,10 @@ impl ZendFunction {
     pub fn call_method<T: 'static>(
         &mut self,
         object: &mut Object<T>,
-        arguments: &mut [Val],
+        mut arguments: impl AsMut<[Val]>,
     ) -> crate::Result<EBox<Val>> {
         let mut ret_val = EBox::new(Val::undef());
+        let arguments = arguments.as_mut();
 
         let mut fci = zend_fcall_info {
             size: size_of::<zend_fcall_info>(),
diff --git a/phper/src/objects.rs b/phper/src/objects.rs
@@ -3,7 +3,7 @@
 use crate::{
     alloc::{EAllocatable, EBox},
     classes::ClassEntry,
-    errors::CallMethodError,
+    errors::{CallMethodError, NotRefCountedTypeError},
     functions::ZendFunction,
     sys::*,
     values::Val,
@@ -67,6 +67,17 @@ impl<T: 'static> Object<T> {
     }
 
     pub fn get_property(&self, name: impl AsRef<str>) -> &Val {
+        self.get_mut_property(name)
+    }
+
+    pub fn duplicate_property(
+        &self,
+        name: impl AsRef<str>,
+    ) -> Result<EBox<Val>, NotRefCountedTypeError> {
+        self.get_mut_property(name).duplicate()
+    }
+
+    fn get_mut_property(&self, name: impl AsRef<str>) -> &mut Val {
         let name = name.as_ref();
 
         let prop = unsafe {
@@ -194,7 +205,7 @@ impl<T: 'static> Object<T> {
         }
     }
 
-    pub(crate) fn call_construct(&mut self, arguments: &mut [Val]) -> crate::Result<bool> {
+    pub(crate) fn call_construct(&mut self, arguments: impl AsMut<[Val]>) -> crate::Result<bool> {
         unsafe {
             match (*self.inner.handlers).get_constructor {
                 Some(get_constructor) => {
diff --git a/phper/src/values.rs b/phper/src/values.rs
@@ -262,7 +262,8 @@ impl Val {
     /// # Errors
     ///
     /// Return Err when self is not callable.
-    pub fn call(&self, arguments: &[Val]) -> Result<EBox<Val>, CallFunctionError> {
+    pub fn call(&self, mut arguments: impl AsMut<[Val]>) -> Result<EBox<Val>, CallFunctionError> {
+        let arguments = arguments.as_mut();
         let mut ret = EBox::new(Val::null());
         unsafe {
             if phper_call_user_function(
@@ -271,7 +272,7 @@ impl Val {
                 self.as_ptr() as *mut _,
                 ret.as_mut_ptr(),
                 arguments.len() as u32,
-                arguments.as_ptr() as *const Val as *mut Val as *mut zval,
+                arguments.as_mut_ptr().cast(),
             ) && !ret.get_type().is_undef()
             {
                 Ok(ret)
diff --git a/tests/integration/src/functions.rs b/tests/integration/src/functions.rs
@@ -1,5 +1,4 @@
 use phper::{
-    alloc::EBox,
     arrays::Array,
     functions::{call, Argument},
     modules::Module,
@@ -22,8 +21,12 @@ pub fn integrate(module: &mut Module) {
 
     module.add_function(
         "integrate_functions_call_callable",
-        |arguments: &mut [Val]| -> phper::Result<EBox<Val>> {
-            Ok(arguments[0].call(&arguments[1..])?)
+        |arguments: &mut [Val]| {
+            if let [head, tail @ ..] = arguments {
+                Ok::<_, phper::Error>(head.call(tail)?)
+            } else {
+                unreachable!()
+            }
         },
         vec![Argument::by_val("fn")],
     );

Original file line number	Diff line number	Diff line change
`@@ -81,3 +81,5 @@ impl<T: EAllocatable> Drop for EBox<T> {`
`81`	`81`	`<T>::free(self.ptr);`
`82`	`82`	`}`
`83`	`83`	`}`
	`84`	`+`
	`85`	`+unsafe impl<T: EAllocatable> Send for EBox<T> {}`
Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ impl<T: 'static> ClassEntry<T> {`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	/// Create the object from class and call `__construct` with arguments.
`225`		`- pub fn new_object(&self, arguments: &mut [Val]) -> crate::Result<EBox<Object<T>>> {`
	`225`	`+ pub fn new_object(&self, arguments: impl AsMut<[Val]>) -> crate::Result<EBox<Object<T>>> {`
`226`	`226`	`let mut object = self.init_object()?;`
`227`	`227`	`object.call_construct(arguments)?;`
`228`	`228`	`Ok(object)`