merfolk

merfolk 是一个最小化且可扩展的远程过程调用框架。

架构分为三个模块部分：后端、前端和可选的中间件。

merfolk 是一系列组件的集合。主要组件是 Mer，一个指挥类型，以及一个 集合，包含后端、前端和中间件（即 Folk）。

Mer 可以根据配置作为服务器、客户端或两者兼而有之。

后端

后端负责发送和接收 RPC。根据后端的不同，这可以通过不同的通道发生（例如 http、串行端口等）。后端使用 [serde] 框架序列化和反序列化 RPC。

前端

前端提供了一个 API 来创建 RPC 并接收它们。客户端如何创建 RPC 以及服务器如何处理 RPC 取决于前端。

中间件

中间件可以修改发送和接收的 RPC 及其响应。或者对发送或接收的 RPC 及其响应执行自定义操作。

使用 Mer

Mer 需要一个 Backend 和一个 Frontend 来运行。以下示例使用了 Http Backend 以及 Register 和 Derive Frontend（有关如何使用它们的文档请参阅）。

如何使用 Mer（如何设置服务器和客户端）与使用的 Frontend 密切相关。

服务器

// remote procedure definitions
fn add(a: i32, b: i32) -> i32 {
  a + b
}
fn subtract(a: i32, b: i32) -> i32 {
  a - b
}

// build the backend
let backend = Http::builder()
  // configure backend as server
  .listen(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080))
  .build()
  .unwrap();

// build the frontend
let frontend = Register::builder()
  .procedures(
    vec![
      ("add", Register::<Http>::make_procedure(|(a, b)| add(a, b))),
      ("subtract", Register::<Http>::make_procedure(|(a, b)| subtract(a, b))),
    ]
    .into_iter()
    .collect(),
  )
  .build()
  .unwrap();

// register the procedures in the frontend
frontend.register("add", |(a, b)| add(a, b)).unwrap();
frontend.register("subtract", |(a, b)| subtract(a, b)).unwrap();

// build merfolk instance acting as server
let _merfolk = Mer::builder().backend(backend).frontend(frontend).build().unwrap();

客户端

// build the backend
let backend = Http::builder()
  // configure backend as client
  .speak("https://127.0.0.1:8080".parse::<hyper::Uri>().unwrap())
  .build()
  .unwrap();

// build the frontend
let frontend = Register::builder().build().unwrap();

// build merfolk instance acting as client
let merfolk = Mer::builder().backend(backend).frontend(frontend).build().unwrap();

// call remote procedures via the frontend
let result_add: Result<i32> = merfolk.frontend(|f| f.call("add", &(1, 2))).unwrap();
let result_subtract: Result<i32> = merfolk.frontend(|f| f.call("subtract", &(1, 2))).unwrap();

高级

// remote procedure definitions for server
#[frontend()]
struct Receiver {}

#[frontend(target = "Receiver")]
trait Definition {
  fn some_function(arg: String) {}
}

// build the backend
let backend = Http::builder()
  // configure backend as client
  .speak("https://127.0.0.1:8080".parse::<hyper::Uri>().unwrap())
  // configure backend as server
  .listen(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8081))
  .build()
  .unwrap();

// build the client frontend
let caller_frontend = Register::builder().build().unwrap();

// build the server frontend
let receiver_frontend = Receiver::builder().build().unwrap();

// combine the frontends using the [`Duplex`](/merfolk_frontend_derive) frontend
let frontend = Duplex::builder().caller(caller_frontend).receiver(receiver_frontend).build().unwrap();

// build router middleware
let middleware = Router::builder().routes(vec![("prefix_(.*)".to_string(), "$1".to_string())]).build_boxed().unwrap();

// build merfolk instance acting as client and server
let merfolk = Mer::builder().backend(backend).frontend(frontend).middlewares(vec![middleware]).build().unwrap();

// call remote procedures via the caller frontend
let result: String = merfolk.frontend(|f| f.caller.call("some_remote_function", &()).unwrap()).unwrap();

提供的模块

为 Mer 开发模块（称为 Folk）

如果需要通过特定的通道或不同的前端等进行通信，可以通过实现 Backend、Frontend 或 Middleware 特性来创建模块。

有关示例，请参阅 提供的模块