noblog 0.0.2 → 0.0.4

package/dist/lib/notion/client.js

@@ -1,48 +0,0 @@
-import 'dotenv/config';
-import retry from 'async-retry';
-import { Client, APIResponseError } from '@notionhq/client';
-const NOTION_API_SECRET = process.env.NOTION_API_SECRET ?? '';
-const NOBLOG_DATABASE_ID = process.env.NOBLOG_DATABASE_ID ?? '';
-export const client = new Client({
-    auth: NOTION_API_SECRET,
-});
-const numberOfRetry = 2;
-export async function GetAllPosts() {
-    const params = {
-        database_id: NOBLOG_DATABASE_ID,
-        filter: {
-            and: [{
-                    property: 'publish',
-                    checkbox: { equals: true, },
-                }]
-        },
-        sorts: [{
-                property: 'date',
-                direction: 'descending',
-            }],
-        page_size: 100,
-    };
-    let results = [];
-    while (true) {
-        const res = await retry(async (bail) => {
-            try {
-                return (await client.databases.query(params));
-            }
-            catch (error) {
-                if (error instanceof APIResponseError) {
-                    if (error.status && error.status >= 400 && error.status < 500) {
-                        bail(error);
-                    }
-                }
-                throw error;
-            }
-        }, { retries: numberOfRetry, });
-        results = results.concat(res.results);
-        if (!res.has_more) {
-            break;
-        }
-        params['start_cursor'] = res.next_cursor;
-    }
-    return results;
-}
-//# sourceMappingURL=client.js.map

package/dist/lib/notion/client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/lib/notion/client.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAA;AAEtB,OAAO,KAAK,MAAM,aAAa,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAI3D,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,EAAE,CAAA;AAC7D,MAAM,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,EAAE,CAAA;AAE/D,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC;IAC/B,IAAI,EAAE,iBAAiB;CACxB,CAAC,CAAA;AAEF,MAAM,aAAa,GAAG,CAAC,CAAA;AAEvB,MAAM,CAAC,KAAK,UAAU,WAAW;IAC/B,MAAM,MAAM,GAA0B;QACpC,WAAW,EAAE,kBAAkB;QAC/B,MAAM,EAAE;YACN,GAAG,EAAE,CAAC;oBACJ,QAAQ,EAAE,SAAS;oBACnB,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,GAAG;iBAC5B,CAAC;SACH;QACD,KAAK,EAAE,CAAC;gBACN,QAAQ,EAAE,MAAM;gBAChB,SAAS,EAAE,YAAY;aACxB,CAAC;QACF,SAAS,EAAE,GAAG;KACf,CAAA;IAED,IAAI,OAAO,GAAW,EAAE,CAAA;IACxB,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,GAAG,GAAG,MAAM,KAAK,CACrB,KAAK,EAAE,IAAI,EAAE,EAAE;YACb,IAAI,CAAC;gBACH,OAAO,CAAC,MAAM,MAAM,CAAC,SAAS,CAAC,KAAK,CAClC,MAAa,CACd,CAA0B,CAAA;YAC7B,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,KAAK,YAAY,gBAAgB,EAAE,CAAC;oBACtC,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;wBAC9D,IAAI,CAAC,KAAK,CAAC,CAAA;oBACb,CAAC;gBACH,CAAC;gBACD,MAAM,KAAK,CAAA;YACb,CAAC;QACH,CAAC,EAAE,EAAE,OAAO,EAAE,aAAa,GAAG,CAC/B,CAAA;QAED,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QACrC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;YAAC,MAAK;QAAC,CAAC;QAC5B,MAAM,CAAC,cAAc,CAAC,GAAG,GAAG,CAAC,WAAqB,CAAA;IACpD,CAAC;IAED,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/lib/notion/object.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=object.js.map

package/dist/lib/notion/object.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.js","sourceRoot":"","sources":["../../../src/lib/notion/object.ts"],"names":[],"mappings":""}

package/dist/lib/notion/request.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=request.js.map

package/dist/lib/notion/request.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"request.js","sourceRoot":"","sources":["../../../src/lib/notion/request.ts"],"names":[],"mappings":""}

package/output/00097769-2aac-4b6f-8f37-d9b658d46b2e

@@ -1,435 +0,0 @@
-
-> 💡 **Notion Tip:** Please read [golang修养之路](https://github.com/aceld/golang/tree/main) to develop a basic understanding about go. A lot of the content is from that book. I assume you have already known the syntax and memory model in c.
-
-
-> GO哲学圣经镇楼：  
-> Do not communicate by sharing memory; instead, share memory by communicating.
-
-
-
-
-
-# nil
-
-
-In Go, `nil` can represent zero values of the following kinds of types:
-
-- pointer types (including type-unsafe ones).
-- map types.
-- slice types.
-- function types.
-- channel types.
-- interface types.
-
----
-
-
-# Interface & Memory model
-
-
-在 Go 语言中，接口类型的内存模型是指，一个接口变量实际上只是一个包含指向底层数据的指针和类型信息的数据结构。该指针指向实现了该接口的具体类型的实例。因此，使用接口类型时，实际上使用的是底层数据的指针。
-
-
-```go
-type Animal interface {
-    Speak() string
-}
-
-type Dog struct {
-    Name string
-}
-
-func (d *Dog) Speak() string {
-    return "Woof!"
-}
-```
-
-
-我们现在将 `Dog` 类型的值赋给 `Animal` 类型的变量：
-
-
-```go
-var animal Animal = &Dog{"Fido"}
-```
-
-
-在这个例子中，我们为 `Dog` 结构体实现了 `Speak()` 方法，并将其赋给了 `Animal` 接口类型的变量 `animal`。由于 `Dog` 实现了 `Animal` 接口，所以可以将 `Dog` 实例作为 `Animal` 类型的值传递。
-
-
-在这里，变量 `animal` 中实际上存储了 `Dog` 实例的地址信息，以及对应的类型信息。当我们调用 `animal.Speak()` 方法时，由于 `Dog` 类型实现了 `Speak()` 方法，**Go 会自动将底层值指针转换为** **`*Dog`** **类型**，并调用 `Speak()` 方法。
-
-
-需要注意的是，由于指针包含了地址信息，因此通过接口来操作变量的时候，**会使用额外的内存进行指针的转换**。此外，当使用接口类型时，由于需要动**态判断底层数据的类型**，因此会导致一些性能上的损失。**编译器来检查一个类型是否实现了某个接口的所有方法**。如果一个类型没有实现某个接口的全部方法，则会在编译时产生错误。
-
-
-# const
-
-
-C++ 和 Go 两种语言中的常量有所不同，可能导致它们在寻址方面的特性表现不同。
-
-
-**在 C++ 中，常量（如** **`const int a = 10`****）实际上是变量，只是它们被声明为不可修改**（即 const 类型），因此编译器会将这些变量存储在内存中的只读区域。因为它们实际上是变量，在内存中占用了一定的空间，所以可以对其取地址。
-
-
-而在 Go 中，常量（如 `const a = 10`）是无类型的，它们在**编译时就被解析并直接替换为使用该常量的值**。也就是说，在编译时，它们不会分配任何内存，并且不属于程序的运行时状态。因此，Go 编译器不支持获取常量的地址，因为它们没有在内存中分配任何空间。
-
-
-总的来说，C++ 和 Go 中的常量有着不同的实现方式和语义约束。C++ 中的常量是实际的变量，但被限制为不可修改；而 **Go 中的常量则是编译时常量，它们在程序运行时不存在**。
-
-
-需要注意的是，某些 C++ 编译器可能会将常量优化为立即数，这样，它们就不会在内存中分配任何空间。这种优化行为类似于 Go 中的常量实现方式。因此，在 C++ 中也应该避免对常量进行不必要的取地址操作，这些操作可能会被编译器优化掉，或者在某些平台上导致未定义的行为。
-
-
-# make & new
-
-
-`make`只能用于 slice, map 和 chan
-
-
-### Declaration of var
-
-
-```text
-var i int
-var s string
-```
-
-
-变量的声明我们可以通过var关键字，然后就可以在程序中使用。当我们不指定变量的默认值时，这些变量的默认值是他们的零值，比如int类型的零值是0,string类型的零值是 `""`，引用类型的零值是 `nil`。
-
-
-```go
-package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	var i *int
-	*i = 10
-	fmt.Println(*i)
-}
-```
-
-
-以上代码会报错，对于引用类型的变量，我们不光要声明它，还要为它分配内容空间，正确代码如下
-
-
-```go
-func main() {
-  
-   var i *int
-   i=new(int)
-   *i=10
-   fmt.Println(*i)
-  
-}
-```
-
-
-
-
-- `new` 函数用于分配一个指定类型的零值并返回该类型的指针。换句话说，`new(T)` 返回类型为 `T` 的指针，并将其初始化为 T 的零值。例如，`new(int)` **创建一个整数类型的指针**，并将其**初始化为零值 0**。
-- `make` 函数用于创建引用类型（如 slice、map 和 channel）的对象，并**返回它们的引用**。它接受一个类型和一些适当的参数，然后**返回初始化后的对象**。例如，`make([]int, 10)` 将创建一个初始长度为 10 的整数切片，并返回该切片的引用。
-
-**new always allocate memory on heap?**
-
-
-In Go, the `new` function always returns a pointer to a newly allocated zeroed value of the specified type. However, whether that memory is allocated on the heap or not depends on the context in which the `new` function is called. If it's used with a composite literal, such as `new(T)` where `T` is a struct type, then the memory is allocated on the heap. This is because the returned pointer must survive beyond the lifetime of the function that called `new`.
-
-
-However, if `new` is used with a built-in type or an array type, then the memory is allocated on the stack if possible. This is because these types have a fixed size and can be efficiently allocated on the stack.
-
-
-# Escape
-
-
-go中，这段代码是不会出问题的 rnm，退钱！！！
-
-
-```go
-package main
-
-func foo(arg_val int)(*int) {
-
-    var foo_val int = 11;
-    return &foo_val;
-}
-
-func main() {
-
-    main_val := foo(666)
-
-    println(*main_val)
-}
-```
-
-
-go语言编译器会自动决定把一个变量放在栈还是放在堆，编译器会做**逃逸分析(escape analysis)**，**当发现变量的作用域没有跑出函数范围，就可以在栈上，反之则必须分配在堆**。go语言声称这样可以释放程序员关于内存的使用限制，更多的让程序员关注于程序功能逻辑本身。
-
-
-简而言之，不管你想把变量放到栈上还是堆上，编译器觉得应该放在哪，那它就得放在哪，一切以程序的运行逻辑为准。
-
-
-# Pointer type & struct type 
-
-
-```go
-package main
-
-import "fmt"
-
-type User struct {
-    Name string
-}
-
-func (u *User) Greeting() string {
-    u.Name = u.Name+" modify"
-    return fmt.Sprintf("Greetings %s!", u.Name)
-}
-
-func main() {
-    p := &User{"cppgohan by pointer"}
-    u := User{"cppgohan by value"}
-
-    fmt.Println(p.Greeting(), p)
-    fmt.Println(u.Greeting(), u)
-}
-```
-
-
-`p.Greeting()`和 `u.Greeting()`的调用方式本质上没有区别
-
-
-对于 `p`，调用 `Greeting()` 就是 `p.Greeting()`。对于 `u` 隐式转换为调用 `(&u).Greeting()`
-
-
-# Garbage collection (IMPORTANT!)
-
-
-[Golang三色标记 混合写屏障GC模式全分析](https://github.com/aceld/golang/blob/main/5%E3%80%81Golang%E4%B8%89%E8%89%B2%E6%A0%87%E8%AE%B0%2B%E6%B7%B7%E5%90%88%E5%86%99%E5%B1%8F%E9%9A%9CGC%E6%A8%A1%E5%BC%8F%E5%85%A8%E5%88%86%E6%9E%90.md)
-
-
-**mark and sweep algorithm**
-
-
-此算法主要有两个主要的步骤：
-
-- 标记(Mark phase)
-- 清除(Sweep phase)
-
-Mark and Sweep算法在执行的时候，需要程序暂停，即 STW（Stop The World）。STW的过程中，CPU不执行用户代码，全部用于垃圾回收，这个过程的影响很大，所以STW也是一些回收机制最大的难题和希望优化的点。
-
-
-## 一些理解
-
-
-想要理解gc，首先需要理解的是堆和栈的区别，栈空间的特点是容量小,但是要求相应速度快,因为函数调用弹出频繁使用，所以我们希望的是尽可能地减少gc和栈的关联，或者说对栈的元素的gc应该速战速决。
-
-
-$写屏障=插入屏障+删除屏障$
-
-
-插入屏障为了解决这个问题，基于强三色不变式在开始和结束的时间对栈进行了两次扫描，第一次为并发扫描，第二次为STW
-
-
-基于弱三色不变式的删除屏障是比较难理解的（删除屏障中就已经开启了插入屏障，来应对堆区黑色对象引用新建的孤独对象的情况），这里写一下我的理解。设父对象为`x`，其引用对象为`y`，最基础的删除屏障，是将删除的引用全部变为灰色（除非已经是黑色），对栈和堆的对象都是有效的。分两种情况讨论：
-
-1. 父对象本来就不可达：此时，反而是救活了这个本应该被删除的对象，但是对不可达对象的操作本来就是违规的（涉及野指针），可以不考虑。
-2. 父对象可达：可以等价认为可达`y`的链路上存在灰色对象，此时，为了让其他的黑色对象（特指栈上的黑色对象，因为栈上的对象不开启写屏障）可以自由引用`y`和`y`链路上的子对象（在删除屏障之前，不然又是野指针了），需要将`y`无脑变灰来满足弱三色不等式。
-
-可以理解到，如果`y`和`y`链路上的子对象没有被黑色对象引用，那么删除屏障实际上是活佛再世，抬了这些入土半截的对象一手，回收精度是偏低的。
-
-
-![Untitled.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/4bf3ed8a-98c2-4da6-a69b-5cc4b3e582d6/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45HZZMZUHI%2F20240727%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20240727T100307Z&X-Amz-Expires=3600&X-Amz-Signature=4898733c3d04b2e26384a303b44a25265aec033f072a3fe4c1c0c8017b47acc1&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-那么混合写屏障呢？
-
-1. 前面说到的插入屏障明显针对的是堆区的元素为黑色的情况，加之中途还可能有新创建的栈对象，所以最后还要使用STW进行栈对象的清理。删除屏障也是没有考虑中途加入的栈元素。于是，可以优化的是：
-
-栈上新加入的对象直接变黑
-
-2. 对于删除屏障的栈对象：
-
-你一个一个从白变灰变黑，回收精度还没提高多少，不如一步到位，在开始的时候就并发扫描直接变黑
-
-3. 既然栈对象直接就黑了：
-
-堆区的对象可能被栈区的黑色对象引用，删除屏障的祖宗之法不可变
-
-4. 连带的：
-
-堆区的插入屏障作为删除屏障的影子，也就跟着了。
-
-
-写屏障（删除屏障+插入屏障），其根本目的就是为了保护对象不被删除。而混合写屏障则是结合了go并发的优势，尽可能减少STW的gc方法。
-
-
-**ATTENTION:** 混合写屏障并不能完全消除STW，尽管从原理来看，混合写屏障已经是 STW free 的了，但是由于go的高并发特性，为了使gc的结果保持一致性，在某些时候还是需要 STW 的。
-
-
-# Complement
-
-
-## map
-
-
-[map](9c060d29-39a2-432b-b06b-b0bd91989a52.md)
-
-
-**为什么Go语言中的map并不支持直接对map元素进行取址操作**
-
-
-由于 `map` 中的元素存储在哈希表中，并且哈希表可能会因为容量变化而重新分配内存，因此对 `map` 元素进行取址操作并不可行。如果你试图对 `map` 元素进行取址操作，编译器会报错，提示可能导致指针无效。简而言之，对map元素的修改可能会导致哈希表rehash，所以不能直接修改。在并发程序中，可以使用互斥锁来保证在并发程序中对 `map` 进行安全的访问和修改。另外，还可以考虑使用 Go 语言提供的并发安全的映射类型 `sync.Map`，它可以安全地在多个 goroutine 中读取和写入数据。
-
-
-**以下代码有什么问题，说明原因**
-
-
-```go
-package main
-
-import (
-    "fmt"
-)
-
-type student struct {
-    Name string
-    Age  int
-}
-
-func main() {
-    //定义map
-    m := make(map[string]*student)
-
-    //定义student数组
-    stus := []student{
-        {Name: "zhou", Age: 24},
-        {Name: "li", Age: 23},
-        {Name: "wang", Age: 22},
-    }
-
-    //将数组依次添加到map中
-    for _, stu := range stus {
-        m[stu.Name] = &stu
-    }
-
-    //打印map
-    for k,v := range m {
-        fmt.Println(k ,"=>", v.Name)
-    }
-}
-```
-
-
-遍历结果出现错误，输出结果为
-
-
-```text
-zhou => wang
-li => wang
-wang => wang
-```
-
-
-map中的3个key均指向数组中最后一个结构体。
-
-
-```text
-0xc000010030
-0xc000010030
-0xc000010030
-zhou => wang
-li => wang
-wang => wang
-```
-
-
-从内存的角度来看，3个key都对应 `&stu`这个指针，这个指针的内存地址是临时的，同时也可以推断出在golang中，for循环的临时变量的虚拟地址是复用的。所以结果出错。
-
-
-**正确写法**
-
-
-```go
-// 遍历结构体数组，依次赋值给map
-for i := 0; i < len(stus); i++  {
-    m[stus[i].Name] = &stus[i]
-}
-```
-
-
-## slice
-
-
-[slice](18f0fae1-b7ca-40ea-b725-4e69404429dc.md)
-
-
-## compile
-
-
-[compile](b8cbb8f9-f702-4a43-943c-02a6e39683d5.md)
-
-
-## context
-
-
-[context](34f4d4af-812e-4e56-a6dd-deb96e7f605c.md)
-
-
-## reflect
-
-
-[reflect](6ff91a18-494e-4ffc-a33b-b9fd2c36f43f.md)
-
-
-## unsafe
-
-
-[unsafe](4bac355b-24f0-49e7-a317-e4f1cad63c79.md)
-
-
-## interface
-
-
-[interface](e339a686-bbb1-41d9-b6b5-18111e72a68c.md)
-
-
-## channel
-
-
-[channel](232ae8ce-5ec3-4737-a18e-077774b84b1e.md)
-
-
-## GMP
-
-
-[GMP](0b903359-2337-4ad9-adef-e77b69142581.md)
-
-
-[Golang的协程调度器原理及GMP设计思想](https://github.com/aceld/golang/blob/main/2%E3%80%81Golang%E7%9A%84%E5%8D%8F%E7%A8%8B%E8%B0%83%E5%BA%A6%E5%99%A8%E5%8E%9F%E7%90%86%E5%8F%8AGMP%E8%AE%BE%E8%AE%A1%E6%80%9D%E6%83%B3%EF%BC%9F.md) 
-
-
-[对于操作系统而言进程、线程以及Goroutine协程的区别](https://github.com/aceld/golang/blob/main/3%E3%80%81%E5%AF%B9%E4%BA%8E%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E8%80%8C%E8%A8%80%E8%BF%9B%E7%A8%8B%E3%80%81%E7%BA%BF%E7%A8%8B%E4%BB%A5%E5%8F%8AGoroutine%E5%8D%8F%E7%A8%8B%E7%9A%84%E5%8C%BA%E5%88%AB.md)
-
-
-**控制goroutines数量**
-
-
-[Go是否可以无限go？如何限定数量？](https://github.com/aceld/golang/blob/main/4%E3%80%81Go%E6%98%AF%E5%90%A6%E5%8F%AF%E4%BB%A5%E6%97%A0%E9%99%90go%EF%BC%9F%E5%A6%82%E4%BD%95%E9%99%90%E5%AE%9A%E6%95%B0%E9%87%8F%EF%BC%9F.md)
-
-- 方法一：只是用有buffer的channel来限制 (无法等待回收goroutine结束，资源回收)
-- 方法二：只使用sync同步机制 (无法控制数量)
-- 方法三：channel与sync同步组合方式 (perfect)
-- 方法四：利用无缓冲channel与任务发送/执行分离方式
-
-**WaitGroup与goroutine的竞速问题**
-
-
-[WaitGroup](https://github.com/aceld/golang/blob/main/6%E3%80%81WaitGroup.md)
-
-
-总结：在goroutine前add WaitGroup会好一些。
-

package/output/1707063b-7c0a-4572-9526-f7db2f7bbc49

@@ -1,162 +0,0 @@
-
-
-
-
-> ZeroMQ is an **asynchronous** messaging library, aimed at use in distributed or concurrent applications. It provides a message queue, but unlike message-oriented middleware, a ZeroMQ system can run without a dedicated message broker; the zero in the name is for zero broker.
-
-
-### 为什么需要ZeroMQ
-
-
-简单，可拓展性。帮助开发者专注于消息的传递和网络拓扑的设计，而不是连接的建立或可用性的保证。（支持自动重连）
-
-
-[https://zguide.zeromq.org/docs/chapter1/#Why-We-Needed-ZeroMQ](https://zguide.zeromq.org/docs/chapter1/#Why-We-Needed-ZeroMQ)
-
-
-### ZeroMQ的通信哲学
-
-
-> To fix the world, we needed to do two things. One, to solve the general problem of “how to connect any code to any code, anywhere”. Two, to wrap that up in the simplest possible building blocks that people could understand and use _easily_.
-
-
-namely, 用最简单的方式建立连接，另外，在使用zmq进行通信开发时，你需要忘记掉所有有关tcp的知识，因为zmq包装了所有的连接，在套接字之上又抽象包装了一层，因此部分概念会与常规的计算机网络概念相悖。
-
-
-### ZeroMQ的通信特点
-
-1. ZeroMQ doesn’t know anything about the data you send except its size in bytes.
-
-也就是说，如同 c 这样的以 null 结尾字符串的方式需要进行额外的处理。
-
-
-同时，这也意味着从二进制到解析结果这部分需要用户自己进行处理。（尽管现在的zmq已经提供了常用的解码方式）
-
-2. In theory with ZeroMQ sockets, it does not matter which end connects and which end binds. However, in practice there are undocumented differences that I’ll come to later.
-
-理论求自由，实践不逾矩
-
-
-### Basic
-
-1. 连接就是连接，连接建立一个结构，不要考虑其他的
-
-> Now, imagine we start the client _before_ we start the server. In traditional networking, we get a big red Fail flag. But ZeroMQ lets us start and stop pieces arbitrarily. As soon as the client node does [zmq_connect()](http://api.zeromq.org/master:zmq_connect), the connection exists and that node can start to write messages to the socket. At some stage (hopefully before messages queue up so much that they start to get discarded, or the client blocks), the server comes alive, does a [zmq_bind()](http://api.zeromq.org/master:zmq_bind), and ZeroMQ starts to deliver messages.
-
-2. 服务节点可以绑定多个端点
-
-如果不理解，请重读**ZeroMQ的通信哲学**小节
-
-
-```python
-zmq_bind (socket, "tcp://*:5555");
-zmq_bind (socket, "tcp://*:9999");
-zmq_bind (socket, "inproc://somename");
-```
-
-3. 合法的组合
-- PUB and SUB
-- REQ and REP
-- REQ and ROUTER (take care, REQ inserts an extra null frame)
-- DEALER and REP (take care, REP assumes a null frame)
-- DEALER and ROUTER
-- DEALER and DEALER
-- ROUTER and ROUTER
-- PUSH and PULL
-- PAIR and PAIR
-
-### 头疼msg，理解msg，维护msg
-
-1. 帧是zmq通信的基本传输格式（basic wire format）
-
-Frames (also called “message parts” in the ZeroMQ reference manual pages) are the basic wire format for ZeroMQ messages. A frame is a **length-specified block of data**. The length can be zero upwards. If you’ve done any TCP programming you’ll appreciate why frames are a useful answer to the question “how much data am I supposed to read of this network socket now?”
-
-2. **从概念来说，ZeroMQ 消息是一个帧**，就像 UDP 一样。但是其可以[用标志位对消息进行扩展](https://rfc.zeromq.org/spec/15/)，也就是说，实际使用上，一个zmq消息可以由多个帧组成。
-
-Originally, a ZeroMQ message was one frame, like UDP. We later extended this with multipart messages, which are quite simply series of frames with a “more” bit set to one, followed by one with that bit set to zero. The ZeroMQ API then lets you write messages with a “more” flag and when you read messages, it lets you check if there’s “more”.
-
-- A message can be one or more parts.
-- These parts are also called “frames”.
-- Each part is a object `zmq_msg_t`
-- You send and receive each part separately, in the low-level API.
-- Higher-level APIs provide wrappers to send entire multipart messages.
-3. msg 的一些注意事项
-- 可以发送0长度的msg作为信号
-
-You may send zero-length messages, e.g., for sending a signal from one thread to another.
-
-- 保证消息传递的原子性
-
-ZeroMQ guarantees to deliver all the parts (one or more) for a message, or none of them.
-
-- 异步发送，要保证内存中的队列不会爆
-
-ZeroMQ does not send the message (single or multipart) right away,
-but at some indeterminate later time. A multipart message must therefore fit in memory.
-
-- 大文件的发送需要自己手动拆分，多次发送
-
-A message (single or multipart) must fit in memory. If you want to
-send files of arbitrary sizes, you should break them into pieces and
-send each piece as separate single-part messages. _Using multipart data will not reduce memory consumption._
-
-- You must call [zmq_msg_close()](http://api.zeromq.org/master:zmq_msg_close) when finished with a received message, in languages that don’t automatically destroy objects when a scope closes. You don’t call this method after sending a message.
-- [zmq_msg_init_data()](http://api.zeromq.org/master:zmq_msg_init_data) 是一种 zero-copy 的方法，需要谨慎使用
-
-### 同步 PUB-SUB，捕获第一条消息
-
-<details>
-<summary>The **subscriber** will always miss the first messages that the **publisher** sends.</summary>
-
-This is because as the subscriber connects to the publisher (something that takes a small but non-zero time), the publisher may already be sending messages out.
-
-
-> Making a TCP connection involves to and from handshaking that takes several milliseconds depending on your network and the number of hops between peers. In that time, ZeroMQ can send many messages. For sake of argument assume it takes 5 msecs to establish a connection, and that same link can handle 1M messages per second. During the 5 msecs that the subscriber is connecting to the publisher, it takes the publisher only 1 msec to send out those 1K messages.
-
-
-</details>
-
-
-[https://zguide.zeromq.org/docs/chapter2/#Node-Coordination](https://zguide.zeromq.org/docs/chapter2/#Node-Coordination)
-
-
-### 解读 ROUTER-ROUTER
-
-
-zmq 的基础使用中，不应该存在 ROUTER-ROUTER 的双端通信。（虽然 ROUTER-ROUTER 是合法的组合）ROUTER-ROUTER 的强行通信（不交换IDENTITY）会导致tcp握手一直被rst。
-
-- ~~在 tdserver 中，DEALER 被封装在了 wrapper 文件定义的对象中，后来又被隐晦地调用了，所以给人一种 ROUTER-ROUTER 通信的错觉~~
-- 本质上是，DEALER 通信时，会隐式地在序列开头添加自己随机的一个 IDENTITY，这个 IDENTITY 会让 ROUTER 在内部维护一个映射关系，即 IDENTITY->DEALER 的映射，如此来把返回的结果正确的发送给对应的 DEALER ，而在封装的实现中，ROUTER 是不会主动添加 IDENTITY 的（其本身也没有初始化的 IDENTITY）
-- **下面说的 DEALER 代指具有 IDENTITY 的 zmq.Socket，使用 DEALER 是为了便于理解**
-- 想要实现 ROUTER-ROUTER 的通信，就需要将 ROUTER 伪装成 DEALER
-- 先从发送讲起，ROUTER A 现在要向另一个 ROUTER B 发送信息，在 A 的眼中，B 是一个 DEALER，所以 A 需要手动添加一个 IDENTITY 在序列的开头，而这个 IDENTITY 必须和 B 的 IDENTITY 完全一样！
-- 接收是正常的流程
-- 发现了吗，在 ROUTER-ROUTER 模型中，他们之间想要实现双端通信，就必须要知道对方的 IDENTITY，但是一般情况下，想要知道对方的 IDENTITY，就要实现双端通信。。。
-- 非常经典的悖论，[官方文档](https://zguide.zeromq.org/docs/chapter4/#reliable-request-reply)中也对这个问题进行了简要的讨论，给出了一些解决方案，但是根据 KISS 原则，如此模型是不应该存在于任何一种设计中的
-
-### 为什么是zmq_poll()而不是zmq_epoll()？
-
-
-[https://github.com/zeromq/libzmq/issues/1667](https://github.com/zeromq/libzmq/issues/1667)
-
-
-### zmq_proxy()里的配对瞎配会怎么样？
-
-
-> If you’re like most ZeroMQ users, at this stage your mind is starting to think, “What kind of evil stuff can I do if I plug random socket types into the proxy?” The short answer is: try it and work out what is happening. In practice, you would usually stick to ROUTER/DEALER, XSUB/XPUB, or PULL/PUSH.
-
-
-经过wireshark抓包发现，对于接收信息来说瞎配啥事也没有，能收到。但是一旦proxy的组合不符合配对规律，frontend 到 backend 的通信会连包都发不出去，也就是在函数内部进行了阻断。
-
-
-### zmq 错误处理之道
-
-
-[https://zguide.zeromq.org/docs/chapter2/#Handling-Errors-and-ETERM](https://zguide.zeromq.org/docs/chapter2/#Handling-Errors-and-ETERM)
-
-
-### zmq之信息丢失
-
-
-[https://zguide.zeromq.org/docs/chapter2/#Missing-Message-Problem-Solver](https://zguide.zeromq.org/docs/chapter2/#Missing-Message-Problem-Solver)
-