feat(fiber): implement deferred fibers without yields

Current implementations uses the lua runtime to achieve this goal. This
is necessary due to the limitation of tarantool ffi api. We are planning
to fix this in the future by adding a single function to tarantool api.

Author: gmoshkin

hlua/hlua/src/lib.rs

@@ -125,9 +125,12 @@ pub use lua_tables::LuaTable;
 pub use lua_tables::LuaTableIterator;
 pub use tuples::TuplePushError;
 pub use userdata::UserdataOnStack;
-pub use userdata::{push_userdata, read_userdata};
+pub use userdata::{push_userdata, read_userdata, push_some_userdata};
 pub use values::StringInLua;
 
+// Needed for `lua_error` macro
+pub use ffi::luaL_error;
+
 mod any;
 mod functions_write;
 mod lua_functions;

hlua/hlua/src/macros.rs

@@ -60,3 +60,21 @@ macro_rules! implement_lua_read {
         }
     };
 }
+
+#[macro_export]
+macro_rules! c_ptr {
+    ($s:literal) => {
+        ::std::concat!($s, "\0").as_bytes().as_ptr() as *mut i8
+    };
+}
+
+#[macro_export]
+macro_rules! lua_error {
+    ($l:expr, $msg:literal) => {
+        {
+            $crate::luaL_error($l, c_ptr!($msg));
+            unreachable!()
+        }
+    }
+}
+

hlua/hlua/src/userdata.rs

@@ -13,8 +13,45 @@ use crate::{
     LuaRead,
     InsideCallback,
     LuaTable,
+    c_ptr,
 };
 
+/// Pushes `value` of type `T` onto the stack as a userdata. The value is
+/// put inside a `Option` so that it can be safely moved out of there. Useful
+/// for example when passing `FnOnce` as a c closure, because it must be dropped
+/// after the call.
+/// *[0, +1, -]*
+pub unsafe fn push_some_userdata<T>(lua: *mut ffi::lua_State, value: T) {
+    type UDBox<T> = Option<T>;
+    let ud_ptr = ffi::lua_newuserdata(lua, std::mem::size_of::<UDBox<T>>());
+    std::ptr::write(ud_ptr as *mut UDBox<T>, Some(value));
+
+    if std::mem::needs_drop::<T>() {
+        // Creating a metatable.
+        ffi::lua_newtable(lua);
+
+        // Index "__gc" in the metatable calls the object's destructor.
+        ffi::lua_pushstring(lua, c_ptr!("__gc"));
+        ffi::lua_pushcfunction(lua, wrap_gc::<T>);
+        ffi::lua_settable(lua, -3);
+
+        ffi::lua_setmetatable(lua, -2);
+    }
+
+    /// A callback for the "__gc" event. It checks if the value was moved out
+    /// and if not it drops the value.
+    unsafe extern "C" fn wrap_gc<T>(lua: *mut ffi::lua_State) -> i32 {
+        let ud_ptr = ffi::lua_touserdata(lua, 1);
+        let ud = (ud_ptr as *mut UDBox<T>)
+            .as_mut()
+            .expect("__gc called with userdata pointing to NULL");
+        drop(ud.take());
+
+        0
+    }
+}
+
+
 // Called when an object inside Lua is being dropped.
 #[inline]
 extern "C" fn destructor_wrapper<T>(lua: *mut ffi::lua_State) -> libc::c_int {

tarantool/src/error.rs

@@ -26,6 +26,7 @@ use rmp::decode::{MarkerReadError, NumValueReadError, ValueReadError};
 use rmp::encode::ValueWriteError;
 
 use crate::ffi::tarantool as ffi;
+use crate::hlua::LuaError;
 
 /// A specialized [`Result`] type for the crate
 pub type Result<T> = std::result::Result<T, Error>;
@@ -71,6 +72,9 @@ pub enum Error {
     #[cfg(feature = "net_box")]
     #[fail(display = "Sever respond with error: {}", _0)]
     Remote(crate::net_box::ResponseError),
+
+    #[fail(display = "Lua error: {}", _0)]
+    LuaError(LuaError),
 }
 
 impl From<io::Error> for Error {
@@ -142,6 +146,12 @@ impl From<crate::net_box::ResponseError> for Error {
     }
 }
 
+impl From<LuaError> for Error {
+    fn from(error: LuaError) -> Self {
+        Error::LuaError(error)
+    }
+}
+
 /// Transaction-related error cases
 #[derive(Debug, Fail)]
 pub enum TransactionError {