rust axum 项目实践 deno js运行时集成

rust axum使用deno runtime

使用场景：
例如在创建订单的过程中,订单创建完成之后
需要根据订单的金额,和订单下单数量进行
1：增加用户积分
2：赠送优惠券
3：消息推送
。。。
对于这些需求来说 是根据营销规则定的，每次活动的规则不一样
需求不一样 只有创建订单是固定业务流程,所以说要把 这种边缘
需求进行可配置化处理
在这里想到要把执行逻辑脚本化，并放到数据库里
根据数据库的配置动态触发
这是时候就需要用到动态执行 代码的技术
那要看怎么实现了

前言

项目中我们使用到的脚本语言是JavaScript，把js存储到数据库里
根据资源的不通进行触发 多个脚本顺序执行

提示：以下是本篇文章正文内容，下面案例可供参考

一、deno 是什么？

deno 是rust 语言的 js runtime,对标的是nodejs,是这两年新兴的
js运行时,提供和nodejs一样的功能并且更强大

二、使用步骤

1.引入库

代码如下（示例）：引入crate

deno_core = "0.130.0"
deno_runtime = "0.56.0"

2.使用JsRuntime

代码如下（示例）：

use deno_core::op;
use deno_core::Extension;
use deno_core::JsRuntime;
use deno_core::RuntimeOptions;
use deno_core::*;
//自定义方法 这个方法会在 JavaScript进行调用
#[op]
fn op_sum(nums: Vec<f64>) -> Result<f64, deno_core::error::AnyError> {
  let sum = nums.iter().fold(0.0, |a, v| a + v);
  Ok(sum)
}

fn main() {
 //创建 Extension 并添加自定义方法op_sum 到js上下文
  let ext = Extension::builder()
    .ops(vec![
      op_sum::decl(),
    ])
    .build();
    //实例化JsRuntime 并设置 Extension
  let mut runtime = JsRuntime::new(RuntimeOptions {
    extensions: vec![ext],
    ..Default::default()
  });
  //执行 JavaScript脚本
  runtime
    .execute_script(
      "<usage>",
      r#"
          function print(value) {
            Deno.core.print(value.toString()+"\n");
          }
          const arr = [1, 2, 3];
          print("The sum of");
          print(arr);
          print("is");
          print(Deno.core.opSync('op_sum', arr));
          try {
            print(Deno.core.opSync('op_sum', 0));
          } catch(e) {
            print('Exception:');
            print(e);
          }
"#,
    )
    .unwrap();
}

该处使用的是deno_core 的JsRuntime运行时 这是一个最小版本的
js运行时 只是在v8引擎的基础上封装了高阶的api
对于日志打印来说 还是不能使用console.log()这种方式的
因为 对于 console ，http,fs …这些常规的运行时对象不在
deno_core的包含之内,所以使用的时候不能完全像使用nodejs
一样

3.使用MainWorker

代码如下（示例）：

use deno_core::error::AnyError;
use deno_core::{FsModuleLoader, v8};
use deno_runtime::deno_broadcast_channel::InMemoryBroadcastChannel;
use deno_runtime::deno_web::BlobStore;
use deno_runtime::permissions::Permissions;
use deno_runtime::worker::MainWorker;
use deno_runtime::worker::WorkerOptions;
use deno_runtime::BootstrapOptions;
use std::path::Path;
use std::rc::Rc;
use std::sync::Arc;

fn get_error_class_name(e: &AnyError) -> &'static str {
  deno_runtime::errors::get_error_class_name(e).unwrap_or("Error")
}

#[tokio::main]
async fn main() -> Result<(), AnyError> {
  let module_loader = Rc::new(FsModuleLoader);
  let create_web_worker_cb = Arc::new(|_| {
    todo!("Web workers are not supported in the example");
  });
  let web_worker_preload_module_cb = Arc::new(|_| {
    todo!("Web workers are not supported in the example");
  });
  let options = WorkerOptions {
    bootstrap: BootstrapOptions {
      args: vec![],
      cpu_count: 1,
      debug_flag: false,
      enable_testing_features: false,
      location: None,
      no_color: false,
      is_tty: false,
      runtime_version: "x".to_string(),
      ts_version: "x".to_string(),
      unstable: false,
    },
    extensions: vec![],
    unsafely_ignore_certificate_errors: None,
    root_cert_store: None,
    user_agent: "hello_runtime".to_string(),
    seed: None,
    source_map_getter: None,
    js_error_create_fn: None,
    web_worker_preload_module_cb,
    create_web_worker_cb,
    maybe_inspector_server: None,
    should_break_on_first_statement: false,
    module_loader,
    get_error_class_fn: Some(&get_error_class_name),
    origin_storage_dir: None,
    blob_store: BlobStore::default(),
    broadcast_channel: InMemoryBroadcastChannel::default(),
    shared_array_buffer_store: None,
    compiled_wasm_module_store: None,
  };
  let js_path =
    Path::new(env!("CARGO_MANIFEST_DIR"));
  let main_module = deno_core::resolve_path(&js_path.to_string_lossy())?;
  let permissions = Permissions::allow_all();

  let mut worker = MainWorker::bootstrap_from_options(
    main_module.clone(),
    permissions,
    options,
  );
  worker.execute_script("hello_runtime.js",r#"console.log("Hello world!")"#);
  worker.run_event_loop(false).await?;
  Ok(())
}

该处使用的是deno_runtime的MainWorker，deno_runtime是在
deno_core的基础上进行的二次封装扩展，在这里扩展了
deno_webidl,deno_console,deno_web等等

  /*初始化的时候扩展了
let mut extensions: Vec<Extension> = vec![
      // Web APIs
      deno_webidl::init(),
      deno_console::init(),
      deno_url::init(),
      deno_web::init::<Permissions>(
        options.blob_store.clone(),
        options.bootstrap.location.clone(),
      ),
     ...
    ];
  
 */
 let mut worker = MainWorker::bootstrap_from_options(
    main_module.clone(),
    permissions,
    options,
  );

项目实践

提示：这里主要是在项目中使用的代码

pub mod event_service;
pub mod ops;
use casbin::function_map::key_match2;
use cassie_domain::dto::sys_event_dto::EventConfigDTO;
use log::info;
use pharos::SharedPharos;
use serde_json::json;

use crate::{
    initialize::rules::init,
    observe::event::{CassieEvent, CustomEvent},
    service::crud_service::CrudService,
    APPLICATION_CONTEXT,
};

use self::event_service::EventConfigService;

use super::log::log_service::{LogLoginService, LogOperationService};

//事件消费
pub async fn consume(e: CassieEvent) {
    //在这里是获取不到 thread_local 的值 异步消费过来 已经不在同一个线程里了
    match e {
        //登录事件
        CassieEvent::LogLogin(dto) => {
            let mut entity = dto.into();
            let log_login_service = APPLICATION_CONTEXT.get::<LogLoginService>();
            log_login_service.save(&mut entity).await;
        }
        //操作事件
        CassieEvent::LogOperation(dto) => {
            let mut entity = dto.into();
            let log_operation_service = APPLICATION_CONTEXT.get::<LogOperationService>();
            log_operation_service.save(&mut entity).await;
        }
        //消息事件
        CassieEvent::Sms { sms_type } => todo!("待开发"),
        //自定义事件
        CassieEvent::Custom(custom) => {
            let event_config_service = APPLICATION_CONTEXT.get::<EventConfigService>();
            //获取到所有的事件配置
            let list = event_config_service.load_event().await;
            if let Ok(data) = list {
                let d = data
                    .iter()
                    .filter(|item| {
                        key_match2(&custom.path.clone().as_str(), &item.path().clone().unwrap())
                            || item.path().clone().unwrap().contains(&custom.path.clone())
                    })
                    .collect::<Vec<_>>();

                if d.len() > 0 {
                    execute_script(d, &custom);
                }
            }
        }
    }
}
//核心动态脚本执行方法
fn execute_script(data: Vec<&EventConfigDTO>, custom: &CustomEvent) {
    let init_code = format!(
        r#" var request_context=JSON.parse({});"#,
        serde_json::to_string_pretty(&serde_json::to_string_pretty(&json!(custom)).unwrap())
            .unwrap()
    );
    let mut workers = init(None);
    workers.execute_script("init_request_context", &init_code);
    //根据数据库的配置  循环执行JavaScript脚本 
    for event in data {
       match workers.js_runtime.execute_script(
            event.event_name().clone().unwrap().as_str(),
            event.event_script().clone().unwrap().as_str(),
        ){
            Ok(data) => {},
            Err(e) => {
                info!("error info {:#?}",e.to_string());
            },
        }
    }
}

//发布事件
pub async fn fire_event(e: CassieEvent) {
    let pharos = APPLICATION_CONTEXT.get::<SharedPharos<CassieEvent>>();
    pharos.notify(e).await;
}

1：增加用户积分
2：赠送优惠券
3：消息推送
ps:根据上述需求我们以下需求的 JavaScript脚本配置到数据库里,
根据router 进行配置. 当创建订单的时候发布一个自定义事件
事件消费的时候,根据router从数据里去取对应的 脚本进行排序执行,
当营销业务有所变动的时候不需要更改rust代码只需要动态
变更数据库脚本就可以了

项目源码