Deno通过V8和Rust的数据传递

叁歲伎倆 2022-09-02 12:51 197阅读 0赞

## 题外话 ##

这几天终于能放下一些事情，回头来关注一下Deno，打开Deno目录，git pull一下，突然有点小惊喜，那一大坨C++ binding相关的东西被移除了，感觉整个Deno目录整洁了许多，再仔细瞧瞧，发现整个项目的目录重构后，也比原来理解起来也轻松多了。Rust中使用V8，避免不了使用C++，那么V8和C++那一部分到哪儿去了呢？

答案是:

[denoland/rusty\_v8github.com/denoland/rusty\_v8][denoland_rusty_v8_github.com_denoland_rusty_v8]

![20c3c09806ebcf424109c73a28fbb007.png][]

打开rusty\_*v8的目录，可以熟悉的看到[http://binding.cc][http_binding.cc]这个文件，这个rust的crate算是对原来Deno中V8 binding部分的提炼和封装。rusty\_*v8的出现对于Deno和Rust社区无疑都是好事儿。

[https://github.com/denoland/rusty\_v8/blob/master/src/binding.cc\#L6github.com/denoland/rusty\_v8/blob/master/src/binding.cc\#L6][https_github.com_denoland_rusty_v8_blob_master_src_binding.cc_L6_github.com_denoland_rusty_v8_blob_master_src_binding.cc_L6]

胡扯了一通，还是回到这篇文章的正题《Deno通过V8和Rust的数据传递》。

## 一、函数的注册 ##

重新来看Deno的函数绑定，没有太大的变化，只是改为在Rusty\_v8的API基础上去进行封装了。抄段代码就能一下看明白了。send和recv等方法的作用基本没变，都是binding到V8的scope上，提供给JavaScript调用，在某种程度上可以和JsBridge做个类比。变化的只是由原来的C++代码改为了Rust代码。

let mut recv_tmpl = v8::FunctionTemplate::new(scope, recv);
     let recv_val = recv_tmpl.get_function(scope, context).unwrap();
      core_val.set(
        context,
        v8::String::new(scope, "recv").unwrap().into(),
        recv_val.into(),
      );
    
     let mut send_tmpl = v8::FunctionTemplate::new(scope, send);
     let send_val = send_tmpl.get_function(scope, context).unwrap();
      core_val.set(
        context,
        v8::String::new(scope, "send").unwrap().into(),
        send_val.into(),
      );

详细列举一下Deno中绑定的对象：

***Deno***

v8::String::new(scope, "Deno").unwrap().into(),

***core***

v8::String::new(scope, "core").unwrap().into(),

***print***

v8::String::new(scope, "print").unwrap().into(),

***recv***

v8::String::new(scope, "recv").unwrap().into(),

以及send、evalContext、errorToJSON、shared等。

## 二、shared\_queue.js中封装通信接口 ##

*shared\_queue.js*中封装了JavaScript和Deno传递数据的函数。

### *1.shared\_queue.js*加载时机 ###

shared\_queue.js是在Deno执行业务JavaScript代码（此处业务JavaScript代码是指基于*Deno*这个运行时编写的逻辑代码）之前去执行的。文字有点拗口，上一段代码，估计就清晰了。

在Rust中，执行shared\_*queue.js的代码封装在名为shared\_init*的方法方法中的。

pub(crate) fn shared_init(&mut self) {
     if self.needs_init {
     self.needs_init = false;
     js_check(
     self.execute("shared_queue.js", include_str!("shared_queue.js")),
          );
     // Maybe execute the startup script.
     if let Some(s) = self.startup_script.take() {
     self.execute(&s.filename, &s.source).unwrap()
          }
        }
      }

在执行业务*JavaScript*代码时，会去调用内部的*execute*方法（该方法的具体代码见下文），*execute*方法中的第一行即是调用shared\_*init*方法去加载*shared\_queue.js。*

pub fn execute(
        &mut self,
        js_filename: &str,
        js_source: &str,
      ) -> Result<(), ErrBox> {
     self.shared_init();
     let isolate = self.v8_isolate.as_ref().unwrap();
     let mut locker = v8::Locker::new(isolate);
     assert!(!self.global_context.is_empty());
     let mut hs = v8::HandleScope::new(&mut locker);
     let s = hs.enter();
     let mut context = self.global_context.get(s).unwrap();
        context.enter();
     let source = v8::String::new(s, js_source).unwrap();
     let name = v8::String::new(s, js_filename).unwrap();
     let mut try_catch = v8::TryCatch::new(s);
     let tc = try_catch.enter();
     let origin = bindings::script_origin(s, name);
     let mut script =
          v8::Script::compile(s, context, source, Some(&origin)).unwrap();
     let result = script.run(s, context);
     if result.is_none() {
     assert!(tc.has_caught());
     let exception = tc.exception().unwrap();
     self.handle_exception(s, context, exception);
        }
        context.exit();
     self.check_last_exception()
      }

### *2.shared\_queue.js*内部逻辑 ###

文件内部是一个自执行函数，同时传入this作为参数。形式如下：

(function() {
    ...
    })(this)

传入的this为全局上下文，类似于浏览器中的window。

接下来列举自执行函数内部的几个重点部分。

重点一：dispatch方法，基于binding的send方法去实现，用于JavaScript调用Rust函数。

function dispatch(opId, control, zeroCopy = null) {
     return Deno.core.send(opId, control, zeroCopy);
    }

重点二：handleAsyncMsgFromRust方法，该方法的作用可以简单理解为回调。在Rust执行完异步任务后，通过该方法通知V8上下文中等待的异步代码继续往下执行。

下面通过Deno打开文件的一段逻辑来举例说明一下。

let filename = Deno.args[i];
    let file = await Deno.open(filename);
    ...

如上所示，在执行到open方法时，会通过Rust起一个异步的Worker去执行打开文件的逻辑，open方法会返回一个pending状态的Promise，所以会停止执行open方法后面的逻辑。当Rust执行完打开文件的操作后，会调用handleAsyncMsgFromRust并传入opId等参数。通过opId查找到Deno.open返回的Promise，将其状态置为*fulfilled，*在*Promise*状态修改后，会继续执行Open方法后面的逻辑。**在理解上需要注意的是Rust调用handleAsyncMsgFromRust后，后续的执行逻辑就切回到V8上下文了。**

这里还有个问题没解释清楚，Rust是如何可以调用V8中的handleAsyncMsgFromRust函数的呢？答案是在初始化*shared\_queue.js*时*，*会通过binding的recv方法把*handleAsyncMsgFromRust*函数传给*Rust*。

Deno.core.recv(handleAsyncMsgFromRust);

重点三：在*shared\_queue.js*封装的方法是通过复制给core对象作为基础Api给其它代码使用的。

const Deno = window[GLOBAL_NAMESPACE];
    const core = Deno[CORE_NAMESPACE];
    ...
    const denoCore = {
     setAsyncHandler,
     dispatch,
     sharedQueue: {
     MAX_RECORDS,
     head,
     numRecords,
     size,
     push,
     reset,
     shift
        },
     ops
      };
    ...
     Object.assign(core, denoCore);

在其它模块可以基于dispatch去封装Rust调用逻辑。

const resUi8 = core.dispatch(opId, argsUi8, zeroCopy);

## 三、传递数据的格式 ##

JavaScript调用Rust函数，或是Rust调用JavaScript函数，传参数都是基于`Uint8Array`格式的。 JavaScript中可以通过TextEncoder实现JSON和Uint8Array之间的转换。

const s = JSON.stringify(args);
    new TextEncoder().encode(s);
    
    const s = new TextDecoder().decode(ui8);
    JSON.parse(s) as JsonResponse;

[denoland_rusty_v8_github.com_denoland_rusty_v8]: https://link.zhihu.com/?target=https%3A//github.com/denoland/rusty_v8
[20c3c09806ebcf424109c73a28fbb007.png]: /images/20220829/5c4961f6695949ecace964d64fdb0386.png
[http_binding.cc]: https://link.zhihu.com/?target=http%3A//binding.cc
[https_github.com_denoland_rusty_v8_blob_master_src_binding.cc_L6_github.com_denoland_rusty_v8_blob_master_src_binding.cc_L6]: https://link.zhihu.com/?target=https%3A//github.com/denoland/rusty_v8/blob/master/src/binding.cc%23L6