关键点：

• 3478 必须放行 UDP（不是 TCP）：很多云安全组 TCP/UDP 分开选，别选错。
• 不要对公网暴露 3477：只监听 127.0.0.1，由反代统一出入口。

1. 前置准备（替换占位符）

把下面占位符替换成你的值：

• hs.example.com：你的控制面域名（必须 HTTPS 可访问）
• SERVER_PUBLIC_IP：服务器公网 IPv4
• REGION_CODE：自建 DERP code（建议小写，例如 myderp）

准备项：

• 一台 Linux 服务器（有公网 IPv4）
• 一个域名 A 记录指向 SERVER_PUBLIC_IP
• 已有证书（或你能自己搞定 ACME 申请；本文不展开）
• Nginx 或 OpenResty 已安装

2. 安装 Headscale（二进制）

从 juanfont/headscale 的 Releases 下载与你机器架构匹配的二进制：

• juanfont/headscale Releases

安装到 /usr/local/bin/headscale：

1
2
3

sudo cp ./headscale /usr/local/bin/headscale
sudo chmod 0755 /usr/local/bin/headscale
/usr/local/bin/headscale version

小坑：如果遇到 sudo headscale: command not found，多半是 sudo 的 secure_path 不含 /usr/local/bin。本文后续统一用绝对路径：sudo /usr/local/bin/headscale ...

3. 生成必须密钥（v0.28+ 常见强制项）

创建目录：

1
2

sudo mkdir -p /etc/headscale /var/lib/headscale
sudo chmod 700 /var/lib/headscale

生成 Noise 私钥：

1
2
3

sudo /usr/local/bin/headscale generate private-key \
  | sudo tee /var/lib/headscale/noise_private.key >/dev/null
sudo chmod 600 /var/lib/headscale/noise_private.key

说明：这里用 tee 是为了解决“sudo + 重定向”权限问题（sudo cmd > file 的重定向不在 sudo 权限里执行）。
另外，内容通常带 privkey: 前缀，别手动删，否则可能报 “expected type prefix privkey:”。

4. 写入 Headscale 配置（最小可用模板）

保存为：/etc/headscale/config.yaml

说明：先关闭 DNS/MagicDNS，减少必填项耦合；跑通后再按「进阶」章节开启。

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
58

# /etc/headscale/config.yaml

# 必须替换：你的控制面公网 HTTPS 地址（反代场景也一样）
server_url: "https://hs.example.com" # ← 替换为你的域名

# 只在本机监听，由 Nginx/OpenResty 对外提供 443
listen_addr: "127.0.0.1:3477"

tls_cert_path: ""
tls_key_path: ""

prefixes:
  v4: "100.64.0.0/10"
  v6: "fd7a:115c:a1e0::/48"

database:
  type: sqlite
  sqlite:
    path: "/var/lib/headscale/db.sqlite"

# v0.28+ 常见强制项：Noise 私钥
noise:
  private_key_path: "/var/lib/headscale/noise_private.key"

# 先关闭 DNS 功能，避免引入 base_domain/nameservers 等额外必填项
dns:
  magic_dns: false
  override_local_dns: false

derp:
  server:
    enabled: true
    # 可替换：自建 DERP 的 region 信息（便于识别/排查；避免与官方冲突即可）
    region_id: 901                 # ← 可改；只要不和官方/其他自建重复即可
    region_code: "REGION_CODE"     # ← 必须替换：建议小写，例如 "myderp"
    region_name: "REGION_NAME"     # ← 必须替换：随便取一个可读名字即可

    private_key_path: "/var/lib/headscale/derp_server_private.key"

    # STUN（UDP/3478）
    stun_listen_addr: "0.0.0.0:3478"

    # 告诉客户端 DERP 的公网入口（域名 + 公网 IPv4）
    hostname: "hs.example.com"     # ← 必须替换：你的域名（与 server_url 一致）
    ipv4: "SERVER_PUBLIC_IP"       # ← 必须替换：服务器公网 IPv4

    # 更安全：只允许你 tailnet 的节点使用这个 DERP
    verify_clients: true

    automatically_add_embedded_derp_region: true

  # 建议保留官方 DERP 兜底（否则单点）
  urls:
    - "https://controlplane.tailscale.com/derpmap/default"
  paths: []

log:
  level: "info"

配置校验（必须过）：

1

sudo /usr/local/bin/headscale configtest -c /etc/headscale/config.yaml

5. systemd 启动 Headscale

创建：/etc/systemd/system/headscale.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[Unit]
Description=Headscale
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
ExecStart=/usr/local/bin/headscale serve -c /etc/headscale/config.yaml
Restart=on-failure
RestartSec=3
LimitNOFILE=1048576

[Install]
WantedBy=multi-user.target

启动并自启：

1
2
3

sudo systemctl daemon-reload
sudo systemctl enable --now headscale
sudo systemctl status headscale --no-pager

生产提示：为简单起见，上面未指定 User=/Group=，默认 root 运行。生产环境建议创建专用用户（如 headscale）并收紧 /var/lib/headscale 权限后再以非 root 运行。

6. Nginx/OpenResty 反代（关键是 Upgrade + 长连接）

示例：/etc/nginx/conf.d/headscale.conf

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

map $http_upgrade $connection_upgrade {
  default upgrade;
  ''      close;
}

server {
  listen 443 ssl;
  http2 on;
  server_name hs.example.com;

  ssl_certificate     /path/to/fullchain.pem;
  ssl_certificate_key /path/to/privkey.pem;

  location / {
    proxy_pass http://127.0.0.1:3477;

    proxy_http_version 1.1;
    proxy_set_header Host              $host;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto https;

    # DERP/控制面都可能需要 Upgrade（保险起见全站都保留）
    proxy_set_header Upgrade    $http_upgrade;
    proxy_set_header Connection $connection_upgrade;

    proxy_read_timeout  3600s;
    proxy_send_timeout  3600s;
    proxy_buffering off;
  }
}

检查并重载：

1
2

sudo nginx -t
sudo systemctl reload nginx

7. 创建用户 + 客户端接入

先说明一下什么是“用户（user）”：

• Headscale 的 user 不是登录账号/密码体系，而是一个命名空间/分组：把一批设备（nodes）归到同一个用户下面，便于管理与发放入网 key。
• 个人/小团队最常见：只建 1 个 user，然后所有设备都加入这个 user。
• tailnet-user 只是示例名，你可以改成自己的（例如 alice / team-a）。

创建用户：

1
2
3

# 创建一个 user（示例名：tailnet-user）
sudo /usr/local/bin/headscale users create tailnet-user
sudo /usr/local/bin/headscale users list

生成 preauth key（优先用用户名；旧版本不支持再用数字 ID）：

1
2
3
4
5

# 优先：直接用用户名
sudo /usr/local/bin/headscale preauthkeys create -u tailnet-user --reusable --expiration 24h

# 兜底：用 users list 里的 USER_ID
sudo /usr/local/bin/headscale preauthkeys create -u USER_ID --reusable --expiration 24h

客户端加入（Linux 示例）：

1
2
3
4
5
6

sudo tailscale up \
  --reset \
  --login-server https://hs.example.com \
  --authkey hskey-auth-xxxxxxxxxxxxxxxx \
  --accept-dns=false \
  --accept-routes

后续新增设备：重复本节“生成 key → 客户端 tailscale up”即可。

8. 验收清单（所有检查统一在这里做）

8.1 服务器侧

1
2
3
4
5
6

sudo /usr/local/bin/headscale configtest -c /etc/headscale/config.yaml
systemctl status headscale --no-pager
sudo ss -lntp | egrep ':443|:3477'
sudo ss -ulnp | egrep ':3478'
curl -i https://hs.example.com/derp
sudo /usr/local/bin/headscale nodes list

看到 curl -i https://hs.example.com/derp 返回 426 且包含 DERP requires connection upgrade：正常（代表路由打通）。

8.2 客户端侧（最重要）

1
2
3

tailscale status
tailscale ping <peer_100.64.x.x>
tailscale netcheck

tailscale status 速记：

• relay / via DERP(...)：走 DERP 中继（慢一些，但能通）
• direct：P2P 打洞成功（更快、更稳定）

9. 常见疑难杂症（只保留“现象级”问题）

Q1：一直走很远的 DERP（例如 DERP(nue)），不走自己的 REGION_CODE

优先用裁判命令：

1

tailscale netcheck

常见原因：

• derp.server.hostname/ipv4 没配全或配错
• 客户端被代理影响（netcheck 会出现 tshttpproxy: using proxy ...）

Q2：客户端日志出现 dial tcp4 SERVER_PUBLIC_IP:3477: i/o timeout

典型“反代场景端口混淆”：

• 客户端误以为 DERP 对外端口是 3477
• 但 3477 只在本机回环监听，公网必超时

根治：确保 server_url 是 https://hs.example.com，并在 derp.server 明确：

• hostname: hs.example.com
• ipv4: SERVER_PUBLIC_IP

Q3：macOS 节点名变成 invalid-xxxxx

Headscale 对 hostname 限制严格（小写字母/数字/-/.）。macOS 设备名带中文/空格等会被拒绝。

修复：在服务器端用 headscale nodes rename 改“显示名”（需要节点 ID；先用 headscale nodes list 查到 ID 即可）。示例（一步）：

1

sudo /usr/local/bin/headscale nodes rename -i <node-id> mac-home

Q4：tailscale debug derp REGION_CODE 里 IPv6 报错，但 IPv4 OK

域名只有 A 记录、无 AAAA 且服务器无公网 IPv6 时属于正常探测失败；只要实际 tailscale ping 正常即可忽略。

10. 进阶（可选）：MagicDNS / Split DNS / Subnet Router

10.1 MagicDNS：用机器名互访

开启 MagicDNS 时 必须配置 base_domain，并且建议显式设置 nameservers.global：

1
2
3
4
5
6
7
8
9
10
11

dns:
  magic_dns: true
  base_domain: tailnet.internal
  override_local_dns: true
  nameservers:
    global:
      - 1.1.1.1
      - 8.8.8.8
      # 国内服务器如遇解析超时/阻断，可替换为：
      # - 223.5.5.5     # 阿里 DNS
      # - 119.29.29.29  # 腾讯 DNS

客户端侧需要接收 DNS 下发：

1

sudo tailscale up --accept-dns=true

10.2 Split DNS：只分流特定后缀到公司 DNS

模板（示例）：

1
2
3
4
5
6
7
8
9
10
11

dns:
  magic_dns: true
  base_domain: tailnet.internal
  override_local_dns: true
  nameservers:
    global:
      - 1.1.1.1
      - 8.8.8.8
    split:
      company.local:
        - COMPANY_DNS_IP

关键前提：如果 COMPANY_DNS_IP 在公司内网网段里，你在家里必须先通过 Subnet Router 把这个网段路由进 Tailnet，否则会出现“DNS 服务器不可达”。

10.3 Subnet Router：把公司内网网段“桥接进 Tailnet”

在公司内网找一台长期在线且已入网的机器，执行（示例网段）：

关键步骤：开启内核 IP 转发（Subnet Router 必须）

1 2 3

echo 'net.ipv4.ip_forward = 1' | sudo tee /etc/sysctl.d/99-tailscale.conf echo 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf sudo sysctl -p /etc/sysctl.d/99-tailscale.conf

1
2
3

sudo tailscale up \
  --advertise-routes=192.168.10.0/24 \
  --accept-dns=false

在 headscale 上批准路由：

1
2

sudo /usr/local/bin/headscale routes list
sudo /usr/local/bin/headscale routes enable -r <route-id>

在家里的机器上接收路由：

1

sudo tailscale up --accept-routes

引言

Hexo是一个快速、简单、功能强大的博客框架，基于Node.js开发，以其生成静态页面的高效性而广受欢迎。它让创作者能够专注于内容本身，而将网站搭建和部署的复杂性降至最低。本文将详细指导您如何在一个已有的Hexo项目中，从撰写到发布的完整流程，确保您的精彩内容能够顺利与读者见面。

前置条件：已克隆的Hexo项目

假设您已经将包含Hexo博客的Git仓库（例如 tianyk/note）克隆到了本地的工作目录，路径为 coding/note。所有的操作都将在这个项目的根目录下进行。

第一步：创建新文章

Hexo通过命令行工具简化了文章的创建过程。您只需一个命令，即可生成带有预设结构的Markdown文件。

1. 进入项目目录：
   首先，确保您在Hexo项目的根目录下：

   1	cd coding/note

2. 使用 hexo new 命令：
   执行以下命令来创建一篇新文章，将 "您的文章标题" 替换为您博客文章的实际标题。

   1	hexo new "您的文章标题"

   此命令会在 coding/note/source/_posts/ 目录下创建一个新的Markdown文件（例如 您的文章标题.md），并根据 scaffolds/post.md 模板自动填充一些基本内容。

第二步：编辑文章内容

新创建的Markdown文件是您撰写文章的核心。它由两部分组成：YAML Front Matter（元数据）和文章正文。

1. 打开文章文件：
   您需要使用文本编辑器打开 coding/note/source/_posts/您的文章标题.md。

2. YAML Front Matter：
   文件顶部由三横线 --- 包裹的部分是文章的元数据，称为YAML Front Matter。您需要根据文章内容修改这些信息。

   1 2 3 4 5 6 7 8 9

   --- title: 您的文章标题 # 文章的显示标题 date: YYYY-MM-DD HH:MM:SS # 文章发布日期和时间，建议精确到秒 tags: # 文章标签，可以有零个、一个或多个 - Hexo - 教程 categories: # 文章分类，可以有零个、一个或多个 - 技术分享 ---

   请注意，tags 和 categories 可以方便读者进行分类检索。

3. 文章正文：

   在YAML Front Matter之后，您可以使用标准的Markdown语法撰写文章内容。包括标题、段落、列表、代码块、图片链接等。

第三步：本地预览文章

在正式发布之前，强烈建议您在本地预览文章，确保其布局、格式和内容符合预期，避免不必要的修改和重复部署。

1. 启动本地服务器：
   在 coding/note 项目根目录下，运行以下命令启动Hexo的本地服务器。如果您希望预览草稿文章，请使用 npm run dev。

   1 2 3

   npm run dev # 或者直接使用 hexo s --draft (会显示草稿，即使未指定为 post 类型) # 或者 hexo s (只预览已发布状态的文章)

   服务器通常会在 http://localhost:4000 端口运行。

2. 浏览器检查：
   在您的Web浏览器中访问 http://localhost:4000，并导航到您新创建的文章页面，仔细检查显示效果。

第四步：编译、提交并推送至Git仓库

当您对文章内容和排版满意，并在本地预览确认无误后，即可准备发布。由于您的部署流程涉及独立服务器拉取并编译，这里的“发布”指的是将所有更新（包括生成的网站文件）推送到您的Git仓库。

1. 编译网站文件：
   在提交任何新内容或修改后，您需要首先在 coding/note 项目根目录下运行编译命令。这将根据您的Markdown文件生成静态的HTML、CSS、JavaScript等网站资源。

   1 2	npm run build # 或者直接使用 hexo g

   此命令会在 coding/note/public/ 目录下创建或更新所有需要部署的网站文件。

2. 提交更改：
   确保已生成的网站文件（位于 public/ 目录）以及您的源文件（新文章、图片或其他资源）都被Git追踪。然后，将这些更改添加到Git的暂存区，并进行提交。

   1 2 3

   cd coding/note git add . git commit -m "feat: 发布新博客文章 - [您的文章标题]"

   请将提交信息中的 [您的文章标题] 替换为实际的文章标题。

3. 推送更改：
   最后，将本地的提交推送到远程Git仓库。

   1 2	git push origin master # 如果您的主分支是 main，则使用 git push origin main

进阶优化与常见问题：让发布之旅更顺畅

在Hexo博客的撰写和发布过程中，我们可能会遇到一些初始化或环境配置上的小挑战。以下是一些常见问题及其解决方案，希望能帮助您的发布之旅更加顺畅：

1. Hexo命令未识别的问题

初次使用Hexo时，如果直接输入 hexo new 等命令发现系统提示“command not found”，这通常是因为Hexo工具没有被正确地加入到您的系统路径中。
解决方案：建议使用 npx hexo new 命令。npx 是一个强大的工具，它允许您执行npm包中的命令，无论这些包是全局安装的还是项目本地安装的，确保您能够顺利地使用Hexo的各项功能。

2. 依赖安装速度缓慢的问题

在项目初始化阶段运行 npm install 来安装项目依赖时，可能会遇到安装速度非常慢，甚至卡顿的情况。这通常与网络环境、npm注册表响应速度或node_modules的缓存机制有关。
解决方案：

• 优化镜像源：确保您的项目或全局npm配置指向一个快速的镜像源（例如，在项目根目录的 .npmrc 文件中配置 registry = https://registry.npmmirror.com）。
• 切换包管理器：如果项目存在 pnpm-lock.yaml 文件（表明项目可能期望使用 pnpm），强烈建议切换到 pnpm install。pnpm 以其独特的包管理方式，通常能提供更快的安装速度和更高效的磁盘空间利用。

3. Git提交时身份信息缺失

在尝试 git commit 时，如果遇到“Author identity unknown”的错误提示，这意味着Git客户端尚未知道是谁在进行这次提交。

解决方案：您需要在Git配置中设置提交者的用户名称和邮箱。您可以使用以下命令为当前项目配置（推荐）或全局配置：

1
2
3

git config user.email "ai@example.com"
git config user.name "OpenClaw AI"

4. Git推送时的凭证验证问题

当您运行 git push 命令时，如果 Git 提示需要用户名和密码进行身份验证，这通常发生在您使用HTTPS方式克隆仓库，并且凭证未被缓存的情况下。AI通常无法直接输入这些凭证。

解决方案：

• 切换到SSH协议：将Git远程仓库的URL从HTTPS格式（https://github.com/user/repo.git）修改为SSH格式（git@github.com:user/repo.git）。

  1 2	git remote set-url origin git@github.com:user/repo.git

  这允许Git使用您系统上已配置的SSH密钥进行免密验证。

• 配置SSH密钥：确保您的宿主机器已生成并配置了SSH密钥，并将公钥添加到了您的Git服务提供商（如GitHub）的账户设置中。

5. SSH主机真实性验证提示

当您首次通过SSH协议连接到一个新的Git宿主时，可能会收到一个安全提示，询问“Are you sure you want to continue connecting (yes/no/[fingerprint])?”，要求您验证主机的真实性。

解决方案：这是一个必要的安全步骤。您需要在宿主机器的终端中，手动对该提示输入 yes 并回车。这将把该Git宿主的公钥指纹添加到您系统上的 ~/.ssh/known_hosts 文件中，确保后续的SSH连接能够直接被信任。

预集成这些经验，希望能让您未来的Hexo博客管理和发布工作更加便捷高效。

结语

通过以上步骤，您可以高效地在Hexo博客中撰写、预览并发布新的文章。专注于高质量的内容创作，而技术细节将由Hexo和您的自动化部署流程轻松处理。祝您写作愉快！

大模型有训练和推理两部分，训练会产生一个大模型文件，这些文件通常包含了模型架构以及每个神经元的权重和偏置值。llama.cpp主要用在推理部分，它是一个是一个使用c++开发的大模型推理框架。它可以在普通家用电脑上完成推理，只需要CPU和几个G的内存就能运行。

编译安装

参考 https://github.com/ggerganov/llama.cpp?tab=readme-ov-file#build

1. 拉取代码

   1	git clone https://github.com/ggerganov/llama.cpp.git

2. 编译

   对于非Apple Silicon系列芯片推理时如果有问题可以在编译时禁用GPU。编译时使用LLAMA_NO_METAL=1或者LLAMA_METAL=OFF参数。https://github.com/ggerganov/llama.cpp?tab=readme-ov-file#metal-build

   1

   make

编译完成会参数mian和quantize文件，前者用来运行大模型推理，后者用来模型向量化处理。

模型转换

一般大模型文件都托管在Hugging Face上面。一般情况下llama.cpp不能直接使用这些大模型进行推理，我们需要先对这些模型进行转换，转为ggml格式。支持转换的大模型列表参考官方README国产大模型百川、千问等都支持转为ggml格式。

转换使用llama.cpp项目内的convert.py或者convert-hf-to-gguf.py处理，详细步骤参考 https://github.com/ggerganov/llama.cpp?tab=readme-ov-file#prepare-data--run。这里对Python版本有一定的要求，模块的依赖在requirements.txt和requirements目录下。

一般情况先使用convert.py转换，如果转换失败在使用convert-hf-to-gguf.py尝试处理。注意，使用convert-hf-to-gguf.py时需要我们安装额外的依赖，依赖列表在requirements/requirements-convert-hf-to-gguf.txt。

转换后的模型我们需要进行向量化，使用./quantize对转换后的模型进行向量化。向量化后的模型就可以进行推理了。

和llama.cpp类似的工具

• chatglm.cpp

  一个用于ChatGLM大模型推理框架

• PowerInfer

  • 一个可以在消费级GPU运行的大模型推理框架

Hugging Face 镜像

• modelscope

  可以直接使用git clone拉取大模型。注意，需要安装LFS

• hf-mirror

  配置镜像后可以使用huggingface官方命令行huggingface-cli工具下载模型文件

  1	export HF_ENDPOINT=https://hf-mirror.com

名词解释

• B
  大模型权重参数单位，1B表示十亿。例如有7B、14B表示参数有70亿和140亿，参数越大推理时耗费的资源越多

• FP16、int8、int4

  FP16、int8、int4 等通常指的是模型权重、激活值或梯度的数值表示方式，表示数值精度。

  FP16 指的是 16 位浮点数（即半精度浮点数），每个数值占用 2 字节。

  int8 指的是 8 位整数，每个数值占用 1 字节。

  1B的FP16精度的大模型为1000,000,000 * 2Byte ≈ 2GB，1B的int8精度的大模型为1000,000,000 * 1Byte ≈ 1GB

• Quantization (量化)

  量化 是一种通过降低数值表示精度（如将 FP32 降为 int8）的技术，以减少内存和计算资源的消耗。

  量化后的模型可以在内存占用和计算复杂度方面更高效，尤其是在推理阶段显著提高速度。

在有多个goroutines同时访问并且至少有一个goroutines在修改数据的情况下就会存在并发问题。Golang处理并发安全有锁和channel两种方案，前者通过加锁方式保证同一时刻只有一个操作在访问数据，后者是将操作串行化来来实现同一时刻只能有一个操作访问数据。这两种方法都是在通过约束并发访问/修改数据来解决并发安全问题。

在Golang官网有一段关于并发安全的建议：

Advice

Programs that modify data being simultaneously accessed by multiple goroutines must serialize such access.
To serialize access, protect the data with channel operations or other synchronization primitives such as those in the sync and sync/atomic packages.
If you must read the rest of this document to understand the behavior of your program, you are being too clever.
Don’t be clever.

下面我将从实现一个并发安全的队列来介绍Golang里面的并发工具。

并发安全的队列

一个简单的队列最少有Add和Pop两个操作，队列内部一般通过列表或者链表来存放数据。这两个操作都是对底层的列表或者链表的写操作。底层的列表和链表并不是并发安全的，在多个goroutines在同时Add或Pop时就会有并发问题。

要实现一个并发安全的队列，就要在Add和Pop操作加锁：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

type Queue struct {
    elements []interface{}
    lock *sync.Mutex
}

func (q *Queue) Pop() (ele interface{}) {
    q.lock.Lock()
    defer q.lock.Unlock()

    ele = q.elements[q.Size()-1]
    q.elements = q.elements[:q.Size()-1]
    return
}

func (q *Queue) Add(ele interface{}) {
    q.lock.Lock()
    defer q.lock.Unlock()

    q.elements = append(q.elements, ele)
}

考虑到现实的情况，我们队列的容量不能是没有限制的，这会有内存方面的问题，我们要限制队列的容量。队列空的时候Pop时我们要阻塞直到有值，队列满时我们Add要阻塞到队列不满，这种情况就需要sync.Cond来阻塞。它和Java中的内置条件队列类似，可以使当前goroutine在某个状态上一直等待，直到这个状态被激活。

我们需要两个sync.Cond条件来分别表示队列为空和队列满两种状态，这两个sync.Cond内部要使用同一把锁用在操作Add和Pop来避免并发问题。

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
58
59
60
61
62
63
64
65
66
67
68
69

type Queue struct {
    elements []interface{}
    capacity int

    // 队列未空条件队列
    notEmptyCond *sync.Cond
    // 队列未满条件队列
    notFullCond *sync.Cond
}

func (q *Queue) Size() int {
    return len(q.elements)
}

func (q *Queue) isFull() bool {
    return q.Size() >= q.capacity
}

func (q *Queue) isEmpty() bool {
    return q.Size() == 0
}

func (q *Queue) Pop() (ele interface{}) {
    q.notEmptyCond.L.Lock()
    defer q.notEmptyCond.L.Unlock()

    for q.isEmpty() {
        // 如果队列是空的，就在 `notEmptyCond` 条件上等待 
        // Wait 内部会先释放锁，等到收到满足信号时将重新尝试获得锁
        q.notEmptyCond.Wait()
    }

    ele = q.elements[q.Size()-1]
    q.elements = q.elements[:q.Size()-1]
    // 此时队列中已经 Pop 一个值，不再满。发送`notFullCond`信号激活再此条件 `Wait` 的操作
    q.notFullCond.Signal()
    return
}

// Add
func (q *Queue) Add(ele interface{}) (err error) {
    q.notEmptyCond.L.Lock()
    defer q.notEmptyCond.L.Unlock()

    for q.isFull() {
       q.notFullCond.Wait()
    }

    q.elements = append(q.elements, ele)
    // 此时队列中已经有值，发送队列不为空的信号激活再此条件 `Wait` 的操作
    q.notEmptyCond.Signal()
    return
}

func NewQueue(capacity int) *Queue {
    // 使用同一把锁
    var lock sync.Mutex
    notEmptyCond := sync.NewCond(&lock)
    notFullCond := sync.NewCond(&lock)

    return &Queue{
        elements: make([]interface{}, 0, capacity),
        capacity: capacity,

        notEmptyCond: notEmptyCond,
        notFullCond:  notFullCond,
    }
}

Cond.Wait()在没有收到条件满足信号时会一直阻塞，有时会出现父goroutine异常退出时子goroutine还在等待的情况。比如下面的例子：

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

func TestQueue_Add(t *testing.T) {
    queue := NewQueue(10)
     // 系统当前`goroutine`数量
    expectedNumGoroutine := runtime.NumGoroutine()

    // 新起一个协程 `Pop`，由于队列此时为空。`Pop` 操作永远不会返回
    // chanel要有缓冲区，如果父`goroutine`提前退出，chanel无接收者时。done <- ele 会阻塞，此`goroutine`将不能退出，造成 goroutine leak。
    done := make(chan interface{}, 1)
    go func() {
        // 如果父`goroutine`此时已经退出，这时`Pop`出来的消息将丢失
        ele, _ := queue.Pop()
        done <- ele
    }()

    select {
    case <-time.After(100 * time.Millisecond):
        // parent goroutine exit
        // 由于Pop操作此时还没返回，实际协程数量+1
        assert.Equal(t, expectedNumGoroutine+1, runtime.NumGoroutine())
    case <-done:
        assert.Equal(t, expectedNumGoroutine, runtime.NumGoroutine())
    }
    queue.Add(1)
    time.Sleep(time.Millisecond)

    // 这条消息可能会在父`goroutine`退出后才返回
    assert.Equal(t, 1, <-done)
    assert.Equal(t, 0, queue.Size())
}

要解决上面问题，我们就需要使用来Context来取消子goroutine。下面是完整的例子：

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

import (
    "context"
    "sync"

    "github.com/pkg/errors"
)

// waitWithCancel 可取消的 Wait
func waitWithCancel(ctx context.Context, cond *sync.Cond) error {
    if ctx.Done() != nil {
        done := make(chan struct{})
        go func() {
            cond.Wait()
            close(done)
        }()

        select {
        case <-ctx.Done():
            return errors.Wrap(ctx.Err(), "cancel wait")
        case <-done:
            return nil
        }
    } else {
        cond.Wait()
        return nil
    }
}

type Queue struct {
    elements []interface{}
    capacity int

    // 队列未空条件队列
    notEmptyCond *sync.Cond
    // 队列未满条件队列
    notFullCond *sync.Cond
}

func (q *Queue) Size() int {
    return len(q.elements)
}

func (q *Queue) isFull() bool {
    return q.Size() >= q.capacity
}

func (q *Queue) isEmpty() bool {
    return q.Size() == 0
}

// Pop
// 可以使用 `Context` 来终止 Wait 阻塞
func (q *Queue) Pop(ctx context.Context) (ele interface{}, err error) {
    q.notEmptyCond.L.Lock()
    defer func() {
        // Wait 内部已经释放了锁，避免 `unlock of unlocked mutex` 错误
        if originalErr := errors.Cause(err);
            originalErr != context.DeadlineExceeded && originalErr != context.Canceled {
            q.notEmptyCond.L.Unlock()
        }
    }()

    for q.isEmpty() {
        err = waitWithCancel(ctx, q.notEmptyCond)
        if err != nil {
            return
        }
    }

    ele = q.elements[q.Size()-1]
    q.elements = q.elements[:q.Size()-1]
    // 此时队列中已经 Pop 一个值，不再满。发送队列不为满的信号激活再此条件 `Wait` 的操作
    q.notFullCond.Signal()
    return
}

// Add
// 可以使用 `Context` 来终止 Wait 阻塞
func (q *Queue) Add(ctx context.Context, ele interface{}) (err error) {
    q.notEmptyCond.L.Lock()
    defer func() {
       // Wait 内部已经释放了锁，避免 `unlock of unlocked mutex` 错误
       if originalErr := errors.Cause(err);
           originalErr != context.DeadlineExceeded && originalErr != context.Canceled {
           q.notEmptyCond.L.Unlock()
       }
    }()

    for q.isFull() {
       err = waitWithCancel(ctx, q.notFullCond)
       if err != nil {
           return
       }
    }

    q.elements = append(q.elements, ele)
    // 此时队列中已经有值，发送队列不为空的信号激活再此条件 `Wait` 的操作
    q.notEmptyCond.Signal()
    return
}

func NewQueue(capacity int) *Queue {
    var lock sync.Mutex
    notEmptyCond := sync.NewCond(&lock)
    notFullCond := sync.NewCond(&lock)

    return &Queue{
        elements: make([]interface{}, 0, capacity),
        capacity: capacity,

        notEmptyCond: notEmptyCond,
        notFullCond:  notFullCond,
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

func TestQueue_Add(t *testing.T) {
    queue := NewQueue(10)

    // 100毫秒秒后超时取消
    ctx, cancel := context.WithTimeout(context.Background(), 100 * time.Millisecond)
    defer cancel()
    go func() {
        _, err := queue.Pop(ctx)
        // 超时取消
        assert.Equal(t, context.DeadlineExceeded, errors.Cause(err))
    }()

    // 延迟直到`Pop`超时取消
    time.Sleep(200 * time.Millisecond)
    queue.Add(context.Background(), 1)

    assert.Equal(t, 1, queue.Size())
}

参考

• Java并发编程 内置条件队列
• Go 语言设计与实现 6.1 上下文 Context
• Go 语言设计与实现 6.2 同步原语与锁
• Implementing Timeout in Golang

1. 批量排除文件

   timemachine 不支持通配符匹配排除，需要添加多条规则来排除。

   1 2 3 4 5

   # 排除所有的 `node_modules` 文件夹 find . -maxdepth 3 -type d -name 'node_modules' | xargs -n 1 tmutil addexclusion # 排除所有的 `.git` 目录 find . -maxdepth 3 -type d -name '.git' | xargs -n 1 tmutil addexclusion

2. 检查文件是否被排除

   1	find . -exec tmutil isexcluded {} + | grep -F "[Excluded]" | sed -E 's/^\[Excluded\][[:space:]]*//'

参考

1. Exclude node_modules in timemachine

login-path 选项能实现快捷登录MySQL服务器，我们不需要每次都输入用户名、host、密码等登录认证信息，是一种即安全又遍历的方法。

使用 mysql_config_editor 工具将登录MySQL服务的认证信息加密保存在 .mylogin.cnf 文件（默认位于用户主目录）。之后 MySQL 客户端工具可通过读取该加密文件连接 MySQL，避免重复输入登录信息和敏感信息暴露。

配置 login-path

1

mysql_config_editor set --login-path=dev --user=dev --host=172.26.8.143 --password

可以配置多个登录信息。login-path可以看做登录信息的别名，方便使用时引用。更详细的配置信息查看 mysql_config_editor set --help。

1

mysql_config_editor set --login-path=test --user=test --host=172.26.8.144 --password

这里又配置了一个 login-path 为 test 的登录信息。

查看配置过的登录信息

1

mysql_config_editor print --all

1
2
3
4
5
6
7
8

[dev]
user = dev
password = *****
host = 172.26.8.143
[test]
user = test
password = *****
host = 172.26.8.144

使用 login-path 登录

1

mysql --login-path=dev

删除 login-path

1

mysql_config_editor remove --login-path=dev

参考

• MySQL login-path 本地快捷登录
• MySQL Configuration Utility

我们常说的计算机系统（类Unix系统）时间是一个相对值，它表示距离1970年1月1日00:00:00过去的秒数。

时间通常在程序中有时间戳和日期字符串两种表现形式。但是在计算机中其实只有一种，就是时间戳。使用时间戳是永远不会出问题，但是使用日期字符串某些时候就会出现问题。出现问题的原因一般就是因为省略了时区。

时区

我们生活中常常用日期字符串来表示时间，如下：

可能有些人在程序中也会使用日期字符串来初始化日期：

1

new Date('2020-08-07 18:21:33');

很多情况下这样都没有问题，但是一旦用户分布在不同时区或修改系统时区时就会出现问题。上面的日期字符串其实隐含了一个条件时区，比如我们生活中常说“今天下午五点见个面”这里隐含的条件就是大家都在东八区。

在东八区（北京时间）时，上面的时间等价于这个形式：

1

new Date('2020-08-07T18:21:33+08:00');

但是在东九区（东京时间）它等价于：

1

new Date('2020-08-07T18:21:33+09:00');

这两个时间并不是同一个日期。这就是日期字符串在夸时区出现问题的原因。

在实际开发中，我们应该避免使用简单字符串格式YYYY-MM-DD HH:mm:ss表示日期，这是非常危险的。如果要使用字符串来存储和初始化日期应该加上时区，使用ISO 8601格式的字符串YYYY-MM-DDTHH:mm:ss.sssZ。

参考

• ISO 8601
• toISOString

@babel/preset-env

用来取代以前的 es2016、es2017、stage-x 等等 preset、它是一个合集，包含已经成为标准的提案。它的useBuiltIns能配置如何处理polyfill，现在已经不在推荐使用@babel/polyfill。一般的配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

{
"presets": [
[
"@babel/preset-env",
{
"targets": [
"chrome >= 58",
"iOS >= 9",
"Android >= 5"
],
"useBuiltIns": "usage",
"corejs": 3
}
]
]
}

• useBuiltIns 用来指定 polyfill 如何处理，配合 core-js使用（推荐使用core-js@3）有以下三个取值：

  1 2 3 4 5 6

  const foo = { name: 'Ming' }; const bar = { address: 'Beijing', age: '18' }; Object.assign(foo, bar); const map = new Map();

  • usage:（推荐）会按需引入 polyfill

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

    "use strict"; require("core-js/modules/es.array.iterator"); require("core-js/modules/es.map"); require("core-js/modules/es.object.assign"); require("core-js/modules/es.object.to-string"); require("core-js/modules/es.string.iterator"); require("core-js/modules/web.dom-collections.iterator"); var foo = { name: 'Ming' }; var bar = { address: 'Beijing', age: '18' }; Object.assign(a, b); var map = new Map();

  • entry: 会引入全部 polyfill

    搞不清楚结果为什么和 false 一样，打开 debug 选项后会有如下提示Import of core-js was not found.

    更新：需要在代码中手动引入 import 'core-js'，结果会加载非常多的polyfill。

    1 2 3 4 5 6 7 8 9 10 11

    "use strict"; var foo = { name: 'Ming' }; var bar = { address: 'Beijing', age: '18' }; Object.assign(foo, bar); var map = new Map();

  • false: 不引入 polyfill

    debug 提示 Using polyfills: No polyfills were added, since the *useBuiltIns* option was not set.

    1 2 3 4 5 6 7 8 9 10 11

    "use strict"; var foo = { name: 'Ming' }; var bar = { address: 'Beijing', age: '18' }; Object.assign(foo, bar); var map = new Map();

• targets 选项用来配置配置兼容范围，语法参考 browserslist

• exclude 和 include 用来排查和强制引入某些ployfill，例如下例：

  测试中发现设置 "in P clude": ["es.set"] 并未生效

  设置 "exclude": ["es.object.assign"]，即使我们代码中用到了Object.assign方法，也不会自动引入这个polyfill。

@babel/plugin-transform-runtime

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
"presets": [
[
"@babel/preset-env",
{
"targets": [
"chrome >= 58",
"iOS >= 9",
"Android >= 5"
],
"useBuiltIns": "usage"
}
]
],
"plugins": [
[
"@babel/plugin-transform-runtime",
{
"corejs": 3
}
]
]
}

一般情况下不需要，需要配置 @babel/runtime（不是开发依赖） 一起使用。使用了这个后能复用一些helpers代码，能避免污染全局。下面是打开使用这个插件后的转义代码：

我们看到 Map 和 Object.assign 不在是全局的了

1
2
3
4
5
6
7
8
9
10
11
12
13

var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/map"));
var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));

var foo = {
  name: 'Ming'
};
var bar = {
  address: 'Beijing',
  age: '18'
};
(0, _assign.default)(foo, bar);
var map = new _map.default();

其它

• 配合webpack的 splitChunks 将 polyfill 打包到一个文件中

1
2
3
4
5
6
7
8
9
10
11
12
13

optimization: {
splitChunks: {
// cacheGroups 指定拆分规则 默认的拆分规则如下 <https://webpack.js.org/plugins/split-chunks-plugin/#optimizationsplitchunks>
cacheGroups: {
polyfill: {
// 一个正则匹配那些代码适用这个规则
test: /core-js/, 
// 表示从哪些chunks里面抽取代码，除了三个可选字符串值 initial、async、all 之外，还可以通过函数来过滤所需的 chunks
chunks: 'all' 
}
}
}
}

参考

• @babel/preset-env
• @babel/polyfill
• @babel/plugin-transform-runtime
• SplitChunksPlugin

jq 是个非常强大的处理 JSON 数据的命令行工具。

安装

• Linux

  1	yum install jq

• macOS

  1	brew install jq

使用示例

注意：示例数据不是一段json数据，它的每一行都是一条json数据。每一行都会处理一次。

1. 格式化

这里的 . 表示当前JSON对象

1

curl -s https://kekek.cc/static/jq.json | jq .

2. 查询

查询 remote_addr 为 187.141.142.230 的用户

1

curl -s https://kekek.cc/static/jq.json | jq 'select (.["remote_addr"] == "187.141.142.230")'

select(boolean_expression) 为查询语句，.["remote_addr"] 表示取对象的remote_addr属性（除了可以用.[]取值还可以直接.取值，前者可以处理特殊字符的情况）。 == 表示等于。

查询 method 为 GET 的请求，并且status 为 200

1

curl -s https://kekek.cc/static/jq.json | jq 'select (.["method"] == "GET" and .status == 200)'

3. 管道

1
2
3
4
5

interface AccessLog {
ip: string;
method: string;
url: string;
}

1

curl -s https://kekek.cc/static/jq.json | jq '. | {ip: .["remote_addr"], method: .method, url: .["request_uri"]}'

这里使用了管道符 | 可以多次处理结果

4. 输出csv格式

csv 的输入要求必须是一个数组

1

curl -s https://kekek.cc/static/jq.json | jq '. | [.["remote_addr"], .method, .status]] | @csv'

5. 数组

.[] 表示取整个数组，一般配合管道符号一起使用 .[] | {ip: .["remote_addr"], method: .method, url: .["request_uri"]}

.[0] 表示取数组的第一个元素

参考

• Tutorial
• jq Manual

5G（5th-Generation）是第五代移动通信技术的意思，相比4G它有更低的延时和更快的速度。

1. 低延时

   我们常听到5G可以把延时降低到1ms，这句话很有误导性。会让大部分人觉得端到端的延迟在5G时代只有1ms了，这其实是不准确的。这个1ms其实指的是从设备到5G基站的延时，并不是端到端的延时。换个角度想，5G基站还是要通过光纤网络接入互联网的，那么它就不可能比光纤延时更低了。现在光纤网络的延时通常远远大于1ms，这主要取决于距离。

2. 更快的速度

   移动网络速度每一代都比上一代有很大的提升。最新在网络上看到的一些测试，在5G网络中下载速度能到达900Mbps，约为110MB/s左右。

5G带来的影响

我们先看下网上常说的5G对未来生活的影响，来一一分析一下。

1. 万物互联

   我觉得这主要这主要得益于5G后整体带宽的提升，各种设备要传输大量的数据。低延时对于这方面的提升并不会明显。伴随着万物互联IPV6可能会迎来发展。现有网络环境下我们通过NAT技术缓解了IPV4不够用的问题，这也导致了IPV6这么多年来发展十分缓慢。在5G时代可能会有更多的设备，传感器通过5G网络接入互联网，那就需要大量IP了。

2. 自动驾驶

   5G对于自动驾驶的影响可能不是特别大，自动驾驶并不是将数据传输到服务器计算的，它是本地计算的。自动驾驶更大的难点可能还是现有道路规则都是为有人驾驶设计的，自动驾驶只能去适应现有规则。有了更高的网速，在道路上停留一个多小时下载更新包的尴尬情况起码不会再出现了╮(╯_╰)╭ 但是如果汽车间以后要互相通信，那么低延时技术可能会有帮助。

3. 远程医疗

   我觉得5G对于远程医疗的影响我觉得极其有限。远程医疗非常依赖于低延时，但是5G在低延时和稳定性方面都不会比直接使用光纤网络更好。手术设备完全可以接入现有光纤网络，通过5G接入完全是没有必要的。有人说对于偏远地区光纤不好铺设，这时候使用5G就很方便了。这种观点其实也有问题，5G网络的覆盖非常小。只有几百米。也就是说我们能搜索到5G信号的地方都最近的光纤网络也只有几百米。

4. 云

   云存储会迎来大发展。5G时代如果我们下载速度能达到100+MB/s，iCloud类的服务将会迎来更大发展。我们的设备完全没必要很大的存储了，我们不需要把数据都存在本地。128G、256G甚至更大容量的手机可能会很少了。

   云操作系统、云游戏可能会迎来发展的机会。对于延时不高的操作完全可以再云服务器上完成，我们的设备不在需要强大的硬件。Chromebook类似的设备和Google Stadia类似的云游戏平台可能会有更多。

我觉得5G对我们影响最大的还是更快的网速，这将极大提升效率，为我们生活带来更多的便利。

手里有一个树莓派，刚好有几张闲置的SD卡。闲来没事搭建个NAS（Network Attached Storage）服务。使用树莓派搭建NAS服务优点就是省电，缺点是网卡有点差。

部署及配置

1. 安装samba

   1	$ apt-get install samba samba-common-bin

2. 配置

   1	$ vim /etc/samba/smb.conf

   找到Share Definitions部分在后面配置共享目录

   1 2 3 4 5 6 7 8

   # [共享名] [ytdl] comment = share # 共享描述 path = /data/share/ # 共享目录 valid users = pi # 允许访问该共享的用户 多个用户逗号分隔 browseable = yes # 该指定共享目录可浏览 public = no # 允许guest用户访问 writable = yes # 允许可写

   配置完成重启服务器即可

3. 添加用户

   1	$ smbpasswd -a [user]

   根据提示输入密码即可

4. 启动和停止

   • 启动：/etc/init.d/samba restart
   • 停止：/etc/init.d/samba stop
   • 重启：/etc/init.d/samba restart
   • 重新加载配置文件：/etc/init.d/samba reload

参考

• 在树莓派上安装Samba实现树莓派与Windows间的文件共享
• Linux samba的配置和使用

端口映射

局域网到公网要经过一层net地址转换，在路由器中有一张表记录着：

我们要搭建Web服务器就需要把80端口配置到这张表中，

注意：北京地区家庭宽带80端口被封，可以使用HTTPS443端口。

随着这些年宽带提速以及各种直播类的需求现在家庭宽带上行速度已经不是问题。

动态域名解析

家庭宽带有个特点不是固定IP，每次重新拨号就会分配一个新的IP。这就要使用动态域名解析服务了，像花生壳之类的软件。我们也可以基于阿里云提供的DNS API自己来实现这个功能：

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316

#!/usr/bin/env node

const url = require('url');
const http = require('http');
const https = require('https');
const crypto = require('crypto');

const stringCompare = String.prototype.localeCompare;
const padStart = String.prototype.padStart;
const padEnd = String.prototype.padEnd;

// accesskeys 访问<https://ram.console.aliyun.com/#/user/list>申请
const ACCESS_KEY_ID = 'YOUR_ACCESS_KEY_ID';
const ACCESS_KEY_SECRET = 'YOUR_ACCESS_KEY_SECRET';


/**
 * 比较字符串
 * 
 * String.prototype.localeCompare 算法有问题 AA > Aa 
 *
 * @param {*} str1
 * @param {*} str2
 * @returns
 */
function compareString(str1, str2) {
    const len1 = str1.length;
    const len2 = str2.length;
    const lim = Math.min(len1, len2);

    const str1codes = str1.split('').map(char => char.codePointAt(0));
    const str2codes = str2.split('').map(char => char.codePointAt(0));

    let k = 0, c1, c2;
    while (k < lim) {
        c1 = str1codes[k];
        c2 = str2codes[k];

        if (c1 !== c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}


function sha1(str, key) {
    return crypto.createHmac('sha1', key)
        .update(str)
        .digest()
        .toString('base64');
}


/**
 * 获取时间字符串 YYYY-MM-DDTHH:mm:ssZ
 *
 * @param {*} date
 * @returns
 */
function utcDateFormat(time) {
    // YYYY-MM-DDTHH:mm:ss.sssZ include milliseconds
    // return time.toISOString().match(/^(\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:\d{2})/)[1] + 'Z';

    const year = time.getUTCFullYear();
    const month = padStart.call(time.getUTCMonth() + 1, 2, '0');
    const date = padStart.call(time.getUTCDate(), 2, '0');
    const hours = padStart.call(time.getUTCHours(), 2, '0');
    const minutes = padStart.call(time.getUTCMinutes(), 2, '0');
    const secounds = padStart.call(time.getUTCSeconds(), 2, '0');

    return `${year}-${month}-${date}T${hours}:${minutes}:${secounds}Z`;
}


/**
 * 字符串编码（阿里规则）
 * 
 * 规则：<https://help.aliyun.com/document_detail/29747.html> 1.b
 * 
 * @param {*} str
 * @returns
 */
function percentEncode(str) {
    return encodeURIComponent(str).replace('+', '%20').replace('*', '%2A').replace('%7E', '~');
}


/**
 * HTTPs GET
 * 
 * @param {*} { url, timeout = 5000, json = true }
 * @param query 请求参数对象
 * @param json 如果为true并且content-type为application/json的情况下会反序列化
 * @returns 
 * @throws 如果响应码为4xx或者5xx响应会作为错误抛出
 */
async function request({ url: uri, query = {}, timeout = 5000, json = true }) {
    return new Promise((resolve, reject) => {
        // 合并query
        const urlObject = url.parse(uri, true);
        Object.assign(urlObject.query, query);
        urlObject.search = null;
        uri = url.format(urlObject);

        // support HTTPs
        let protocol;
        if (urlObject.protocol === 'https:') protocol = https;
        else if (urlObject.protocol === 'http:') protocol = http;
        else { throw new Error(`unsupported protocol [${urlObject.protocol}]`) };

        const req = protocol.get(uri)
        req.setTimeout(timeout);
        req.on('timeout', () => req.abort());

        req.on('response', (res) => {
            res.setEncoding('utf8');
            const { statusCode, headers } = res;

            let rawData = '';
            res.on('data', (chunk) => { rawData += chunk; });
            res.on('end', () => {
                let data = rawData;
                if (json && -1 !== headers['content-type'].indexOf('application/json')) {
                    data = JSON.parse(rawData);
                }

                if (statusCode >= 400) {
                    reject(data);
                } else {
                    resolve(data);
                }
            });
        });

        req.on('error', reject);
    });
}


function timeout(time) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            reject(new Error('operation timed out'));
        }, time);
    });
}


/**
 * 查询本机公网IP
 *
 * @returns
 */
async function findMyIP() {
    const rawData = await Promise.race([
        request({ url: 'http://myip.ipip.net', json: false }),
        // request({ url: 'http://ipinfo.io', json: false }),
        request({ url: 'https://api.ipify.org', json: false })
    ]);

    const match = rawData.match(/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/);
    if (!match) throw new Error(`无法解析IP。${rawData}`)

    return match[1];
}

/**
 * 生成公共参数
 * 
 * 参考：<https://help.aliyun.com/document_detail/29745.html>
 *
 * @param {*} { accessKeyId, format = 'JSON', signatureNonce = Math.random(), timestamp = utcDateFormat(new Date()) }
 * @returns
 */
function generatePublicParams({ accessKeyId, format = 'JSON', signatureNonce = Math.random(), timestamp = utcDateFormat(new Date()) }) {
    return {
        'AccessKeyId': accessKeyId,
        'Format': format,
        'Version': '2015-01-09',
        'SignatureMethod': 'HMAC-SHA1',
        'SignatureNonce': signatureNonce,
        'SignatureVersion': '1.0',
        'Timestamp': timestamp
    };
}

/**
 * 签名
 * 
 * 规则：<https://help.aliyun.com/document_detail/29747.html>
 *
 * @param {*} { params, accesskeySecret }
 * @returns
 */
function sign({ params, accesskeySecret }) {
    const query = Object.entries(params)
        .sort((param1, param2) => compareString(param1[0], param2[0]))
        .map(([key, val]) => [percentEncode(key), percentEncode(val)])
        .map(param => param.join('='))
        .join('&');


    let stringToSign = 'GET&' + percentEncode('/') + '&' + percentEncode(query);
    const signStr = sha1(stringToSign, `${accesskeySecret}&`);
    return signStr;
}

/**
 * 请求接口
 *
 * @param {*} { params, accessKeyId, accesskeySecret }
 * @returns
 */
async function callApi({ params, accessKeyId, accesskeySecret }) {
    // 签名
    const signStr = sign({ params, accesskeySecret });
    params['Signature'] = signStr;

    const data = await request({ url: 'https://alidns.aliyuncs.com/', query: params });
    return data;
}


/**
 * 获取解析记录列表
 *
 * 参考：<https://help.aliyun.com/document_detail/29776.html>
 * 
 * @param {*} { domainName, rrKeyWord, pageNumber = 1, pageSize = 20, typeKeyWord = 'A', accessKeyId = ACCESS_KEY_ID, accesskeySecret = ACCESS_KEY_SECRET }
 * @returns
 */
async function describeDomainRecords({ domainName, rrKeyWord, pageNumber = 1, pageSize = 20, typeKeyWord = 'A', accessKeyId = ACCESS_KEY_ID, accesskeySecret = ACCESS_KEY_SECRET }) {
    const params = {
        'Action': 'DescribeDomainRecords',
        'DomainName': domainName,
        'PageNumber': pageNumber,
        'PageSize': pageSize,
        'RRKeyWord': rrKeyWord,
        'TypeKeyWord': typeKeyWord
    };

    Object.assign(params, generatePublicParams({ accessKeyId }));

    const resp = await callApi({ params, accessKeyId, accesskeySecret });
    return resp;
}


/**
 * 修改解析记录
 * 
 * 参考：<https://help.aliyun.com/document_detail/29774.html>
 * 
 * @param {*} { recordId, rr, value, type = 'A', ttl = 600, line = 'default', accessKeyId = ACCESS_KEY_ID, accesskeySecret = ACCESS_KEY_SECRET }
 * @param ttl 基础版最小600秒
 * @returns
 */
async function updateDomainRecord({ recordId, rr, value, type = 'A', ttl = 600, line = 'default', accessKeyId = ACCESS_KEY_ID, accesskeySecret = ACCESS_KEY_SECRET }) {
    const params = {
        'Action': 'UpdateDomainRecord',
        'RecordId': recordId,
        'RR': rr,
        'Type': type,
        'Value': value,
        'TTL': ttl,
        'Line': line
    };

    Object.assign(params, generatePublicParams({ accessKeyId }));

    const resp = await callApi({ params, accessKeyId, accesskeySecret });
    return resp;
}

// findMyIP().then(console.log).catch(console.error);

// describeDomainRecords({ domainName: 'kekek.cc', rrKeyWord: 'www' }).then((recoder) => {
//     console.log(JSON.stringify(recoder, null, 2))
// }).catch(console.error)

// updateDomainRecord({ recordId: '3535020439014400', rr: 'www', value: '202.106.0.21' }).then(console.log).catch(console.error)

// ========================================>

(async () => {
    // 要更新的域名
    let records = [];
    try {
        records = require('./domains.json');
    } catch (ignored) {
        records = [
            {
                domainName: 'kekek.cc',
                rrKeyWord: 'www'
            },
            {
                domainName: 'kekek.cc',
                rrKeyWord: '@'
            }
        ];
    }

    const myip = await findMyIP();

    for (const record of records) {
        const recordDetails = await describeDomainRecords(record);
        const recordDetail = recordDetails.DomainRecords.Record.filter(_record => _record.RR === record.rrKeyWord)[0];

        if (recordDetail && recordDetail['Value'] !== myip) {
            console.log('[update] domainName: %s, rr: %s, before: %s, after: %s', record.domainName, record.rrKeyWord, recordDetail['Value'], myip);
            await updateDomainRecord({ recordId: recordDetail['RecordId'], rr: record.rrKeyWord, value: myip, ttl: record.ttl });
        }
    }
})().then(() => console.log(new Date())).catch(console.error)

缺陷：DNS是有缓存的，更新了新的解析后不能立即生效。这样网站会在一段时间内不可用。

缓存的问题可以通过购买DNSvip服务实现最低1秒的缓存。

设备

旧电脑或者树莓派

创建服务

vim /etc/systemd/system/nginx.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/usr/sbin/nginx -s reload
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

初始化时自动启动服务

1

ln -s /lib/systemd/system/nginx.service  /etc/systemd/system/multi-user.target.wants/nginx.service

或者

1

systemctl enable nginx

刷新配置

1

systemctl daemon-reload

启动、重启、停止

1. 启动nginx

   1	$ systemctl start nginx

2. 重启nginx

   1	$ systemctl restart nginx

3. 停止nginx

   1	$ systemctl stop nginx

开机启动

1

systemctl enable nginx

查看状态

1

systemctl status nginx

参考

• systemctl管理Redis启动、停止、开机启动
• NGINX systemd service file

我们调试JavaScript时经常会用到console.log打印，但是console.log打印对象时不那么准确。看下面的例子：

1
2
3

const user = { name: 'Ming' };
console.log(user);
user.name = 'Lee';

user.name的初始值为Ming，打印user看到的name值也是Ming。紧接着修改user.name值为Lee，然后再暂开前面打印user对象就看到name值变成了Lee。

这个展开看到的值是Chrome为了优化console.log进行的延迟计算，我们看到对象展开后的值是在展开时实时计算的。如果留意在展开对象时会有一个提示Value below was evaluated just now.。

为了避免上述问题在打印对象时可以将对象序列化：

1

console.log(JSON.stringify(user, null, 2)); // 格式化

科学上网和调试网站时经常会用到代理服务器，那么代理服务器是怎么实现的呢？代理服务器和web服务器本身没有太多差别，如果是走代理请求浏览器会把请求发送到代理服务器，并且请求报文中使用完整URI（参考下图中a/b）。

使用telnet模拟普通请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$ telnet css.kekek.cc 80
Trying 47.94.202.145...
Connected to css.kekek.cc.
Escape character is '^]'.
GET / HTTP/1.0
host: css.kekek.cc

HTTP/1.1 200 OK
Server: openresty
Date: Fri, 24 Aug 2018 08:48:31 GMT
Content-Type: text/html; charset=UTF-8
Content-Length: 3876
Last-Modified: Thu, 03 May 2018 13:28:06 GMT
Connection: close
ETag: "5aeb0e66-f24"
Accept-Ranges: bytes

<!DOCTYPE html>
<html lang="en">
...

使用telnet模拟显示代理请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$ telnet proxy.kekek.cc 1337
Trying 39.106.12.213...
Connected to proxy.kekek.cc.
Escape character is '^]'.
GET http://css.kekek.cc/ HTTP/1.0
host: css.kekek.cc

HTTP/1.1 200 OK
server: openresty
date: Fri, 24 Aug 2018 08:50:21 GMT
content-type: text/html; charset=UTF-8
content-length: 3876
last-modified: Thu, 03 May 2018 13:28:06 GMT
connection: close
etag: "5aeb0e66-f24"
accept-ranges: bytes

<!DOCTYPE html>
<html lang="en">
...

HTTPS模式下的代理和HTTP方式会有所不同，因为我们无法解析HTTPS请求。针对这种情况只能使用透传的方式，在tcp层直接将请求转发到目标服务器即可。

PAC

现代浏览器几乎都支持 Proxy Auto-Configuration （PAC），这个可以让我们更灵活的使用代理。比如公司网站使用代理其它网站不走代理，有了PAC这都可以做到。PAC是一个JavaScript文件，MIME为application/x-ns-proxy-autoconfig。每个PAC文件必须有一个名为FindProxyForURL(url,host)的函数，用来计算访问URI时使用的代理服务器。函数返回值格式如下表：

示例：

1
2
3
4
5
6
7
8
9
10
11

// Proxy Auto-Configuration (PAC) file
var proxy = "PROXY proxy.kekek.cc:1337; DIRECT;";
var direct = 'DIRECT;';

function FindProxyForURL(url, host){
    if (/\.google\.com$/.test(host)) {
        return proxy;
    } else {
        return direct;
    }
}

可以使用pacparser来测试我们的PAC文件。

1

brew install pacparser

代码实现

GitHub

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

// 2018-08-24 17:20:00
const http = require('http');
const net = require('net');
const url = require('url');

const PORT = process.env.PORT || 1337;
const HOST = process.env.HOST || '127.0.0.1';
const MY_IP = '0.0.0.0';

const SERVER_TIMEOUT = 2 * 60 * 1000; // 2mins
const SEND_TIMEOUT  = 1000;
const PROXY_TIMEOUT = 60 * 1000; // 1mins


// 创建一个 HTTP 代理服务器
const proxy = http.createServer();

proxy.on('request', (cReq, cRes) => {
    const cUrl = cReq.url;
    console.log(cUrl);

    // 代理模式
    if (cUrl.startsWith('http')) {
        const { method, headers } = cReq;
        const { hostname, port = 80, path } = url.parse(cReq.url);

        // via
        let via = headers['via'];
        if (via) {
            via = via += ', 1.1 proxy.kekek.cc (KEKE-Proxy)';
        } else {
            via = '1.1 proxy.kekek.cc (KEKE-Proxy)';
        }
        headers['via'] = via;

        // x-forward-for
        let ips = headers['x-forward-for'];
        if (ips) {
            ips += `, ${MY_IP}`;
        } else {
            ips = MY_IP;
        }
        headers['x-forward-for'] = ips;
        
        // Max-Forwards
        
        // 服务器响应超时
        // cRes.setTimeout(SEND_TIMEOUT, () => {
        //     cRes.writeHead(504, { 'content-type': 'text/plain' });
        //     cRes.end('Send Timeout');
        // });

        // <http.ClientRequest>
        const pReq = http.request({ hostname, port, path, method, headers });
        pReq
            .setTimeout(PROXY_TIMEOUT)
            .on('response', (pRes) => {
                // <http.IncomingMessage>
                console.log(`[response] [proxy] ${cUrl}`);

                cRes.writeHead(pRes.statusCode, pRes.headers);
                pRes.pipe(cRes);
            })
            .on('timeout', () => {
                // 代理请求超时
                console.log(`[timeout] [proxy-req] ${cUrl}`);
                pReq.abort();
            })
            .on('abort', () => {
                console.log(`[abort] [proxy-req] ${cUrl}`);
            })
            .on('close', () => {
                console.log(`[close] [proxy-req] ${cUrl}`);
            })
            .on('error', (err) => {
                console.log(`[error] [proxy-req] ${cUrl} \r\n${err.stack}`);
                cRes.writeHead(500, { 'content-type': 'text/plain' });
                cRes.end(`Proxy Error: ${err.code || err.message || err.name}`);
            });

        // 请求重定向
        cReq.pipe(pReq);

        // 客户端中止
        cReq.on('aborted', () => {
            console.log(`[aborted] [client] ${cUrl}`);
            // 中止代理
            pReq.abort();
        });
    } else {
        // http-server
        if (cUrl === '/proxy.pac') {
            cRes.setHeader('content-type', 'application/x-ns-proxy-autoconfig');
            const pac = `// Proxy Auto-Configuration (PAC) file
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Proxy_servers_and_tunneling/Proxy_Auto-Configuration_(PAC)_file
// DIRECT        不经过任何代理，直接进行连接
// PROXY host:port应该使用指定的代理
// SOCKS host:port应该使用指定的 SOCKS 服务器

var proxy = "PROXY proxy.kekek.cc:1337; DIRECT;";
var direct = 'DIRECT;';
function FindProxyForURL(url, host){
    if (/\.\kekek\.cc$/.test(host)) {
        return proxy;
    } else {
        return direct;
    }
}`;

            cRes.end(pac);
        } else {
            cRes.setHeader('content-type', 'text/plain');
            cRes.end('proxy: proxy.kekek.cc\r\nport: 1337\r\npac: http://proxy.kekek.cc:1337/proxy.pac');
        }
    }
});


// https
proxy.on('connect', (req, cltSocket, head) => {
    console.log(req.url, head.length)
    // 连接到一个服务器
    const { port, hostname } = url.parse(`http://${req.url}`);

    const srvSocket = net.connect(port, hostname);

    srvSocket.on('connect', () => {
        cltSocket.write('HTTP/1.1 200 Connection Established\r\n' +
            'Proxy-agent: Node.js-Proxy\r\n' +
            '\r\n');
        srvSocket.write(head);
        // 连接管道
        srvSocket.pipe(cltSocket);
        cltSocket.pipe(srvSocket);
    });

    // srvSocket.on('end', () => {
    //     // 远程服务器断开
    //     console.log(`[end] ${req.url}`);
    //     cltSocket.end();
    // });

    // srvSocket.on('timeout', () => {
    //     console.log(`[timeout] ${req.url}`);
    //     srvSocket.end();
    //     cltSocket.end();
    // });

    // srvSocket.on('close', (hasError) => {
    //     // 远程服务器完全断开
    //     console.log(`[close] ${req.url} ${hasError}`);
    // });

    srvSocket.on('error', (err) => {
        // 远程服务器报错
        console.log(`[error] ${req.url} \r\n${err.stack}`);
        const error = `Proxy Error: ${err.code || err.message || err.name}`
        cltSocket.end(`HTTP/1.1 500 Internal Server Error\r\ncontent-type:text/plain\r\ncontent-length:${err.length}\r\n\r\n${error}`);
    });
});

proxy.on('listening', () => {
    console.log(`Proxy-Server running on http://${HOST}:${PORT}`);
});

// 代理服务器正在运行
proxy.listen(PORT, HOST);

代码实现

参考

• HTTP权威指南-第六章 代理
• Proxy Auto-Configuration (PAC) file