  
## 概要

Rustの?演算子(question mark operator)がとても便利なのでメモしておく

## Option 型に対して使う

例：function `get` は、Option 型を返すfunction  `get_opt` の戻り値がNoneならそのままNoneを返してSomeなら加工して返却する。
```rust
fn get_opt() -> Option<()> {  
    None  
}  
  
fn get() -> Option<()> {  
    let val = get_opt();  
    if val.is_none() {  
        return None;  
    }  
    let unwrapped = val.unwrap();  
    // 何かしらの加工処理  
    Some(unwrapped)  
}
```

上記のよくある処理を?演算子(question mark operator)を使うとこう書ける

```rust
fn get_opt() -> Option<()> {  
    None  
}  
  
fn get() -> Option<()> {  
    let val = get_opt()?;  
    // 何かしらの加工処理  
    Some(val)  
}
```

めっちゃ楽だし意図がわかりやすい。

## Result 型に対して使う

さっきと似たような例。Option部分がResultだったとしても同様な処理になる。
(Error型を定義するのが面倒なのでanyhowを使ってるのは見逃して欲しい)

```rust
use anyhow::{anyhow, Result};

fn get_result() -> Result<()> {  
    Err(anyhow!("missing value"))  
}  
  
fn get() -> Result<()> {  
    let val = get_result();  
    if val.is_err() {  
        return Err(anyhow!("some value"));  
    }  
    let unwrapped = val.unwrap();  
    // 何かしらの加工処理  
    Ok(unwrapped)  
}
```

これも?演算子(question mark operator)を使うことで簡単にできる。

```rust
use anyhow::{anyhow, Result};

fn get_result() -> Result<()> {  
    Err(anyhow!("missing value"))  
}  

fn get() -> Result<()> {  
    let val = get_result()?;  
  
    // 何かしらの加工処理  
    Ok(val)  
}
```


## Option 型 と Result 型 の混合パターン

```rust
use anyhow::{anyhow, Result};

fn get_opt() -> Option<()> {  
    None  
}  
  
fn get() -> Result<()> {  
    let val = get_opt().ok_or(anyhow!("some value"))?;  
    // 何かしらの加工処理  
    Ok(val)  
}
```

`ok_or` と ?演算子(question mark operator)を使うことでかなり簡潔に書ける。
これに気づいてしまって便利すぎると思ってこの記事を書いた。

[Rust] OptionやResultと組み合わせて使える?演算子

  
## 概要

 [prisma-client-rust](https://github.com/Brendonovich/prisma-client-rust) の 0.6.1 を試していたら、`Undefined symbols for architecture arm64` で build が失敗した。解決方法をメモしておく。(こういうやつに限ってまた引っかかるし思い出せなくて詰むのでメモしておく)

## 発生した事象


buildしたら `Undefined symbols for architecture arm64`  とうエラーが出た。
対象はどうやらこれ↓

```
/var/folders/gx/vpnqx7ln6cd0gtd8rt32fdj80000gn/T/rustcTP444Y/symbols.o
```

ただ調べてみたところ、そもそもこんなファイルは存在しなかった

## 解決方法

```bash
$ rustup update
```

で toolchain を update したら解決した。
原因はわからないが、ライブラリが求める version とあってないものがあったとか?

### 解決しなかった方法

- ライブラリのバーションをいじってみる
- コードを変更してみる
- build周りの設定を変えてみる

などなど


[Rust] `Undefined symbols for architecture arm64` で build が失敗したときにやったこと

  
## 概要

Rust で DB 接続を試してみる。DBスキーマの管理とかは prisma 使いたいので、探してみたところ 非公式だが [prisma-client-rust](https://github.com/Brendonovich/prisma-client-rust) を見つけたので試してみる。

余談だが、 2022/08/24 に `0.5.3` が出るまでまともに動かなかった。

これはタイミング悪く 2022/08/22 に  `0.5.2`  を試してしまった時の嘆き
[https://twitter.com/homura10059/status/1561687326564417537](https://twitter.com/homura10059/status/1561687326564417537)

## 検証結果

- 最低限動かすことはできる
- 少し複雑な schemaだとclientの生成に失敗するのでまだ趣味で使うにしても早そう。
- 2022/08 末に `0.6.0` を出すらしいので待つ


## 検証メモ

### 最終的なフォルダ構成

```text
|---- .cargo
|      `---- config.toml
|
|---- prisma
|      `---- schema.prisma
|
|---- prisma-cli  
|     |---- src
|     |     `---- main.rs
|     `---- Cargo.toml
|
|---- repositories
|     |---- src
|     |     `---- lib.rs
|     `---- Cargo.toml
|
|---- .env
`---- Cargo.toml
```

cargo workspaces を使った構成で最終的にはこのような構成を作る。
ここからは [ドキュメント](https://github.com/Brendonovich/prisma-client-rust/tree/main/docs) に沿ってやっていく

### 01-Installation

[https://github.com/Brendonovich/prisma-client-rust/blob/main/docs/01-installation.md](https://github.com/Brendonovich/prisma-client-rust/blob/main/docs/01-installation.md)

まず Rust 用の prisma-cli  を binary-crate としてを作る
```sh
$ cargo new prisma-cli 
```

作成完了したら Cargo.toml に以下のような dependencies を設定する

```toml
############################
# ./prisma-cli/Cargo.toml
############################

[package]  
name = "prisma-cli"  
version = "0.1.0"  
edition = "2021"  
  
  
[dependencies]  
prisma-client-rust = { git = "https://github.com/Brendonovich/prisma-client-rust", tag = "0.5.3" }  
prisma-client-rust-cli = { git = "https://github.com/Brendonovich/prisma-client-rust", tag = "0.5.3" }
```

設定終わったら main.rs を以下のように書き換える

```rust
//
// ./prisma-cli/src/main.rs
//

fn main() {  
    prisma_client_rust_cli::run();  
}
```

これで準備は完了。
作成した crate を root にある Cargo.toml に追加しておく

```toml
############################
# ./Cargo.toml
############################

[workspace]  
  
members = [  
    "prisma-cli",  
]
```

この状態で、一旦作った prisma-cli が動作するか確認してみる
```sh 
$ cargo run --bin prisma-cli -- -h
```
で cli の help が表示されれば問題なし。

このままだと使いづらいので、aliasを設定しておく
```toml
############################
# ./cargo/config.toml
############################

[alias]  
prisma = "run --bin prisma-cli --"
```
設定が終わったら以下を実行してみる。 help が表示されれば問題なし。

```sh
$ cargo prisma -h
```

### 02-Setup

[https://github.com/Brendonovich/prisma-client-rust/blob/main/docs/02-setup.md](https://github.com/Brendonovich/prisma-client-rust/blob/main/docs/02-setup.md)

prisma の schema ファイルを作成しておく
```
//
// ./prisma/schema.prisma
//

generator client {  
  provider = "cargo prisma"  
  output   = "../repositories/src/prisma.rs"  
}  
  
datasource db {  
  provider = "postgresql"  
  url      = env("DATABASE_URL")  
}  
  
model User {  
  id          String   @id @default(cuid())  
  displayName String  
  email       String?  
}
```

generate 先の lib-crate を作っておく
```sh
$ cargo new --lib repositories 
```

prisma-client を generate しておく
```sh
$ cargo prisma generate
```
`./repositories/src/prisma.rs` に client が生成されるので確認しておく。

ついでに接続先の設定を書いておく。[supabase](https://supabase.com/) などで postgresql を作っておいくとよい。
```
############################
# .env
############################
  
DATABASE_URL="TODO:ここにURLを入れる"
```

DB も migrate しておく
```sh
$ cargo prisma migrate dev --name init 
```

### 03-Overview


lib.rs の方に cliet を読み込めるか試してみる。その前に tokio への依存を追加しておく
```toml
############################
# ./repositories/Cargo.toml
############################

[dependencies]  
tokio = { version = "1.20.1", features = ["full"] }
prisma-client-rust = { git = "https://github.com/Brendonovich/prisma-client-rust", tag = "0.5.3" }  
prisma-client-rust-cli = { git = "https://github.com/Brendonovich/prisma-client-rust", tag = "0.5.3" }
```

こんな感じで、client を生成して、クエリが実行できる
```rust
mod prisma;  
  
use prisma::user;  
  
#[tokio::main]  
async fn main() {  
    let client= prisma::new_client().await?;  
    let users = client.user()  
        .find_many(vec![user::display_name::equals("homura".to_string())])  
        .exec().await?;  
}
```

あとは必要に応じて実装していけばいい。
このあと色々試したが、少し複雑な schemaだとclientの生成に失敗するのでまだ趣味で使うにしても早そう。2022/08 末に `0.6.0` を出すらしいのでそれに期待。

prisma-client-rust を試してみる

  
## 概要
Rust で作ったものをAWS Lambda で動かしてみようと思う。aws-lambda-rust-runtime を使えばできそうだったので試してみる。
Rust自体を書けるようになることが先じゃないかという考え方もある気がするが、実際に動く環境を先に作っておくと後々ハマったりしないので先に動く環境を整える

## やったことメモ

[https://github.com/awslabs/aws-lambda-rust-runtime](https://github.com/awslabs/aws-lambda-rust-runtime) のREADMEに沿ってやっていく

### サンプルコードの生成

まずは cargo-lambda を install する
```bash
$ brew tap cargo-lambda/cargo-lambda
$ brew install cargo-lambda
$ cargo install cargo-lambda
```

インストールが終わったらサンプルプロジェクトを作成する

```bash
$ cargo lambda new aws-lambda-sample
? Is this function an HTTP function? No
? AWS Event type that this function receives cloudwatch_events::CloudWatchEvent
```

とりあえず `CloudWatchEvent` で作っておく。作っただけで動くサンプルができているので lambda 用にビルドしてみる

```bash 
$ cargo lambda build --release --arm64 --bins
```

これで lambda にデプロイできる形に build できた

### AWS-lambda へのデプロイ方法の選定

1. cargo-lambda を使ってデプロイ
2. AWS CLI を使ってデプロイ
3. AWS Serverless Application Model (SAM) を使ってデプロイ
4. Serverless Framework を使ってデプロイ
5. Docker を使ってデプロイ

READMEを読む限り、方法としては上記の5種類があるっぽい。
ここで慣れてない方法を選択すると目的外のことでハマって時間を食うので、慣れてるSAMでやることにする。


### local から `sam deploy`

SAM CLI などのセットアップは終わっている前提。
終わってない場合は、[公式のドキュメント](https://docs.aws.amazon.com/ja_jp/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) を参考に導入しておく。

以下のように `template.yaml` を準備しておく

```yaml
# template.yaml
AWSTemplateFormatVersion: '2010-09-09'  
Transform: AWS::Serverless-2016-10-31  
  
Resources:  
  SampleRustFunction:  
    Type: AWS::Serverless::Function  
    Properties:  
      MemorySize: 128  
      Architectures: ["arm64"]  
      Handler: bootstrap  
      Runtime: provided.al2  
      Timeout: 5  
      CodeUri: ./target/lambda/aws-lambda-sample/bootstrap 
  
Outputs:  
  FunctionName:  
    Value: !Ref SampleRustFunction  
    Description: sample
```

SAMでデプロイするための設定ファイルを生成する。最近は `sam deploy --guided` で出来るようになったらしい。

```bash
$ sam deploy --guided

Configuring SAM deploy
======================

        Looking for config file [samconfig.toml] :  Not found

        Setting default arguments for 'sam deploy'
        =========================================
        Stack Name [sam-app]: aws-lambda-sample
        AWS Region [us-east-1]: ap-northeast-1
        #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
        Confirm changes before deploy [y/N]: 
        #SAM needs permission to be able to create roles to connect to the resources in your template
        Allow SAM CLI IAM role creation [Y/n]: y
        #Preserves the state of previously provisioned resources when an operation fails
        Disable rollback [y/N]: 
        Save arguments to configuration file [Y/n]: Y
        SAM configuration file [samconfig.toml]: 
        SAM configuration environment [default]: 

        Looking for resources needed for deployment:
         Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-1943pn3c3rsgk
         A different default S3 bucket can be set in samconfig.toml

        Saved arguments to config file
        Running 'sam deploy' for future deployments will use the parameters saved above.
        The above parameters can be changed by modifying samconfig.toml
        Learn more about samconfig.toml syntax at 
        https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html

Error: Unable to upload artifact ../target/aarch64-unknown-linux-gnu/release/aws-lambda-sample referenced by CodeUri parameter of SampleRustFunction resource.

S3 Bucket does not exist.
```

このままではS3バケットがなくてデプロイできないので `samconfig.toml` を書き換える。
S3バケットは事前に作っておく。

```yaml
# samconfig.toml 
version = 0.1  
[default]  
[default.deploy]  
[default.deploy.parameters]  
stack_name = "aws-lambda-sample"  
s3_bucket = "TODO:ここを準備したバケットに書き換える"  
s3_prefix = "aws-lambda-sample"  
region = "ap-northeast-1"  
capabilities = "CAPABILITY_IAM"  
image_repositories = []

```

ここまで来ればデプロイできるはずなので、以下のコマンドでデプロイする

```bash
$ sam deploy
```

CloudWatchEvent のテンプレートを使ってテストしてみる。
動いたのでこれで問題なし。

![](https://i.imgur.com/36GwbUc.webp)


[Rust] AWS Lambda へデプロイしてみる

  
## 概要

Rust は簡単に monorepo が試せて良い。
ただ、GitHub Actions で CI 環境を構築する上で Rust かつ monorepo 用のCI環境構築経験がないので素振りしておく。


## ディレクトリ構成

Rustの monorepo に関しては [Cargoのワークスペース](https://doc.rust-jp.rs/book-ja/ch14-03-cargo-workspaces.html) が詳しいので説明を省くとして、sample-a/b 二つの repo がある状態で sample-a に対してCI を設定する

```bash
├── Cargo.lock
├── Cargo.toml
├── ./.github/workflows
├── ./sample-a
└── ./sample-b
```

## やること
以下のように GitHub Actions 用の設定ファイルを用意する

```yaml
# .github/workflows/sample-a.yml
on:  
  push:  
    branches:  
      - main  
    paths:  
      - 'sample-a/**'
      - '.github/workflows/sample-a.yml'  
  
defaults:  
  run:  
    working-directory: './sample-a'  
  
jobs:  
  build-test:  
    runs-on: ubuntu-latest  
    steps:  
      - uses: actions/checkout@v2  
      - uses: actions-rs/toolchain@v1  
        with:  
          profile: minimal  
          toolchain: stable  
          components: rustfmt, clippy  
      - name: build  
        run: 'cargo build'  
      - name: test  
        run: 'cargo test'
```

- `sample-a` ディレクトリの中に変更があるか、この設定ファイル自体に変更があった場合に実行する
- デフォルトで  `sample-a`  ディレクトリ内でactionを実行する
- Rust の CI 環境は [actions-rs/toolchain@v1](https://actions-rs.github.io/#toolchain) を使う
- `cargo build` と `cargo test` を実行する

## 参考
- [Mono Repo のための GitHub Actions の Tips 集](https://gist.github.com/yuya-takeyama/47fb261625e67c8efabadcf8c6f237ef)

[https://www.amazon.co.jp/dp/4297125625](https://www.amazon.co.jp/dp/4297125625)


[Rust] GitHub Actions で monorepo の CI 環境を整える

  
## 概要
Rustの勉強をしているが、npm-scripts 的なタスクランナーが欲しくなったので cargo-xtaskを試してみる。

## 前準備

ワークスペースが使える状態で導入するのが良いらしいので、チュートリアルの [Cargoのワークスペース](https://doc.rust-jp.rs/book-ja/ch14-03-cargo-workspaces.html) を終わらせておく

## cargo-xtask の導入

[https://github.com/matklad/cargo-xtask](https://github.com/matklad/cargo-xtask) 通りにやってみる

### workspace に xtask を追加
```diff
# Cargo.toml

[workspace]  
  
members = [  
    "adder",  
    "add-one",  
+    "xtask",  
]
```
Cargo.tomlに追加した後、`cargo new` する
```shell
$ cargo new --bin xtask
```

### xtask を alias に追加

```toml
# .cargo/config
[alias]
xtask = "run --package xtask --"
```

### xtask 用のコードを作る
[https://github.com/matklad/cargo-xtask/blob/master/examples/hello-world/xtask/src/main.rs](https://github.com/matklad/cargo-xtask/blob/master/examples/hello-world/xtask/src/main.rs)
を参考に、今回は reformatとlintをいっぺんに動かすようなtaskを作る
簡単にいうと以下の3つのコマンドを順に実行していくだけ
```shell
$ cargo fmt
$ cargo fix
$ cargo clippy
```

実際のコードは以下
```rust
# xtask/src/main.rs
use std::{  
    env,  
    path::{Path, PathBuf},  
    process::Command,  
};  
  
type DynError = Box<dyn std::error::Error>;  
  
fn main() {  
    if let Err(e) = try_main() {  
        eprintln!("{}", e);  
        std::process::exit(-1);  
    }  
}  
  
fn try_main() -> Result<(), DynError> {  
    let task = env::args().nth(1);  
    match task.as_ref().map(|it| it.as_str()) {  
        Some("lint") => lint()?,  
        _ => print_help(),  
    }  
    Ok(())  
}  
  
fn print_help() {  
    eprintln!(  
        "Tasks:  
lint            fmt & fix & clippy  
"  
    )  
}  
  
fn format() -> Result<(), DynError> {  
    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());  
    let status = Command::new(cargo)  
        .current_dir(project_root())  
        .arg("fmt")  
        .status()?;  
  
    if !status.success() {  
        Err("cargo fmt failed")?;  
    }  
  
    Ok(())  
}  
  
fn fix() -> Result<(), DynError> {  
    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());  
    let status = Command::new(cargo)  
        .current_dir(project_root())  
        .args(&["fix", "--allow-dirty", "--allow-staged"])  
        .status()?;  
  
    if !status.success() {  
        Err("cargo fix failed")?;  
    }  
  
    Ok(())  
}  
  
fn clippy() -> Result<(), DynError> {  
    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());  
    let status = Command::new(cargo)  
        .current_dir(project_root())  
        .arg("clippy")  
        .status()?;  
  
    if !status.success() {  
        Err("cargo clippy failed")?;  
    }  
  
    Ok(())  
}  
  
fn lint() -> Result<(), DynError> {  
    format()?;  
    fix()?;  
    clippy()?;  
  
    Ok(())  
}  
  
fn project_root() -> PathBuf {  
    Path::new(&env!("CARGO_MANIFEST_DIR"))  
        .ancestors()  
        .nth(1)  
        .unwrap()  
        .to_path_buf()  
}
```

このファイルを追加した後以下のコマンドで実行できる

```shell
$ cargo xtask lint
```

## 参考
- [cargo で npm-scripts 的なことをする](https://ubnt-intrepid.netlify.app/introduce-cargo-xtask/)

[https://www.amazon.co.jp/dp/4297125625](https://www.amazon.co.jp/dp/4297125625)


Rust

[Rust] OptionやResultと組み合わせて使える?演算子

[Rust] `Undefined symbols for architecture arm64` で build が失敗したときにやったこと

prisma-client-rust を試してみる

[Rust] AWS Lambda へデプロイしてみる

[Rust] GitHub Actions で monorepo の CI 環境を整える

[Rust] cargo-xtask でタスクランナーを実現する