Exceptions

Author: joehoyle

src/lib.rs

@@ -12,6 +12,10 @@ use std::collections::HashMap;
 mod runtime;
 
 pub use crate::runtime::JSRuntime;
+pub use crate::runtime::Error as RuntimeError;
+
+static mut V8JSTIMELIMITEXCEPTION_EXCEPTION: Option<&'static ClassEntry> = None;
+static mut V8JSMEMORYLIMITEXCEPTION_EXCEPTION: Option<&'static ClassEntry> = None;
 
 pub fn zval_from_jsvalue(result: v8::Local<v8::Value>, scope: &mut v8::HandleScope) -> Zval {
     if result.is_string() {
@@ -207,7 +211,17 @@ impl V8Js {
                     Ok(zval)
                 }
             },
-            _ => Err(PhpException::default(String::from("Exception"))),
+            Err(e) => {
+                match e {
+                    RuntimeError::ExecutionTimeout => {
+                        Err(PhpException::new("".into(), 0, unsafe{ V8JSTIMELIMITEXCEPTION_EXCEPTION.unwrap() } ))
+                    },
+                    RuntimeError::MemoryLimitExceeded => {
+                        Err(PhpException::new("".into(), 0, unsafe{ V8JSMEMORYLIMITEXCEPTION_EXCEPTION.unwrap() } ))
+                    },
+                    _ => Err(PhpException::default(String::from("Exception")))
+                }
+            }
         }
     }
 
@@ -447,6 +461,22 @@ pub extern "C" fn php_module_info(_module: *mut ModuleEntry) {
     info_table_end!();
 }
 
+
+#[php_startup]
+pub fn startup() {
+    let ce = ClassBuilder::new("V8JsTimeLimitException")
+        .extends(ce::exception())
+        .build()
+        .expect("Failed to build V8JsTimeLimitException");
+    unsafe { V8JSTIMELIMITEXCEPTION_EXCEPTION.replace(ce) };
+
+    let ce = ClassBuilder::new("V8JsMemoryLimitException")
+        .extends(ce::exception())
+        .build()
+        .expect("Failed to build V8JsMemoryLimitException");
+    unsafe { V8JSMEMORYLIMITEXCEPTION_EXCEPTION.replace(ce) };
+}
+
 #[php_module]
 pub fn get_module(module: ModuleBuilder) -> ModuleBuilder {
     module.info_function(php_module_info)
@@ -526,6 +556,16 @@ mod integration {
         run_php("commonjs_modules.php");
     }
 
+    #[test]
+    fn time_limit() {
+        run_php("time_limit.php");
+    }
+
+    #[test]
+    fn memory_limit() {
+        run_php("memory_limit.php");
+    }
+
     #[test]
     fn v8js_version() {
         run_php("version.php");

src/runtime.rs

@@ -168,7 +168,6 @@ impl JSRuntime {
         // If we have time / memory limits, we have to spawn a monitoring thread
         // to periodically check the run time / memory usage of V8.
         if memory_limit.is_some() || time_limit.is_some() {
-            println!("checking limit");
             std::thread::spawn({
                 let should_i_stop = stop_flag.clone();
                 let time_limit_hit = time_limit_hit.clone();
@@ -179,7 +178,6 @@ impl JSRuntime {
                 static MEMORY_LIMIT_HIT_CALLBACK: std::sync::atomic::AtomicBool =
                     std::sync::atomic::AtomicBool::new(false);
                 move || {
-                    println!("{:#?}", time_limit);
                     // Callbacl function that is passed to V8. This is not able to catpure
                     // anythign locally, so we use a static to flag whether the memory limit is
                     // hit. The c_void pointer called in to the callback is used to pass the
@@ -194,9 +192,7 @@ impl JSRuntime {
                         }
                     }
                     while !should_i_stop.load(std::sync::atomic::Ordering::SeqCst) {
-                        println!("{:#?}", time_limit);
                         if time_limit.as_millis() > 0 {
-                            println!("checlig limimt");
                             if start.elapsed() > time_limit
                                 && !isolate_handle.is_execution_terminating()
                             {

tests/memory_limit.php

@@ -0,0 +1,20 @@
+<?php
+
+$v8js = new V8Js;
+$v8js->sleep = function ( int $milliseconds ) {
+    usleep( $milliseconds * 1000 );
+};
+
+$killed = null;
+$used_memory_limit_exception = false;
+try {
+    $result = $v8js->executeString( 'let my_arr = []; for ( let i = 0; i < 100000 ; i++ ) { my_arr.push( (new Date).toString() ); }; ', null, null, null, 1024 * 10 );
+    $killed = false;
+} catch ( V8JsMemoryLimitException $e ) {
+    $killed = true;
+    $used_memory_limit_exception = true;
+} catch ( Exception $e ) {
+    $killed = true;
+}
+assert( $killed === true );
+assert( $used_memory_limit_exception === true );

tests/resource_limits.php

@@ -0,0 +1,20 @@
+<?php
+
+$v8js = new V8Js;
+$v8js->sleep = function ( int $milliseconds ) {
+    usleep( $milliseconds * 1000 );
+};
+
+$killed = null;
+$used_time_limit_exception = false;
+try {
+    $result = $v8js->executeString( 'for ( let i = 0; i < 100 ; i++ ) { PHP.sleep(100); }; "done"', null, null, 100 );
+    $killed = false;
+} catch( V8JsTimeLimitException ) {
+    $killed = true;
+    $used_time_limit_exception = true;
+} catch ( Exception $e ) {
+    $killed = true;
+}
+assert( $killed === true );
+assert( $used_time_limit_exception === true );