# rust的第一天
## 2022-10-16 02：11

## 1. rust的安装
关于rust的安装，可以参考[官方文档](https://www.rust-lang.org/tools/install)。
因为我的系统为manjaro，所以我选择了使用yay来安装rust。
```bash
yay -S rust
```
安装完成后，可以使用`rustc --version`来查看rust的版本。





## 2. rust的hello world
使用cargo来创建一个新的项目。
```bash
cargo new rust1
```
在rust中，使用`println!`来输出字符串。
```rust
fn main() {
    println!("Hello, world!");
}
```
使用`cargo run`来运行程序。
```bash
cargo run
```
输出结果：
```bash
 Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.40s
     Running `target/debug/rust1`
Hello, world!
```

## 3. rust的数据类型
rust的数据类型分为两类：标量和复合。
### 3.1 标量
标量类型包括整型、浮点型、布尔型和字符型。
#### 3.1.1 整型
| 大小 | 有符号 | 无符号 |
| --- | --- | --- |
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| arch | isize | usize |
> 值得注意的是，rust数据类型和go一样是自动推断的，所以在声明变量的时候，可以不用指定类型。
> 但是，如果想要指定类型，可以使用`let x: i32 = 5;`来指定类型。
1. 如果你确定了类型，但类型不匹配，rust会报错。
```rust
 Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
error[E0600]: cannot apply unary operator `-` to type `u32`
  --> src/main.rs:11:19
   |
11 |     let x : u32 = -67;
   |                   ^^^ cannot apply unary operator `-`
   |
   = note: unsigned values cannot be negated

For more information about this error, try `rustc --explain E0600`.
error: could not compile `rust1` due to previous error
```
2. 如果i8的数据类型，我们给他赋值为129，rust会报错。
```rust
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
error: literal out of range for `i8`
  --> src/main.rs:11:16
   |
11 |     let x:i8 = 129;
   |                ^^^
   |
   = note: `#[deny(overflowing_literals)]` on by default
   = note: the literal `129` does not fit into the type `i8` whose range is `-128..=127`
   = help: consider using the type `u8` instead

error: could not compile `rust1` due to previous error
```
3. 不同大小的整形的长度
```rust
   Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
i8的最大值: 127
i8的最小值: -128
i16的最大值: 32767
i16的最小值: -32768
i32的最大值: 2147483647
i32的最小值: -2147483648
i64的最大值: 9223372036854775807
i64的最小值: -9223372036854775808
i128的最大值: 170141183460469231731687303715884105727
i128的最小值: -170141183460469231731687303715884105728
```

#### 3.1.2 浮点型
rust的浮点型包括f32和f64。
```rust
let x:f32 = 889_990_3.0;
println!("x = {}",x);
println!("f32的最大值: {}",std::f32::MAX);
println!("f32的最小值: {}",std::f32::MIN);
println!("f64的最大值: {}",std::f64::MAX);
println!("f64的最小值: {}",std::f64::MIN);
```
如上，我们可以使用`_`来分隔数字，使得数字更加易读。
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 8899903
f32的最大值: 340282350000000000000000000000000000000
f32的最小值: -340282350000000000000000000000000000000
f64的最大值: 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
f64的最小值: -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
```
#### 3.1.3 布尔型
rust的布尔型只有true和false。
```rust
let x = true;
let y:bool = false;
println!("x = {},y = {}",x,y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = true,y = false
```
#### 3.1.4 字符型
rust的字符型是`char`，它的长度是4个字节。也就是单个字符或者汉字的长度。
使用utf-8编码。
```rust
let x = 'a';
let y:char = 'b';
println!("x = {},y = {}",x,y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = a,y = b
```

### 3.2 复合类型
#### 3.2.1 元组
元组是一个有序的列表，可以存储不同类型的数据。
```rust
let x = (1,2,3);
let y = (1,"hello",true);
println!("x = {:?}",x);
println!("y = {:?}",y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = (1, 2, 3)
y = (1, "hello", true)
```
#### 3.2.2 数组
数组是一个有序的列表，可以存储相同类型的数据。
```rust 
let x = [1,2,3];
let y = [1,2,3,4,5];
println!("x = {:?}",x);
println!("y = {:?}",y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = [1, 2, 3]
y = [1, 2, 3, 4, 5]
```
#### 3.2.3 字符串
rust的字符串是`String`类型，它是一个可变的字符串。
```rust
let mut x = String::from("hello");
x.push_str(" world");
println!("x = {}",x);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = hello world
```

## 3. 变量
### 3.1 变量的声明
rust的变量声明使用`let`关键字。
```rust
let x = 1;
let y:i32 = 2;
println!("x = {},y = {}",x,y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 1,y = 2
```
### 3.2 变量的修改
rust的变量默认是不可变的，如果想要修改变量的值，需要使用`mut`关键字。
```rust
let mut x = 1;
x = 2;
println!("x = {}",x);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 2
```
### 3.3 变量的隐藏
rust的变量可以隐藏，隐藏的变量会覆盖之前的变量。
```rust
let x = 1;
let x = 2;
println!("x = {}",x);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 2
```
### 3.4 常量
rust的常量使用`const`关键字声明。
```rust
const X:i32 = 1;
const Y:i32 = 2;
println!("x = {},y = {}",X,Y);
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
x = 1,y = 2
```

## 4. 函数
### 4.1 函数的声明
rust的函数使用`fn`关键字声明。
```rust
fn add(x:i32,y:i32) -> i32{
    x + y
}
fn main() {
    let x = 1;
    let y = 2;
    let z = add(x,y);
    println!("z = {}",z);
}
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
z = 3
```
### 4.2 函数的参数
rust的函数参数可以有默认值。
```rust
fn add(x:i32,y:i32 = 2) -> i32{
    x + y
}
fn main() {
    let x = 1;
    let y = 2;
    let z = add(x);
    println!("z = {}",z);
}
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
z = 3
```
### 4.3 函数的返回值
rust的函数可以有返回值，如果没有返回值，可以使用`()`表示。
```rust
fn add(x:i32,y:i32) -> i32{
    x + y
}
fn main() {
    let x = 1;
    let y = 2;
    let z = add(x,y);
    println!("z = {}",z);
}
```
输出结果：
```bash
  Compiling rust1 v0.1.0 (/home/duty/rust/rust1)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rust1`
z = 3
```


## 5. 注释
rust的注释有两种，一种是单行注释，一种是多行注释。
单行注释使用`//`，多行注释使用`/* */`。
```rust
//单行注释
/*
多行注释
*/
```
## 6. 运算符
### 6.1 算术运算符
|运算符|描述|
|:---|:---|
|+|加|
|-|减|
|*|乘|
|/|除|
|%|取余|
### 6.2 比较运算符
|运算符|描述|
|:---|:---|
|==|等于|
|!=|不等于|
|>|大于|
|<|小于|
|>=|大于等于|
|<=|小于等于|
### 6.3 逻辑运算符
|运算符|描述|
|:---|:---|
|&&|逻辑与|
|\|\||逻辑或|
|!|逻辑非|
### 6.4 赋值运算符
|运算符|描述|
|:---|:---|
|=|赋值|
|+=|加赋值|
|-=|减赋值|
|*=|乘赋值|
|/=|除赋值|
|%=|取余赋值|
### 6.5 位运算符
|运算符|描述|
|:---|:---|
|&|按位与|
|\||按位或|
|^|按位异或|
|~|按位取反|
|<<|左移|
|>>|右移|
### 6.6 其他运算符
|运算符|描述|
|:---|:---|
|.|成员访问|
|->|成员访问|
|::|作用域|
|:|类型标注|
|@|模式匹配|
|..|范围|
|..=|范围|
|...|范围|
|,|分隔符|
|;|分隔符|
|=>|键值对|
|->|返回类型|
|=>|闭包|
|->|闭包|

rust-1

## next-terminal中的context

```go
package repository

import (
	"context"

	"next-terminal/server/constant"
	"next-terminal/server/env"

	"gorm.io/gorm"
)

type baseRepository struct {
}

func (b *baseRepository) GetDB(c context.Context) *gorm.DB {
	db, ok := c.Value(constant.DB).(*gorm.DB)
	if !ok {
		return env.GetDB()
	}
	return db
}
```

其中定义了一个基础的baseRepository,所有的rep全部组合baseRepository,然后通过GetDB方法获取其中的gorm.DB.目前来看,这种方式可以减少大量的repo的初始化过程,新创建的repo只需要组合baseRepository即可正常的使用gorm.DB.
这里使用它来存储一个gorm.DB,数据,以便每次需要使用时直接在context中取出来.





## Gorm Docs中的context描述

1. 单一会话模式
`db.WithContext(ctx).Find(&users)`
这种情况下,我不太理解这样用的目的,但可以将其中的ctx初始化为一个超时返回context`ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)`,这样的话,可以在sql语句超时后及时返回.

2. 连续会话模式
这个是我觉得最有用的一种context的使用,使用context将多条语句的操作联系起来.
```go
tx := db.WithContext(ctx)
tx.First(&user, 1)
tx.Model(&user).Update("role", "admin")
```

3. 携带值的context
通过context的方式将gorm.DB放在context中,在编写api需要gorm.DB时直接取出,这样看来,和上文next-terminal中的context的使用方式类似.

```go
func SetDBMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    timeoutContext, _ := context.WithTimeout(context.Background(), time.Second)
    ctx := context.WithValue(r.Context(), "DB", db.WithContext(timeoutContext))
    next.ServeHTTP(w, r.WithContext(ctx))
  })
}

r := chi.NewRouter()
r.Use(SetDBMiddleware)

r.Get("/", func(w http.ResponseWriter, r *http.Request) {
  db, ok := ctx.Value("DB").(*gorm.DB)

  var users []User
  db.Find(&users)

  // lots of db operations
})
```

Gorm中Context

# 从头配置一个GitNote环境

## 一、安装gitnote
不过多赘述，自己在官网下载即可，不过提一点，我用的github，仓库无法拉取下来，只能自己下载下来后绑定仓库。

> 后续：由于GitHub新建仓库默认只有main分支，而gitnote默认拉取master分支，所以无法拉取成功，解决方法：新建一个master分支，或者直接将默认的main分支改为master。






## 二、配置插件
由于未知因素可能导致插件无法下载成功，我们可以选择通过作者的[插件仓库]()将插件下载到本地，然后解压`{user}/.gitnote/plugins`中。

### 配置图床
由于自带的github图床永远无法成功，可以使PicGo+GitHub+jsdelivr配置图床，具体操作如下：
 1. 在Github创建一个用于存放图片的仓库。

 2. 创建一个访问令牌，具体权限如下：![](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/20220915005550.png)

 3. 配置PicGo，如图，仓库名和分支名按实际情况填写，Token即为上步设置的访问令牌，存储路径按自己想法填写，**自定义域名为: `https://gcore.jsdelivr.net/gh/{git用户名}/{仓库名}`**![](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/20220915005700.png)

 4. 设置完成后，就通过PicGo上传图片。

## 三、Git更新仓库
目前来看，GitNote只能将变更提交到本地而无法推送到远端，所以，我们只能自己进行`git pull`之后，才能更新远端仓库中的内容。

从头配置一个GitNote环境

# grpc 的初次实践

## 一、前期准备

### 1. 安装 protoc

```shell
wget https://github.com/protocolbuffers/protobuf/releases/download/v21.5/protobuf-all-21.5.zip
unzip protobuf-all-21.5.zip && cd protobuf-21.5/
./configure
make
make install
```







安装完成后，可以通过 `protoc --version` 查看是否安装成功。

### 2. 安装 protoc-gen-go

```shell
go get -u github.com/golang/protobuf/protoc-gen-go
go install github.com/golang/protobuf/protoc-gen-go
mv $GOPATH/bin/protoc-gen-go /usr/local/bin/
```

### 3. 初始化一个项目

```shell
mkdir grpc-demo && cd grpc-demo
go mod init grpc-demo
mkdir client server proto
```

## 二、编写 proto 文件

### 1. 创建 proto 文件

```proto
syntax = "proto3";

package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
```

### 2. 生成 pb.go 文件

```shell
protoc --go_out=plugins=grpc:. ./proto/*.proto
```

> 报错 1：
> go_out: protoc-gen-go: Plugin failed with status code 1.
> 由于没有指定.proto 文件路径，在 proto 文件第三行加上`option go_package ="./proto";`

> 报错 2：
> --go_out: protoc-gen-go: plugins are not supported; use 'protoc --go-grpc_out=...' to generate gRPC
> 由于 proto 版本过高，无法使用`plugins=grpc`，需要使用`--go-grpc_out=.`
> 将生成的 proto-gen-go-grpc 文件移动到/usr/local/bin/目录下
> 使用新的命令：
> protoc --go_out=. --go_opt=paths=source_relative \\
> --go-grpc_out=. --go-grpc_opt=paths=source_relative \\
> ./proto/\*.proto

## 三、编写 GRPC

### 1. 一元 RPC

> 一元 RPC 是指客户端发送一个请求到服务器，并获得一个响应，就像是一个简单的函数调用。


1. Proto

```proto
rpc SayHello (HelloRequest) returns (HelloReply) {};
```

2. server.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct{
	pb.UnimplementedGreeterServer
}

func (s *GreeterServer) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message: "Hello " + req.Name}, nil
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis,_ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}
```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHello(client)
}

func SayHello(client pb.GreeterClient) {
	resp, err := client.SayHello(context.Background(), &pb.HelloRequest{Name: "duty"})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", resp.Message)
}
```

### 2. 服务端流 RPC

> 服务端流 RPC 是指客户端发送一个请求到服务器，服务器可以返回多个流，直到没有任何消息返回。

1. Protot

```proto
rpc SayHelloAgain (HelloRequest) returns (stream HelloReply) {};
```

2. server.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct{
	pb.UnimplementedGreeterServer
}

// 服务端流式 RPC
func (s *GreeterServer) SayHelloAgain(req *pb.HelloRequest, stream pb.Greeter_SayHelloAgainServer) error {
	for i := 0; i < 10; i++ {
		if err := stream.Send(&pb.HelloReply{Message: "Hello " + req.Name}); err != nil {
			return err
		}
	}
	return nil
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis,_ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}

```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHelloAgain(client)
}

// 服务端流式 RPC
func SayHelloAgain(client pb.GreeterClient) {
	stream, err := client.SayHelloAgain(context.Background(), &pb.HelloRequest{Name: "duty"})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	for {
		resp, err := stream.Recv()
		if err != nil {
			break
		}
		log.Printf("Greeting: %s", resp.Message)
	}
}

```

### 3. 客户端流 RPC

> 客户端流 RPC 是指客户端发送多个请求到服务器，服务器返回一个响应。

1. Proto

```proto
rpc SayHelloStream (stream HelloRequest) returns (HelloReply) {};
```

2. server.go

```go
package main

import (
	pb "grpc-demo/proto"
	"io"
	"log"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct {
	pb.UnimplementedGreeterServer
}

// 客户端流式 RPC
func (s *GreeterServer) SayHelloStream(stream pb.Greeter_SayHelloStreamServer) error {
	for {
		req, err := stream.Recv()
		if err == io.EOF {
			return stream.SendAndClose(&pb.HelloReply{Message: "Hello " + "duty"})
		}
		if err != nil {
			return err
		}
		log.Printf("resp: %s", req)
	}
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis, _ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}

```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHelloStream(client)
}

// 客户端流式 RPC
func SayHelloStream(client pb.GreeterClient) {
	stream, err := client.SayHelloStream(context.Background())
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	for i := 0; i < 10; i++ {
		if err := stream.Send(&pb.HelloRequest{Name: "duty"}); err != nil {
			log.Fatalf("56 could not greet: %v", err)
		}
	}
	resp, err := stream.CloseAndRecv()
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", resp.Message)
}

```

### 4. 双向流 RPC

> 双向流 RPC 是指客户端和服务器都可以在双向流中发送多个消息。

1. Proto

```proto
rpc SayHelloStreamAll (stream HelloRequest) returns (stream HelloReply) {};
```

2. server.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"io"
	"log"
	"net"

	"google.golang.org/grpc"
)

type GreeterServer struct {
	pb.UnimplementedGreeterServer
}

// 双向流式 RPC
func (s *GreeterServer) SayHelloStreamAll(stream pb.Greeter_SayHelloStreamAllServer) error {
	n := 0
	for {
		err := stream.Send(&pb.HelloReply{Message: "Hello " + "duty"})
		if err != nil {
			return err
		}
		req, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}
		n++
		log.Printf("resp: %s,%d", req, n)
	}
}

func main() {
	server := grpc.NewServer()
	pb.RegisterGreeterServer(server, &GreeterServer{})
	lis, _ := net.Listen("tcp", ":8080")
	server.Serve(lis)
}
```

3. client.go

```go
package main

import (
	"context"
	pb "grpc-demo/proto"
	"io"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewGreeterClient(conn)
	SayHelloStreamAll(client)
}

// 双向流式 RPC
func SayHelloStreamAll(client pb.GreeterClient) error {
	stream, err := client.SayHelloStreamAll(context.Background())
	if err != nil {
		log.Fatalf("could not greet: %v", err)
		return err
	}
	for n := 0; n < 10; n++ {
		err := stream.Send(&pb.HelloRequest{Name: "duty"})
		if err != nil {
			log.Fatalf("could not greet: %v", err)
			return err
		}
		resp, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("could not greet: %v", err)
			return err
		}
		log.Printf("Greeting: %s", resp)
	}

	err = stream.CloseSend()
	if err != nil {
		log.Fatalf("could not greet: %v", err)
		return err
	}
	return nil
}

```

grpc的初次实践

错误如下

![image.png](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/562b3e34dcfb1d6591882addcceec5bc.image.png)


尝试使用换源解决失败，最后使用激活一个新的环境成功安装

    conda create --name myenv
    conda activate myenv






----------


上面的方法治标不治本


![image.png](https://gcore.jsdelivr.net/gh/blue-duty/gitnote-images/img/5c9bf6c791d4c2f6c549fcaee931f72b.image.png)

这个方法实测可用