Hydra

使用 Rust 编程语言编写容错、高度可扩展应用的框架。它是

• 快速：由 Tokio 的轻量级任务架构驱动的原生性能。
• 可扩展：所有 Hydra 代码都在轻量级执行线程（称为 进程）中运行，这些线程是隔离的，并通过消息交换信息。
• 容错：受 Erlang/Elixir 的 OTP 启发，Hydra 提供了许多相同的概念，如 GenServer 和 Supervisor，在系统出现问题时重启系统的一部分。
• 分布式：Hydra 提供了对在任意大小网络上的完全分布式进程集群的内置支持。

概述

Hydra 在 Tokio 运行时上运行，该运行时以其使用 Rust 编程语言构建可靠、异步和精简的应用而闻名。从高层次来看，Hydra 提供以下主要组件

• 进程：支持发送和接收消息的轻量级任务。
• GenServer：提供请求/回复和状态管理的通用服务器进程。
• Supervisor：管理其他进程的进程，用于提供容错并封装应用程序的启动和关闭（优雅地）方式。
• 注册表：作为进程集中注册表的进程，允许您通过任何键查找正在运行的进程。
• 节点：连接多个 Hydra 节点（实例）的机制，并监控这些连接。

示例

Hydra 中的基本 GenServer 栈应用程序。

确保您已经在 Cargo.toml 中添加了 Hydra 和 Serde。

[dependencies]
hydra = "0.1"
serde = { version="1.0", features = "derive" }

确保您没有在 panics 上终止，Hydra 会捕获并管理所有 进程 的 panics。如果您的 Cargo.toml 中存在此行，请找到并 删除 它。

panic = "abort"

然后，在您的 main.rs 中

use hydra::Application;
use hydra::ExitReason;
use hydra::From;
use hydra::GenServer;
use hydra::GenServerOptions;
use hydra::Pid;

use serde::Deserialize;
use serde::Serialize;

#[derive(Debug, Serialize, Deserialize)]
enum StackMessage {
    Pop,
    PopResult(String),
    Push(String),
}

struct Stack {
    stack: Vec<String>,
}

impl Stack {
    pub fn with_entries(entries: Vec<&'static str>) -> Self {
        Self {
            stack: Vec::from_iter(entries.into_iter().map(Into::into)),
        }
    }
}

impl GenServer for Stack {
    type Message = StackMessage;

    async fn init(&mut self) -> Result<(), ExitReason> {
        Ok(())
    }

    async fn handle_call(
        &mut self,
        message: Self::Message,
        _from: From,
    ) -> Result<Option<Self::Message>, ExitReason> {
        match message {
            StackMessage::Pop => Ok(Some(StackMessage::PopResult(self.stack.remove(0)))),
            _ => unreachable!(),
        }
    }

    async fn handle_cast(&mut self, message: Self::Message) -> Result<(), ExitReason> {
        match message {
            StackMessage::Push(value) => self.stack.insert(0, value),
            _ => unreachable!(),
        }
        Ok(())
    }
}

struct StackApplication;

impl Application for StackApplication {
    // Here, we must link a process for the application to monitor, usually, a Supervisor, but it can be any process.
    async fn start(&self) -> Result<Pid, ExitReason> {
        let pid = Stack::with_entries(vec!["hello", "world"])
            .start_link(GenServerOptions::new())
            .await
            .expect("Failed to start stack!");

        let result = Stack::call(pid, StackMessage::Pop, None)
            .await
            .expect("Stack call failed!");

        tracing::info!("{:?}", result);

        Stack::cast(pid, StackMessage::Push(String::from("rust")));

        let result = Stack::call(pid, StackMessage::Pop, None)
            .await
            .expect("Stack call failed!");

        tracing::info!("{:?}", result);

        // Otherwise, the application will run forever waiting for Stack to terminate.
        Stack::stop(pid, ExitReason::Normal, None).await?;

        Ok(pid)
    }
}

fn main() {
    // This method will return once the linked Process in StackApplication::start has terminated.
    Application::run(StackApplication)
}

更多示例在 示例 文件夹中。您可以使用以下命令运行它们：cargo run --example=stack。

相关项目

以下项目与Hydra相关或已在Hydra中使用，因此学习它们也是明智的：

• tokio：使用Rust编程语言编写可靠、异步和精简应用程序的运行时。
• serde：一个用于高效和通用地序列化和反序列化Rust数据结构的框架。
• tracing：一个用于应用程序级跟踪和异步诊断的框架。

变更日志

查看变更日志

基准测试

在示例中有一个消息传递基准测试，您可以使用以下命令运行：cargo run --example=benchmark --release。我已经得到了以下结果

• Intel 14700k：26257627 msg/s
• Intel 7700k：7332666 msg/s
• Apple M1 Max：5743765 msg/s

许可证

本项目受MIT许可证许可。

贡献

除非您明确声明，否则您提交给Hydra的任何有意贡献的代码都将按MIT许可证许可，没有任何附加条款或条件。