Callback system

[J-Cake]

Hi again, I'm still somewhat stuck on an issue I raised before, which was helpfully answered, but I've hit another roadblock.

I'm wanting to develop a plugin system which is asynchronous. I'm taking a NodeJS approach here by handling callbacks. Issue is I seem to be running into threading issues.

struct Plugin {
  lua: Arc<rlua::Lua>
}

impl Plugin {
  fn new() {
    Arc::clone(&self.lua).context(|ctx| {
      let lua = Arc::clone(&self.lua);
      ctx.globals().set("do_async_operation", ctx.create_function(|_, (callback,): (rlua::Function,)| {
        lua.context(|ctx| callback.call(()).unwrap());
      }
    }).unwrap());
  }
}

do_async_operation(function ()
  print("[Lua] Async Operation Successful")
end)

But I seem to be getting thread-safety errors:

• error[E0277]: *mut rlua_lua54_sys::bindings::lua_State cannot be shared between threads safely
• error[E0277]: UnsafeCell<()> cannot be shared between threads safely

To summarise:

1. I've got a system which exposes functions which require callbacks
2. I'd like to call these callbacks asynchronously (not necessarily in a multithreaded manner)

Any pointers would be much appreciated

[jugglerchris]

Hi,
It would be useful to see which lines are causing the error messages, but, thinking aloud:

Arc<Lua> probably isn't what you want; Lua isn't Sync (i.e. it can't be shared between threads) so even if you sent the Arc<Lua> to another thread you wouldn't be allowed to use it. If you want to stay on one thread, I would use Rc<Lua> instead (or just Lua if you don't need to share it).

If you do want to share between threads (or use APIs which assume you might need to), then you probably want Arc<Mutex<Lua>>.

Chris

[J-Cake]

Hi Chris,

Although this was my setup before posting here, I thought I'd try my options, as it doesn't require mutable access to open contexts. I originally didn't use any synchronisation mechanisms at all and and saw the same behaviour

Regardless of what I did there was always these two errors and sometimes others.

Here is the offending code.

I get the feeling that doubly- or even triply-nested lambdas are somewhat of an antipattern, so any suggestions on how to get past that would be fantastic. Keeping in mind that the lambda inside the create_frame function requires multithreaded access.

Thanks so much for your help
Jake

[jugglerchris]

Hi again,

Ok, I think the problem is that you're trying to capture a reference to Lua in the closure. You don't need to (and can't) - the closure is given a Context which you can use directly:

            globals.set("create_frame", ctx.create_function(move |ctx, (options, on_create): (FrameOptions, rlua::Function)| -> rlua::Result<()> {
                // Move the `on_create` callback into the plugin registry
                let registry_key = ctx.create_registry_value(on_create).unwrap();

                // Dispatch the actual event
                sender.send((registry_key, PluginRequest::CreateFrame(options))).unwrap();

                Ok(())
            }).unwrap()).unwrap();

The above version compiles for me (with some stubs for types not in your example).

[J-Cake]

Mate have you got a sponsor link?
I'll send you a few bucks.
you're a legend

[jugglerchris]

Glad to be able to help, and thanks for the kind words!

There's https://ko-fi.com/jugglerchris if you would like, though of course it's certainly not necessary.