WASI探索（二） -- 将猜数字编译为WASI目标并使用Wasmer运行

拼搏现实的明天。 2022-09-11 06:10 3阅读 0赞

猜数字作为入门Rust时第一次编写并具有实际功能的程序，适合让读者快速掌握rust的基本概念。同时，为了让程序更加有趣，  
博主在原本的猜数字程序上添加了日志和从运行时参数传递游戏难度的功能。此外，由于博主偏好改变，本文还会涉及到另外一款  
WASI运行时Wasmer，以及他们为了丰富WASI生态而推出的wasm包管理器wapm

## 阅读须知 ##

学习外部资料更有助于读者了解相关生态，因此本文将不赘述：

*  [WASI是什么？][WASI]
 *  [Wasmer与wapm如何安装？][Wasmer_wapm]
 *  [rust是什么？][rust] [如何安装Rust？][Rust] [如何学习rust？][rust 1]
 *  [cargo是什么？要怎样使用？][cargo]
 *  [猜数字原版程序在哪？][Link 1]
 *  [log crate][]与[env\_log crate][env_log crate]详细如何使用？
 *  [structopt][]如何使用？

而阅读本文，你将了解：

*  如何用日志debug的一些原则
 *  一个简单的配置文件的设计
 *  读者对Wasmer的一些浅薄看法

## 原版猜数字 ##

我们从[官方书][Link 1]拷贝了一份猜数字程序：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
</pre> </td> 
   <td> <pre>// main.rs
use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

let secret_number = rand::thread_rng().gen_range(1, 101);

loop {
        println!("Please input your guess.");

let mut guess = String::new();

io::stdin().read_line(&amp;mut guess)
            .expect("Failed to read line");

let guess: u32 = match guess.trim().parse() {
            Ok(num) =&gt; num,
            Err(_) =&gt; continue,
        };

println!("You guessed: {}", guess);

match guess.cmp(&amp;secret_number) {
            Ordering::Less =&gt; println!("Too small!"),
            Ordering::Greater =&gt; println!("Too big!"),
            Ordering::Equal =&gt; {
                println!("You win!");
                break;
            }
        }
    }
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
</pre> </td> 
   <td> <pre># Cargo.toml
[package]
name = "guessing_game"
version = "0.1.0"
authors = ["Your Name &lt;you@example.com&gt;"]
edition = "2018"

[dependencies]
rand = "0.3.14"
</pre> </td> 
  </tr> 
 </tbody> 
</table>

## 一次游戏只猜一个数 ##

我们可以看到，这个程序每次运行，只能猜一个数字，如果要继续玩就只能重新启动。但是博主想让这个游戏，能在一次运行时  
可以生成不同难度关卡，因此首先我们将“猜一个数字”逻辑抽取成可复用函数

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
</pre> </td> 
   <td> <pre>// main.rs
fn guess_a_number() {
    println!("Guess the number!");

let secret_number = rand::thread_rng().gen_range(1, 101);

loop {
        println!("Please input your guess.");

let mut guess_str = String::new();

io::stdin().read_line(&amp;mut guess_str)
            .expect("Failed to read line");

let guess: u32 = match guess_str.trim().parse() {
            Ok(num) =&gt; num,
            Err(_) =&gt; continue,
        };

println!("You guessed: {}", guess);

再将配置文件修改一下：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
</pre> </td> 
   <td> <pre># Cargo.toml
[package]
name = "guess_wasi"
version = "0.1.0"
authors = ["huangjj27 &lt;huangjj.27@qq.com&gt;"]
edition = "2018"

[dependencies]
# 使用最新的随机生成数包以支持rust nightly的`wasm32-wasi`目标
rand = "0.7.0-pre.1"
</pre> </td> 
  </tr> 
 </tbody> 
</table>

此外，猜数字游戏的难度取决于随机生成数字的范围, 为了生成不同的难度关卡，我们需要`guess_a_number`接受一组控制  
生成数字范围的参数：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
</pre> </td> 
   <td> <pre>// main.rs
/// 生成熟悉范围的下界（lower bound，lb)与上界（higher bound，hb）在主函数中读取配置文件得到
fn guess_a_number((lb, hb): (u32, u32)) {
    println!("Guess the number!");

let secret_number = rand::thread_rng().gen_range(lb, hb + 1);

// ...
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

这里在传入参数时，直接[解构][Link 2]了[元组][Link 3], 这样后面就可以直接使用传入的上界与下界来控制生成数范围

然后，博主发现， 原版猜数字如果解析数字错误的话会直接跳过，博主觉得这里应该至少提醒一下用户输入错误了：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
</pre> </td> 
   <td> <pre>// main.rs
fn guess_a_number((lb, hb): (u32, u32)) {
    // ...
        let guess: u32 = match guess_str.trim().parse() {
            Ok(num) =&gt; num,
            Err(_) =&gt; {
                println!("Input not a number! please input a number");
                continue;
            },
        };
    // ...
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

## 加上log追踪生成的数据情况 ##

使用log去追踪数据与可能产生bug的代码有以下好处：

*  了解运行时所关注的数据情况， 方便定位bug
 *  清晰地知道实际运行流程是否如期望那样执行
 *  即便使用release版目标， 仍然可以获得需要的分析信息
 *  区分产生信息的层级，以便将精力集中在优先需要处理的信息中

回到猜数字游戏上，博主想要知道每一次游戏中知道生成的`secret_number`是多少， 并且根据运行时输入的日志层级的参数  
决定是否显示这个数字，需求相对简单，因此使用rust生态中比较常用的[log crate][]与[env\_log crate][env_log crate]。在`Cargo.toml`中加入两个新依赖：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
</pre> </td> 
   <td> <pre># Cargo.toml

# ...

[dependencies]
# 使用最新的随机生成数包以支持rust nightly的`wasm32-wasi`目标
rand = "0.7.0-pre.1"

# 总是使用最新的log与env_log
log = "*"
env_log = "*"
</pre> </td> 
  </tr> 
 </tbody> 
</table>

加入追踪日志代码：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
</pre> </td> 
   <td> <pre>// main.rs
use log::{trace, debug};

fn main() {
    // 别忘了初始化日志生成器， 才能获取日志！
    env_log::init();
    guess_a_number((1, 100));
}

fn guess_a_number((lb, hb): (u32, u32)) {
    println!("Guess the number!");

let secret_number = rand::thread_rng().gen_range(lb, hb + 1);
    trace!("secret number: {}", secret);

loop {
        println!("Please input your guess.");

let mut guess_str = String::new();
        io::stdin().read_line(&amp;mut guess_str)
            .expect("Failed to read line");
        debug!("scaned string: {:?}", guess_str);

// ...
    }
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

## 向高难度挑战！ ##

现在我们来到最后了一个需求：通过运行时参数来给每次游戏输入多个游戏难度，这个难度由随机数生成的范围决定– 随机数  
生成的范围越大，一次猜中这个数的概率就越小。为方便地写出输入参数的命令，我们需要引入`structopt`库（crate）,  
最后获得类似`--levels=10 100 1000`这样的参数输入方式, 参数中每个数字表示每次生成随机数的生成范围上界。

配置文件追加：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
</pre> </td> 
   <td> <pre># Cargo.toml

# ...

[dependencies]
# 使用最新的随机生成数包以支持rust nightly的`wasm32-wasi`目标
rand = "0.7.0-pre.1"

# 总是使用最新的log与env_log
log = "*"
env_log = "*"

# 用户生成命令行参数
structopt = "*"
</pre> </td> 
  </tr> 
 </tbody> 
</table>

编写参数代码。

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
</pre> </td> 
   <td> <pre>// main.rs

// ...
use structopt::StructOpt;

// 定义参数只需要把他们的名字和类型写在一个参数结构体中即可！
#[derive(StructOpt)]
#[structopt(name="guess_wasi")]
struct Opt {
    #[structopt(long="levels")]
    levels: Vec&lt;u32&gt;,
}

fn main() {
    env_logger::init();

// 获取并访问levels参数, 只需要访问参数结构体的对应成员即可， 细节处理可以方便地交给库执行！
    let opt = Opt::from_args();
    for &amp;lv in &amp;opt.levels {
        println!("given number range 0~{}", lv);
        guess_a_number((0, lv));
    }
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

## 完整代码 ##

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
</pre> </td> 
   <td> <pre># guess_wasi/Cargo.toml
[package]
name = "guess_wasi"
version = "0.1.0"
authors = ["huangjj27 &lt;huangjj.27@qq.com&gt;"]
edition = "2018"

[dependencies]
rand = "0.7.0-pre.1"
log = "*"
env_logger = "*"
structopt = "*"
</pre> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
</pre> </td> 
   <td> <pre>// guess_wasi/src/
use std::io;
use std::cmp::Ordering;
use rand::Rng;  // currently only support wasm32-wasi target in nightly
use log::{debug, trace};

use structopt::StructOpt;

#[derive(StructOpt)]
#[structopt(name="guess_wasi")]
struct Opt {
    #[structopt(long="levels")]
    levels: Vec&lt;u32&gt;,
}

fn main() {
    env_logger::init();
    let opt = Opt::from_args();
    for &amp;lv in &amp;opt.levels {
        println!("given number range 0~{}", lv);
        guess_a_number((0, lv));
    }
}

// While a game has many levels, we guess a number in each level.
fn guess_a_number((lb, hb): (u32, u32)) {
    let secret = rand::thread_rng().gen_range(lb, hb + 1);
    trace!("secret number: {}", secret);

loop {
        println!("Please input your guess.");

let mut guess_str = String::new();
        io::stdin().read_line(&amp;mut guess_str)
            .expect("Failed to read line");
        debug!("scaned string: {:?}", guess_str);

let guess: u32 = match guess_str.trim().parse() {
            Ok(num) =&gt; num,
            Err(_) =&gt; {
                println!("Input not a number! please input a number");
                continue;
            },
        };

println!("You guessed: {}", guess);

match guess.cmp(&amp;secret) {
            Ordering::Less =&gt; println!("too small!"),
            Ordering::Greater =&gt; println!("too big!"),
            Ordering::Equal =&gt; {
                println!("You get it!");
                break;
            }
        }
    }
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

读到这里，读者可以发现前文**根本没涉及到WASI，甚至没有涉及WASM**。这因为WASI作为应用与运行时交互的接口，被rust编译器封装成为编译目标，读者只需要编译到对应目标即可让自己的程序在对应平台上运行. 这是Rust编程语言现代化与工程学的体现：  
一般应用研发工程师可以通过使用已经适配所需平台的底层库(这些底层库通常已经针对所有支持平台做了最优化适配)，就能让自己的应用支持对应的平台而无需重新编写针对某平台的特化版本源码！

## 是时候编译成WASI目标了 ##

由于`rand`库暂时只支持nightly工具链的`wasm32-wasi`目标(该目标的改动与稳定版的`wasm32-unknown-wasi`不兼容),  
因此我们还需要添加对应的编译目标：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
</pre> </td> 
   <td> <pre>rustup target add wasm32-wasi --toolchain=nightly
</pre> </td> 
  </tr> 
 </tbody> 
</table>

编译到`wasm32-wasi`目标上：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
</pre> </td> 
   <td> <pre>$ cargo +nightly build --target=wasm32-wasi --release
   Compiling proc-macro2 v0.4.30
   Compiling libc v0.2.58
   Compiling unicode-xid v0.1.0
   Compiling memchr v2.2.0
   Compiling syn v0.15.36
   Compiling autocfg v0.1.4
   Compiling bitflags v1.1.0
   Compiling regex v1.1.7
   Compiling unicode-segmentation v1.3.0
   Compiling rand_chacha v0.2.0
   Compiling rand v0.7.0-pre.1
   Compiling getrandom v0.1.3
   Compiling heck v0.3.1
   Compiling clap v2.33.0
   Compiling aho-corasick v0.7.3
   Compiling rand_core v0.5.0
   Compiling quote v0.6.12
   Compiling env_logger v0.6.1
   Compiling structopt-derive v0.2.16
   Compiling structopt v0.2.16
   Compiling guess_wasi v0.1.0 (E:\learning-rust\guess_wasi)
    Finished release [optimized] target(s) in 1m 51s
</pre> </td> 
  </tr> 
 </tbody> 
</table>

现在，我们来运行一下程序[1][]吧：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
</pre> </td> 
   <td> <pre>$ wasmer run .\target\wasm32-wasi\release\guess_wasi.wasm --env RUST_LOG=trace -- --levels 10 100 1000
given number range 0~10
[2019-06-22T07:21:22Z TRACE guess_wasi] secret number: 4
Please input your guess.
4qp
[2019-06-22T07:21:27Z DEBUG guess_wasi] scaned string: "4qp\r\n"
Input not a number! please input a number
Please input your guess.
3
[2019-06-22T07:21:34Z DEBUG guess_wasi] scaned string: "3\r\n"
You guessed: 3
too small!
Please input your guess.
5
[2019-06-22T07:21:35Z DEBUG guess_wasi] scaned string: "5\r\n"
You guessed: 5
too big!
Please input your guess.
4
[2019-06-22T07:21:38Z DEBUG guess_wasi] scaned string: "4\r\n"
You guessed: 4
You get it!
given number range 0~100
[2019-06-22T07:21:38Z TRACE guess_wasi] secret number: 54
Please input your guess.
54
[2019-06-22T07:21:40Z DEBUG guess_wasi] scaned string: "54\r\n"
You guessed: 54
You get it!
given number range 0~1000
[2019-06-22T07:21:40Z TRACE guess_wasi] secret number: 135
Please input your guess.
135
[2019-06-22T07:21:43Z DEBUG guess_wasi] scaned string: "135\r\n"
You guessed: 135
You get it!
$
</pre> </td> 
  </tr> 
 </tbody> 
</table>

调试后，确认我们的程序可以正常执行了， 去掉`--env RUST_LOG=trace`参数，享受自己制作的这个小游戏吧！

## Wasmer与Wapm ##

[Wasmer][]可以是说在WASI生态中响应速度仅次于Mozilla的组织，他们号称打造了  
一款可以让代码“一次构建，处处运行”（Build Once, Run Anywhere.)的运行时环境，该环境可以运行ECMAScripten标准与  
WASI标准的wasm栈机码。并且方便为wasm代码分发，该组织开发了类似于nodejs生态中npm的包管理工具wapm，这样用户就可以  
很轻松地发布自己的程序，以及利用他人的程序了–这促进了WASM生态的发展，同时作为生态底层的领导者，Wasmer也将拥有  
更多发言权。

作为边缘人士（稍微知道WASM生态但没很深入了解），博主看到这项目背后的布局很像上世纪Sun公司的Java和JVM（尽管WASM并不是Wasmer的发明，但这样反而不必为WASM这样可以作为主流编程语言编译目标工具投入过多精力宣传，可以集中精力去优化wasmer与wapm；同时因为wasmer是使用MIT协议授权，不会产生类似OracleJDK专利权所属的问题，相信随着生态的进一步发展，在虚拟机运行时领域会逐步替代JVM成为主流，届时将解放程序员更多生产力 – 不必要求掌握Java而是通过自己熟悉的编程语言（c/c++/rust/python/…)通过统一的标准相互调用（进一步微型化的微服务）。

而这个在服务器/PC桌面应用占主导地位的标准，就是WASI。

--------------------

1.  1.如果运行时出现了报错，那因为有些bugfix在已经发布的wasmer 0.4.2版本中尚未更新，请采用最新源码编译并替换到  
    已经安装好的`wasmer.exe`程序

[WASI]: https://huangjj27.gitlab.io/posts/first-wasi
[Wasmer_wapm]: https://wapm.io/help/install
[rust]: https://www.rust-lang.org/zh-CN/
[Rust]: https://www.rust-lang.org/zh-CN/tools/install
[rust 1]: https://www.rust-lang.org/zh-CN/learn
[cargo]: https://doc.rust-lang.org/cargo/index.html
[Link 1]: https://doc.rust-lang.org/book/ch02-00-guessing-game-tutorial.html
[log crate]: https://docs.rs/log/0.4.6/log/
[env_log crate]: https://docs.rs/env_logger/0.6.1/env_logger/
[structopt]: https://docs.rs/releases/search?query=structopt
[Link 2]: https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html?highlight=destruct#destructuring-to-break-apart-values
[Link 3]: https://doc.rust-lang.org/book/ch03-02-data-types.html#compound-types
[1]: https://huangjj27.gitlab.io/posts/wasmer-guess-game/#fn:1
[Wasmer]: https://github.com/wasmerio/wasmer