noblog 0.0.1 → 0.0.3

package/output/sub/e7931a8e-45ca-444a-8d6f-e6fed9415c26

@@ -1,110 +0,0 @@
-
-# char
-
-
-在老牌语言中，char通常是 1 Byte 的长度，储存一个ASCII字符。但是在rust中，字符是utf-8编码的，而utf-8采用的是变长编码 (长度为 1-4 Byte)。为了内存对齐，rust中最小的char长度应当是可以是2的幂次的，大于等于4的最小长度，也就是4。
-
-
-# 字符串的实现
-
-
-字符串储存了文本的字面量，首先要明确这一点
-
-
-然后需要理解的是，所有的类型，都是固定长度的，比如`i32`就是4个字节。而字符串的长度显然是不定的，是可变的，作为 byte sequence `[u8]` 被直接储存在可执行文件的 data section 中。
-
-
-```rust
-┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
-│  H  │  e  │  l  │  l  │  o  │     │  W  │  o  │  r  │  l  │  d  │
-└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
-┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
-│  72 │ 101 │ 108 │ 108 │ 111 │  32 │  87 │ 111 │ 114 │ 108 │ 100 │
-└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
-```
-
-
-### C 的方法
-
-
-在 C 中，`\0` 作为字符串的结束符 `append` 在字符串的末尾。为了确定字符串的长度，就需要遍历每个 byte。
-
-
-### Rust 的方法
-
-
-```rust
-let arr = [1, 2, 3, 4]; // array
-
-// 以下是slice
-let slice1 = &arr[..];
-let slice2 = &arr[1..3];
-let slice3 = &arr[..3];
-let slice4 = &arr[1..];
-```
-
-
-rust中的切片类型就是 `&[T]`，表示连续内存序列(数组) `[T]` 的`视图`，这个指针在最底层是通过称为胖指针（`FatPtr`）的结构体来模拟的:
-
-
-```rust
-// src/libcore/ptr/mod.rs
-
-// Repr<T> 联合体定义了不同种类的指针，用于引用数组（切片）的数据。这个联合体使用了 repr(C) 属性，这表示 Rust 应该按照 C 语言的内存布局规则来布局这个联合体，以便与其他语言进行交互。
-
-#[repr(C)]
-pub(crate) union Repr<T> {
-    pub(crate) rust: *const [T],
-    rust_mut: *mut [T],
-    pub(crate) raw: FatPtr<T>,
-}
-
-#[repr(C)]
-pub(crate) struct FatPtr<T> {
-    data: *const T,
-    pub(crate) len: usize,
-}
-```
-
-
-在内存布局（memory layout）上, 切片变量和`FatPtr`类型的变量共享同一片内存空间，而FatPtr中则保存了"切片"的必要特征：
-
-- data: 指向若干同质连续数据内存首地址的指针；
-- len: `data`指针所指向的连续内存段中存放的元素数目；
-
-而借助于Rust类型系统的优势，标准库在`[T]`类型上定义的方法和trait则完全封装了底层负责解释指针含义的工作（这部分解释工作需要依赖unsafe rust来实现）。
-
-
-str 在本质上是 `‘static str`，对应的，`s: &’static str = “foo”`。
-
-
-str在rust中是很特殊的一个存在，由于utf-8动态编码的性质，如果你想要获得str的第n个字符
-
-
-```c++
-&str.chars().nth(n)
-```
-
-
-## 浅浅对比 String
-
-
-```rust
-pub struct String {
-    vec: Vec<u8>,
-}
-```
-
-
-rust的String实际上就很直观了，底层就是一个vec，只不过因为是private的，必须要通过暴露的借口进行初始化。
-
-
-```rust
-pub const fn new() -> String {
-  String { vec: Vec::new() }
-}
-```
-
-
-同时，在rust中，str被硬编码在了程序的二进制文件中（static data），而&str正是硬编码后的str在文件中的地址。而string则是被创建在堆上的。
-

package/output/sub/e859552b-c597-49ed-9ede-fab320fafd87

@@ -1,150 +0,0 @@
-
-# **Raft paper summarization**
-
-
-[Raft paper summarization](9a33b8cc-101a-4f6a-9852-115595cd166b.md)
-
-
-# **Part 2A: leader election**
-
-
-> Implement Raft leader election and heartbeats (`AppendEntries` RPCs with no log entries). The goal for Part 2A is for a single leader to be elected, for the leader to remain the leader if there are no failures, and for a new leader to take over if the old leader fails or if packets to/from the old leader are lost. Run `go test -run` 2A to test your 2A code.
-
-<details>
-<summary>**Goal**</summary>
-
-Sending and receiving RequestVote RPCs
-
-
-</details>
-
-
-![figure2-2A.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/816ab0e2-0bbf-4fbc-a791-de833db1ae15/bf799b2f-6287-4999-b548-4974769458ec/figure2-2A.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=20240727T092513Z&X-Amz-Expires=3600&X-Amz-Signature=e96fc27813785c92bd6144647840aa67ec78e540237b7fac3cd29a2b67a87110&X-Amz-SignedHeaders=host&x-id=GetObject)
-
-
-Step**s:**
-
-<details>
-<summary>Add the state for leader election to the `Raft` struct in `raft.go`</summary>
-
-```go
-	// 2A
-	currTerm   int32
-	votedFor   int
-	logEntries []logEntry
-```
-
-
-</details>
-
-<details>
-<summary>define a struct to hold information about each log entry</summary>
-
-```go
-type logEntry struct {
-	command string
-	term    int32
-}
-```
-
-
-</details>
-
-<details>
-<summary>Fill in the `RequestVoteArgs` and `RequestVoteReply` structs</summary>
-
-```go
-// example RequestVote RPC arguments structure.
-// field names must start with capital letters!
-type RequestVoteArgs struct {
-	// Your data here (2A, 2B).
-	term         int32
-	candidateId  int
-	lastLogIndex int32
-	lastLogTerm  int32
-}
-
-// example RequestVote RPC reply structure.
-// field names must start with capital letters!
-type RequestVoteReply struct {
-	// Your data here (2A).
-	term        int32
-	voteGranted bool
-}
-```
-
-
-</details>
-
-<details>
-<summary>Modify `Make()` to create a background goroutine that will kick off leader election periodically by sending out `RequestVote` RPCs when it hasn't heard from another peer for a while.</summary>
-
-```go
-
-```
-
-
-</details>
-
-<details>
-<summary>Implement the `RequestVote()` RPC handler so that servers will vote for one another</summary>
-
-</details>
-
-<details>
-<summary>To implement heartbeats, define an `AppendEntries` RPC struct, and have the leader send them out periodically.</summary>
-
-</details>
-
-<details>
-<summary>Write an `AppendEntries` RPC handler method that resets the election timeout so that other servers don't step forward as leaders when one has already been elected.</summary>
-
-</details>
-
-<details>
-<summary>The tester requires that the leader send heartbeat RPCs no more than ten times per second.</summary>
-
-</details>
-
-
-# **Part 2B: log**
-
-- [x] 从当前的Leader处收到AppendEntries RPCs或向Candidate投票的时候reset ElectionTimeout()
-<details>
-<summary>All you need to know about index</summary>
-1. Leader开始，接受Client的命令，将Command append到log尾部，让Server更新状态机
-2. Server更新状态机中的log并返回true的reply。注意，此时Leader和Server的commitIndex都没有发生变化，变化的只是Leader中的nextIndex和matchIndex。这里在Term相同的情况下返回false的reply，会让Leader中的nextIndex自减。
-3. 每当一个AppendEntries返回true以后，触发信号，让Leader检查commitIndex是否能够更新，能更新就增大commitIndex，在下次heartbeat的时候就会更新Server中的commitIndex。
-
-</details>
-
-
-# **Part 2C: persistence**
-
-
-# **Part 2D: log compaction**
-
-
-实现Snapshot，index意味着所有index之前的log都将被丢弃
-
-
-Follower应该使用快照来赶上整体的进度
-
-
-忽略CondInstallSnapshot
-
-
-可以先将index设为0,慢慢增大来尝试通过2D的第一个test
-
-
-如果leader没有能让follower up-to-date的条目，则发送快照
-
-
-不要实现论文中figure 13的offset
-
-
-需要让GC可以access被丢弃的条目，即不存在可访问被丢弃条目的指针
-
-
-保存最新快照的lastIncludedTerm和lastIncludedIndex
-

package/output/sub/f4237e72-fdce-44a4-b62c-659dce24b1ee

@@ -1,107 +0,0 @@
-
-在仅支持进程的操作系统中，进程是拥有资源和独立调度的基本单位。在引入线程的操作系统中，**线程是独立调度的基本单位，进程是资源拥有的基本单位**。在同一进程中，线程的切换不会引起进程切换。在不同进程中进行线程切换,如从一个进程内的线程切换到另一个进程中的线程时，会引起进程切换
-
-
-线程创建、管理、调度等采用的方式称为线程模型。线程模型一般分为以下三种：
-
-- 内核级线程(Kernel Level Thread)模型
-- 用户级线程(User Level Thread)模型
-- 两级线程模型，也称混合型线程模型
-
-三大线程模型最大差异就在于用户级线程与内核调度实体KSE（KSE，Kernel Scheduling Entity）之间的对应关系。**KSE是Kernel Scheduling Entity的缩写，其是可被操作系统内核调度器调度的对象实体，是操作系统内核的最小调度单元，可以简单理解为内核级线程**。
-
-
-**用户级线程即协程**，由应用程序创建与管理，协程必须与内核级线程绑定之后才能执行。**线程由 CPU 调度是抢占式的，协程由用户态调度是协作式的，一个协程让出 CPU 后，才执行下一个协程**。
-
-
-用户级线程(ULT)与内核级线程(KLT)比较：
-
-
-| 特性         | 用户级线程                           | 内核级线程                          |
-| ---------- | ------------------------------- | ------------------------------ |
-| 创建者        | **应用程序**                        | **内核**                         |
-| 操作系统是否感知存在 | 否                               | 是                              |
-| 开销成本       | **创建成本低，上下文切换成本低**，上下文切换不需要硬件支持 | **创建成本高，上下文切换成本高**，上下文切换需要硬件支持 |
-| 如果线程阻塞     | 整个进程将被阻塞。即不能利用多处理来发挥并发优势        | 其他线程可以继续执行,进程不会阻塞              |
-| 案例         | Java thread, POSIX threads      | Window Solaris                 |
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-### 内核级线程模型
-
-
-![ult_klt_1_1.jpg](https://static.cyub.vip/images/202008/ult_klt_1_1.jpg)
-
-
-**内核级线程模型中用户线程与内核线程是一对一关系（1 : 1）**。**线程的创建、销毁、切换工作都是由内核完成的**。应用程序不参与线程的管理工作，只能调用内核级线程编程接口(应用程序创建一个新线程或撤销一个已有线程时，都会进行一个系统调用）。每个用户线程都会被绑定到一个内核线程。用户线程在其生命期内都会绑定到该内核线程。一旦用户线程终止，两个线程都将离开系统。
-
-
-操作系统调度器管理、调度并分派这些线程。运行时库为每个用户级线程请求一个内核级线程。操作系统的内存管理和调度子系统必须要考虑到数量巨大的用户级线程。操作系统为每个线程创建上下文。进程的每个线程在资源可用时都可以被指派到处理器内核。
-
-
-内核级线程模型有如下优点：
-
-- 在多处理器系统中，内核能够并行执行同一进程内的多个线程
-- 如果进程中的一个线程被阻塞，不会阻塞其他线程，是能够切换同一进程内的其他线程继续执行
-- 当一个线程阻塞时，内核根据选择可以运行另一个进程的线程，而用户空间实现的线程中，运行时系统始终运行自己进程中的线程
-
-缺点：
-
-- 线程的创建与删除都需要CPU参与，成本大
-
-### 用户级线程模型
-
-
-![ult_klt_n_1.jpg](https://static.cyub.vip/images/202008/ult_klt_n_1.jpg)
-
-
-**用户线程模型中的用户线程与内核线程KSE是多对一关系（N : 1）**。**线程的创建、销毁以及线程之间的协调、同步等工作都是在用户态完成**，具体来说就是由应用程序的线程库来完成。**内核对这些是无感知的，内核此时的调度都是基于进程的**。线程的并发处理从宏观来看，任意时刻每个进程只能够有一个线程在运行，且只有一个处理器内核会被分配给该进程。
-
-
-从上图中可以看出来：库调度器从进程的多个线程中选择一个线程，然后该线程和该进程允许的一个内核线程关联起来。内核线程将被操作系统调度器指派到处理器内核。用户级线程是一种”多对一”的线程映射
-
-
-用户级线程有如下优点：
-
-- 创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多, 因为保存线程状态的过程和调用程序都只是本地过程
-- 线程能够利用的表空间和堆栈空间比内核级线程多
-
-缺点：
-
-- 线程发生I/O或页面故障引起的阻塞时，如果调用阻塞系统调用则内核由于不知道有多线程的存在，而会阻塞整个进程从而阻塞所有线程, 因此同一进程中只能同时有一个线程在运行
-- 资源调度按照进程进行，多个处理机下，同一个进程中的线程只能在同一个处理机下分时复用
-
-### 两级线程模型
-
-
-![ult_klt_n_m.jpg](https://static.cyub.vip/images/202008/ult_klt_n_m.jpg)
-
-
-**两级线程模型中用户线程与内核线程是一对一关系（N : M）**。两级线程模型充分吸收上面两种模型的优点，尽量规避缺点。其线程创建在用户空间中完成，线程的调度和同步也在应用程序中进行。一个应用程序中的多个用户级线程被绑定到一些（小于或等于用户级线程的数目）内核级线程上。
-
-
-### Golang的线程模型
-
-
-**Golang在底层实现了混合型线程模型**。M即系统线程，由系统调用产生，一个M关联一个KSE，即两级线程模型中的系统线程。G为Groutine，即两级线程模型的的应用及线程。M与G的关系是N:M。
-
-
-![golang_ult_klt.jpg](https://static.cyub.vip/images/202008/golang_ult_klt.jpg)
-

package/src/cmds/generate.ts

@@ -1,54 +0,0 @@
-import * as path from "path"
-import { Logger } from "tslog";
-
-import { Noblog } from "../lib/nomd/nomd.js";
-import { GetAllPosts } from "../lib/notion/client.js";
-
-let v: boolean = false;
-let save_dir = "./content/markdown"
-let sub_dir = "sub"
-const nob = new Noblog()
-const logger = new Logger({ name: "noblog" });
-
-function help() {
-  const usage = "Usage: noblog <SAVE_DIR>";
-  const example = "Example:\n  noblog .";
-
-  const output = usage + "\n" + example + "\n";
-  return output;
-}
-
-async function main() {
-  const argv = process.argv.slice(2,);
-  if (argv.length > 1) {
-    console.error("Error: invallid arg.");
-    console.log(help());
-  }
-  save_dir = argv[0] ?? save_dir;
-  sub_dir = path.join(save_dir, sub_dir)
-
-  const pages = await GetAllPosts();
-  const futures = pages.map(page => {
-    return nob.FromPageid(page.id)
-  })
-
-  try {
-    await Promise.all(futures);
-    for (const pageid of Object.keys(nob.MdCollection)) {
-      let fpath = save_dir;
-      if (pages.find(page => page.id !== pageid))
-        fpath = sub_dir
-      const log = await nob.SaveJelly(pageid, fpath, nob.MdCollection[pageid])
-      if (v) logger.info(log);
-    }
-    console.log(`success: finish dump all files to "${save_dir}"`)
-  } catch (error) {
-    if (error instanceof Error) {
-      console.log(`failed: consider running with "v=true" - ${error.message}`);
-    } else {
-      console.log('failed: an unknown error occurred');
-    }
-  }
-}
-
-main()

package/src/index.ts

@@ -1,22 +0,0 @@
-export * from './lib/nomd/nomd.js'
-export * from './lib/notion/client.js'
-
-// ---------------- test -----------------
-import 'dotenv/config'
-import { Noblog } from './lib/nomd/nomd.js'
-import { GetAllPosts } from './lib/notion/client.js'
-
-const nob = new Noblog();
-
-GetAllPosts().then(res => {
-  // client.pages.retrieve({ page_id: res[0]?.id } as any).then(
-  //   res => console.log(res))
-  //
-  nob.FromPageid(res[5]?.id as any).then(
-    res => {
-      console.log(nob.MdCollection)
-    }
-  )
-  // client.blocks.children.list({ block_id: res[0]?.id } as any).then(
-  //   res => console.log(res))
-})

package/src/lib/nomd/cvter.ts

@@ -1,143 +0,0 @@
-import fetch from "node-fetch";
-import { markdownTable } from "markdown-table";
-
-
-type CalloutIcon =
-  | { type: "emoji"; emoji?: string }
-  | { type: "external"; external?: { url: string } }
-  | { type: "file"; file: { url: string; expiry_time: string } }
-  | null;
-
-export const inlineCode = (text: string) => {
-  return `\`${text}\``;
-};
-
-export const inlineEquation = (text: string) => {
-  return `$${text}$`;
-};
-
-export const bold = (text: string) => {
-  return `**${text}**`;
-};
-
-export const italic = (text: string) => {
-  return `_${text}_`;
-};
-
-export const strikethrough = (text: string) => {
-  return `~~${text}~~`;
-};
-
-export const underline = (text: string) => {
-  return `<u>${text}</u>`;
-};
-
-export const link = (text: string, href: string) => {
-  return `[${text}](${href})`;
-};
-
-export const codeBlock = (text: string, language?: string) => {
-  if (language === "plain text") language = "text";
-
-  return `\`\`\`${language}
-${text}
-\`\`\``;
-};
-
-export const equation = (text: string) => {
-  return `$$
-${text}
-$$`;
-};
-
-export const heading1 = (text: string) => {
-  return `# ${text}`;
-};
-
-export const heading2 = (text: string) => {
-  return `## ${text}`;
-};
-
-export const heading3 = (text: string) => {
-  return `### ${text}`;
-};
-
-export const quote = (text: string) => {
-  // the replace is done to handle multiple lines
-  return `> ${text.replace(/\n/g, "  \n> ")}`;
-};
-
-export const callout = (text: string, icon?: CalloutIcon) => {
-  let emoji: string | undefined;
-  if (icon?.type === "emoji") {
-    emoji = icon.emoji;
-  }
-
-  // the replace is done to handle multiple lines
-  return `> ${emoji ? emoji + " " : ""}${text.replace(/\n/g, "  \n> ")}`;
-};
-
-export const bullet = (text: string, count?: number) => {
-  let renderText = text.trim();
-  return count ? `${count}. ${renderText}` : `- ${renderText}`;
-};
-
-export const todo = (text: string, checked: boolean) => {
-  return checked ? `- [x] ${text}` : `- [ ] ${text}`;
-};
-
-export const image = async (
-  alt: string,
-  href: string,
-  convertToBase64: boolean = false
-): Promise<string> => {
-  // In case the user does not want to convert the images to Base64
-  // or the image is already base64
-  if (!convertToBase64 || href.startsWith("data:")) {
-    if (href.startsWith("data:")) {
-      // Extract base64 data, i.e. the string after 'data:mime/type;base64,'
-      const base64 = href.split(",").pop();
-
-      // This overrides incorrect data: string format to png
-      // so that browsers can correctly render the data
-      return `![${alt}](data:image/png;base64,${base64})`;
-    }
-
-    return `![${alt}](${href})`;
-  } else {
-    // Otherwise, download the image and convert it to base64
-    const res = await fetch(href);
-    const buf = await res.arrayBuffer();
-
-    const base64 = Buffer.from(buf).toString("base64");
-
-    return `![${alt}](data:image/png;base64,${base64})`;
-  }
-};
-
-export const addTabSpace = (text: string, n = 0) => {
-  const tab = "	";
-  for (let i = 0; i < n; i++) {
-    if (text.includes("\n")) {
-      const multiLineText = text.split(/(?:^|\n)/).join(`\n${tab}`);
-      text = tab + multiLineText;
-    } else text = tab + text;
-  }
-  return text;
-};
-
-export const divider = () => {
-  return "---";
-};
-
-export const toggle = (summary?: string, children?: string) => {
-  if (!summary) return children || "";
-  return `<details>
-<summary>${summary}</summary>
-${children || ""}
-</details>\n\n`;
-};
-
-export const table = (cells: string[][]) => {
-  return markdownTable(cells);
-};

package/src/lib/nomd/nomd.ts

@@ -1,88 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { NotionToMarkdown } from "notion-to-md";
-
-import * as cvtmd from "./cvter.js"
-import { client as notion_client } from "../notion/client.js";
-
-// from notion-to-md
-type MdBlock = {
-  type?: string;
-  blockId: string;
-  parent: string;
-  children: MdBlock[];
-};
-
-export type MdJelly = {
-  content: string;    // markdown content
-  children: string[]; // child_page
-}
-
-export class Noblog extends NotionToMarkdown {
-  MdCollection: Record<string, MdJelly> = {};
-
-  constructor() {
-    super({ notionClient: notion_client });
-    this.setCustomTransformer("child_page", async (block) => {
-      const page = block as any;
-      if (!page?.id) return false;
-      return `[${page.child_page.title}](${page.id}.md)`;
-    })
-  }
-
-  async FromBlocks(blocks: MdBlock[], recursive: boolean): Promise<MdJelly> {
-    let jelly: MdJelly = { content: "", children: [] }
-    for (const block of blocks) {
-      const subjelly = await this.FromBlocks(block.children, recursive);
-
-      if (block.type === "toggle") {
-        jelly.content += cvtmd.toggle(block.parent, subjelly.content);
-        jelly.children = [...jelly.children, ...subjelly.children];
-        continue;
-      }
-      let line_wrap = "";
-      if (
-        block.type !== "to_do" &&
-        block.type !== "bulleted_list_item" &&
-        block.type !== "numbered_list_item"
-      ) {
-        line_wrap = "\n";
-      }
-      jelly.content += (line_wrap + `${cvtmd.addTabSpace(block.parent, 0)}\n` + line_wrap);
-      if (block.type === "child_page") {
-        jelly.children = [...jelly.children, block.blockId];
-        if (recursive) await this.FromPageid(block.blockId, recursive);
-      } else {
-        jelly.content += subjelly.content;
-        jelly.children = [...jelly.children, ...subjelly.children];
-      }
-    }
-    return jelly;
-  }
-
-  async FromPageid(page_id: string, recursive: boolean = true) {
-    if (this.MdCollection.hasOwnProperty(page_id)) {
-      return this.MdCollection[page_id];
-    }
-    const blocks = await this.pageToMarkdown(page_id);
-    const jelly = await this.FromBlocks(blocks, recursive);
-    this.MdCollection[page_id] = jelly;
-    return jelly;
-  }
-
-  async SaveJelly(fname: string, dir: string, jelly: MdJelly | undefined): Promise<string> {
-    if (jelly === undefined) return `failed: ${fname} has empty jelly: `
-    try {
-      await fs.mkdir(dir, { recursive: true });
-      const filePath = path.join(dir, fname);
-      await fs.writeFile(filePath, jelly.content, 'utf-8');
-      return `success: ${fname} saved to ${filePath}`;
-    } catch (error) {
-      if (error instanceof Error) {
-        return `failed: ${fname} - ${error.message}`;
-      } else {
-        return 'failed: an unknown error occurred';
-      }
-    }
-  }
-}

package/src/lib/nosm/nosm.ts

@@ -1,3 +0,0 @@
-// noblog style manager
-
-