一个低调的单终端登录系统

灰太狼 2023-02-19 13:27 4阅读 0赞

尝试在一周内学习 c++、grpc、bazel、docker compose、google test、gmock，然后实现一个单终端登录系统。

需求说明：

> 设计一套单终端登录系统
> 
> 1. 具备注册登录功能  
> 2. 一个用户只能在一个设备上登录，切换终端登录时，其他已登录的终端会被踢出

# 1 部署环境，构思项目流程 #

[grpc][]

[bazel][]

[Bazel: Building a C++ Project][Bazel_ Building a C_ Project]

[docker 莱鸟教程][docker]

[docker][docker 1]

项目的大致流程

1.  部署 grpc，bazel
2.  基于 grpc c++ 编写命令行客户端，采用 bazel 进行编译
3.  基于 grpc c++ 编写服务端，采用 bazel 进行编译
4.  部署 docker，docker compose
5.  创建 2 个镜像，服务端 user\_server 和 mysql，分别基于 user\_server 镜像和 mysq 镜像启动容器
6.  通过 bazel 编译启动客户端 user\_client
7.  使用Docker部署项目，并使用Docker Compose编排容器

思路很清晰，而现实很残酷，grpc 下载慢（多下几次），编译源码蹦出来各种坑（主要是依赖库没下好）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

嘴上一直说着不弄了，还好身体很诚实，一直坐着敲敲，终于整出了一个振奋人心的 “Hello world”。

![20200623234358764.png][]

![20200623234419462.png][]

# 2 表设计 #

**用户表**

CREATE TABLE `user` (
      `id` bigint(20) NOT NULL COMMENT '主键id',
      `mobile` varchar(255) NOT NULL COMMENT '手机号，用于登录',
      `password` varchar(32) DEFAULT NULL COMMENT '加密密码'，
      `create_time` datetime(0) NULL COMMENT '创建时间',
      `update_time` datetime(0) NULL COMMENT '更新时间',
      PRIMARY KEY (`id`),
      UNIQUE INDEX `phone_idx`(`phone`) USING HASH,
      INDEX()
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

**token表**

CREATE TABLE `billing`.`Untitled`  (
      `id` bigint(20) NOT NULL COMMENT '主键id',
      `phone` varchar(255) NULL COMMENT '手机号',
      `token` varchar(255) NULL COMMENT '加密后的 token',
      `status` tinyint(3) NULL COMMENT '状态：0生效 1失效',
      `expire_time` datetime(0) NULL COMMENT '过期时间',
      `device` varchar(255) NULL COMMENT '设备号',
      `create_time` datetime(0) NULL COMMENT '创建时间',
      `update_time` datetime(0) NULL COMMENT '更新时间',
      PRIMARY KEY (`id`),
      UNIQUE INDEX `phone_idx`(`phone`) USING HASH,
      INDEX()
    );

# 3 安全性设计 #

## 3.1 协议 ##

参考：[常见web安全问题][web]

> Even though users may use strong passwords, attackers might be able to eavesdrop on their connections. Use [HTTPS][] to avoid sending passwords (or any other sensitive data) over plain HTTP connections because they will be vulnerable to password sniffing.
> 
> 使用 HTTPS 替代 HTTP，HTTPS 比 HTTP 多了一层 SSL 安全协议，其主要任务是负责压缩和加密。

## 3.2 密码加密 ##

[PBKDF2][] 算法与 SHA256 哈希结合，这是 [NIST][] 推荐的密码扩展机制。PBKDF2 算法通过多次 hash 来对密码进行加密。原理是通过 password 和 salt 进行 hash，然后将结果作为 salt 再与 password 进行 hash，多次重复此过程，生成最终的密文。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1][]

### 3.2.1 PBKDF2 算法 ###

DK = PBKDF2(PRF, Password, Salt, c, dkLen)

> PRF 是一个伪随机函数，可以简单的理解为 Hash 函数，它会输出固定长度的字符串。
> 
> Password 是用来生成密钥的原文密码。
> 
> Salt 是一个加密用的盐值。
> 
> c 是进行重复计算的次数。
> 
> dkLen 是期望得到的密钥的长度。
> 
> DK 是最后产生的密钥。

### 3.2.2 SHA（安全哈希算法） ###

**安全散列算法**（Secure Hash Algorithm，缩写为SHA）是一个[密码哈希函数][Link 1]家族，是[FIPS][]所认证的安全[散列算法][Link 2]。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。

**SHA家族：**SHA-1（摘要长度为 160），SHA-2（SHA-224 、SHA-256、SHA-384、SHA-512），其中 224，256，384，512 是生成的消息摘要的长度。

[SHA256算法原理详解][SHA256]

[sha256的C++实现][sha256_C]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2][]

（[图片来源][Link 3]）

### 3.2.3 结合 PBKDF2 算法 与 SHA256 哈希算法加密用户密码 ###

// 计算次数
    #define COUNT = 2000;
    // 最终加密密码长度
    #define LENGTH = 32;
    
    // 待加密密码
    std::string password = "123456"; 
    // 随机盐值
    std::string salt = Encrypt::randomSalt();;
    // 初始化Sha256对象
    mySHA::Sha256 sha256; 
    // 经SHA256加密后的消息摘要
    std::string message_digest = sha256.getHexMessageDigest(message); 
    // 初始化 Pbkdf2 对象
    myPbkdf2::Pbkdf2 pbkdf2;
    std::string dk = pbkdf2.getDk(message_digest,password,password,salt,COUNT,LENGTH);

# 4 单终端登录控制 #

账号每次登录成功后，给客户端下发一个 token，用于后续的接口调用。服务端通过对 token 进行校验来对用户进行认证。

token：对 phone 进行哈希，返回 32 位的字符串，返回客户端，再用 PBKDF2 算法加密保存到数据库。

1.  客户端调用登录接口，传参 phone, password, deviceId；
2.  服务端校验 phone 和 password 是否正确，正确则往下执行；
3.  根据 phone 查询 token 表

*  为空，则生成新的 token 记录，status 置为 0 生效，过期时间置为 2 小时后，保存。
 *  不为空，判断时间是否过期，判断设备 id 是否一致，设备 id 一致则将上一条记录的状态置为 1 失效，新增一条token记录，保存。设备 id 不一致，通过deviceId\_old，往设备推送一条 push 消息，客户端接收到之后自动删除本地缓存的账号信息，并提示用户。

# **5 下线消息推送** #

通过 gRPC 框架的 stream 机制来实现下线通知的推送。

## 5.1 gRPC Streaming ##

普通的 gRPC 是直接返回一个 `Reply`对象，而流式响应可以通过方法返回多个 `HelloReply`对象，对象流序列化后流式返回。

### 5.1.1 Server-side streaming 服务端流式 ###

客户端发起一次普通的 RPC 请求，服务端通过流式响应，多次发送数据集。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3][]

### 5.1.2 Client-side streaming 客户端流式 ###

客户端通过流式发起多次 RPC 请求给服务端，服务端发起一次响应给客户端

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4][]

### 5.1.3 Bidiretional streaming 双向流式 ###

客户端以流式的方式发起请求，服务端同样以流式的方式响应请求。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5][]

## 5.2 消息推送实现 ##

基于服务端流式 RPC，向客户端推送下线通知。

# 5 项目的诞生 #

## 5.1 创建接口定义语言(interface definition language) ##

通过 protobuf 定义客户端和服务端交换的数据格式，以及服务端与客户端之间的 RPC 调用接口。如下：user.proto

syntax = "proto3";
    
    package user;
    
    service User {
    	
        rpc SignUp(UserInfo) returns (UserReply) {}
    
        rpc SignIn(UserInfo) returns (UserReply) {}
    }
    
    message UserInfo {
        string phone = 1;
        string password = 2;
        String device = 3;
    }
    
    message UserReply {
        int32 err = 1;
        string msg = 2;
        Data data = 3;
    }
    
    message Data {
        string token = 1;
    }

通过 protoc 工具生成客户端和服务端代码

protoc -I=./ --cpp_out=./ user.proto
    
    protoc -I=./ --grpc_out=./ --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` user.proto

当前目录下会生成四个文件：

> user.pb.cc：the header which declares your generated message classes
> 
> user.pb.h：which contains the implementation of your message classes
> 
> user.grpc.pb.cc：the header which declares your generated service classes
> 
> user.grpc.pb.h：which contains the implementation of your service classes

## 5.2 客户端伪代码  ##

std::string SignUp(const std::string& mobile, const std::string& password, const std::string device) {
            UserRequest request;
            request.set_mobile(mobile);
            // md5 第一次加密，结合盐值
            std::string salt = Encrypt::randomSalt();
            std::string pwdHash = Encrypt::md5(password + salt);
            request.set_password(pwdHash);   
            request.set_device(device);
            
            UserReply reply;
            ClientContext context;
    
            Status status = stub_->SignUp(&context, request, &reply);  
            if (status.ok()) {
                return "sign up success";
            } else {
                // 返回服务端回传的错误信息
                return message;
            }
        }
    
    std::string SignIn(const std::string& mobile, const std::string& password, const std::string device) {
            UserRequest request;
            // 密码加密
            request.set_mobile(mobile);
            std::string salt = Encrypt::randomSalt();
            std::string pwdHash = Encrypt::md5(password + salt);
            request.set_password(pwdHash);
            request.set_device(device);
    
            UserReply reply;     
            ClientContext context;
    
            Status status = stub_->SignIn(&context, request, &reply);
            // 根据状态码返回不同的信息
            if (status.ok()) {
                return "sign in success";
            } else {
                // 返回服务端回传的错误信息
                return message;
            }
    }

## 5.3 服务端伪代码 ##

ServerResult SignUp(ServerContext* context, const UserRequest* request,
                      UserReply* reply) override {
            UserDB userDb;
            ServerResult result;
            User user userDb->getUser(request->phone(),pwdHash);
            if(user != null){
                result->setErr(1);
                result->sermessage("user is exit, please sign in");
            }
            // PBKDF2算法加密密码
            // 根据 phone 生成 32 位的 token，回传客户端
            // PBKDF2算法加密token保存到数据库
    }
    
    ServerResult SignIn(ServerContext* context, const UserRequest* request,
                      UserReply* reply) override {
            UserDB userDb;
            ServerResult result;
            User user userDb->getUser(request->phone(),pwdHash);
            // 服务端校验 phone 和 password 是否正确
            // PBKDF2算法加密token再与 DB 中的 token 比较
            // 比较设备号
            if(device != ole_device){
                // 启动下线通知
            }
    }

# 6 Bazel 构建项目 #

Bazel的编译基于工作区（workspace）。工作区是一个存放了所有源代码和 Bazel 编译输出文件的目录，是整个项目的根目录。指定一个目录为 Bazel 的工作区，就只要在该目录下创建一个空的WORKSPACE 文件即可。

## 6.1 WORKSPACE文件 ##

WORKSPACE 文件 用于指定当前文件夹就是一个 Bazel 的工作区，所以 WORKSPACE 文件总是存在于项目的根目录下。此外，WORKSPACE 文件还用于引入其他文件系统或网络的第三方库（因此在不依赖第三方库构建时，WORKSPACE基本没用，可以看到官网 examples 中的 WORKSPACE 是个空文件）

**外部依赖：**[在 WORKSPACE 中引入外部依赖][WORKSPACE]

>  *  local\_repository：本地
>  *  git\_repository：git仓库
>  *  http\_archive：网络下载

本项目的 WORKSPACE 文件

# load加载http.bzl工具，用于以http_archive的方式进行依赖的下载
    load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
    
    http_archive(
        # 下载一个压缩格式的 Bazel 仓库，并解压出来，然后绑定使用。BUILD 文件根据 name 引用
        name = "com_github_grpc_grpc",
        urls = [
            "https://github.com/grpc/grpc/archive/v1.30.0.tar.gz",
        ],
        # 用来消除前缀目录
        strip_prefix = "grpc-1.30.0",
    )
    
    load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")
    
    grpc_deps()
    
    http_archive(
        name = "com_google_protobuf",
        strip_prefix = "protobuf-3.12.3",
        # Protocol Buffer 是一种轻便高效的结构化数据存储格式,可以用于结构化数据串行化,适用于RPC数据交换格式
        urls = ["https://github.com/protocolbuffers/protobuf/archive/v3.12.3.tar.gz"],
    )

## 6.2 BUILD 文件 ##

BUILD 文件用于告诉 Bazel 怎么构建项目，如果工作区中的一个目录包含 BUILD 文件，那么它就是一个 package。一个 BUILD 文件包含了几种不同类型的指令。其中最重要的是编译指令，用于指导 Bazel 编译。BUILD 文件中的每一条编译指令被称为一个 target，它指向一系列的源文件和依赖，一个 target 也可以指向别的 target。

### （1）客户端的 BUILD ###

cc_binary(
        # target 的名称
        name = "user_client",
        # 源文件
        srcs = ["user_client.cpp",
                "user_client.hpp",
                "user.grpc.pb.cc",
                "user.pb.cc",
                "user.grpc.pb.h",
                "user.pb.h"],
        deps = ["@com_github_grpc_grpc//:grpc++", "@com_github_grpc_grpc//:grpc_plugin_support"]
    )

### （2）服务端的 BUILD ###

cc_binary(
        name = "user_server",
        srcs = ["user.server.hpp",
                "user_server.cpp",
                "user.grpc.pb.cc",
                "user.pb.cc",
                "user.grpc.pb.h",
                "user.pb.h"],
    	includes = ["grpc/", "./"],
        deps = ["@com_github_grpc_grpc//:grpc++",
                "@com_github_grpc_grpc//:grpc_plugin_support",
                "@mysql_connector//:mysql_connector"]
    )

## 6.3 编译项目 ##

首先进入到 user 目录下，执行一下命令

编译客户端

bazel build //main:user_client

编译服务端

bazel build //main:user_server

注意target中的`//main:`是BUILD文件相对于WORKSPACE文件的位置，`user-client 和 user-server`则是 BUILD 文件中命名好的 target 的名字。

一切都看似很正常，突然，bug 来了

![20200627190535461.png][]

> error loading package '@com\_github\_grpc\_grpc//': in /private/var/tmp/\_bazel\_vincentwen/617a9793a26c68f1cfb352d1cc00ccbb/external/com\_github\_grpc\_grpc/bazel/grpc\_build\_system.bzl:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7][]

*  预测是网络问题，导致包没下好，清除该缓存目录，重新编译，重复循环多次。只有一次成功，所以真的是包的问题。
 *  WORKSPACE 和 BUILD 还没理解透
 *  部署到 docker 去编译，非常好，依旧编译失败
 *  把手动把包下到本地，再用本地库引入项目，再编译，失败
 *  更新 bazel 再编译，brew upgrade bazel，再编译，失败
 *  @com\_github\_grpc\_grpc 定义在 bazel:grpc\_deps.bzl 里
 *  后来我遇到了 bazel build，虽然依旧编译失败 [Linux开发环境学习--bazel+gtest在c++项目中的使用][Linux_--bazel_gtest_c]

> **其中"…"表示编译该项目中的所有模块，包括依赖项目。**

就有缘再来解决你了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 8][]

## 6.4 **Mac 生成项目树形结构图** ##

# 安装 tree
    brew install tree
    
    # 安装后在文件夹内执行
    tree

# 7 Docker Compose 部署项目 #

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Compose 使用的三个步骤：

*  使用 Dockerfile 定义应用程序的环境。
 *  使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
 *  最后，执行 docker-compose up 命令来启动并运行整个应用程序。

## 7.1 服务端 user\_server 镜像 ##

Dockerfile 文件

FROM ubuntu
    
    ADD . /user_server
    WORKDIR /user_server
    
    RUN set -e; \
      apt-get update; \
      apt-get install -y curl gnupg; \
      echo "deb [arch=amd64] https://storage.googleapis.com/bazel-apt stable jdk1.8" | tee /etc/apt/sources.list.d/bazel.list \
      curl https://bazel.build/bazel-release.pub.gpg | apt-key add -; \
      apt-get update; \
      apt-get install -y bazel; \
      apt-get install --only-upgrade -y bazel; \
      bazel build ...; \
      apt-get update; \
      apt-get install build-essential;

## 7.2 mysql 镜像 ##

Dockerfile 文件

FROM mysql
    
    # ARGS
    ARG CHANGE_SOURCE=false
    
    # Change Timezone
    ARG TIME_ZONE=UTC
    ENV TIME_ZONE ${TIME_ZONE}
    RUN ln -snf /usr/share/zoneinfo/$TIME_ZONE /etc/localtime && echo $TIME_ZONE > /etc/timezone
    
    
    RUN  apt-get -o Acquire::Check-Valid-Until=false update && apt-get -y upgrade
    
    # Install Base Components
    RUN apt-get install -y --no-install-recommends cron vim curl

##  7.3 docker-compose.yml ##

version: '3'
    services:
      ### user server container #########################################
      server:
          build: ./grpc/server
          ports:
            - "50051:50051"
          depends_on:
            - mysql
          links:
            - mysql:mymysql
          restart: always
          networks:
            - default
    
      ### Mysql container #########################################
    
      mysql:
          build: ./mysql
          ports:
            - "3306:3306"
          volumes:
            - ./mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf
          privileged: true
          environment:
            - MYSQL_DATABASE=user
            - MYSQL_USER=root
            - MYSQL_PASSWORD=123456
            - MYSQL_ROOT_PASSWORD=123456
          restart: always
          networks:
            - default

# 8 项目的启动 #

## 8.1 启动服务端 ##

通过 docker compose 启动

cd user
    docker-compose up --build

## 8.2 启动客户端 ##

通过 bazel 编译运行

cd user
    
    bazel build ... 
    
    bazel-bin/main/user_client

# 9 复盘 #

**正确流程：**

1 用 bazel 编译 grpc 的 helloworld 项目，生成可执行文件

2 为 helloworld 的服务端创建镜像，部署到 docker，创建相应的容器

3 docker 启动 helloworld 的服务端容器，执行可执行文件

4 本地启动 helloworld 的客户端

上面调通后，开始加入注册登录逻辑，再一步步调试

**踩坑**  
1 grpc 下载慢，依赖库过于庞大。bazel 编译 grpc项目不通过，占用了很久的时间，导致代码逻辑思考时间很少。

2 概念不清晰，要先弄清楚配置相互间的关系，便于改错，如 WORKSPACE 和 BUILD 还没理解透

3 本地编译失败后，部署到 docker 里编译，依旧编译失败

4 网络得好，不然疯狂踩坑

[grpc]: https://www.grpc.io/docs/languages/cpp/quickstart/
[bazel]: https://docs.bazel.build/versions/3.3.0/install-os-x.html#install-on-mac-os-x-homebrew
[Bazel_ Building a C_ Project]: https://docs.bazel.build/versions/3.3.0/tutorial/cpp.html
[docker]: https://www.runoob.com/docker/docker-tutorial.html
[docker 1]: https://docs.docker.com/get-started/#docker-concepts
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200621225954752.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[20200623234358764.png]: https://img-blog.csdnimg.cn/20200623234358764.png
[20200623234419462.png]: https://img-blog.csdnimg.cn/20200623234419462.png
[web]: https://docs.djangoproject.com/en/3.0/topics/auth/passwords/
[HTTPS]: https://docs.djangoproject.com/en/3.0/topics/security/#security-recommendation-ssl
[PBKDF2]: https://en.wikipedia.org/wiki/PBKDF2
[NIST]: https://dx.doi.org/10.6028/NIST.SP.800-132
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200629224805670.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[Link 1]: https://baike.baidu.com/item/%E5%AF%86%E7%A0%81%E6%95%A3%E5%88%97%E5%87%BD%E6%95%B0
[FIPS]: https://baike.baidu.com/item/FIPS
[Link 2]: https://baike.baidu.com/item/%E6%95%A3%E5%88%97%E7%AE%97%E6%B3%95
[SHA256]: https://blog.csdn.net/u011583927/article/details/80905740
[sha256_C]: https://www.cnblogs.com/padana/p/8305628.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200630003353652.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[Link 3]: https://blog.csdn.net/flymoringbird/article/details/99004784?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-13.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-13.nonecase
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200630235933772.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200701000015981.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200701000105745.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[WORKSPACE]: https://docs.bazel.build/versions/3.3.0/external.html
[20200627190535461.png]: https://img-blog.csdnimg.cn/20200627190535461.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200627190450611.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200705110833750.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70
[Linux_--bazel_gtest_c]: https://blog.csdn.net/likewind1993/article/details/104891958
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200705120129769.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw,size_16,color_FFFFFF,t_70