diff --git a/2018/02/21/git/index.html b/2018/02/21/git/index.html new file mode 100644 index 0000000..6874024 --- /dev/null +++ b/2018/02/21/git/index.html @@ -0,0 +1,833 @@ + + + + + + + + + 常用 Git 命令清单 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ 常用 Git 命令清单 +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.7k字 + + + + +   |   + + + 阅读时长≈ + 6分 + + +
+ + + +
+ +
+ +

常用 Git 命令清单

+
+ + + +

我每天使用 Git ，但是很多命令记不住。

+

一般来说，日常使用只要记住下图6个命令，就可以了。但是熟练使用，恐怕要记住60～100个命令。

+

+

下面是我整理的常用 Git 命令清单。几个专用名词的译名如下。

+
    +
  • Workspace：工作区
    • +
  • Index / Stage：暂存区
    • +
  • Repository：仓库区（或本地仓库）
    • +
  • Remote：远程仓库
    • +
+

一、新建代码库


# 在当前目录新建一个Git代码库
$ git init

# 新建一个目录，将其初始化为Git代码库
$ git init [project-name]

# 下载一个项目和它的整个代码历史
$ git clone [url]

+ +

二、配置

Git的设置文件为.gitconfig，它可以在用户主目录下（全局配置），也可以在项目目录下（项目配置）。

+ 

# 显示当前的Git配置
$ git config --list

# 编辑Git配置文件
$ git config -e [--global]

# 设置提交代码时的用户信息
$ git config [--global] user.name "[name]"
$ git config [--global] user.email "[email address]"

+ +

三、增加/删除文件


# 添加指定文件到暂存区
$ git add [file1] [file2] ...

# 添加指定目录到暂存区，包括子目录
$ git add [dir]

# 添加当前目录的所有文件到暂存区
$ git add .

# 添加每个变化前，都会要求确认
# 对于同一个文件的多处变化，可以实现分次提交
$ git add -p

# 删除工作区文件，并且将这次删除放入暂存区
$ git rm [file1] [file2] ...

# 停止追踪指定文件，但该文件会保留在工作区
$ git rm --cached [file]

# 改名文件，并且将这个改名放入暂存区
$ git mv [file-original] [file-renamed]

+ +

四、代码提交


# 提交暂存区到仓库区
$ git commit -m [message]

# 提交暂存区的指定文件到仓库区
$ git commit [file1] [file2] ... -m [message]

# 提交工作区自上次commit之后的变化，直接到仓库区
$ git commit -a

# 提交时显示所有diff信息
$ git commit -v

# 使用一次新的commit，替代上一次提交
# 如果代码没有任何新变化，则用来改写上一次commit的提交信息
$ git commit --amend -m [message]

# 重做上一次commit，并包括指定文件的新变化
$ git commit --amend [file1] [file2] ...

+ +

五、分支


# 列出所有本地分支
$ git branch

# 列出所有远程分支
$ git branch -r

# 列出所有本地分支和远程分支
$ git branch -a

# 新建一个分支，但依然停留在当前分支
$ git branch [branch-name]

# 新建一个分支，并切换到该分支
$ git checkout -b [branch]

# 新建一个分支，指向指定commit
$ git branch [branch] [commit]

# 新建一个分支，与指定的远程分支建立追踪关系
$ git branch --track [branch] [remote-branch]

# 切换到指定分支，并更新工作区
$ git checkout [branch-name]

# 切换到上一个分支
$ git checkout -

# 建立追踪关系，在现有分支与指定的远程分支之间
$ git branch --set-upstream [branch] [remote-branch]

# 合并指定分支到当前分支
$ git merge [branch]

# 选择一个commit，合并进当前分支
$ git cherry-pick [commit]

# 删除分支
$ git branch -d [branch-name]

# 删除远程分支
$ git push origin --delete [branch-name]
$ git branch -dr [remote/branch]

+ +

六、标签


# 列出所有tag
$ git tag

# 新建一个tag在当前commit
$ git tag [tag]

# 新建一个tag在指定commit
$ git tag [tag] [commit]

# 删除本地tag
$ git tag -d [tag]

# 删除远程tag
$ git push origin :refs/tags/[tagName]

# 查看tag信息
$ git show [tag]

# 提交指定tag
$ git push [remote] [tag]

# 提交所有tag
$ git push [remote] --tags

# 新建一个分支，指向某个tag
$ git checkout -b [branch] [tag]

+ +

七、查看信息


# 显示有变更的文件
$ git status

# 显示当前分支的版本历史
$ git log

# 显示commit历史，以及每次commit发生变更的文件
$ git log --stat

# 搜索提交历史，根据关键词
$ git log -S [keyword]

# 显示某个commit之后的所有变动，每个commit占据一行
$ git log [tag] HEAD --pretty=format:%s

# 显示某个commit之后的所有变动，其"提交说明"必须符合搜索条件
$ git log [tag] HEAD --grep feature

# 显示某个文件的版本历史，包括文件改名
$ git log --follow [file]
$ git whatchanged [file]

# 显示指定文件相关的每一次diff
$ git log -p [file]

# 显示过去5次提交
$ git log -5 --pretty --oneline

# 显示所有提交过的用户，按提交次数排序
$ git shortlog -sn

# 显示指定文件是什么人在什么时间修改过
$ git blame [file]

# 显示暂存区和工作区的差异
$ git diff

# 显示暂存区和上一个commit的差异
$ git diff --cached [file]

# 显示工作区与当前分支最新commit之间的差异
$ git diff HEAD

# 显示两次提交之间的差异
$ git diff [first-branch]...[second-branch]

# 显示今天你写了多少行代码
$ git diff --shortstat "@{0 day ago}"

# 显示某次提交的元数据和内容变化
$ git show [commit]

# 显示某次提交发生变化的文件
$ git show --name-only [commit]

# 显示某次提交时，某个文件的内容
$ git show [commit]:[filename]

# 显示当前分支的最近几次提交
$ git reflog

+ +

八、远程同步


# 下载远程仓库的所有变动
$ git fetch [remote]

# 显示所有远程仓库
$ git remote -v

# 显示某个远程仓库的信息
$ git remote show [remote]

# 增加一个新的远程仓库，并命名
$ git remote add [shortname] [url]

# 取回远程仓库的变化，并与本地分支合并
$ git pull [remote] [branch]

# 上传本地指定分支到远程仓库
$ git push [remote] [branch]

# 强行推送当前分支到远程仓库，即使有冲突
$ git push [remote] --force

# 推送所有分支到远程仓库
$ git push [remote] --all

+ +

九、撤销


# 恢复暂存区的指定文件到工作区
$ git checkout [file]

# 恢复某个commit的指定文件到暂存区和工作区
$ git checkout [commit] [file]

# 恢复暂存区的所有文件到工作区
$ git checkout .

# 重置暂存区的指定文件，与上一次commit保持一致，但工作区不变
$ git reset [file]

# 重置暂存区与工作区，与上一次commit保持一致
$ git reset --hard

# 重置当前分支的指针为指定commit，同时重置暂存区，但工作区不变
$ git reset [commit]

# 重置当前分支的HEAD为指定commit，同时重置暂存区和工作区，与指定commit一致
$ git reset --hard [commit]

# 重置当前HEAD为指定commit，但保持暂存区和工作区不变
$ git reset --keep [commit]

# 新建一个commit，用来撤销指定commit
# 后者的所有变化都将被前者抵消，并且应用到当前分支
$ git revert [commit]

# 暂时将未提交的变化移除，稍后再移入
$ git stash
$ git stash pop

+ +

十、其他


# 生成一个可供发布的压缩包
$ git archive

+ +

（完）

+ + + + + + +
+
    +
  • + 本文作者： + Alex guo +
    • +
  • + 本文链接： + https://www.goroutine.cn/2018/02/21/git/ +
    • + +
  • + 版权声明： + + 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！ +
    • + +
+
+ + +
+
+ + +
+ +
    + +
  • + git +
    • + +
+
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/03/03/RWMutex-in-go/index.html b/2018/03/03/RWMutex-in-go/index.html new file mode 100644 index 0000000..c8547de --- /dev/null +++ b/2018/03/03/RWMutex-in-go/index.html @@ -0,0 +1,836 @@ + + + + + + + + + RWMutex in go | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ RWMutex in go +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.2k字 + + + + +   |   + + + 阅读时长≈ + 5分 + + +
+ + + +
+ +
+ +

RWMutex

使用场景

读写锁适用于读多写少的场景。基础特性包括:

+
    +
  • RLock被reader占用时，Lock(/WLock)会被block。反之依然
    • +
  • RLock被占用时，其他读线程也可以获取到RLock。即允许多个reader同时访问共享资源
    • +
  • WLock同一时间只能被一个routine/thread获取
    • +
+

根据不同的优先级策略，可以有不同的实现方案：

+
    +

  • 读优先(Read-preferring RW locks)
    读优先允许最大量的并发，但是竞争激烈时可能导致write-starvation。因为读多写少的场景下，如果读请求的优先级更高，写锁获取成功的概率就更低了。

    +
    • +

  • 写优先(Write-preferring RW locks)
    为了避免write-starvation的情况出现，给WLock的优先级更高，如果RLock已经被占用，那么WLock也将会在block中， 此时后续的新到的RLock调用也将被block，直到RLock被释放，WLock被writer获取成功后释放。
    对比读优先，所允许的并发量相对要小一些。且实现更为复杂，性能也相对也要差一些。

    +
    • +

  • 总结：A good way to think about it is RWMutex is a Mutex with a reader counter. RLock increments the counter while RUnlock decrements it. A call to Lock will block as long as that counter is > 0.

    +
    • +
+ + +

实现原理

一些大致的实现思路

+

思路一

一个写锁(mutex)保证writer互斥
一个读锁和计数器实现读锁。读锁用户维护计数器的准确性。计数器用于多个reader计数

+

读优先的实现:

+
//读锁
RLock()
    r.lock()
    r_cnt++
    if r_cnt==1: // 读写互斥
        w.lock()
    r.unlock()

RUnlock()
    r.lock()
    r_cnt--
    if r_cnt==0:
        w.unlock()
    r.unlock()

//写锁
Lock()
    w.lock()

Unlock()
    w.unlock()

+ +

思路二

使用锁和条件变量

+
RLock()
    m.lock()
    while w: // wLock使用中，block到被唤醒
        c.wait(m)
    r++
    m.unlock()

RUnlock()
    m.lock()
    r--
    if r==0:
        c.signal_all() // 唤醒writer
    m.unlock()

Lock()
    m.lock()
    while w || r > 0 :  // 有reader，block到被唤醒
        c.wait(m)
    w = true
    m.unlock()

Unlock()
    m.lock()
    w = false
    c.signal_all()  // 唤醒reader或writer
    m.unlock()
+ +

golang的实现

为避免writer被饿死，RWMutex中至少需要记录三个信息：

+
    +
  • 使用中的reader计数器：a
    • +
  • writer请求中/使用中的标志：b
    • +
  • 挂起在writer之后的reader：c
    • +
+

golang用两个变量包括了以上三部分信息，具体见golang的实现(忽略race部分)

+
type RWMutex struct {
	w           Mutex  // held if there are pending writers
	writerSem   uint32 // semaphore for writers to wait for completing readers. writer等待reader完成的信号量
	readerSem   uint32 // semaphore for readers to wait for completing writers. reader等待writer完成的信号量

    // 计数器承担两个作用，一个是用来记录reader的个数，另一个作用用作判断是否有writer挂起或者在占有锁
	readerCount int32  // number of pending readers. 挂起的reader和使用中的reader，如果有writer操作（挂起/占有），计数器会变为负数以示区分
	readerWait  int32  // number of departing readers. 使用中的reader
}

func (rw *RWMutex) RLock() {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}

    // 没有writer时只需执行+1操作. 
    // 如果有writer调用，计数器会被置为负数。此时reader被block，等待writer unlock后唤醒 
	if atomic.AddInt32(&rw.readerCount, 1) < 0 {
		// A writer is pending, wait for it.
		runtime_Semacquire(&rw.readerSem)
	}

	if race.Enabled {
		race.Enable()
		race.Acquire(unsafe.Pointer(&rw.readerSem))
	}
}

// RUnlock undoes a single RLock call;
// it does not affect other simultaneous readers.
// It is a run-time error if rw is not locked for reading
// on entry to RUnlock.
func (rw *RWMutex) RUnlock() {
	if race.Enabled {
		_ = rw.w.state
		race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
		race.Disable()
	}

    // 计数器小于0，表示有writer在等待
	if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
		if r+1 == 0 || r+1 == -rwmutexMaxReaders {
			race.Enable()
			throw("sync: RUnlock of unlocked RWMutex")
		}
		// A writer is pending.
		// 使用中的reader已全部释放，唤醒等待中的writer
		if atomic.AddInt32(&rw.readerWait, -1) == 0 {
			// The last reader unblocks the writer.
			runtime_Semrelease(&rw.writerSem, false)
		}
	}
	if race.Enabled {
		race.Enable()
	}
}

// Lock locks rw for writing.
// If the lock is already locked for reading or writing,
// Lock blocks until the lock is available.
func (rw *RWMutex) Lock() {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}

	// First, resolve competition with other writers.
	rw.w.Lock()

	// Announce to readers there is a pending writer.
	r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
	// Wait for active readers.
	if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
		runtime_Semacquire(&rw.writerSem)
	}
	if race.Enabled {
		race.Enable()
		race.Acquire(unsafe.Pointer(&rw.readerSem))
		race.Acquire(unsafe.Pointer(&rw.writerSem))
	}
}

// Unlock unlocks rw for writing. It is a run-time error if rw is
// not locked for writing on entry to Unlock.
//
// As with Mutexes, a locked RWMutex is not associated with a particular
// goroutine. One goroutine may RLock (Lock) an RWMutex and then
// arrange for another goroutine to RUnlock (Unlock) it.
func (rw *RWMutex) Unlock() {
	if race.Enabled {
		_ = rw.w.state
		race.Release(unsafe.Pointer(&rw.readerSem))
		race.Release(unsafe.Pointer(&rw.writerSem))
		race.Disable()
	}

	// Announce to readers there is no active writer.
	r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
	if r >= rwmutexMaxReaders {
		race.Enable()
		throw("sync: Unlock of unlocked RWMutex")
	}
	// Unblock blocked readers, if any.
	for i := 0; i < int(r); i++ {
		runtime_Semrelease(&rw.readerSem, false)
	}
	// Allow other writers to proceed.
	rw.w.Unlock()
	if race.Enabled {
		race.Enable()
	}
}

+ +

参考

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/05/01/nginx-accel-redirect/index.html b/2018/05/01/nginx-accel-redirect/index.html new file mode 100644 index 0000000..e0f21cf --- /dev/null +++ b/2018/05/01/nginx-accel-redirect/index.html @@ -0,0 +1,824 @@ + + + + + + + + + nginx-accel-redirect | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ nginx-accel-redirect +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 408字 + + + + +   |   + + + 阅读时长≈ + 1分 + + +
+ + + +
+ +
+ +

背景

项目需要，提供一个对外的文件下载服务，详细需求点如下：

+
    +
  • 需要对接多个客户
    • +
  • 各个客户要求的数据格式不同，内容不同
    • +
  • 客户间权限隔离
    • +
  • 文件可能较大
    • +
+ + +

方案

文件下载的第一方案自然想到了nginx，ip、流量控制等nginx都只要配置就可以实现，但似乎无法做好各个客户间的权限隔离(当然localtion隔离也可以，但维护成本比较大)。搜索之后了解到了nginx的X-Accel

+

X-accel allows for internal redirection to a location determined by a header returned from a backend.

+
+ +

X-Accel比较特殊的地方是利用upstream返回的头部信息进行对应处理。常见的配置方式如下：

+
nginx配置link
http {
    ....
    server {
        listen       80;
        server_name  your-domain.com;

        location / {
            rewrite ^/download/(.*) /down.php?path=$1 last;

            proxy_pass         http://127.0.0.1:8080/;
            proxy_redirect     off;

            proxy_set_header   Host             $host;
            proxy_set_header   X-Real-IP        $remote_addr;
            proxy_set_header   X-Forwarded-For  $proxy_add_x_forwarded_for;

            client_max_body_size       10m;
            client_body_buffer_size    128k;

            proxy_connect_timeout      90;
            proxy_send_timeout         90;
            proxy_read_timeout         90;

            proxy_buffer_size          4k;
            proxy_buffers              4 32k;
            proxy_busy_buffers_size    64k;
            proxy_temp_file_write_size 64k;

        }

        location /files {
            root /var/www;
            internal;
        }
    }
}
+ +

注意interval保证了文件不能直接被外部访问，只能用于内部跳转，upstream的返回中通过X-Accel-Redirect指定真实的跳转文件名。

+
down.php
<?php
// Get requested file name
$path = $_GET["path"];

//...
// Perform any required security checks, validation 
// and/or stats accounting
//...

// And redirect user to internal location
header("X-Accel-Redirect: /files/" . $path);

?>
+ +

在cgi中我们可以根据实际情况做一些安全检查、验证、统计等。如针对我们的实际场景，校验请求方ip、签名是否有效，可以对每家客户做到权限的隔离。

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/06/03/HTTPS-explained-with-carrier-pigeons/index.html b/2018/06/03/HTTPS-explained-with-carrier-pigeons/index.html new file mode 100644 index 0000000..60f5baf --- /dev/null +++ b/2018/06/03/HTTPS-explained-with-carrier-pigeons/index.html @@ -0,0 +1,840 @@ + + + + + + + + + HTTPS explained with carrier pigeons | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ HTTPS explained with carrier pigeons +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.2k字 + + + + +   |   + + + 阅读时长≈ + 7分 + + +
+ + + +
+ +
+ +

HTTPS explained with carrier pigeons

转载一篇HTTPS的科普的文章。link

+ + +

Cryptography can be a hard subject to understand. It’s full of mathematical proofs. But unless you are actually developing cryptographic systems, much of that complexity is not necessary to understand what is going on at a high level.

+

If you opened this article hoping to create the next HTTPS protocol, I’m sorry to say that pigeons won’t be enough. Otherwise, brew some coffee and enjoy the article.

+

Alice, Bob and … pigeons?

Any activity you do on the Internet (reading this article, buying stuff on Amazon, uploading cat pictures) comes down to sending and receiving messages to and from a server.

+

This can be a bit abstract so let’s imagine that those messages were delivered by carrier pigeons. I know that this may seem very arbitrary, but trust me HTTPS works the same way, albeit a lot faster.

+

Also instead of talking about servers, clients and hackers, we will talk about Alice, Bob and Mallory. If this isn’t your first time trying to understand cryptographic concepts you will recognize those names, because they are widely used in technical literature.

+

A first naive communication

If Alice wants to send a message to Bob, she attaches the message on the carrier pigeon’s leg and sends it to Bob. Bob receives the message, reads it and it’s all is good.

+

But what if Mallory intercepted Alice’s pigeon in flight and changed the message? Bob would have no way of knowing that the message that was sent by Alice was modified in transit.

+

This is how HTTP works. Pretty scary right? I wouldn’t send my bank credentials over HTTP and neither should you.

+

A secret code

Now what if Alice and Bob are very crafty. They agree that they will write their messages using a secret code. They will shift each letter by 3 positions in the alphabet. For example D → A, E → B, F → C. The plain text message “secret message” would be “pbzobq jbppxdb”.

+

Now if Mallory intercepts the pigeon she won’t be able to change the message into something meaningful nor understand what it says, because she doesn’t know the code. But Bob can simply apply the code in reverse and decrypt the message where A → D, B → E, C → F. The cipher text “pbzobq jbppxdb” would be decrypted back to “secret message”.

+

Success!

+

This is called symmetric key cryptography, because if you know how to encrypt a message you also know how to decrypt it.

+

The code I described above is commonly known as the Caesar cipher. In real life, we use fancier and more complex codes, but the main idea is the same.

+

How do we decide the key?

Symmetric key cryptography is very secure if no one apart from the sender and receiver know what key was used. In the Caesar cipher, the key is an offset of how many letters we shift each letter by. In our example we used an offset of 3, but could have also used 4 or 12.

+

The issue is that if Alice and Bob don’t meet before starting to send messages with the pigeon, they would have no way to establish a key securely. If they send the key in the message itself, Mallory would intercept the message and discover the key. This would allow Mallory to then read or change the message as she wishes before and after Alice and Bob start to encrypt their messages.

+

This is the typical example of a Man in the Middle Attack and the only way to avoid it is to change the encryption system all together.

+

Pigeons carrying boxes

So Alice and Bob come up with an even better system. When Bob wants to send Alice a message she will follow the procedure below:

+
    +
  • Bob sends a pigeon to Alice without any message.
    • +
  • Alice sends the pigeon back carrying a box with an open lock, but keeping the key.
    • +
  • Bob puts the message in the box, closes the locks and sends the box to Alice.
    • +
  • Alice receives the box, opens it with the key and reads the message.
    • +
+

This way Mallory can’t change the message by intercepting the pigeon, because she doesn’t have the key. The same process is followed when Alice wants to send Bob a message.

+

Alice and Bob just used what is commonly known as asymmetric key cryptography. It’s called asymmetric, because even if you can encrypt a message (lock the box) you can’t decrypt it (open a closed box).
In technical speech the box is known as the public key and the key to open it is known as the private key.

+

How do I trust the box?

If you paid attention you may have noticed that we still have a problem. When Bob receives that open box how can he be sure that it came from Alice and that Mallory didn’t intercept the pigeon and changed the box with one she has the key to?

+

Alice decides that she will sign the box, this way when Bob receives the box he checks the signature and knows that it was Alice who sent the box.

+

Some of you may be thinking, how would Bob identify Alice’s signature in the first place? Good question. Alice and Bob had this problem too, so they decided that, instead of Alice signing the box, Ted will sign the box.

+

Who is Ted? Ted is a very famous, well known and trustworthy guy. Ted gave his signature to everyone and everybody trusts that he will only sign boxes for legitimate people.

+

Ted will only sign an Alice box if he’s sure that the one asking for the signature is Alice. So Mallory cannot get an Alice box signed by Ted on behalf of her as Bob will know that the box is a fraud because Ted only signs boxes for people after verifying their identity.

+

Ted in technical terms is commonly referred to as a Certification Authority and the browser you are reading this article with comes packaged with the signatures of various Certification Authorities.

+

So when you connect to a website for the first time you trust its box because you trust Ted and Ted tells you that the box is legitimate.

+

Boxes are heavy

Alice and Bob now have a reliable system to communicate, but they realize that pigeons carrying boxes are slower than the ones carrying only the message.

+

They decide that they will use the box method (asymmetric cryptography) only to choose a key to encrypt the message using symmetric cryptography with (remember the Caesar cipher?).

+

This way they get the best of both worlds. The reliability of asymmetric cryptography and the efficiency of symmetric cryptography.

+

In the real world there aren’t slow pigeons, but nonetheless encrypting messages using asymmetric cryptography is slower than using symmetric cryptography, so we only use it to exchange the encryption keys.

+

Now you know how HTTPS works and your coffee should also be ready. Go drink it you deserved it.

+

参考：图解SSL/TLS协议

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/06/03/HTTPS-performacne-tips/index.html b/2018/06/03/HTTPS-performacne-tips/index.html new file mode 100644 index 0000000..e2824c5 --- /dev/null +++ b/2018/06/03/HTTPS-performacne-tips/index.html @@ -0,0 +1,839 @@ + + + + + + + + + HTTPS performacne tips | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ HTTPS performacne tips +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.2k字 + + + + +   |   + + + 阅读时长≈ + 5分 + + +
+ + + +
+ +
+ +

HTTP vs HTTPS performance

相对HTTP，影响HTTPS性能的因素包括以下几个方面。

+ + +

TLS协议开销

TLS协议采用主从式架构模型，用于在两个应用程序间通过网络创建起安全的连接，防止在交换数据时受到窃听及篡改。
TLS协议的优势是与高层的应用层协议（如HTTP、FTP、Telnet等）无耦合。应用层协议能透明地运行在TLS协议之上，由TLS协议进行创建加密通道需要的协商和认证。应用层协议传送的数据在通过TLS协议时都会被加密，从而保证通信的私密性。

+

TLS握手

握手流程

+

The SSL or TLS handshake enables the SSL or TLS client and server to establish the secret keys with which they communicate.

+
    +
  1. TCL client send “client hello“ to TLS server. include:
      +
    • cryptographic information such as the SSL or TLS version
      • +
    • the CipherSuites supported by the client
      • +
    • a random byte string that is used in subsequent computations
      • +
    • data compression methods supported by the client
      • +
    +
    2. +
  2. The TLS server responds with a “server hello“ message that contains:
      +
    • the CipherSuite chosen by the server from the list provided by the client.
      • +
    • the session ID.
      • +
    • another random byte string.
      • +
    • The server also sends its digital certificate.
      • +
    • If the server requires a digital certificate for client authentication, the server sends a “client certificate request” that includes a list of the types of certificates supported and the Distinguished Names of acceptable Certification Authorities (CAs).
      • +
    +
    3. +
  3. The TLS client verifies the server’s digital certificate. For more information, see How SSL and TLS provide identification, authentication, confidentiality, and integrity.
    4. +
  4. The TLS client sends the random byte string (also called pre-master-secret) that enables both the client and the server to compute the secret key to be used for encrypting subsequent message data. The random byte string itself is encrypted with the server’s public key.
    5. +
  5. (optional)If the TLS server sent a “client certificate request”, the client sends a random byte string encrypted with the client’s private key, together with the client’s digital certificate, or a “no digital certificate alert”. This alert is only a warning, but with some implementations the handshake fails if client authentication is mandatory.
    6. +
  6. The SSL or TLS server verifies the client’s certificate. For more information, see How SSL and TLS provide identification, authentication, confidentiality, and integrity.
    7. +
  7. The SSL or TLS client sends the server a “finished” message, which is encrypted with the secret key, indicating that the client part of the handshake is complete. 客户端握手结束通知，表示客户端的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供服务器校验。
    8. +
  8. The SSL or TLS server sends the client a “finished” message, which is encrypted with the secret key, indicating that the server part of the handshake is complete.
    9. +
  9. For the duration of the SSL or TLS session, the server and client can now exchange messages that are symmetrically encrypted with the shared secret key.
    10. +
+

可见，相比http，client和server至少增加了2个来回的交互。
对于长连接的使用场景影响还好，因为handshake只影响到了session建立的过程，对于后面的数据交互无影响，但对于端链接的场景冲击会相对较大，每次请求都会多了2个来回的交互。

+

交换数据加解密

TLS连接建立后，CS间采用secret key来加密交换数据。对称加密会对服务端的性能造成一些压力。

+

注意secret key的生成依赖上面提到的三个随机数，原因如下

+
+

ssl3_send_client_key_exchange是openssl中客户端确定密钥的函数，同时也发送了“一部分”数据给服务器，这一部分数据就是所谓的pre_master，不管是客户端还是服务器都根据对端传过来的pre_master和自己计算出来的另一部分数据来生成最终的对称密钥，生成过程中需要hello消息中的随机数，这样生成的密钥才不会每次都一样。由于ssl协议中dh份额来源于证书，而证书又是静态的，因此十分有必要引入一种随机因素来保证通过静态证书导出的密钥份额协商出来的密钥的随机性。同时这也是pre_master的意义，那就是随机，对于rsa密钥交换算法来说，pre-master-key本身就是一个随机数，再加上hello消息中的随机，三个随机数通过一个密钥导出器最终导出一个对称密钥，但是对于dh，包括ecdh算法(不考虑匿名dh和瞬时dh)，就只有hello消息中的两个随机数因子了。
pre master的存在在于ssl协议不信任每个主机都能产生完全随机的随机数，如果随机数不随机，那么pre master secret就有可能被猜出来，那么仅适用pre master secret作为密钥就不合适了，因此必须引入新的随机因素，那么客户端和服务器加上pre master secret三个随机数一同生成的密钥就不容易被猜出了，一个伪随机可能完全不随机，可是是三个伪随机就十分接近随机了，每增加一个自由度，随机性增加的可不是一。

+
+

CA验证

(未完)

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/06/03/nginx-forward-http-x-forwarded-proto-header/index.html b/2018/06/03/nginx-forward-http-x-forwarded-proto-header/index.html new file mode 100644 index 0000000..86fbfea --- /dev/null +++ b/2018/06/03/nginx-forward-http-x-forwarded-proto-header/index.html @@ -0,0 +1,863 @@ + + + + + + + + + nginx-forward-http-x-forwarded-proto-header | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ nginx-forward-http-x-forwarded-proto-header +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 758字 + + + + +   |   + + + 阅读时长≈ + 2分 + + +
+ + + +
+ +
+ +

nginx透传X-Forwarded-Proto

+ +

背景

业务接入https，后端服务需要需要客户端的请求schma是老版本http，还是新版的https请求。这里通常采用的方案是通过X-Forwarded-Proto头来识别：

+
+

X-Forwarded-Proto (XFP) 是一个事实上的标准首部，用来确定客户端与代理服务器或者负载均衡服务器之间的连接所采用的传输协议（HTTP 或 HTTPS）。在服务器的访问日志中记录的是负载均衡服务器与服务器之间的连接所使用的传输协议，而非客户端与负载均衡服务器之间所使用的协议。为了确定客户端与负载均衡服务器之间所使用的协议， X-Forwarded-Proto 就派上了用场。

+
+

通常在ng中通过设置XFP来指定URI的scheme信息，如：

+
proxy_set_header X-Forwarded-Proto $scheme;
+ +

然后后端可以通过读取header X-Forwarded-Proto来获得对应的scheme。

+

但是现网的接入环境会比较复杂，通常存在多层反向代理的情况，这种简单粗暴的方式就不灵验了。
一个比较常见的https请求路径如下：

+

User-Agent —[https]—> haproxy(公司级接入) —[http]—> nginx（业务级接入） —[http]—> apache/php（后端服务接入）

+

最外层的接入收到User-Agent的https请求，但在内部和nginx的交互协议为http，所以nginx取到的scheme值就是http了，而非原始的https。 php（后端）也就无法知道真实的schema了。

+

解决方案

修改配置如下（以ng为例）：

+
map $http_x_forwarded_proto $thescheme {
    default $scheme;
    https https;
}
proxy_set_header X-Forwarded-Proto $thescheme;
+ +

与之前的解决方案不同，不是将XFP设置为固定的scheme值，而是通过计算得出scheme。
map配置的意思是先判断是否已经存在XFP的header信息，如果是https则透传，否则使用连接的scheme。在最外层的反向代理中，没有XFP的header信息，所以会写入request，后续的接入层会逐步透传，一直到后端服务。

+

map directives

用法

+

Syntax: map string $variable { … }
Default: —
Context: http

+
+

功能：创建一个新的结果变量variable，其值依赖于源变量string。map block内指定了源变量值和结果值的映射关系。

+

性能

参考连接:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
mapping条目直接访问(rps)map第一条url(rps)map最后一条url(rps)不存在的url(rps)
1002829.441819.631765.259740.53
1000-1816.001509.524094.68
10000-1813.22514.24658.32
100000-1836.0262.4065.80
+
+

跟预想的一样，mapping的条目确实会对请求效率产生影响。而且几万条的映射在较高并发的情况下已经到了勉强能用的临界了。
在并发不是很高的时候mapping的条目可以更多。100000个条目大概只会影响整个请求15ms左右，可以忽略不计。如果说150ms的延迟是可以接受的，那么在一个并发不是很高的情况下，mapping最多可以有100w条，还是很多的

+
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/06/24/Unique-ID-generator/index.html b/2018/06/24/Unique-ID-generator/index.html new file mode 100644 index 0000000..7a5a348 --- /dev/null +++ b/2018/06/24/Unique-ID-generator/index.html @@ -0,0 +1,881 @@ + + + + + + + + + Unique ID generator | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Unique ID generator +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.4k字 + + + + +   |   + + + 阅读时长≈ + 4分 + + +
+ + + +
+ +
+ +
+

Written with StackEdit.

+
+

本文介绍分布式ID生成的几种思路

+

背景

底层数据存储时每条记录通常需要一个唯一ID来标识记录本身，然后根据该ID建立对应的各类索引列表。以微博为例，用户A发表的每条微博内容在底层存储时会为其分配一条索引ID，然后该ID也会写入follow的Timeline中（假设为写扩散模式）。各follower在阅读时先读取道好友发表的索引ID列表，然后根据其ID拉取微博内容。

+

分布式ID系统的目标

+
    +
  • 全局唯一
    • +
  • 趋势有序
    • +
+

“有序”并非时必须的，实际使用中通常业务都会依赖ID的有序特性，来实现排序等特性。所以使用UUID之类简单粗暴的方案就不在我们讨论范围之内了。

+ + +

思路

方案一：使用db的自增索引

这种在简单的架构设计中比较常见，如商品ID，入库时生成的uniqueid即为索引ID，生成方法以mysql为例：

+
mysql>CREATETABLE `get_max_id` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '业务主键',
 `content` char(25) DEFAULT NULL COMMENT '业务内容',
  PRIMARY KEY (`id`) 
 )ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
+ +

如何获取maxid之类的就不再详述。
除了mysql之外，也有一些类似的替代品，比如redis也提供了INCR指令。对使用方来说大同小异，做好组件的容灾即可。

+

优点

    +
  • 架构简单，小型业务足够使用
    • +
  • 维护简单，只需要保证db的容灾
    • +
+

缺点

    +
  • 性能
    • +
  • db单点
    • +
+

方案二：db扩展

方案1的方案还离分布式差得很远，在其基础上可以进一步扩展，比较常见的扩展方案有几种

+

多机器+不同的自增范围

使用不同的初始值和步长，可以解决生成id的冲突问题。当某一台db挂掉时，只会影响对应的seq序列。

+

批量获取

性能的瓶颈主要时因为过多的依赖db，为减少db的访问，可以一次从db获取多个ID，缓存到ID server的内存即可。实现方式上可以调整步长即可。

+

方案三：snowflake

snowflake是twitter用来生成唯一ID的服务，其产生的需求背景：

+
    +
  • 发表量大：每条上万条发表消息，高峰期峰值更加明显
    • +
  • ID可排序：A和B同一时间发表的消息应该比较接近。这样客户端可以排序展示。
    • +
  • 长度要求64bits以内
    • +
+

详见twitter的blog。

+
原理

enter image description here

+
    +
  • 最高位是符号位，始终为0。
    • +
  • 41位的时间序列（精确到毫秒，41位的长度可以使用69年）
    • +
  • 10位的机器标识（10位的长度最多支持部署1024个节点）
    • +
  • 12位的计数顺序号（12位的计数顺序号支持每个节点每毫秒产生4096个ID序号）
    • +
+
优点
    +
  • 高性能，低延迟；
    • +
  • 可以根据自由的业务需求扩展变更
    • +
+
缺点
    +
  • 需要独立的开发和部署。
    • +
+

扩展

相对snowflake服务本身，其思想更值得借鉴。我们在使用时可以在其设计纸上进一步改造成符合业务的使用场景，比如在其中加入业务id、机房id等信息，这样也便于问题定位。

+

snowflake算法中的机器标识其实已经包含了路由信息。数据proxy层根据机器标志可以直接定位对应的worker ID，并将ID转发给对应的数据层处理读取请求。
底层在根据ID来读取数据时，根据底层存储模型的不同，这里可以有不同的实现。已bitcask模型为例：
bitcask
这里的ID（key）对存储层本身无任何关联，hash表中的value为数据存放的地址。对于存储层来说，只要上层保证ID唯一即可。

+

之前还见过另外一种存储模型，ID的产生跟底层数据存储强耦合，ID由数据存储层来生成，里面包含了机器、磁盘、存储偏移等信息。这种存储模型有几个好处：

+
    +
  • ID自带路由信息，不用再额外维护ID跟数据存储的映射。
    • +
  • 不用再维护单独的ID service
    • +
  • 逻辑层调用简单，一次调用即可完成写入
    • +
+

带来的缺点也很明显：

+
    +
  • 不支持update操作：数据ID不可变，其存储地址也不可变，这样导致存储的内容也可能变长等操作。如果需要update操作，只能以其他方式来绕过。
    • +
  • 运维成本：因为ID跟存储地址有绑定关系，当机器故障需要替换时，需要确保备份机器的文件存储内容一模一样。否则通过偏移等定位数据时就会产生异常。
    • +
+

方案四：微信的序列号生成器

与上面各使用场景不同的是，微信的seq server主要用于client和server间数据同步，所以在实现目标上也有一定的差别：

+
    +
  • 只要求单用户空间内全局唯一，即用户A和用户B可能有相同的seqID
    • +
  • 只要求单用户空间内趋势有序。
    • +
+

enter image description here
具体的实现方案参考这里。

+

其中对于“一组用户共享一个max_seq”的设计思路还是不错的。

+

参考资料：

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/09/09/upload-file-via-http/index.html b/2018/09/09/upload-file-via-http/index.html new file mode 100644 index 0000000..2ef9b7d --- /dev/null +++ b/2018/09/09/upload-file-via-http/index.html @@ -0,0 +1,828 @@ + + + + + + + + + upload file via http | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ upload file via http +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 540字 + + + + +   |   + + + 阅读时长≈ + 2分 + + +
+ + + +
+ +
+ +

背景

两台外网服务器之间需要传输一个较大的文件，目标服务器有webserver。

+ + +

解决方案

初步想了下，有几种思路：

+
    +
  • ftp：目标服务器搭建ftp。通过ftp client上传。部署成本太高（主要是懒），放弃
    • +
  • nginx-upload-module: 较为理想的方案，使用nginx插件支持，成本小。但在编译module时卡住了，忘了之前的编译选项，加入upload module之后编译又报错，不想太折腾，放弃了。
    • +
  • 在webserver上自己实现file upload server：此方案看似成本高，翻了一下，其实还挺简单。那就动手吧
    • +
+

流程

http upload server搭建

方法有很多，搭建webserver第一个想到的就是node了。于是找到了express-fileupload。npm库上代码都是现成的。

+

const express = require('express');
const fileUpload = require('express-fileupload');
const app = express();
 
// default options
app.use(fileUpload());
 
app.post('/upload', function(req, res) {
  if (!req.files)
    return res.status(400).send('No files were uploaded.');
 
  // The name of the input field (i.e. "sampleFile") is used to retrieve the uploaded file
  let sampleFile = req.files.sampleFile;
 
  // Use the mv() method to place the file somewhere on your server
  sampleFile.mv('/somewhere/on/your/server/filename.jpg', function(err) {
    if (err)
      return res.status(500).send(err);
 
    res.send('File uploaded!');
  });
});

// app.listen(8080);
+ +

nginx路由

反向代理增加路由配置：

+
location /upload {
    proxy_pass http://127.0.0.1:5000;
    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 $scheme;
}

+ +

并设置最大包大小，否则文件过大会被ng拒绝413 (Request Entity Too Large)。

+
client_max_body_size       200m;
+ + +

上传

使用curl模拟表单上传:

+
curl -F 'sampleFile=@path/to/local/file' UPLOAD_ADDRESS
+

curl支持一次上传多个，不过upload server实现得修改支持命名。

+

其他

线上上传时发现上传还是失败了，因为文件太大，导致node进程OOM kill了。。
不想在折腾了，直接用split把文件切成几个小文件后上传，然后再到目标机器使用cat合并。

+
# binary拆分成多个20m的文件，输出文件名类似outputSerial_aa, outputSerial_ab, outputSerial_ac....
split -b 20m uploadfile outputSerial_
+ +

在目标机器执行合并操作：

+
cat outputSerial_* > uploadfile
+ +

总结起来，对比重编ng貌似也不简单:P)。。

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2018/10/29/Puppeteer-coverage/index.html b/2018/10/29/Puppeteer-coverage/index.html new file mode 100644 index 0000000..ddce8da --- /dev/null +++ b/2018/10/29/Puppeteer-coverage/index.html @@ -0,0 +1,823 @@ + + + + + + + + + Puppeteer coverage | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Puppeteer coverage +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 419字 + + + + +   |   + + + 阅读时长≈ + 2分 + + +
+ + + +
+ +
+ +

Using Puppeteer to Extract Code Coverage Data from Chrome Dev Tools

阅读puppeteer example的代码，看到了里面有使用Coverage的使用，由于API中没有其目的的详细介绍，花了点时间研究了一下。

+ + +

作用

Puppeteer的目的其实是对Chrome DevTools API的封装，而Coverage其实是对Chrome DevTools中的检查CSS 和 JS 代码覆盖率的功能的封装。

+

代码覆盖率面板

+

API

class: Coverage
    coverage.startCSSCoverage(options)
    coverage.startJSCoverage(options)
    coverage.stopCSSCoverage()
    coverage.stopJSCoverage()
+ +

调用顺序：

+
    +
  • 创建page，并调用startCSSCoverage/startJSCoverage开启分析js、css。
    • +
  • page.goto(URL);
    • +
  • 调用stopCSSCoverage/stopJSCoverage取回分析结果
    • +
+

分析结果为数组，没项包含了按url统计的js/css分析结果。

+
url <string> StyleSheet URL
text <string> StyleSheet content
ranges <Array<Object>> StyleSheet ranges that were used. Ranges are sorted and non-overlapping.
    start <number> A start offset in text, inclusive
    end <number> An end offset in text, exclusive
+ + +

DEMO

下面为一个完整的列子，用来分析某个网站的覆盖率数据。

+
(async () => {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();
    await page.emulate(iPhone);

    //Begin collecting CSS coverage data
    await Promise.all([
        page.coverage.startCSSCoverage()
    ]);

    //Visit desired page
    await page.goto('http://www.baidu.com/');

    //Stop collection and retrieve the coverage iterator
    const [cssCoverage] = await Promise.all([
        page.coverage.stopCSSCoverage(),
    ]);

    //Investigate CSS Coverage and Extract Used CSS
    const css_coverage = [...cssCoverage];
    let css_used_bytes = 0;
    let css_total_bytes = 0;
    let covered_css = "";

    for (const entry of css_coverage) {
        css_total_bytes += entry.text.length;
        console.log(`Total Bytes for ${entry.url}: ${entry.text.length}`);
        for (const range of entry.ranges){
            css_used_bytes += range.end - range.start - 1;
            covered_css += entry.text.slice(range.start, range.end) + "\n";
        }
    }

    console.log(`Total Bytes of CSS: ${css_total_bytes}`);
    console.log(`Used Bytes of CSS: ${css_used_bytes}`);
    fs.writeFile("./exported_css.css", covered_css, function(err) {
        if(err) {
            return console.log(err);
        }
        console.log("The file was saved!");
    });

    await browser.close();
})();
+ + +

参考：Using Puppeteer to Extract Code Coverage Data from Chrome Dev Tools

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2019/03/16/golang-pprof/index.html b/2019/03/16/golang-pprof/index.html new file mode 100644 index 0000000..4d00f95 --- /dev/null +++ b/2019/03/16/golang-pprof/index.html @@ -0,0 +1,827 @@ + + + + + + + + + golang pprof | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ golang pprof +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 908字 + + + + +   |   + + + 阅读时长≈ + 5分 + + +
+ + + +
+ +
+ +

golang pprof

以常见的one-gouroutine-per-connection模式来介绍pprof的用法

+ + +
# server.go
func main() {
    ln, err := net.Listen("tcp", ":8972")
    if err != nil {
        panic(err)
    }
    go func() {
        if err := http.ListenAndServe(":6060", nil); err != nil {
            log.Fatalf("pprof failed: %v", err)
        }
    }()
    var connections []net.Conn
    defer func() {
        for _, conn := range connections {
            conn.Close()
        }
    }()
    for {
        conn, e := ln.Accept()
        if e != nil {
            if ne, ok := e.(net.Error); ok && ne.Temporary() {
                log.Printf("accept temp err: %v", ne)
                continue
            }
            log.Printf("accept err: %v", e)
            return
        }
        go handleConn(conn)
        connections = append(connections, conn)
        if len(connections)%100 == 0 {
            log.Printf("total number of connections: %v", len(connections))
        }
    }
}
func handleConn(conn net.Conn) {
    io.Copy(ioutil.Discard, conn)
}
+ +
# client.go

var (
	ip          = flag.String("ip", "127.0.0.1", "server IP")
	connections = flag.Int("conn", 1, "number of tcp connections")
)

func main() {
    flag.Parse()
    rand.Seed(time.Now().UnixNano())

    addr := *ip + ":8972"
    var conns []net.Conn
    for i := 0; i < *connections; i++ {
        c, err := net.DialTimeout("tcp", addr, 10*time.Second)
        if err != nil {
            fmt.Println("failed to connect", i, err)
            i--
            continue
        }
        conns = append(conns, c)
        time.Sleep(time.Millisecond)
    }
    defer func() {
        for _, c := range conns {
            c.Close()
        }
    }()
    log.Printf("完成初始化 %d 连接", len(conns))
    wg := sync.WaitGroup{}
    for i := 0; i < len(conns); i++ {
        wg.Add(1)
        go func(conn net.Conn) {
            defer wg.Done()
            for {
                time.Sleep(time.Duration(rand.Int31n(1000)) * time.Millisecond)
                conn.Write([]byte("hello world\r\n"))
            }
        }(conns[i])
    }
    wg.Wait()
}
+ +

测试数据

CPU Profiling

go tool pprof http://localhost:6060/debug/pprof/profile?seconds=60
+
    +
  • flat：给定函数上运行耗时
    • +
  • flat%：同上的 CPU 运行耗时总比例
    • +
  • sum%：给定函数累积使用 CPU 总比例
    • +
  • cum：当前函数加上它之上的调用运行总耗时
    • +
  • cum%：同上的 CPU 运行耗时总比例
    • +
+

10000个connection时测试数据

+
(pprof) top
Showing nodes accounting for 2350ms, 70.57% of 3330ms total
Dropped 34 nodes (cum <= 16.65ms)
Showing top 10 nodes out of 79
      flat  flat%   sum%        cum   cum%
     560ms 16.82% 16.82%      560ms 16.82%  runtime.epollwait /usr/local/go/src/runtime/sys_linux_amd64.s
     560ms 16.82% 33.63%      790ms 23.72%  syscall.Syscall /usr/local/go/src/syscall/asm_linux_amd64.s
     310ms  9.31% 42.94%      310ms  9.31%  runtime.futex /usr/local/go/src/runtime/sys_linux_amd64.s
     210ms  6.31% 49.25%      210ms  6.31%  runtime.usleep /usr/local/go/src/runtime/sys_linux_amd64.s
     170ms  5.11% 54.35%     1490ms 44.74%  io/ioutil.devNull.ReadFrom /usr/local/go/src/io/ioutil/ioutil.go
     120ms  3.60% 57.96%     1210ms 36.34%  internal/poll.(*FD).Read /usr/local/go/src/internal/poll/fd_unix.go
     110ms  3.30% 61.26%      110ms  3.30%  runtime.deferreturn /usr/local/go/src/runtime/panic.go
     110ms  3.30% 64.56%      220ms  6.61%  runtime.netpollready /usr/local/go/src/runtime/netpoll.go
     110ms  3.30% 67.87%      110ms  3.30%  runtime.netpollunblock /usr/local/go/src/runtime/netpoll.go
      90ms  2.70% 70.57%      870ms 26.13%  runtime.netpoll /usr/local/go/src/runtime/netpoll_epoll.go
+ +

Heap profiling

go tool pprof http://localhost:6060/debug/pprof/heap
+
    +
  • -inuse_space：分析应用程序的常驻内存占用情况(default)
    • +
  • -alloc_objects：分析应用程序的内存临时分配情况
    • +
+

10000个connection的测试数据

+
(pprof) top
Showing nodes accounting for 19080.60kB, 100% of 19080.60kB total
Showing top 10 nodes out of 22
      flat  flat%   sum%        cum   cum%
17544.35kB 91.95% 91.95% 17544.35kB 91.95%  io/ioutil.glob..func1 /usr/local/go/src/io/ioutil/ioutil.go
 1024.06kB  5.37% 97.32%  1024.06kB  5.37%  syscall.anyToSockaddr /usr/local/go/src/syscall/syscall_linux.go
  512.19kB  2.68%   100%   512.19kB  2.68%  runtime.malg /usr/local/go/src/runtime/proc.go
         0     0%   100%   512.03kB  2.68%  internal/poll.(*FD).Accept /usr/local/go/src/internal/poll/fd_unix.go
         0     0%   100%   512.03kB  2.68%  internal/poll.accept /usr/local/go/src/internal/poll/sock_cloexec.go
         0     0%   100% 17544.35kB 91.95%  io.Copy /usr/local/go/src/io/io.go
         0     0%   100% 17544.35kB 91.95%  io.copyBuffer /usr/local/go/src/io/io.go
         0     0%   100% 17544.35kB 91.95%  io/ioutil.(*devNull).ReadFrom <autogenerated>
         0     0%   100% 17544.35kB 91.95%  io/ioutil.devNull.ReadFrom /usr/local/go/src/io/ioutil/ioutil.go
         0     0%   100% 17544.35kB 91.95%  main.handleConn /home/gelco/code/go/src/gelco/1m-go-tcp-connection/goroutine-per-conn/server.go
+ + +

Others

#Block profiling
go tool pprof http://localhost:6060/debug/pprof/block

#Mutex profiling
go tool pprof http://localhost:6060/debug/pprof/mutex
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2019/08/21/groupcache/index.html b/2019/08/21/groupcache/index.html new file mode 100644 index 0000000..2119226 --- /dev/null +++ b/2019/08/21/groupcache/index.html @@ -0,0 +1,823 @@ + + + + + + + + + groupcache | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ groupcache +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 668字 + + + + +   |   + + + 阅读时长≈ + 3分 + + +
+ + + +
+ +
+ +

groupcache简介

周末阅读groupcache的源码，比较简单，也总结一下。

+ + +

定位

groupcache虽然跟memcache是出自同一作者之手，但是定位相差挺大。memcached（简称mc）是一个独立的nosql存储服务，后台服务必须按照mc协议与之通信来实现数据缓存功能。而groupcache只是一个简单的缓存lib，定位类似于leveldb，后台服务必须继承到代码中来实现缓存的能力。

+

代码及功能简介

    +

  • LRU
    支持LRU的cache实现，与传统的LRU实现没有大的差别。核心数据结构：

    +
    type  Cache  struct  {
      // MaxEntries is the maximum number of cache entries before
      // an item is evicted. Zero means no limit.
      MaxEntries int

      // OnEvicted optionally specifies a callback function to be
      // executed when an entry is purged from the cache.
      OnEvicted func(key Key, value interface{})

      ll *list.List
      cache map[interface{}]*list.Element
    }

    // A Key may be any value that is comparable. See http://golang.org/ref/spec#Comparison_operators
    type  Key  interface{}

    type  entry  struct  {
      key Key
      value interface{}
    }
    +

    为保证Add/Get/Remove性能，底层使用map结构来存储。可以通过key快速定位。
    注意map中的value并不是实际数据，而是list.Element指针，list.Element封装了key、value。引入list的目的是为了实现Least recently used，跟memcached等实现在struct中加入双链表的结构，目的是一样的。

    +
    • +

  • Consistent hash
    一致性hash实现，用作HTTPPool中的peers管理。注意有使用副本replicas参数控制虚拟节点数大小。

    +
    • +

  • Single flight
    用于控制key的并发访问个数。使用memcache等缓存的毛病就是当cache中的key过期后，逻辑层短时间内可能有大量的cache miss，并发访问导致底层出现毛刺、雪崩。Single Fligth的目的就是为了避免这种场景，同一时间只允许一个到peers的访问，其他请求被block。

    +
    • +
+
// Group represents a class of work and forms a namespace in which
// units of work can be executed with duplicate suppression.
type Group struct {
    mu sync.Mutex       // protects m
    m  map[string]*call // lazily initialized
}

// Do executes and returns the results of the given function, making
// sure that only one execution is in-flight for a given key at a
// time. If a duplicate comes in, the duplicate caller waits for the
// original to complete and receives the same results.
func (g *Group) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
    g.mu.Lock()
    if g.m == nil {
        g.m = make(map[string]*call)
    }
    // 对应key已有请求flight中，等待返回
    if c, ok := g.m[key]; ok {
        g.mu.Unlock()
        c.wg.Wait()
        return c.val, c.err
    }
    c := new(call)
    c.wg.Add(1)
    g.m[key] = c
    g.mu.Unlock()

    c.val, c.err = fn()
    c.wg.Done()

    g.mu.Lock()
    delete(g.m, key)
    g.mu.Unlock()

    return c.val, c.err
}
+ +
    +
  • Peer
    • +
+

管理peers节点，groupcache从远程load数据时，需要通过PickPeer方法获取一个peer对象。

+
    +
  • Http poll
    • +
  • Hot Cache
    • +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2019/09/13/docker-nginx-install/index.html b/2019/09/13/docker-nginx-install/index.html new file mode 100644 index 0000000..d2f4a03 --- /dev/null +++ b/2019/09/13/docker-nginx-install/index.html @@ -0,0 +1,825 @@ + + + + + + + + + docker nginx install | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ docker nginx install +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 412字 + + + + +   |   + + + 阅读时长≈ + 1分 + + +
+ + + +
+ +
+ +

docker新手，docker nginx的安装折腾了半天，记录一下。

+ + +

流程

    +

  1. 下载镜像
    docker pull nginx

    +
    2. +

  2. 静态文件目录、log目录
    直接使用本地目录即可，因为不需要从container中copy源文件到本地，所以宿主主机本地mkdir对应的目录即可。
    mkdir ~/development/docker/docker-nginx/log
    mdkir ~/development/docker/docker-nginx/html

    +
    3. +

  3. 配置文件
    需要从container中的文件中copy一份到本地，作为初始配置，所以先启动一个默认container，copy文件后将其删除即可。
    mkdir ~/development/docker/docker-nginx/conf
    docker cp 525adda2ecb7:/etc/nginx/* ~/development/docker/docker-nginx/conf/
    配置文件这里花了不少时间，因为link的配置之前没有正确配置。可以从错误日志中查看到对应的错误信息

    +
    open() "/etc/nginx/nginx.conf" failed (2: No such file or directory)
    +

    之前copy时将“/etc/nginx”这个目录copy到本地conf目录了，而非”/etc/nginx”下的所有文件。。

    +
    4. +

  4. 创建容器&启动

    +
    docker container create -it --name=docker-nginx -v ~/development/docker/docker-nginx/html/:/usr/share/nginx/html:ro -v ~/development/docker/docker-nginx/conf:/etc/nginx:ro -v ~/development/docker/docker-nginx/logs:/var/log/nginx  -p 80:80 nginx
    +

    暂时没有启动多个nginx容器的需求，这里使用了固定端口的模式（-p 80:80）。
    发现没有指定固定端口，也没有使用随机端口（-P）时，访问一次nginx之后就不可访问了，但是container状态正常。不知道这个是什么原因？

    +
    5. +
+

reference

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2019/11/17/docker-redis-install/index.html b/2019/11/17/docker-redis-install/index.html new file mode 100644 index 0000000..61da4ad --- /dev/null +++ b/2019/11/17/docker-redis-install/index.html @@ -0,0 +1,834 @@ + + + + + + + + + docker redis install | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ docker redis install +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 482字 + + + + +   |   + + + 阅读时长≈ + 2分 + + +
+ + + +
+ +
+ +

记录docker-redis安装过程

+ + +

流程

    +

  • 下载镜像
    docker pull redis

    +
    • +

  • 静态文件目录、log目录
    mkdir ./redis/conf
    mdkir ./redis/data

    +
    • +

  • 配置文件
    从官方下载一份最新的redis.conf
    cd ./redis/conf
    wget http://download.redis.io/redis-stable/redis.conf

    +
    • +

  • 创建容器&启动

    +
    • +
+
docker run \
-p 6379:6379 \
-v $PWD/data:/data \
-v $PWD/conf/redis.conf:/etc/redis/redis.conf \
--name myredis \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes
+ +

appendonly为落地方案，可选。
启动之后redis应该为正常状态了，可以使用docker上的redis-cli查看。

+
docker exec -it myredis redis-cli
+ +
    +
  • 宿主主机访问
    • +
+

查看端口映射状态

+
# docker port myredis
6379/tcp -> 0.0.0.0:6379
+ +

表示本机端口状态映射正常，使用telnet可以连接本地6379，但是连接成功之后会立即被redis server断开.
需要关闭bind、protected-mode。

+
# ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
# internet, binding to all the interfaces is dangerous and will expose the
# instance to everybody on the internet. So by default we uncomment the
# following bind directive, that will force Redis to listen only into
# the IPv4 lookback interface address (this means Redis will be able to
# accept connections only from clients running into the same computer it
# is running).
#
# IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
# JUST COMMENT THE FOLLOWING LINE.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# bind 127.0.0.1


# Protected mode is a layer of security protection, in order to avoid that
# Redis instances left open on the internet are accessed and exploited.
#
# When protected mode is on and if:
#
# 1) The server is not binding explicitly to a set of addresses using the
#    "bind" directive.
# 2) No password is configured.
#
# The server only accepts connections from clients connecting from the
# IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain
# sockets.
#
# By default protected mode is enabled. You should disable it only if
# you are sure you want clients from other hosts to connect to Redis
# even if no authentication is configured, nor a specific set of interfaces
# are explicitly listed using the "bind" directive.
# protected-mode yes
+ +

protected-mode应该是redis增加的一个双重保护，避免更改ip后直接面向外网。只改bind ip外部也是无法访问的.
更改完毕后重启container即可。

+
docker container restart myredis
+ +

reference

+ + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2019/12/15/golang-viper-tips/index.html b/2019/12/15/golang-viper-tips/index.html new file mode 100644 index 0000000..32337a5 --- /dev/null +++ b/2019/12/15/golang-viper-tips/index.html @@ -0,0 +1,857 @@ + + + + + + + + + golang viper tips | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ golang viper tips +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 834字 + + + + +   |   + + + 阅读时长≈ + 3分 + + +
+ + + +
+ +
+ +

viper tips

简介

vipper是golang下一个配置文件的解决方案，功能强大，也被很多开源项目所引用。主要特性包括：

+
    +
  • setting defaults
    • +
  • reading from JSON, TOML, YAML, HCL, envfile and Java properties config files
    • +
  • live watching and re-reading of config files (optional)
    • +
  • reading from environment variables
    • +
  • reading from remote config systems (etcd or Consul), and watching changes
    • +
  • reading from command line flags
    • +
  • reading from buffer
    • +
  • setting explicit values
    • +
+

具体使用方法就不copy了，主要记录下使用过程中遇到的一些小问题，避免后续再次踩坑。

+ + + +

如何使用

配置文件的解析、使用方法有多种，简单的方法在业务代码中直接调用viper相关的API：

+
    +
  • Get(key string) : interface{}
    • +
  • GetBool(key string) : bool
    • +
  • GetFloat64(key string) : float64
    • +
  • GetInt(key string) : int
    • +
  • GetIntSlice(key string) : []int
    • +
  • GetString(key string) : string
    • +
  • GetStringMap(key string) : map[string]interface{}
    • +
  • GetStringMapString(key string) : map[string]string
    • +
  • GetStringSlice(key string) : []string
    • +
  • GetTime(key string) : time.Time
    • +
  • GetDuration(key string) : time.Duration
    • +
+

这种方案简单，各个go文件中引入viper object，需要时读取。个人不太喜欢这种方式，一是太多地方引入了viper，业务跟配置解决方案耦合太高。二是个人喜欢统一对配置做些前置检查，避免无效配置。将配置相关解析的代码放在一起而非散落各地的维护性也更高。所以一般使用struct来承担解析后的结果。典型代码如下：

+
type Pos struct {
    Country string
    Cent    int
}

type CompanyInfomation struct {
    Name                 string
    MarketCapitalization int64
    EmployeeNum          int64
    Department           map[int]Pos
    IsOpen               bool   `mapstructure:"is_open"` 
}

type YamlSetting struct {
    TimeStamp         string
    Address           string
    Postcode          int64
    CompanyInfomation CompanyInfomation
}
v := viper.New()
v.SetConfigName("config")
v.AddConfigPath("./")
v.SetConfigType("yaml")

if err := v.ReadInConfig(); err != nil {
    return err
}
var yamlObj YamlSetting
if err := v.Unmarshal(&yamlObj); err != nil {
    return err
}
+ +

对应配置文件内容如下:

+
TimeStamp: "2018-10-18 10:09:23"
Address: "Shenzhen"
Postcode: 518000
CompanyInfomation:
  Name: "Sunny"
  MarketCapitalization: 50000000
  EmployeeNum: 200
  Department:
    1:
      Country: "Finance"
      Cent: 90
    2:
      Country: "Design"
      Cent: 80
  is_open: true
+ +

注意struct中的mapstructure标签，作用类似于json标签，用作控制marshal/unmarshal的过程。
另外在对一些复杂数据结构的支持上，如上面的map[int] struct也做了很好的支持，避免二次解析。

+

其他

如果仅从上面的内容看，viper跟json直接解析一个config.json库没啥差别。但是viper提供了更多的配置的能力。

+

Viper does the following for you:

+
    +
  1. Find, load, and unmarshal a configuration file in JSON, TOML, YAML, HCL, INI, envfile or Java properties formats.
    2. +
  2. Provide a mechanism to set default values for your different configuration options.
    3. +
  3. Provide a mechanism to set override values for options specified through command line flags.
    4. +
  4. Provide an alias system to easily rename parameters without breaking existing code.
    5. +
  5. Make it easy to tell the difference between when a user has provided a command line or config file which is the same as the default.
    6. +
+

Viper uses the following precedence order. Each item takes precedence over the item below it:

+
    +
  • explicit call to Set
    • +
  • flag
    • +
  • env
    • +
  • config
    • +
  • key/value store
    • +
  • default
    • +
+

个人在项目中遇到个小问题，项目部署使用内部的容器平台，而这种容器平台使用环境变量来映射相关端口等信息。之前在配置文件自己指定端口的方法行不通了。如果之前使用了viper来获取，这个就不再是个问题了，可以通过BindEnv方法来兼容。

+
v.BindEnv("port", "main_port") // for spetial container
if c.Port == 0 {
    c.Port = v.GetInt("port")
}
+ +

viper的更多高级特性有待摸索，后续项目需要实际使用时再研究。

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/04/06/intern-recruitment/index.html b/2020/04/06/intern-recruitment/index.html new file mode 100644 index 0000000..229c4b1 --- /dev/null +++ b/2020/04/06/intern-recruitment/index.html @@ -0,0 +1,846 @@ + + + + + + + + + intern-recruitment | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ intern-recruitment +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.2k字 + + + + +   |   + + + 阅读时长≈ + 4分 + + +
+ + + +
+ +
+ +
+

Written with StackEdit.

+
+

实习生招聘tips

最近几周花了大量的精力在实习生的招聘上，记录过程中的一些心得，用作后续的参考。

+ + +

整体感悟

我厂实习生招聘的流程就是从简历库中筛选简历，然后经过初试、复试及HR面试的过程。初试根据各业务BG的需要，可能分多次。
简历的筛选是一个繁重的工作，需要从数万简历库中筛选出优秀的应聘者，不仅要靠运气，也要靠大量的精力投入，因为竞争激励。个人经验一般在错峰时间（晚上或者清早）能找到优秀的简历的概率要大一些。

+

优秀简历的一些特点：

+
    +
  • 好的学校
    • +
  • 个人简历的细节
    在个人简历中至少要有学校专业课、专业技能、（个人）项目的一些详细介绍。如果能有一些实践的经验会更好。
    • +
  • 个人社会实践、初步职业规划等等
    • +
+

一些硬性指标

行业的关系，一般对实习生有些基础的硬性要求。个人认为专业的基础知识是必须的，当然如果面试人有其他比较优秀的闪光点的话，这方面也可以酌情考虑比重。否则很难保证过程的客观和公正。基础考察点各有差异，个人比较偏重以下点：

+

后端考察点：

+
    +
  • 语言
    • +
  • 计算机网络
    • +
  • 操作系统、linux基础操作
    • +
  • 数据结构与算法
    • +
  • 数据库概念
    • +
+

前端考察点：

+
    +
  • 网络协议（https/h2）
    • +
  • 数据结构与算法
    • +
  • 前端基础（html、css、js）
    • +
  • web安全概念
    • +
  • 数据库基础
    • +
+

关于深度
专业知识的掌握程度一般决定了候选人的第一印象，根据实际情况个人一般允许在某些点上存在不足，比如对web前端的数据结构和算法的要求就没有那么高。但不允许空白，因为在专业课上应该就有涉及。

+

非专业出身
坦白说这点比较难，尤其在一些基础知识的掌握上很难达到要求。也遇到过一个算法掌握非常不错的小伙，应该平时有一些刷题的经验，虽然在计算机基础上比较弱，但在数据结构与算法上的这个闪光点让我纠结了一段时间。但是最后在跟其他候选人比对后还是放弃了。

+

关于Web前端
web前端的简历稍微难找一些，但是对非专业或者专业课没那么优秀的同学来说也是个机会，但是前端的基础知识一般是不包括在专业课外的，需要一些项目经验或者主观学习的能动性。需要对前端有一定的兴趣。

+

加分项

技术深度

对同一个知识点的理解，也分了解、熟悉和掌握等几个等级。个人觉得面试官最难的地方，就在于挖掘应聘者真实的技能掌握程度。尤其对于应聘者是实习生来说，不能使用项目应用的标准来衡量。遇到过一些事前临时准备的应聘者骗过了初试官的情况，基本都是照着网上查找的答案来应答。
个人习惯使用几种套路来应对：

+
    +
  • 自己选择面试题，或者换个相关的问题。
    • +
  • 深挖：同一个课题可以多问几个为什么？
    • +
+

应变能力与态度

一般会给一个开放式的问题来挑战应聘者，来了解应聘者的思维能力。一般会有以下几种响应：

+
    +
  • 直接放弃
    • +
  • 能给出方案：这种我一般会提出更高要求的问题，而又再次回到初始状态。
    • +
  • 会跟面试官探讨各种可行性。虽然答案离可操作性相距胜远，但是可以看出候选人的知识面与面对问题的态度。
    • +
+

沟通能力

这个就不用解释了，水平再行没法解释清楚也会是个问题。

+

综合能力

这个也是前面说的简历需要尽可能详细的地方，大学过程不仅仅是专业技能的学习的过程，各种经历也会为简历加分。要让面试官能找到能够发挥的地方，这个也是对学生更加了解的一个过程。

+

结束

实习生招聘是个比较消耗经历的过程，不管是对面试官还是应聘者，都需要投入大量的精力。虽然方法各异，但是需要对对方要有最基本的尊重，比如守时、变更提前知会等。最后祝福大家找到合适的人和机会吧。

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/06/08/gomicro-config/index.html b/2020/06/08/gomicro-config/index.html new file mode 100644 index 0000000..5937025 --- /dev/null +++ b/2020/06/08/gomicro-config/index.html @@ -0,0 +1,851 @@ + + + + + + + + + gomicro-config | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ gomicro-config +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.5k字 + + + + +   |   + + + 阅读时长≈ + 6分 + + +
+ + + +
+ +
+ +

go-micro配置介绍

go-micro/config基础特性及用法，参考官方文档。

+ + + +

数据结构&流程图

+

核心数据结构

感觉go-micro的设计理念应该是一切皆是Interface，所以除了Pluggable Sources等特性外，内部的一些数据结构上也预留了插件化的可能。几个数据结构在官网上都介绍比较清楚了，主要关注下几个核心数据结构的方法。

+

Config

暴露给用户的对象，用于加载、读取和同步数据源。

+
// 动态配置的抽象接口。可以作为一个单独组建给业务使用，但框架自身依赖**DefaultConfig**实现
// 将多个source聚合成一个对外的统一数据源，支持加载、同步、观测一个或多个source。
type Config interface {
    // provide the reader.Values interface
    reader.Values
    // Init the config
    Init(opts ...Option) error
    // Options in the config
    Options() Options
    // Stop the config loader/watcher
    Close() error
    // Load config sources
    Load(source ...source.Source) error
    // Force a source changeset sync
    Sync() error
    // Watch a value for changes
    Watch(path ...string) (Watcher, error)
}
+ +
    +
  • 通过Load加载数据源(source)到config内部
    • +
  • 通过Watch返回的wather观察数据更新
    • +
  • Sync写回给数据源
    • +
+

虽然gomicro中一切皆Interface，但内部实现依赖DefaultConfig。Config的实现依赖两个核心数据结构：

+
func (c *config) Init(opts ...Option) error {
    c.opts = Options{
        Loader: memory.NewLoader(), // Loader
        Reader: json.NewReader(),   // Reader
    }
    c.exit = make(chan bool)
    for _, o := range opts {
        o(&c.opts)
    }

    // ...
}
+ +

Loader负责加载Source、管理watcher链表、管理sets数据、执行Merge操作等，为Config屏蔽了不少下层逻辑，使对外的接口尽可能干净。
Reader就比较好理解了，参见官方文档。

+

注意Config中存在一个唯一的goroutine，用来聚合各个Source的变更。每个Source在Loader中也维护了一个goroutine，详见后面Loader部分。

+
func (c *config) run() {
    watch := func(w loader.Watcher) error {
        for {
            // get changeset
            snap, err := w.Next()
            if err != nil {
                return err
            }

            c.Lock()

            // save
            c.snap = snap

            // set values
            c.vals, _ = c.opts.Reader.Values(snap.ChangeSet)

            c.Unlock()
        }
    }
+ + +

Source

配置内容源，支持以下格式：

+
    +
  • configmap - k8s configmap
    • +
  • consul - consul
    • +
  • etcd - etcd v3
    • +
  • env - 环境变量
    • +
  • file - 配置文件
    • +
  • flag - 命令行标识
    • +
  • grpc - grpc
    • +
  • memory - 内存
    …
    • +
+
// Source is the source from which config is loaded
type Source interface {
    Read() (*ChangeSet, error) // 提供给Loadder使用，通过Read读取到ChangeSet
    Write(*ChangeSet) error
    Watch() (Watcher, error) // 创建一个Source对应的Watcher
    String() string
}

// 代表从Source读取的内容。可能为全量，也可能为增量，取决于Source的实现
type ChangeSet struct {
    Data      []byte
    Checksum  string
    Format    string
    Source    string
    Timestamp time.Time
}

// Watcher watches a source for changes
type Watcher interface {
    Next() (*ChangeSet, error) // 无变化时会block
    Stop() error
}
+ +

Watcher的底层实现还是依赖各Source的watcher，比如file source，就引入了”fsnotify/fsnotify”来监控文件的变化。每个Source被Loader Load时会生成一个对应的source watcher goroutine，用于监控source的变更。
各种Source的实现就没有具体关注了。

+

Loader

用于加载Source，实现的核心数据结构。

+
// Loader manages loading sources
type Loader interface {
    // Stop the loader
    Close() error
    // Load the sources
    Load(...source.Source) error
    // A Snapshot of loaded config
    Snapshot() (*Snapshot, error)
    // Force sync of sources
    Sync() error
    // Watch for changes
    Watch(...string) (Watcher, error)
    // Name of loader
    String() string
}

// Watcher lets you watch sources and returns a merged ChangeSet
type Watcher interface {
    // First call to next may return the current Snapshot
    // If you are watching a path then only the data from
    // that path is returned.
    Next() (*Snapshot, error)
    // Stop watching for changes
    Stop() error
}

// 功能：ChangeSet的聚合。
// 场景：当loader重新加载数据之后会保存一份snapshot
type Snapshot struct {
    // The merged ChangeSet
    ChangeSet *source.ChangeSet
    // Deterministic and comparable version of the snapshot
    Version string
}
+ +

框架中提供了一个缺省的memory loader，Loader的存在主要基于以下几个原因：
1、Source是可以聚合（Merge）的，在Reader中提供了Merge的实现。当系统存在多份Source时，需要将Source聚合好之后给到Config，否则Config中就得处理此类逻辑。
2、对Source的failover。当Load失败时，提供了Snapshot能力。
Loader还维护了核心的数据结构：watcher列表。source watcher goroutine发现内容变更时会将变更的内容通知给所有goroutine（通过Get读取对应的path值），“通知”只是将内容写到了update 队列。具体的变更逻辑还得外部调用方调用Next感知。
注意调用方增加Watcher时，Loader只是在watcher list中增加一个节点，没有goroutine的开销。但是Suorce的内容变更会通知所有wathcher，wather会根据内容的变化情况(bytes.Equal)来决定是否通知上层变更。

+
    // Loader中通知各个watcher，内容可能已变化，写入changeset
    for _, w := range watchers {
        select {
        case w.updates <- m.vals.Get(w.path...):
        default:
        }
    }

    // ...


// Loader提供的变更获取接口，读取changeset
func (w *watcher) Next() (*loader.Snapshot, error) {
    for {
        select {
        case <-w.exit:
            return nil, errors.New("watcher stopped")
        case v := <-w.updates:
            if bytes.Equal(w.value.Bytes(), v.Bytes()) {
                continue
            }
            w.value = v

            cs := &source.ChangeSet{
                Data:      v.Bytes(),
                Format:    w.reader.String(),
                Source:    "memory",
                Timestamp: time.Now(),
            }
            cs.Sum()

            return &loader.Snapshot{
                ChangeSet: cs,
                Version:   fmt.Sprintf("%d", time.Now().Unix()),
            }, nil
        }
    }
}

// config暴露给外部的watcher接口, 封装Loader的Next接口
func (w *watcher) Next() (reader.Value, error) {
    for {
        s, err := w.lw.Next()   // 内部调用loader的Next获取ChangeSet
        if err != nil {
            return nil, err
        }

        // only process changes
        if bytes.Equal(w.value.Bytes(), s.ChangeSet.Data) {
            continue
        }

        v, err := w.rd.Values(s.ChangeSet)
        if err != nil {
            return nil, err
        }

        w.value = v.Get()
        return w.value, nil
    }
}
+ +

另上面也提供，config中也维护了一个gouroutine，watch的path是各个source的聚合。当一个Source的内容变更时需要将各个Source内容重新聚合后返回给config，以更新Config中的snapshot和value值。

+

总结

图中画得比较明白了，比较难以理解的地方也在于Loader为支持多个Source的一些操作，包括sets列表、Merge操作。当理解需要支持多个Source的聚合之后就比较好理解了。

+

整体感觉config的封装过于复杂了，包括的viper的引入还进行了改造，在代码实现中有比较多的类似的逻辑，包括命名也有不少重复，阅读起来有点心累。估计代码圈复杂度比较高。。

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/06/14/Functional-options-for-friendly-APIs/index.html b/2020/06/14/Functional-options-for-friendly-APIs/index.html new file mode 100644 index 0000000..2086bad --- /dev/null +++ b/2020/06/14/Functional-options-for-friendly-APIs/index.html @@ -0,0 +1,845 @@ + + + + + + + + + Functional options for friendly APIs | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Functional options for friendly APIs +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 736字 + + + + +   |   + + + 阅读时长≈ + 3分 + + +
+ + + +
+ +
+ +
+

Written with StackEdit.

+
+

Functional options for friendly APIs

在一些框架代码中，比较常见的封装配置的方法是使用WithXXX()的API形态对外暴露接口，而非传统的Config配置数据结构。本文解释了配置API的集中方案。

+

原文地址：https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis

+ + +

一个server package的列子

type Server struct {
    listener net.Listener
}

func (s *Server) Addr() net.Addr
func (s *Server) Shutdown()

func NewServer(addr string) (*Server, error) {
    l, err := net.Listen("tcp", addr)
    if err != nil {
        return nil, err
    }
    srv := Server(listener: l)
    go srv.run()
    return &srv, nil
}
+ +

Server暴露出来的API非常简单清晰，但是毫无扩展性。

+

功能扩展

最简单直接的方法，可能就是增加参数了。

+
func NewServer(addr string, 
    clientTimeout time.Duration, // 超时时间
    maxconns int, // 最大连接数
    maxconcurrent int, // 最大并发
    cert *tls.Cert) // 安全tls
+ +

带来的问题：

+
    +
  1. 无法向前兼容的问题
    2. +
  2. 默认值怎么填？如果我们不关心超时，clientTimeout要填什么？
    3. +
+

可以根据使用场景，提供不同的constructor，但是这种方法过于笨重了。

+
// with timeout
NewServerWithTimeout(addr string, timeout time.Duration) (*Server, error)

// secure server
NewTlsServer(addr string, cert *tls.Cert) (*Server, error)
+ +

可配置

将配置单独抽离成Config。

+
type Config struct {
    Cert *tls.Cert
    Timeout time.Duration
}

func NewServer(addr string, config Config) *Server
+ +

优点：

+
    +
  1. 向前兼容，增加参数对老版本兼容
    2. +
  2. 文档化更方便，在Config中针对每项配置说明即可。
    3. +
+

但是还是没有解决默认值的问题，很多时候大部分参数用户是不想去理解的。

+
+
+
+

“I just want a sever, I don’t want to have to think about it”

+
+
+
+

为了避免默认值带来影响，用户在调用的时候对不需要的参数不填默认值。

+
func NewServer(addr string, config ...Config) (*Server, error)

func main() {
    svr, _ = NewServer("localhost") // default
    srv2, _ := NewServer("localhost", Config{
        Timeout: 300 * time.Second,
        MaxConns: 10,
    })
}
+

Functional Options

另一种方法就是将配置拆分成多份，以可变参数的方式传入settler：

+
func NewServer(addr string, options ...func(*Server)) (*Server, error) {
    l, _ := net.Listen("tcp", addr)
    srv := Server{listener: l}
    
    for _, option := range(options) {
        options(&srv)
    }
    return &srv, nil
}

// caller
func main(){
    srv, _ := NewServer("localhost")

    // timeout setter
    timeout := func(srv *Server){
        srv.timeout = 60 * time.Second
    }
    // tls settter
    tls := func(srv *Server){
        config := loadTlsConfig()
        srv.listener = tls.NewListener(srv.listener, &config)
    }
    srv2, _ := NewServer("localhost", timeout, tls)
}

+ +

可以将各种setter function封装在package中，不用直接对外暴露config的内部数据结构，而是暴露API。

+

一个完整的demo如下：

+
// Server Package

package Server

import (
    "fmt"
)

type Options struct {
    Name      string
    Age       int32
    Addesss   string
    IdCard    string
    Cellphone string
}

type Option func(*Options)

func NewOptions(opts ...Option) (opt Options) {
    for _, o := range opts {
        o(&opt)
    }
    return
}

func Name(name string) Option {
    return func(o *Options) {
        o.Name = name
    }
}

func Age(age int32) Option {
    return func(o *Options) {
        o.Age = age
    }
}

func Address(addr string) Option {
    return func(o *Options) {
        o.Addesss = addr
    }
}

// 用户调用demo
func main() {
    var opt Options
    opt = NewOptions(
        Name("xigang"),
        Age(24),
        Address("Beijing"))
}
+ + + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/06/27/Tencent-Scf-Version-Manage/index.html b/2020/06/27/Tencent-Scf-Version-Manage/index.html new file mode 100644 index 0000000..435920d --- /dev/null +++ b/2020/06/27/Tencent-Scf-Version-Manage/index.html @@ -0,0 +1,869 @@ + + + + + + + + + Tencent Scf Version Manage | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Tencent Scf Version Manage +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.3k字 + + + + +   |   + + + 阅读时长≈ + 4分 + + +
+ + + +
+ +
+ +

腾讯云函数的版本管理

前段时间体验了下腾讯云的云函数，试着将一个古老的cgi迁移到云函数，由于特性比较简单，整体还算顺利。

+

云函数的概念比较多，新接入的开发者需要了解许多概念，如果是简单的功能接入还是挺方便的，跟着文档操作一遍就行了。但许多文档还不是很深入。比如如何在golang云函数操作HTTP Header使其返回302，这个就研究了挺久。

+

如果在生产环境使用腾讯云函数相关的能力来进行版本的迭代，官方并没有给出标准解决方案。大致摸索了一下云函数、云网关的相关能力，介绍如下。

+ + +

云函数

通常一个逻辑服务server对应一个云函数。后续相关需求的迭代，对应的逻辑服务也会有频繁的版本更新发布。

+

云函数版本

    +
  • 版本概念跟git/svn仓库类似，但默认只有$Latest版本可以重新上传代码，所以：
      +
    • 建议$Lastest用于开发，其他版本用于（预）发布。
      • +
    • 当存在多人并行开发时，建议建立个人云函数，以及对应的云网关，避免相关影响。
      • +
    +
    • +
  • 功能特性上线时应该发布到新的版本。只能使用 $LATEST 的配置和代码生成新版本，代码版本发布后不可变更。
    • +
+

别名

    +
  • 大部分代码（云函数）的版本特性迭代，是属于云函数内部逻辑的变更，应该不涉及到云网关路由的变更，所以在云函数和云网关之间引入了别名的概念，降低发布成本。
      +
    • 云网关也分多套环境，如果每次逻辑服务的变更需要调整每个云网关下对应函数的版本，这个会是个比较大的发布成本。
      • +
    +
    • +
  • 别名也可以起到流量控制的左右。同一个函数版本可以特定路由规则路由到不同的版本。
    • +
  • 针对不同的版本可以设置几个固定的别名用作路由（流量）控制。建议根据环境的数量，创建对应的别名。如test/release/prepub三个不同的别名，分别用作云网关的三套环境。后续代码迭代变更只需要调整别名的具体路由即可。不涉及网关调整。
    • +
  • 存在一个默认别名DEFAULT，可以用作开发环境。
    • +
+

云网关

云网关属于触发器的一种，用于提供对外的服务API，定位类似接入层。还有其他类型的触发器用作定时任务等场景。此处只讨论云网关触发器+云函数的版本控制。

+

API编辑

    +
  • 云网关下存在多个API（云函数），每个函数的路径不同。也可以在云函数中二次路由，减少维护成本。
    • +
  • 在编辑中可以针对API设置默认参数、参数校验、默认返回值等。
    • +
+

环境

    +
  • 每个云网关存在三套独立环境：test/release/prepub，分别对应不同的path。
    • +
  • 每套环境可以切换不同的云网关版本，一般在无新增API的情况下可以不用变更云网关。
    • +
  • 三套环境的发布流程也是相互隔离的。
    • +
  • 理论上新增API在历史云网关中是无法路由的。【未验证】
    • +
+

云网关的版本

    +

  • 每套环境有不同的云网关版本，每个版本的发布流程都是单独的，发布前需要编辑每个云函数对应的别名、超时时间、参数、默认返回等。（如上所述，如果特性迭代不涉及这些调整，可以忽略）

    +
    • +

  • API调整完毕后就可以发布云网关版本了，发布时需要指定本次发布的环境（test/release/prepub）

    理论上每个特性的发布需要再test/release/prebu上都发布一遍，成本比较高。所以才引入了别名，尽量减少云网关的发布。

    +
    • +

  • 可以切换每个环境对应的版本，但是历史版本不能调整。

    +
    • +
+

总结

    +

  • 云网关、别名和云函数的关系

    +
      +
    • 云网关：用作对外入口，定位类似nginx，云函数版本变更基本不涉及网关的变更。
      • +
    • 云函数：类似内部逻辑层，实现业务逻辑。也可以在云函数内实现多个功能，自己实现二级路由。
      • +
    • 别名：类似内部路由控制层，控制云网关到云函数的路由调度策略。
      • +
    +
    • +

  • 建议部署关系

    +
      +
    1. 新版本直接在Latest上开发、发布。使用test别名+test path访问，多人开发时可以独立拆分云函数，避免相互影响。
      2. +
    2. 提测时发布测试环境，云函数新增一个版本，并调整别名路由策略即可。可以使用prepub用作测试。并调整对应别名路由策略。
      3. +
    3. 正式环境发布，调整release别名对应版本即可。
      4. +
    +
    • +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/07/02/Introduction-to-Go-Modules/index.html b/2020/07/02/Introduction-to-Go-Modules/index.html new file mode 100644 index 0000000..918ef8d --- /dev/null +++ b/2020/07/02/Introduction-to-Go-Modules/index.html @@ -0,0 +1,903 @@ + + + + + + + + + Introduction to Go Modules | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Introduction to Go Modules +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 2.1k字 + + + + +   |   + + + 阅读时长≈ + 9分 + + +
+ + + +
+ +
+ +

Introduction to Go Modules

原文链接

+ + +

Creating a Module

先创建一个package，用于测试go mod的版本管理。

+
$ mkdir testmod
$ cd testmod
$ go mod init github.com/robteix/testmod
+ +

package的代码也很简单：

+
package testmod

import "fmt" 

// Hi returns a friendly greeting
func Hi(name string) string {
   return fmt.Sprintf("Hi, %s", name)
}
+ +

将package放入仓库：

+
$ git init 
$ git add * 
$ git commit -am "First commit" 
$ git push -u origin master
+ +

现在就可以通过go get将package获取到本地使用了：

+
$ go get github.com/robteix/testmod
+ +

注意这里是从master分支获取最新的code，master分支通常处于开发中，特性不稳定，所以这种方式不推荐。

+

语义化版本

了解go module的版本机制之前，需要先对语义化版本有个大致了解。

+

版本格式

常规版本格式：主版本号.次版本号.修订号，版本号递增规则如下：

+
    +
  • 主版本号(major)：当你做了不兼容的 API 修改。
    • +
  • 次版本号(minor)：当你做了向下兼容的功能性新增，可以理解为Feature版本。
    • +
  • 修订号(patch)：当你做了向下兼容的问题修正，可以理解为Bug fix版本。
    • +
+

先行版本号

在常规的版本号命名之上还有一个特殊类别，叫做预发版本号（prerelease version）。它表示当前版本是一个不稳定的版本，使用它时需要注意风险。

+

先行版本号的格式是 <major>.<minor>.<patch>-<stage>.<num>，即前半部分和常规版本号相同，然后跟上连接符 -，后面再跟上字母数字点号连接符。

+

常用的stage有：

+
    +
  • alpha：内测版，内部交流或者专业测试人员测试用；
    • +
  • beta：公测版，专业爱好者大规模测试用，存在一些缺陷，该版本也不适合一般用户安装；
    • +
  • Gamma：比较成熟的测试版，与即将发行的正式版相差无几；
    • +
  • rc：是 Release Candidate的缩写，意思是发布倒计时，候选版本，处于Gamma阶段，该版本已经完成全部功能并清除大部分的BUG。到了这个阶段只会除BUG，不会对软件做任何大的更改。从Alpha到Beta再到Gamma是改进的先后关系，但RC1、RC2往往是取舍关系。
    • +
  • lts：长期维护，long term support 的缩写。
    • +
  • Stable：稳定版。在开源软件中，都有stable版，这个就是开源软件的稳定发行版。
    • +
+

如：1.0.0-alpha.1

+

版本发布准则

列举出比较实用的一些规则：

+
    +
  • 标准的版本号必须采用XYZ的格式，并且X、Y 和 Z 为非负的整数，禁止在数字前方补零，版本发布需要严格递增。例如：1.9.1 -> 1.10.0 -> 1.11.0。
    • +
  • 某个软件版本发行后，任何修改都必须以新版本发行。
    • +
  • 1.0.0 的版本号用于界定公共 API。当你的软件发布到了正式环境，或者有稳定的API时，就可以发布1.0.0版本了。
    • +
  • 版本的优先层级指的是不同版本在排序时如何比较。判断优先层级时，必须把版本依序拆分为主版本号、次版本号、修订号及先行版本号后进行比较。
    • +
+

Quick Intro to Module Versioning

Making our first release

发布我们testmod的第一个版本：

+
$ git tag v1.0.0
$ git push --tags
+ +

同时也拉取一个分支，用作后续的bug fix：

+
$ git checkout -b v1
$ git push -u origin v1
+ +

Using our module

在另一个项目中使用前面创建的testmod package：

+
package main

import (
    "fmt"

    "github.com/robteix/testmod"
)

func main() {
    fmt.Println(testmod.Hi("roberto"))
}
+ +

go module初始化和build之后，默认会生成两个本地文件：go.mod、go.sum

+

go.mod：

+
module mod
require github.com/robteix/testmod v1.0.0
+ +

用于记录当前module的相关依赖，在build过程中会自动解析相关依赖，当发现import 的package不在go.mod文件中时，go会查找“最新的版本”，并写入到go.mod文件中。

+

那么该如何定义“最新”呢？

+
    +
  • 可以是最新的tagged稳定版（非prerelease版本）
    • +
  • 或者是最新的tagged预发布版本
    • +
  • 或者是最新的untagged版本
    • +
+
+

关于伪版本(pseudo-version)：

+

The go.mod file and the go command more generally use semantic versions as the standard form for describing module versions, so that versions can be compared to determine which should be considered earlier or later than another. A module version like v1.2.3 is introduced by tagging a revision in the underlying source repository. Untagged revisions can be referred to using a “pseudo-version” like v0.0.0-yyyymmddhhmmss-abcdefabcdef, where the time is the commit time in UTC and the final suffix is the prefix of the commit hash. The time portion ensures that two pseudo-versions can be compared to determine which happened later, the commit hash identifes the underlying commit, and the prefix (v0.0.0- in this example) is derived from the most recent tagged version in the commit graph before this commit.

+
+

在go.mod文件中可能看到部分间接依赖的module（尾部标识有// inderect），那是因为部分直接依赖的package自身没有包含go.mod文件，所以也将其引入到了当前项目的go.mod文件。

+

可以使用go list -m all列出所有依赖。也可以通过go mod why -m <module> 确认某个模块的依赖路径。

+

go.sum：

+
github.com/robteix/testmod v1.0.0 h1:9EdH0EArQ/rkpss9Tj8gUnwx3w5p0jkzJrd5tRAhxnA=
github.com/robteix/testmod v1.0.0/go.mod h1:UVhi5McON9ZLc5kl5iN2bTXlL6ylcxE9VInV71RrlO8=
+ +

用于记录各个module的Hash值，避免后续下载的module被意外更新的情况。

+

Making a bugfix release

现在testmod v1.0.0的版本需要bug fix，还是在之前的v1分支上进行简单的bug修复，不涉及API的调整：

+
$ git commit -m "Emphasize our friendliness" testmod.go
$ git tag v1.0.1
$ git push --tags origin v1
+ +

Updating modules

为了保证build的稳定，go默认不会更新相关依赖module。可以通过go get来更新：

+
    +
  • go get -u将更新到最新的次版本或者修订版本，比如从1.0.0更新到1.0.1，或者1.1.0 (次版本优先）。
    • +
  • go get -u=patch更新到最新的修订版本，比如从1.0.0更新到1.0.1，而非1.1.0
    • +
  • go get package@version更新到指定版本。
    • +
+

上面的例子中，我们通过以下几种方式都可以将testmod更新到v1.0.1。

+
$ go get -u
$ go get -u=patch
$ go get github.com/robteix/testmod@v1.0.1
+ +

更新完毕后可以看到go.mod中的内容也产生了变化，testmod的依赖版本改为了v1.0.1。

+

Major versions

语义化版本有提到，当你做了不兼容的 API 修改时，主版本号就需要升级了。从go module的角度看，同一个package的两个不同的主版本，可以认为是完全独立的两个package。使用时对应的import path也不一样。

+

现在修改testmod，且API与之前的版本不兼容：

+
// Hi returns a friendly greeting in language lang
func Hi(name, lang string) (string, error) {
    switch lang {
    case "en":
        return fmt.Sprintf("Hi, %s!", name), nil
    case "pt":
        return fmt.Sprintf("Oi, %s!", name), nil
    default:
        return "", errors.New("unknown language")
    }
}
+ +

由于API与之前的v1.X版本完全不兼容，我们需要需要一个新的import path。通常的做法是在现有path的尾部增加版本号：

+
module github.com/robteix/testmod/v2
+ +

发布一个v2的版本：

+
$ git commit testmod.go -m "Change Hi to allow multilang"
$ git checkout -b v2 # optional but recommended
$ echo "module github.com/robteix/testmod/v2" > go.mod
$ git commit go.mod -m "Bump version to v2"
$ git tag v2.0.0
$ git push --tags origin v2 # or master if we don't have a branch
+ +

注意在go.mod中module的名字也做了变更。

+

Updating to a major version

尽管testmod发布了一个不兼容的v2版本，这不影响之前的版本使用，go get -u也不会将testmod升级到v.2版本。

+

如果希望使用testmod的新特性，需要主动指定import的版本：

+
package main

import (
    "fmt"
    "github.com/robteix/testmod/v2" 
)

func main() {
    g, err := testmod.Hi("Roberto", "pt")
    if err != nil {
        panic(err)
    }
    fmt.Println(g)
}
+ +

也可以在同一份代码中引入两个不同的版本，这两个版本会被当做不同的package

+
package main
import (
    "fmt"
    "github.com/robteix/testmod"
    testmodML "github.com/robteix/testmod/v2"
)

func main() {
    fmt.Println(testmod.Hi("Roberto"))
    g, err := testmodML.Hi("Roberto", "pt")
    if err != nil {
        panic(err)
    }
    fmt.Println(g)
}
+ +

Reference

Semantic Import Versioning
Psedo versions

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/10/05/Vscode-Remote-Connect-failed/index.html b/2020/10/05/Vscode-Remote-Connect-failed/index.html new file mode 100644 index 0000000..6c8536c --- /dev/null +++ b/2020/10/05/Vscode-Remote-Connect-failed/index.html @@ -0,0 +1,830 @@ + + + + + + + + + Vscode Remote Connect failed | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Vscode Remote Connect failed +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 279字 + + + + +   |   + + + 阅读时长≈ + 1分 + + +
+ + + +
+ +
+ +

Vscode Remote连接失败

一台很久没有使用vscode remote操作过的机器，今天在调试个项目的时候发现之前配置怎么都连接不上了，一直timeout，也没有给出错误原因。花了些时间来定位，记录一下解决方法。

+ + +

状态

vscode remote点击”Connect to Host”无响应，过一会报connect timeout

+

调试方法

    +
  1. 确认相关配置是否正常。
    2. +
+
    +
  • .ssh/config中remote Host配置是否完整
    • +
  • 本机id_rsa.pub内容是否导入remote Host的authorized_keys文件中，否则无法免密登录成功
    • +
+
    +

  1. 正常情况下应该就可以了在shell中免密登录了。

    +
    2. +

  2. 直接ssh Host发现也无法免密登录，于是登录远程主机后查看登录日志。

    +
    3. +
+
sudo tail -f /var/log/secure
+ +

发现错误提示：

+

Authentication refused: bad ownership or modes for file /data/home/XXX/.ssh/authorized_keys

+

仔细观察XXX用户有两个问题：

+
    +
  • group与authorized_keys创建用户的group不一致。应该是我重新创建过用户的关系
    • +
  • authorized_keys文件权限不对，不允许group有写权限。chmod g-w authorized_keys，去掉后正常。
    • +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2020/12/26/Introduction-to-memberlist/index.html b/2020/12/26/Introduction-to-memberlist/index.html new file mode 100644 index 0000000..f8066a4 --- /dev/null +++ b/2020/12/26/Introduction-to-memberlist/index.html @@ -0,0 +1,1082 @@ + + + + + + + + + Introduction-to-memberlist | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Introduction-to-memberlist +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 4.2k字 + + + + +   |   + + + 阅读时长≈ + 15分 + + +
+ + + +
+ +
+ +

memberlist实现分析

gossip简介

Gossip protocol 也叫 Epidemic Protocol （流行病协议），实际上它还有很多别名，比如：“流言算法”、“疫情传播算法”等。这个协议的作用就像其名字表示的意思一样，非常容易理解，它的方式其实在我们日常生活中也很常见，比如电脑病毒的传播，森林大火，细胞扩散等等。

+

Gossip的基本思想一个节点想要分享一些信息给网络中的其他的一些节点。于是，它周期性的随机选择一些节点，并把信息传递给这些节点。这些收到信息的节点接下来会做同样的事情，即把这些信息传递给其他一些随机选择的节点。一般而言，信息会周期性的传递给N个目标节点，而不只是一个。这个N被称为fan-out（扇出）。

+ + +

数据一致性问题的背景&目标

问题：

+
    +
  1. 如何在多网络中将多个节点实现并保持数据一致性。
    2. +
  2. 能够随着节点数量的增加而优雅地扩展。
    3. +
+

考量的因素：

+
    +
  1. 单节点信息变更后，更新传播到所有其他节点所需的时间
    2. +
  2. 传播单个更新时生成的网络流量
    3. +
+

机制

在《Epidemic Algorithms for Replicated Database Maintenance》论文中主要论述了直接邮寄（direct mail）、反熵传播（anti-entropy）、谣言传播（rumor mongering）三种机制来实现数据更新。Gossip协议主要是通过反熵传播（anti-entropy）、谣言传播（rumor mongering）实现的。

+

直接邮寄（direct mail）

每个节点更新都会立即从其变更节点邮寄通知到所有其他节点。

+ + + + + + + + + + + + + + + + + + + + + + + +
机制直接邮寄（direct mail）
时间复杂度O(n)，n为节点数
网络流量m*n，m为更新消息数，n为节点数
优点更新效率高
缺点不完全可靠，存在信息传递丢失风险
+

当节点有数据更新便开始遍历节点池，遍历发送其他所有节点消息来通知自身节点数据的更新情况，实现算法较为简单。由于是一次性遍历通知，在遇到网络通信故障、节点宕机之后恢复等现实情况时没有办法容错和补偿，这是较为致命性的地方，因此极端情况下它是无法保证分布式环境下各节点数据一致性的。

+

反熵传播（anti-entropy）

每个节点都会定期随机选择节点池中的一些节点，通过交换数据内容来解决两者之间的任何差异。节点只有两种状态，病原（Suspective）和感染（Infective），因此称作SI模型，一般叫做简易流行病（simple epidemics） 。

+

在 SI model 下，一个节点会把所有的数据都跟其他节点共享，以便消除节点之间数据的任何不一致，它可以保证最终、完全的一致。由于在 SI model 下消息会不断反复的交换，因此消息数量是非常庞大的，无限制的（unbounded），这对一个系统来说是一个巨大的开销。通常只用于新加入节点的数据初始化。

+ + + + + + + + + + + + + + + + + + + + + + + +
机制反熵传播（anti-entropy）
时间复杂度O(log2n)，n为节点数
网络流量O((m*n)t)，n为节点数，m为更新消息数，t为周期数
优点1.可靠 2.定时重复 3.可容错
缺点1.消息冗余 2.消息延迟 3.网络流量耗费较多
+

反熵（anti-entropy） 这种和直接邮寄（direct mail）相比的最大特点就是解决了消息丢失无法补偿容错导致的数据无法保持一致的致命问题。它通过单点的定时随机通知周边节点进行数据交互的方式保持各节点之间数据的一致性。这里需要注意的是，一致性的保持是在节点数据变更后一段时间内通过节点间的数据交互逐渐完成的最终一致，并且由于每个节点都定期广播数据到周边随机的一部分节点，因此在数据交互上是存在冗余和延迟的。

+

谣言传播（rumor mongering）

交互如下：

+
    +
  • 所有的节点在最开始没有产生数据变更时都假设是未知状态，它是不知道任何谣言信息的
    • +
  • 当节点收到其他节点更新数据通知时，相当于听到了一条谣言，并将其视为热门开始传播给周边节点
    • +
  • 当某个节点谣言盛行时，它会定期随机选择其他节点，并确保另一个节点知道
    • +
  • 当某个节点发现周边节点都知道这个谣言时，该节点将停止将该谣言视为热点，并保留更新，而不会进一步传播
    • +
+

谣言传播（rumor mongering）中的节点状态有Suspective(病原)、Infective(感染)、Removed(愈除)，因此称作SIR模型，一般叫做复杂流行病（complex epidemics） 。

+
    +
  • 消息生产节点即为Suspective(病原)状态
    • +
  • 消息接收节点即为Infective(感染)状态，会进行消息传播
    • +
  • 节点接收消息后即为Removed(愈除)状态，不再进行传播
    • +
+

Rumor Mongering（SIR Model） 模型下，消息可以发送得更频繁，因为消息只包含最新 update，体积更小。而且，一个 Rumor 消息在某个时间点之后会被标记为 removed，并且不再被传播，因此，SIR model 下，系统有一定的概率会不一致。

+

而由于，SIR Model 下某个时间点之后消息不再传播，因此消息是有限的，系统开销小。

+ + + + + + + + + + + + + + + + + + + + + + + +
机制谣言传播（rumor mongering）
时间复杂度O(log2n)，n为节点数
网络流量O((m*n)t)，n为节点数(递减)，m为更新消息数，t为周期数
优点1.可靠 2.定时重复 3.可容错
缺点1.消息冗余 2.消息延迟 3.网络流量耗费较多
+

总结

Gossip协议通过反熵传播（anti-entropy）和谣言传播（rumor mongering）两种机制进行实现并保证节点数据的最终一致性。

+ + + + + + + + + + + + + + + + + + +
机制工作原理工作时机
反熵传播（anti-entropy）以固定的概率传播所有的数据新加入节点初始化
谣言传播（rumor mongering）仅传播新到达的数据节点增量数据
+

这篇文章对gossip协议更详细的描述。

+

另外gossip-simulator可能会对协议理解更有帮助。

+

通信模式

拉方式（pull）

    +
  • ① A仅将数据 key, version 推送给 B
    • +
  • ② B 将本地比 A 新的数据（Key, value, version）推送给 A
    • +
  • ③ 回传 B 数据给 A
    • +
  • ④ A 更新本地
    • +
+

推方式（push）

    +
  • ① 节点 A 将数据 (key,value,version) 及对应的版本号推送给 B 节点
    • +
  • ② B 节点更新 A 中比自己新的数据
    • +
+

推拉方式（push&pull）

    +
  • ① A仅将数据 key, version 推送给 B
    • +
  • ② B 将本地比 A 新的数据（Key, value, version）推送给 A
    • +
  • ③ 回传 B 数据给 A
    • +
  • ④ A 更新本地
    • +
  • ⑤ 推送比 B 新的数据
    • +
  • ⑥ 更新 B
    • +
+

从消息复杂度来看，Push(1次) < Pull（2次） < Pull&Push（3次）
从时间复杂度来看，Pull > Push
从算法实现上来看，无论是基于何种模式进行数据交互，Gossip都是基于平方概率计算进行最终一致性收敛的
从运行效果上来看，推拉模式（Push/Pull） 最好，理论上一个周期内可以使两个节点完全一致，收敛速度也是最快的，消息通信损耗也是最多的。

+

memberlist实现

功能

memberlist是一个基于gossip（变种）协议的实现，主要使用场景：

+
    +
  • 分布式网络的分区节点管理和故障探测。如服务发现组件Consul使用
    • +
  • 分布式网络的数据同步
    • +
+

memberlist提供了一些Deligate API，可以用作节点间的数据同步。用法可以参考这个asim/memberlist。实际上关注到memberlist也是因为在预研分布式任务调度系统dkron过程中了解到它有使用memberlist来实现节点间的数据同步。

+

源码分析

goroutine分布

从goroutine分布可以大致了解memberlist的工作原理。goroutine主要分为两类：

+

定时器协程
定时器协程主要用于memberlist生命过程中一些常规的定时任务，memberlist.schedule() 会启动三个主要的定时器协程，分别介绍如下：

+
    +

  • Probe timer：执行探测逻辑(Ping)。UDP，也可以强制启用TCP。固定周期。每次只会挑选一个节点进行探测。

    +

    probe的目标是探测节点的存活状态。大致流程：

    +
      +
    • 每次挑选一个节点，组装一个唯一sequence的ping包
      • +
    • 设置超时callback，避免对端节点无响应。
      • +
    • 执行ping，并等待应答
      • +
    • 根据应答or超时结果，执行indirect ping、tcp ping
      • +
    • 根据ack数量，更新节点delta和状态。detal反映了自身的健康程度，delta越大，自己可能出问题的概率越大，ping等待应答的时间越长。
      • +
    +
    • +

  • pushPullTrigger timer：用于两个节点间的全量数据同步。TCP协议+动态实时调整。请求时携带本地全部节点数据，响应中也会携带对端所拥有的节点信息。这样一次交互就实现了一次完整的数据同步。对应gossip协议中的反熵传播（anti-entropy）实现。

    +

    工作流程：

    +
      +
    • 挑选一个其他节点，准备执行pushPullNode操作。
      • +
    • 创建tcp连接
      • +
    • 发送本地全部nodes列表（包含状态）给到对方，并取对方返回nodes列表及数据
      • +
    • 处理pullPushMsg，将对端返回的nodes列表状态与本地进行合并，详见下方tcpListen()中pushPullMsg的处理流程。
      • +
    +
    • +

  • Gossip timer：挑选部分随机节点进行广播推送。采用UDP。对应协议中的谣言传播（rumor mongering）。

    +

    周期GossipInterval执行gossip，大致流程：

    +
      +
    • 挑选若干（m.config.GossipNodes）随机节点（过滤left节点）
      • +
    • 组件广播并批量发送。不需要等待应答？
      • +
    +
    • +
+

监听协程

+

程序在启动之初（NewNetTransport()），会创建一个tcp和一个udp的监听协程，TCP主要用作节点间的全量状态数据同步。UDP主要用作节点间状态探测。其中一部分消息类型（比如ping）在两条通道上都有可能出现。：

+
    +

  • **go tcpListen()**： TCP监听，用于接收新的node连接，并写入到独立协程去处理。

    +

    TCP连接消息的处理见handleConn()，主要处理的是pushPullTrigger timer的节点状态同步消息。里面也包括了用户侧的全量用户数据。消息类型以及处理流程简介：

    +
      +

    • **userMsg**：用户消息要用作上层业务的用户数据传递。

      +

      asim/memberlist项目中可以看到如何利用broadcast传播用户数据。实际上在将用户数据通过broadcasts.QueueBroadcast(data)写入时并没有触发实时的网络数据同步，而是写入了一个有限优先级队列TransmitLimitedQueue中，然后通过两种方式携带出去：网络探测消息或者gossip定时器，整个过程都是异步的。

      +

      问题：异步如何保证数据不会丢失？

      +

      broadcast消息无法完全保证。udp本就有一定的丢失率，但是只要有一个节点成功，数据就会同步到其他节点。如果100%丢失就不行了。如果需要可以调用其他保证可靠性的接口。broadcast一般用作增量数据的同步，memberlist还提供了同步全量数据的能力，通过pushPullMsg的tcp连接同步对端节点来保证可靠性，以达到最终一致性的目的。

      +
      • +

    • pushPullMsg: 用作全量节点状态同步，由对端pushPullTrigger time定期触发。

      +

      收到对端的pushPullMsg之后，首先会将本地的nodes状态也应答给对方，这样就完整了一次完整的全量数据交换。此过程中可以携带用户数据，一般用作调用方全量数据同步。

      +

      然后会将本地nodes状态与对端nodes状态逐一聚合。聚合流程跟节点当前状态有关，大致如下：

      +

      _stateAlive_：插入本地nodes列表，同时对stateSuspect、stateDead状态的节点进行特殊处理。

      +

      _stateLeft_：如果为本机需要refute操作，否则广播通知其他节点。

      +

      stateDead / _stateSuspect_：首次会广播给其他节点。同时也会对通知源节点数计数，一段时间内超过一定阈值（实时计算）会将节点设置为dead。

      +
      • +

    • pingMsg

      +

      tcp的ping。默认是关闭的，可以在config中启用，供UDP异常网络环境时使用。

      +
      • +
    +
    • +

  • **go udpListen()**：udp监听，处理节点探测的消息和gossip消息。

    +

    udp类型的消息比较多，为了提升处理性能考虑，避免各类相互影响，拆分为packetListen、packetHandler两部分。各种探测消息类型简介如下：

    +
      +

    • pingMsg

      +

      Probe timer发起，探测节点是否正常。收到ping之后会立即回复ackRespMsg，并携带广播（其实基本大部分消息都会携带广播）。

      +
      • +

    • ackRespMsg

      +

      ping消息的应答。

      +
      • +

    • indirectPingMsg

      +

      当ping无应答时，会挑选若干节点进发送indirectPingMsg，携带目标节点，以佐证是否本地路由问题。

      +

      本机收到indirectPing指令时，会向指定的目标节点发送ping消息：如果有收到回包，则发送ackRespMsg给源节点。如果超时则回复nackRespMsg消息给到源节点，表明自己导目标节点的状态异常。

      +
      • +

    • nackRespMsg

      +

      收到nackRespMsg到一定阈值时，会将节点置未_stateSuspect_状态，并告知其他节点。

      +
      • +

    • suspectMsg

      +

      收到对端传来的suspectMsg表明节点很可能异常了。如果节点为自己，执行refute操作。否则转发，并判断是否进入stateDead状态。

      +
      • +

    • aliveMsg

      +

      合入本地节点，并broadcast其他节点。

      +
      • +

    • deadMsg

      +

      跟suspectMsg处理流程一致。

      +
      • +

    • userMsg

      +

      通知上层处理增量数据。

      +
      • +
    +
    • +
+

状态合并

节点状态：集群中每个节点可能存在以下4种状态。

+
    +
  • _stateAlive_：节点存活。
    • +
  • _stateLeft_：节点已主动离开
    • +
  • stateDead / _stateSuspect_：节点已经挂了。Suspect只是一个中间态，当两个节点间路由异常时，可能会出现误判的情形，需要其他节点来一起佐只有满足条件才能确定为dead。
    • +
+

介绍几种典型的转换流程：

+

stateAlive -> stateSuspect

+
    +
  1. 节点A（本地）启动，初试状态为stateAlive。通过制定目标节点B（目标）加入集群成功，节点B在A中状态为stateAlive
    2. +
  2. A定期发送pingMsg指令，且超时时间内没有收到应答ackRespMsg。
    3. +
  3. 随机挑选N个其他节点，发送indirectPingMsg，并等待应答nackRespMsg
    4. +
  4. 当收到一定数量的nackRespMsg时，可以确定目标节点B已经异常。于是将B设置stateSuspect状态，并广播给其他节点。
    5. +
+

stateSuspect -> stateDead

+
    +
  1. 在A中节点B刚进入stateSuspect状态之初，会启动一个对应的定时器suspectTimer
    2. +
  2. 将B已进入suspect消息广播给其他节点。
    3. +
  3. 如果B收到了suspect消息，需要执行refute操作，告知其他节点B已恢复正常。如果中间过程中有其他节点通过Ping消息主动发现B已经恢复正常，也会广播告知。
    4. +
  4. suspectTimer超时，节点B如果状态及更新时间都没有变化，则认为节点已经处于stateDead状态。
    5. +
  5. 删除对应suspectTimer，广播告知其他节点
    6. +
+

一些细节

memberlist的整体流程及状态转换其实很简单，但在一些细节的处理上考虑比较多。

+

广播：广播类数据的占比比较高，且很多为重复消息，为了尽可能减少网络交互，做了一些细节上的优化：

+
    +
  1. 优先队列：控制了整体的报文数据量，当超过最大值时会丢弃数据。另外对报文也区分了优先级。
    2. +
  2. compoundMsg+异步：内部交互协议上做了优化，在package长度有限的情况下，尽可能通过一次交互携带尽可能多的数据。如在ping的过程中将队列中的广播消息也一起携带出去。
    3. +
+

awareness：两个节点间的通信失败，很难判断是本机节点还是对端节点的网络异常，所以引入了类似健康度的概念。健康度越低，表明本地网络状态可能越差，执行对应网络请求时设置的超时时间就越长。

+

比如在ping失败后默认是会将本地健康度降低，因为无法排除为自己问题，但是当执行indirectPing并收到其他节点的回复后会再度调整。

+

REFERENCES

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2021/10/04/libuv-source/index.html b/2021/10/04/libuv-source/index.html new file mode 100644 index 0000000..897b9cc --- /dev/null +++ b/2021/10/04/libuv-source/index.html @@ -0,0 +1,877 @@ + + + + + + + + + libuv-source | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ libuv-source +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 2.1k字 + + + + +   |   + + + 阅读时长≈ + 8分 + + +
+ + + +
+ +
+ +

libuv源码简介

习惯了思维图之类的简单整理之后，有一段时间没有认真写写东西了。前段时间为了研究下node的性能指标，特意复习了一下libuv的源码，但是一直懒得去整理，直到今天看到这段话后才决定整理一番：

+
+

学习是一种行动反射，不是为了晓得些『知识』，要切己体察，代入自己要事上琢磨，落实行动，这就是知行合一。否则，读书也是一种玩物尚志。

+
+

定期总结也是学习的一部分。

+ + +

简介

libuv是个异步服务的框架，整体实现及功能先看一下libuv官网的这张分层结构图。
uv arch

+
    +
  1. 底层根据操作系统类型，选择不同的多路复用实现。linux下基本就是epoll了。据说nodejs选择libuv而非libev作为底层实现，是因为libuv等windows的支持更为友好（IOCP）。具体没有对比详细对比过。
    2. +
  2. uv__io_t：从底层看，上层大部分的操作都跟io有关，或者可以转换为io操作。如tcp/udp的网络IO，tty的相应，signal的处理、pipe读写等。所以libuv封装了一层IO“基类”，工其他handler使用。
    3. +
  3. Handler：TCP、UDP、Pipe等，定位类似libevent中的event，通常实现是基于uv__io_t或者其“子类”（如uv_tcp_t、uv_pipe_t、uv_tty_t继承自uv_stream_t），暴露给业务使用的数据&接口封装。
    4. +
  4. 其他：作为框架，也封装了一些常用的能力，如定时器、线程池等，这块没有具体研究。私以为这种操作尽量避免。libevent后面的版本扩展了一堆http的能力，但是后面框架的代码量和复杂度就增加了很多，甚至还有bug，基本没法维护了，感觉一个框架干好一件事就不错了。
    5. +
+

TCP-Echo-Server数据结构图

libuv的源码较多，涉及了大量的IO封装，阅读过程中简单整理了一份用libuv实现的tcp echo server的数据结构图，从中大约可以看出libuv的整体数据结构及关联关系。从而大致了解相关的调度机制。

+

tcp echo server

+

libuv跟libevent、libev等reactor模式框架实现上没有本质上得区别，本质上还是基于select/epoll、IOCP等底层多路复用机制，封装给上层网络（tcp/udp）、文件(read/write、dir)等异步调用场景使用，避免单进程/线程block调用的影响。

+

从左到右分为以下几个部分，后续分别介绍：

+
    +
  1. uv_loop_t
    2. +
  2. uv_io_t
    3. +
  3. 各个handler: uv_tcp_t、uv_udp_t、uv_pipe_t等
    4. +
  4. request对象
    5. +
  5. 内部callback
    6. +
  6. 用户callback
    7. +
+

uv_loop_t

struct  uv_loop_s {
    uv__io_t** watchers;
    void* handle_queue[2];
    void*  watcher_queue[2];
    void*  pending_queue[2];

    int backend_fd;
};
typedef  struct  uv_loop_s  uv_loop_t;
+ +

loop核心流程在官方文档上有介绍，uv_loop_t为事件循环所需的核心数据结构。通常一个进程只需要一个loop对象，即使用default loop即可。

+

beckend_fd的作用类似于epoll fd。用作各类事件的监听。
watchers 是一个指针数组，用于存储fd与handler的关联，通过fd值可以直接索引到对应handler。
water_queue、pending_queue用来串联各种handler。

+

核心实现在uv_run()中，大致流程如下：

+
    +

  1. uv__run_timers：处理超时任务。
    如果没有堆顶元素，则没有任何定时器存在，函数将直接返回。
    如果当前时间小于定时任务的超时间，那么堆顶 timer 未到到超时时间，非堆顶的 timer 更没有达到超时时间，整个 uv__run_timers 也就会退出。
    如果当前时间等于或大于定时任务的超时间，这个 timer 就是一定达到或超过执行时间的。这时，就可以从 timer 堆中将其取出，然后调用其回调函数 handle->timer_cb(handle) 处理定时任务，然后再次重复获取下一个出现在堆顶的 timer，直到情况 1 或 2 成立。

    +
    2. +

  2. uv__run_pending：处理上一轮被挂起的事件回调。
    // 在某些情况下，IO 观察者绑定的回调函数并不是立即调用的，而是被延迟到下一次事件循环的固定阶段调用的，
    // 在 uv_run 中调用的 uv__run_pending 处理这些被延迟的 IO 观察者
    // 该函数遍历 loop->pending_queue 队列节点，取得 I/O 观察者后调用 cb，并且指定 events 参数为固定值 POLLOUT（表示可写），因此可以猜测被插入到 loop->pending_queue 队列中的情形都是可写 I/O 事件。该队列上是用来保存被延迟到下次事件循环中处理的 IO 观察者。
    tcp-server的实现中，通过client fd回写应答包给client时，write操作不一定是同步的（某些条件会同步）。所以才会有pending这种状态存在。

    +
    3. +

  3. uv__run_idle：处理idle事件
    为啥一个loop要存在3个实现方式一样的queue【”unix/loop-watcher.c”中实现】： idle、prepare、check ?
    prepare、check分别在loop的前后。
    parepare、idle的区别在于：存在idle时，循环将执行零超时轮询(timeout=0)。 http://docs.libuv.org/en/v1.x/idle.html

    +
    4. +
+
+

Note
The notable difference with prepare handles is that when there are active idle handles, the loop will perform a zero timeout poll instead of blocking for i/o.

+
+
    +

  1. uv__run_prepare：处理prepare事件

    +
    +

    场景：Prepare handles will run the given callback once per loop iteration, right before polling for i/o.

    +
    +
    2. +

  2. uv_backend_timeout：计算超时阻塞等待时间。
    注意：存在idle handle时不阻塞。

    +
    3. +

  3. uv__io_poll：核心poll操作。处理各种handler

    +
    4. +

  4. uv__run_check：处理check事件。

    +
    +

    场景：Check handles will run the given callback once per loop iteration, right after polling for i/o.

    +
    +
    5. +
+

uv_io_t

typedef  struct  uv__io_s  uv__io_t;

struct  uv__io_s {
    uv__io_cb  cb;
    void* pending_queue[2];
    void* watcher_queue[2];

    unsigned  int  pevents; /* Pending event mask i.e. mask at next tick. */
    unsigned  int  events; /* Current event mask. */

    int  fd;
    UV_IO_PRIVATE_PLATFORM_FIELDS
};
+

各handler通常需要挂在在loop的watchers数组中，uv_io_t最大的作用就是用来串联各handler数组或链表。作为handler的一部分，他也包含了一些通用的数据属性。

+

cb：指向各handler的内部回调。如stream_io时，默认指向uv__stream_io()。如果handler作用有变化时可能会被重置。比如当fd为一个tcp listen fd时，cb会指向uv__server_io()，用来专门处理listen fd的accept操作。
pending_queue、watcher_queue：用作挂在loop中的双向链表指针。用于遍历各handler时使用。当handler状态变更时会被从loop中剔除。
fd、pevents、events 用于存储fd及fd需要监听的事件。

+

uv_tcp_t

struct  uv_tcp_s {
UV_HANDLE_FIELDS
  uv_alloc_cb alloc_cb; //分配读buffer回调  
  uv_read_cb read_cb; //业务指定读回调read-cb**  
  
  uv_connect_t *connect_req;   
  uv_connection_cb connection_cb;  // 业务指定的connection回调

  uv__io_t io_watcher; // 包含了accept成功的client-fd/callback等**

  void* write_queue[2];
  size_t write_queue_size; // uv_write时使用，统计写入buffer大小

  void* write_completed_queue[2]; // 已经write完的queue

  int accepted_fd; // 临时存放accept的fd
};
+

继承自uv_stream_t。属于handler的一种。
Handles是需要挂载在主循环的监听对象，比如socket fd、文件fd，也包括定时器、idle_t等需要每次loop都需要判断是否处理的对象。具有较长的生命周期。

+

request对象

struct  uv_stream_s {
  UV_REQ_FIELDS
  
  uv_write_cb cb; // 写完时的回调**
  uv_stream_t* send_handle;

  uv_stream_t* handle; // 关联handle**

  void* queue[2]; // 挂载到uv_tcp_t.write_queue

  unsigned int write_index;

  uv_buf_t* bufs; // 数据发送前的copy存储指针**
  unsigned int nbufs;
};
+ +

Request为短时间的操作对象，如socket需要的回包，通常挂载在handle对象上（回包需要fd）。也可以不依赖handle.

+

内部callback

典型如uv__server_io、uv__stream_io等，处理accept、read等操作，处理之后再转给业务对应的callback处理。

+

uv__server__io流程：
1、accept fd，存放在accepted_fd
2、fd转给业务connection_cb
3、如果业务主动关闭，跳出listen。否则一直accept

+

uv__stream_io() // stream默认cb
1、uv__read：有读标识，读取消息后转给业务回调read-cb
2、uv__write：有写标识，send()

+

用户callback

这种就是用户/业务层的回调操作了。

+

uv__io_poll

    +
  1. 向epoll里面注入所有I/O观察者。
    2. +
  2. 开始进入 epoll_pwait 轮询IO事件
    通常情况下，在 timeout 大于 0 的情况下，循环不断迭代到 timeout 减小到 0 时，循环跳出
    在没有设置定时器的情况下，如果不出现错误，循环将一直不会跳出
    循环主要由 timeout 和 count 控制是否跳出，符合整个事件循环
    3. +
  3. 处理IO事件：获取IO观察者，调用关联的回调函数。这里通常为内部callback
    4. +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2021/10/10/Reliable-Cron-across-the-Planet/index.html b/2021/10/10/Reliable-Cron-across-the-Planet/index.html new file mode 100644 index 0000000..ce393d0 --- /dev/null +++ b/2021/10/10/Reliable-Cron-across-the-Planet/index.html @@ -0,0 +1,903 @@ + + + + + + + + + Reliable Cron across the Planet | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Reliable Cron across the Planet +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 7.4k字 + + + + +   |   + + + 阅读时长≈ + 26分 + + +
+ + + +
+ +
+ +
+

Written with StackEdit.

+
+

Reliable Cron across the Planet…or How I stopped worrying and learned to love time

Štěpán Davidovič, Kavita Guliani, Google

+

原文: https://queue.acm.org/detail.cfm?id=2745840

+

前段时间预研分布式任务调度系统的方案，了解到了一个比较靠谱的解决方案：dkron，看介绍其实现就是基于基于google的这篇whitepaper 《Reliable Cron across the Planet》。

+

这篇文章也被收录到了书籍《SRE：google运维解密》一书中（第24章），于是将部分内容摘抄了一遍，补充了部分自己的理解，当做自己的读书笔记了。文章较长，部分个人认为不重要的内容就简单跳过了。

+

本文主要介绍了google的cron调度服务的实现机制，重点对实现的难点部分做了详细介绍。详见下文。

+

先对Cron系统的功能做了个简单的介绍。包括单机下crontab格式以及linux下的crond守护进程。此处略。

+ + +

可靠性

从可靠性的角度来看待服务，需要注意几件事情。首先，故障域本质上只是一台机器，如果机器未运行，则Cron 调度程序及其启动的作业也不能运行（例如由于无法访问网络或尝试访问坏掉的硬盘驱动器导致的个别作业失败超出了本文分析的范围）。我们就先考虑使用两台机器的非常简单的分布式案例，其中 Cron 调度程序在单独的机器上运行作业（例如使用SSH）。我们就已经有了不同的可能会影响我们运行作业可靠性的故障域：调度程序或目标机器*可能会失败。

+

另一个重要方面是在 crond 重新启动（包括机器重新启动）时，需要持久化的唯一状态是 crontab配置 本身。Cron 执行者向来都是睡醒就忘的，而且 crond 也不会试图去跟踪它们的状态。

+

Cron任务和幂等性

Cron 工作常常被用于周期任务，但事实上我们很难预料它们可能执行的真正功能。让我们跑题一下，说说Cron 工作本身的行为，因为了解 Cron 工作的各种要求将成为文章其余部分中的一个主题，显然会影响我们的可靠性要求。

+

一些 Cron 作业是幂等的，并且在系统故障的情况下，可以安全地多次运行它们，例如垃圾收集，但是其他 Cron 任务则不然，例如，一个发送电子邮件的任务显然就不应该如此。

+

这种各种各样的 Cron 工作让我们难以定义故障模式：对于像 Cron 这样的服务，没有一个适合各种情况的单一答案。在本文中，我们倾向于采用跳过执行这种方法，而不是像其他基础架构那样采用有风险的再次运行。Cron 管理员可以（并且应该）监视他们的 Cron 任务，例如通过使 Cron 服务为其管理的任务显示状态，或者设置对 Cron 任务的影响的独立监控。如果跳过运行，Cron 管理员可以采取与任务性质相符的行动。相比之下，撤销再次运行可能就很困难了，在某些情况下（考虑发邮件的例子）甚至是不可能的。所以，我们更倾向于失效关闭（fail closed），避免系统自动地创建出不良状态。

+

大规模Cron系统

从单机迁移到大规模部署需要对如何使 Cron 在这样的环境中良好运行做一些根本性的反思，在介绍 Google Cron 解决方案的详细内容之前，让我们先讨论一下这些差异及其在设计上需要做的改变。

+

基础设施扩展

普通 Cron 限于单机，然而，对于大规模的系统部署，我们的 Cron 解决方案却不能与单机绑定。假设如果我们一个单独的数据中心有 1000 台机器，那么只要有 1/1000 的机器发生故障都将会引起整个 Cron 服务不可用，显而易见，这肯定是不可接受的。

+

为了解决这个常见的问题，我们将任务进程与物理机器解耦。如果你想要运行某个服务，只需指定在哪个数据中心运行以及要运行的服务，然后数据中心内的任务调度系统（data center scheduling system，本身应该是可靠的）就可以接管并决定要哪些机器去运行它。“在数据中心中运行一个任务”就有效的转换为“发送一个或多个RPC请求到数据中心的调度程序”。

+
+

说明：google的实现中，Cron Service不负责具体的任务执行，只负责发起任务和接收结果。具体任务执行通过RPC调用，转给数据中心内的任务调度（分发）系统来安排，任务调度系统根据任务所需的资源分配具体执行的机器、 容器节点。google的基建已经很完善了，所以本文的重点也仅限于描述Cron Service的实现。
业界部分分布式调度系统实现将整个系统拆分为调度(schedular)和执行(executor)两个独立模块，调度只负责管理任务和状态存储，但是具体的调度交给executor去完成。

+
+

但是，任务进程执行是需要时间的，有可能发生在 发现机器宕机（健康检查超时）和 将作业重新调度到不同机器（软件安装，过程启动时间）之间。

+

由于将任务进程移动到不同的机器，那就可能意味着可能存在丢失存储在旧机器上的任何本地状态（除非采用实时迁移），并且重新调度时延可能会超过cron最小时间间隔一分钟，所以我们应该清楚如何应对这个情况。最明显的选择之一是简单地将状态保存在分布式文件系统（如GFS）上，并在启动期间使用它来识别由于重新安排而无法启动的作业，这种方案可以让作业快速失败，但是，如果是每五分钟运行一次 Cron 作业，那么由于重新调度导致的延迟时间是一分钟或两分钟，那么这个时间间隔其实就长调度周期的很大一部分了。

+

对需求的扩展

将Cron系统部署到整个数据中心级别，一般来说意味着将进程部署到容器中，以便更好地进行资源隔离。在这里，隔离是很有必要的，因为数据中心中每个独立进程不会互相影响是一个基础性假设。为了保证这种假设有效，我们必须在每个进程运行之前知道它预计使用的资源—不管是Cron系统本身，还是该系统所要运行的任务。某个Cron任务可能由于数据中心没有足够资源满足该任务而延迟。这种资源要求，加上用户对任务运行情况的监控需要，使得我们需要记录Cron任务的全过程，从预计执行一直到任务终止。

+

将进程启动过程与具体运行的机器分离使得整个Cron系统需要处理“部分失败”（partial launch failures）的故障类型。Cron任务的多样性意味着某些任务在启动的时候可能需要发送多个RPC，有时我们会遇到某个RPC成功，而其他RPC不成功的问题（例如，发送RPC的进程本身在发送过程中崩溃了）。Cron 故障恢复过程必须要处理这种情况。

+

在讨论故障模式的时候，一个数据中心相比单个物理机来说是一个更加丰富的生态系统。Cron服务，当大规模部署时从一个简单的二进制文件演变成了一个具有许多明显和不明显的依赖的服务。对Cron这样的基础服务来说，必须保证在数据中心遇到部分故障的时候（例如部分供电系统故障，或者存储系统故障），整个服务仍然能够正常运行。通过在数据中心内部分散地同时运行多份调度器的副本，我们可以避免单个供电单元故障造成整个Cron系统不可用。

+

将Cron服务部署在全球范围内可能是可行的，但是将Cron部署在一个单独的数据中心中有其对应的好处：该服务与其对应的数据中心任务分发系统延迟很低，同时共享一个故障域。毕竟，数据中心任务分发系统是Cron服务的一个核心依赖。

+

google Cron系统的构建过程

本节主要展示构建一个可靠的大型分布式Cron系统所必须要解决的问题。同时也强调了Google的分布式Cron服务的几个设计要点。

+

跟踪Cron任务的状态

如上一节所述，我们需要记录关于Cron任务的一些状态信息，并且必须能够在系统发生故障的时候快速恢复。更重要的是，该状态信息的一致性是关键！还记得前文所述的那些发送邮件和计算工资之类的非幂等的Cron任务吗？
跟踪任务的状态有两个选项：

+

● 将数据存储在一个可用度很高的外部分布式存储上。
● 系统内部自行存储一些（很小量的）状态信息。

+

当Google设计分布式Cron任务的时候，我们选择的是第二个选项。这样选择的原因有以下几个：
● 分布式文件系统，包括GFS和HDFS通常用来存储非常大的文件（例如，网页爬虫程序的输出文件），而我们需要存储的Cron任务状态信息通常来说是非常小的。小型写操作在分布式文件系统上的开销很高，同时延迟也很高，因为这些文件系统就不是为这种类型的写操作进行优化的。
● 基础服务，也就是那些失效时会带来许多副作用的（就像Cron这样的）服务应该依赖越少越好。即使数据中心的一部分出现故障，Cron服务也应该能够持续工作一段时间。但是这个要求并不一定意味着存储区域一定要在Cron进程内部（存储部分其实只是一个实现细节）。然而，Cron服务应该可以独立于下游系统而运行，以便服务更多的内部用户。

+
+

说明：之前了解的一些外部开源实现方案中，部分采用了mysql、redis之类的外部依赖来存储状态数据，好处是实现简单，不用考虑数据一致性问题。坏处在于加入了第三方的依赖，而且也没有解决唯一主调度的问题，需要额外引入etcd等组件来完成竞争锁等机制。google的实现引入了Paxos组件来解决选举及数据同步的问题。

+
+

The Use of Paxos

我们为Cron服务部署了多个副本，同时采用Paxos分布式共识算法保证它们状态的一致。就算某些基础设施出现故障，只要整个组中大多数成员可用，整个分布式系统就可以顺利地进行状态变更。

+

分布式 Cron 使用单个主副本，如图所示，它是唯一可以修改共享状态的副本，也可以是启动 Cron 作业的唯一副本。我们利用 Paxos 的变体（称为 Fast Paxos）在内部使用主副本作为优化 - Fast Paxos 主副本也充当Cron服务主机。

+

Reliable Cron across the Planet: The Interactions Between Distributed Cron Replicas

+

如果主副本崩溃了，Paxos 组的健康检查会很快发现这个问题（通常在几秒之内）。由于已经有另外几个Cron进程处于启动状态，所以可以很快地选举出一个新的主副本。一旦新的主副本选举出来，根据Cron服务自定义的选举过程使得新的主副本进程接手之前领头人未完成的工作。虽然Cron服务的主副本进程和Paxos协议的主副本进程其实是一个，但是Cron主副本在选举结束后需要完成一系列额外的操作。选举速度很快，使我们可以很轻松地保证在可接受的一分钟故障时间内进行故障切换。

+

各个副本利用Paxos协议同步的最重要的状态信息就是哪些Cron任务已经被启动了。该服务需要不停地以同步方式通知大多数的副本每个计划任务的启动和结束信息。因为每个任务的调度周期计算时需要了解上次的执行起止时间。

+

主从副本角色

正如前文所述，Cron服务使用Paxos协议分配两个角色：领导者(主副本、the master)和追随者(从副本、the slave)。下文会详述每种角色的职责。

+

The Master

主副本进程是唯一一个主动启动Cron任务的进程。该进程内部有一个内置调度器，与本章开头提到的简单的crond实现非常类似。该调度器按照预定的启动时间排序维护一个Cron任务列表。进程在第一个任务的预期执行时间之前一直处于等待状态。当到达预定启动时间时，主副本宣布它将要开始启动该Cron任务，同时计算新的（下一次的）启动时间，和普通的crond实现一样。当然，与普通的crond类似，自从上次执行过后，Cron任务的启动条件可能已经变化了，这些启动信息也必须同步给其他所有的副本角色。简单地标记某个Cron任务是不够的，应该将某次启动时间作为唯一标识符标记；否则在记录Cron任务的启动时可能会产生歧义（这种歧义通常出现在那些高频任务中，比如那些每分钟运行一次的任务）。如所示，全部通信都是基于Paxos协议之上完成的

+

Reliable Cron across the Planet: Progress of a Cron Job Launch

+

Paxos 通信的同步性是很重要的，Cron任务的实际启动在得到Paxos法定仲裁过程结束之前不会进行。Cron服务需要知道每个任务是否已经启动了，这样才能在主副本切换的时候决定正确的操作。如果这些操作是异步进行的，可能意味着整个任务的启动过程都在主副本进程上已完成，而没有通知到其他的副本。当故障切换的时候，新的主副本可能会重新进行这次启动，因为它们不知道这个任务已经被启动过一次了。

+

Cron任务启动过程的完成也需要通过Paxos协议同步通知给其他的副本。要注意的是，我们这里仅仅记录了Cron服务在某个时间试图进行一次启动操作，并不关心这次启动是否真正成功或者是否由于外部原因失败了（例如，如果数据中心任务分发系统当前不可用）。下文会提到如何处理发生在这项操作过程中的问题。

+

另外一个作为主副本角色非常重要的功能是，当其由于各种原因失去主副本角色时，该进程必须立刻终止一切和数据中心任务分发系统之间的交互。主副本角色必须意味着对数据中心级别任务分发服务的独占性。如果缺少了这种独占性，新旧主副本进程同时进行相互冲突的操作。

+

The Slave

从副本需要持续跟踪主副本进程提供的目前的系统状态，以便在需要的时候及时替换。所有的状态改变都是从主副本角色基于Paxos协议传递的。就像主副本角色那样，从副本也必须要维护系统中所有Cron任务的列表，这个列表必须在所有副本中保持一致（这就是要使用Paxos协议的原因）。

+

当接收到某个已经执行的“启动”通知时，从副本需要更新该副本内部该任务的下次预计启动时间。这项重要的状态改变（是同步进行的）保证了所有Cron任务在整个系统中的状态是一致的。我们同时也会记录所有的未完成启动。

+

如果主副本进程崩溃，或者由于其他某个原因不再正常工作（例如，由于网络分区问题无法联系到其他的副本），某个从副本进程将会被选举为新的主副本进程。该选举过程必须要在一分钟之内完成，这样可以避免大幅延迟或者跳过某个任务的执行。一旦一个新的主副本被选举出来，所有的未完成状态的启动过程必须被结束。这个过程可能是很复杂的，通常需要Cron系统和数据中心基础服务的共同协作才能完成。下面这一小节会详细讨论如何解决这种部分性失败情况。

+

解决部分性失败问题

正如上文所述，主副本进程和数据中心调度系统之间的单个任务启动的过程可能在多个RPC中间失败。我们的系统应该能处理这种状况。
前文说过，每个任务启动都具有两个Paxos同步点：

+

● 当任务启动执行之前
● 当任务启动执行之后

+

这两个同步点使我们可以界定每一次具体的启动。就算启动过程仅仅需要一个RPC，我们怎么能够知道这个RPC是否已经发出了呢？这里还包括在标记启动已经执行之后，但是启动结束通知发送之前主副本进程就崩溃了的情况。

+

为解决部分失败的问题，有两种思路可选：

+

● 所有需要在选举过后继续的任务，对外部系统的操作必须是幂等的（这样我们可以在选举过后重新进行该操作）。
● 必须能够通过查询外部系统状态来无疑义地决定某次操作是否已经成功。

+

这两个选项中的任意一个都是很大的挑战，可能很难实现。但是实现其中的至少一个是在大型分布式系统中应对单点或多点故障并准确运行一个Cron系统的前提。如果没有正确地处理这些情况，可能会导致错过某些任务的执行，或者重复运行某些任务。

+

在数据中心中管理逻辑性任务的大部分基础设施（例如Mesos）会为这些任务提供某种命名服务，使我们可以通过这些名字查找任务状态、停止任务，或者进行其他的维护操作。一种解决幂等性问题的方案是提前构建一致的任务名称，并且分发给所有的Cron服务副本（这样就可避免在数据中心调度器上进行任何的修改操作）。如果主副本在启动过程中崩溃，新的主副本可以通过预计算的任务名称来查询任务的状态。

+

上文说过，我们在副本之间同步信息的时候会记录预期启动时间。同样的，我们需要将Cron服务与数据中心调度器的交互也使用预期启动时间唯一标识。例如，假设有一个高频运行的，但是运行时间很短的任务。该任务成功启动，但是在启动成功的信息同步到其他副本之前，主副本进程崩溃了。同时故障切换机制由于某种问题造成了延迟，迟到足够这个任务已经结束了。新的主副本进程查询该任务的状态，发现该任务目前处于完成状态，于是尝试再次启动该任务。如果预期启动时间被包含在任务名中，新的领头人副本就可以准确地知道这个任务其实是任务的某个特定启动，于是就避免了这种双重启动情况的发生。

+

在实际的实现中，状态的查询由一个比较复杂的系统组成，这主要是由于底层基础设施的实现细节所决定的。然而，前面的描述适用于任何系统。取决于具体的基础设施，实现者可能要在双重启动的风险和错过启动的风险中进行抉择。

+
+

说明：失败问题应该是整个系统最复杂的部分，仅依靠Cron Service自身是无法解决的，需要借助数据中心调度系统等外部能力。其中一种幂等性问题的解决方案是给每次调度唯一的id。任务执行中或结束后更新相关任务状态到外部系统，容灾切换后新的主副本在执行前先查询上次的执行结果，避免重复执行。

+
+

状态存储

使用Paxos 协议来达成共识只是状态问题的一部分。Paxos 基本上是一个只能新增的日志，在每次状态变化后同步地新增。Paxos协议的这种特性意味着以下两个问题：日志需要定期压缩，以防无限增长；日志必须要存储在某个地方。

+

为了避免Paxos日志的无限增长，可以简单地将目前的状态进行一次快照（snapshot）。这就意味着我们可以不再需要重新回放之前的所有状态改变来得到目前的状态。提供一个例子：如果我们的状态变化存储在日志中的时候是“将某个计数器加1”，那么在1000次迭代之后，可以用一个“将计数器设置为1000”来替代1000条记录。

+

在日志丢失的情况下，我们只会丢失上次快照之后的信息。快照也是我们最重要的状态信息—如果丢失快照信息，我们就必须从零开始，因为已经丢失了全部内部状态。相比之下，丢失日志仅仅会将Cron系统重置回上次快照的时间。

+

存储数据有两个方案：● 外部可用的分布式存储。● 在系统内部存储少量的数据。当设计该系统时，我们采取了一个综合两个选项的方案。

+

我们将Paxos日志存储在服务副本运行的本地磁盘上。在标准情况下，我们有三个副本运行，也就是有三份日志。同时我们也将快照信息保存在本地磁盘上，然而因为这些信息很重要，会同时将它们备份到一个分布式存储上去。这样可以为三个机器同时出现问题的情况提供保护。

+

我们并不将日志直接存储在分布式文件系统上。我们认为丢失日志，也就是丢失一小部分最近的状态改变是一个可以接受的危险。将日志保存在分布式文件系统上可能会造成很严重的性能问题—由大量的小型写操作引起。三个机器同时出现故障是很罕见的，而且如果的确同时发生故障了，我们会自动从快照中恢复。于是，我们仅仅只会丢失一小部分日志信息：这些都是自从上次快照之后产生的。而快照是根据预先配置的时间间隔自动产生的。当然，这些妥协可能根据基础设施的细节而不同，也与Cron系统本身的要求有关系。

+

除了在本地存储的日志和快照，以及分布式文件系统上的快照备份之外，一个刚刚启动的副本可以从另外一个已经运行的副本上获得最新的快照和日志。这个能力使得启动过程可以独立于本地物理机器的任何状态。因此，将系统的某个副本重启，重新调度到另外一台物理机器上（或者由于物理机器故障原因迁移）对服务稳定性来说没有影响。

+

Running a Large Cron

运维一个大型Cron系统同样有一些较小但是也很有趣的问题。传统的Cron系统规模通常很小，最多可能由几十个任务组成。但是，如果我们在一个数千台机器的数据中心上运行Cron系统，系统的用量可能会大幅增加，同时可能会造成一定的问题。

+

一定要小心任何大型分布式系统都熟知的问题：惊群效应（thundering herd）。根据用户的配置，Cron服务可能会造成数据中心的峰值效应。当人们想要配置一个“每日任务”时，他们通常会配置该任务在午夜时运行。这个配置可能在一台机器上还可行，但是当你的任务会产生数千个MapReduce工作进程的时候就不可行了。尤其是当其他30个团队也按照同样的配置在同一个数据中心来运行每日任务呢？为了解决这个问题，我们在crontab 格式上增加了一些扩展。

+

在普通crontab格式中，用户用分钟、小时、月中的日期（或者周内的日期），以及月份来标记某个任务应该运行的时间，或者使用“*”来标记任意值。每天在午夜时候运行会将crontab标记为“0 0 * * *”（也就是0分0时，月内的每一天，每个月，以及周内的每一天都会运行）。我们在这里增加了一个问号“?”，意味着任意一个值都可以接受，Cron系统可以根据需要自行选择一个时间。用户可以将任务分散在整个事件序列里（例如[插图]中的某个小时），因此可以将这些任务分散得更为均匀。

+

就算引入了这个改动，Cron任务带来的系统负载仍然是非常尖锐的。如图所示的是，聚合过的Google全球Cron任务启动数量图。这个图片集中展示了Cron任务经常性的负载峰值，这是因为某些任务需要在特定时间启动—例如，由于对外部事件的某些临时依赖造成。

+

Reliable Cron across the Planet: The Number of Cron Jobs Launched Globally

+
+

说明：典型的峰值问题，根据实际情况想办法削峰即可。cron确实会存在这类问题。

+
+

Summary

A Cron service has been a fundamental feature in UNIX systems for decades. The industry move toward large distributed systems, where a data center may be the smallest unit of hardware, requires changes in large portions of the stack, and Cron is no exception. A careful look at the required properties of a Cron service and the requirements of Cron jobs drives our new design.

+

We have discussed the new constraints and a possible design of a Cron service in a distributed system environment, based on the Google solution. The solution requires strong consistency guarantees in the distributed environment. The core of the distributed Cron implementation is therefore Paxos, a common algorithm for reaching consensus in an unreliable environment. The use of Paxos and correct analysis of new failure modes of Cron jobs in a large-scale, distributed environment allowed us to build a robust Cron service that is heavily used at Google.

+

Acknowledgments

Many thanks to Dermot Duffy and Gabriel Krabbe (designers of the foundation of the system described in this article), Derek Jackson, Chris Jones, Laura Nolan, Niall Murphy, and all other contributors and reviewers for their valuable input on this article.

+

References

    +

  1. Burrows, M. 2006. The Chubby lock service for loosely-coupled distributed systems. Proceedings of the 7th Symposium on Operating Systems Design and Implementation: 335-350. http://research.google.com/archive/chubby-osdi06.pdf

    +
    2. +

  2. Corbett, J. C., et al. 2012. Spanner: Google’s globally-distributed database, Proceedings of OSDI’12. Tenth Symposium on Operating System Design and Implementation. http://research.google.com/archive/spanner-osdi2012.pdf

    +
    3. +

  3. Docker. https://www.docker.com/

    +
    4. +

  4. Junqueira, F. P., Reed, B. C., Serafini, M. 2011. Zab: High-performance broadcast for primary-backup systems. Dependable Systems & Networks (DSN), 2011 IEEE/IFIP 41st International Conference: 245-256. http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=5958223&tag=1

    +
    5. +

  5. Lamport, L. 2001. Paxos made simple. ACM SIGACT News 32 (4): 18-25, http://research.microsoft.com/en-us/um/people/lamport/pubs/pubs.html#paxos-simple

    +
    6. +

  6. Lamport, L. 2006. Fast Paxos. Distributed Computing 19 (2): 79-103, http://research.microsoft.com/pubs/64624/tr-2005-112.pdf

    +
    7. +

  7. Ongaro, D., Ousterhout, J. 2014. In search of an understandable consensus algorithm (extended version). https://ramcloud.stanford.edu/raft.pdf

    +
    8. +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2021/12/04/Application-Tracking/index.html b/2021/12/04/Application-Tracking/index.html new file mode 100644 index 0000000..72ef3e3 --- /dev/null +++ b/2021/12/04/Application-Tracking/index.html @@ -0,0 +1,907 @@ + + + + + + + + + Application Tracking | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Application Tracking +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.2k字 + + + + +   |   + + + 阅读时长≈ + 4分 + + +
+ + + +
+ +
+ +

整理下目前业务已有的监控能力以及相关指标、维度。大部分开发关注的可能只是自身服务的质量，缺乏对整体链条监控的了解。业务的发展过程中，出现过太多非后端服务质量导致的异常，所以要求开发能对服务整体的监控能力有所了解。

+ + +

后台逻辑服务层

后端逻辑服务，目前主要基于123+007平台。

+
    +

  • 【下游】trpc主调

    +
      +
    • 指标：请求量、耗时、失败率（区分超时、异常）
      • +
    • 维度：（下游）服务-接口、ip、返回码
      • +
    +
    • +

  • 【自身】trpc被调

    +
      +
    • 指标：请求量、耗时、失败率（区分超时、异常）
      • +
    • 维度：（本服务）服务名-接口、ip、返回码
      • +
    +
    • +

  • 【自身】trpc属性监控

    +
      +
    • 指标：业务自定义指标，包括trpc框架自动上报性能指标，如goroutine数、node event loop lag等。
      • +
    • 维度：可按单机展开
      • +
    +
    • +

  • 【自身】容器负载

    +
      +
    • 指标：cpu、内存、磁盘、带宽
      • +
    • 维度：可按单机展开
      • +
    +
    • +
+

总结

+
    +
  • 优势：对下游监控完善，容器负载监控可以覆盖自身大部分异常
    • +
  • 不足：服务内部异常（如内部block导致出现服务毛刺等）依赖业务自身上报【自身异常也可以通过上游发现】
    • +
+

业务接入层

实现取决于业务团队能力，小团队一般直接用nginx等API网关即可，有能力的团队可以自行开发。目前业务使用了两层。

+

平台服务统一接入层

统一后端各接口的路由分发，由平台统一开发、维护。
监控方案同后台逻辑服务层，主要关注后端各服务的访问量及质量监控，同时也提供一些通用基础能力，包括：频率限制、协议转换、安全鉴权等。

+

【下游】业务接入层

历史原因，项目中目前采用nginx。定位同上面的后端服务统一接入层类似。

+
    +
  • 指标：基于nginx插件模式开发，包括请求量、失败率
    • +
  • 维度：ip、cgi、业务渠道
    • +
+

总结

+
    +
  • 优势：可靠，监控到所有下游业务逻辑层的对外质量
    • +
  • 不足：
      +
    • 自身缺乏监控（如容器异常）：—— 可以通过上游监控间接发现（ias、sparta）；
      • +
    +
    • +
+

【下游】公司接入层IAS、Sparta

公司接入层目前监控实现也基于007。

+
    +
  • 指标：QPS、转发成功率、请求数（http/https）、耗时（总、rs处理）、https返回状态码、RS（连接、处理耗时）
    • +
  • 维度：RS-IP:Port、Cgi-Path（仅path1）、clb:rs返回码、节点ip、set
    • +
+

总结

+
    +
  • 优势：通常可以明确判断是否为内部服务异常or用户侧/厂商服务异常。ias的007监控指标也能反应整体服务质量。
    • +
  • 不足：
      +
    • 自身缺乏监控（ias/sparta早期bug较多…）：—— 只能通过上游监控间接补齐部分（比如失败量大时的拨测、客户端质量上报）；
      • +
    +
    • +
+

终端

【上游】客户端cgi质量上报

客户端(native)网络库采样上报，采样率：失败时100%，正常10%

+
    +
  • 指标：总量、失败、耗时（curl连接、传输）
    • +
  • 维度：域名、pt、chid、返回码（包括http、网络异常）、cgi、version、http/https、是否ipV6、服务端ip【公司接入层or用户网关代理】、运营商、地区（省/城市）
    • +
+

总结

+
    +
  • 优势：能反应整体趋势；
    • +
  • 不足：
      +
    • 依赖后端的分析上报系统建设的完善程度。目前为atta接入007。基本可用
      • +
    • 本地无法区分本地网络异常（比如tv端设备刚开机时调用的接口失败率普遍偏高）——影响分析
      • +
    +
    • +
+

【上游】【自身】web页面监控

目前基于公司aegis平台，将aegis-sdk集成到各页面。

+
    +
  • 指标：页面性能相关（加载瀑布图、首屏耗时）、api质量相关（cgi访问量、耗时、成功率）、页面访问（pv/uv）、页面资源？
    • +
  • 维度：地区、运营商、浏览器
    • +
+

总结

+
    +
  • 优势：指标丰富，包含服务质量、页面性能、错误日志等
    • +
  • 不足：仅限于web；对hybird支持不够友好。
    • +
+

【上游】拨测

基于腾讯云云拨测平台，与cgi质量上报类似

+
    +
  • 指标：耗时、失败率
    • +
  • 维度：自行配置拨测url、频率
    • +
+

总结

+
    +
  • 优势：不存在本地网络异常问题
    • +
  • 不足：监控点有限（约18个地区✖️平均3个运营商）、频率低
    • +
+

其他补充

    +

  • ifeedback用户反馈分析

    +
      +
    • 优势：用户层面的异常+关键字集中告警
      • +
    +
    • +

  • 链路追踪
    问题定位辅助工具，能快速定位链路相关异常。

    +
    • +

  • 安全监控
    依赖安全中心监控平台

    +
    • +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2022/01/07/Open-Tracing/index.html b/2022/01/07/Open-Tracing/index.html new file mode 100644 index 0000000..c9c04a2 --- /dev/null +++ b/2022/01/07/Open-Tracing/index.html @@ -0,0 +1,968 @@ + + + + + + + + + Open Tracing | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Open Tracing +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 3.2k字 + + + + +   |   + + + 阅读时长≈ + 12分 + + +
+ + + +
+ +
+ +

最近在阅读微服务相关书籍时，提到了微服务相关的监控措施，其中分布式追踪就属于其中不可或缺的一部分，恰好之前也有计划在团队内引入，所以就花了两天时间稍微深入了解了一下相关概念和实现。动手实验了一遍jaeger提供All-In-One+HotROD示例，也大致了解了其基本原理和实现思路。时间关系就没有去学习jaeger之类的系统源码了，深入了解其存储方案之类的细节了，感觉必要性不大。

+ + +

为什么需要Tracing

微服务在部署上线后，需要有一套完善的监控体系来监控服务的质量。可观察性就是更关注的是从系统自身出发，去展现系统的运行状况，为开发运营人员提供故障排查、维护及优化的相关信息。

+

可观察性目前主要包含以下三大支柱：

+
    +
  • 日志（Logging）：Logging 主要记录一些离散的事件，应用往往通过将定义好格式的日志信息输出到文件，然后用日志收集程序收集起来用于分析和聚合。虽然可以用时间将所有日志点事件串联起来，但是却很难展示完整的调用关系路径；
    • +
  • 度量（Metrics）：Metric 往往是一些聚合的信息，相比 Logging 丧失了一些具体信息，但是占用的空间要比完整日志小的多，可以用于监控和报警，在这方面 Prometheus 已经基本上成为了事实上的标准；
    • +
  • 分布式追踪（Tracing）：Tracing 介于 Logging 和 Metric 之间，以请求的维度来串联服务间的调用关系并记录调用耗时，即保留了必要的信息，又将分散的日志事件通过 Span 串联，帮助我们更好的理解系统的行为、辅助调试和排查性能问题。
    • +
+

Tracing及OpenTracing

分布式追踪（Tracing）是一种用于分析和监视应用程序的方法，特别是那些使用微服务体系结构构建的应用程序；分布式追踪有助于查明故障发生的位置或导致性能低下的原因，开发人员可以使用分布式追踪来帮助调试和优化他们的代码，IT 和 DevOps 团队可以使用分布式追踪来监视应用程序。

+

分布式追踪系统的核心步骤一般有三个：代码埋点，数据存储、查询展示。

+

OpenTracing 旨在标准化 Trace 数据结构和格式，其目的是：

+
    +
  • 不同语言开发的 Trace 客户端的互操作性。各语言开发的客户端，只要遵循 OpenTracing 规范，就都可以对接 OpenTracing 兼容的监控后端。
    • +
  • Tracing 监控后端的互操作性。只要遵循 OpenTracing 规范，企业可以根据需要替换具体的 Tracing 监控后端产品，比如从 Zipkin 替换成Jaeger/CAT/Skywalking 等后端。
    • +
+

OpenTracing 数据模型

核心概念：

+
    +
  • Trace (调用链/链路)：在广义上，一个 Trace 代表了一个事务或者流程在（分布式）系统中的执行过程。一个 Trace 是由多个 Span 组成的一个有向无环图（DAG），每一个 Span 代表 Trace 中被命名并计时的连续性的执行片段。
    • +
  • Span (跨度)：一个 Span 代表系统中具有开始时间和执行时长的逻辑运行单元，即应用中的一个逻辑操作。Span 之间通过嵌套或者顺序排列建立逻辑因果关系。一个 Span 可以被理解为一次方法调用，一个程序块的调用，或者一次 RPC / 数据库访问，只要是一个具有完整时间周期的程序访问，都可以被认为是一个 Span。
    • +
  • Logs：每个 Span 可以进行多次 Logs 操作，每一次 Logs 操作，都需要一个带时间戳的时间名称，以及可选的任意大小的存储结构。
    • +
  • Tags：每个Span可以有多个键值对（key:value）形式的 Tags，Tags 是没有时间戳的，支持简单的对 Span 进行注解和补充。
    • +
  • SpanContext：SpanContext 更像是一个“概念”，而不是通用 OpenTracing 层的有用功能。在创建 Span、向传输协议 Inject（注入）和从传输协议 中Extract（提取）调用链信息时，SpanContext 发挥着重要作用
    • +
+

Traces

Trace 描述在分布式系统中的端到端事务，例如来自客户端的一个请求从接收到处理完成的过程。一个 Trace 可以被认为是由一个或多个 Span 组成的有向无环图（DAG）。

+

以下为从jaeger中摘录出的trace记录：

+
"traceID":"3b6ca8e6f4b0a696",
"spans":Array[51],
"processes":Object{...},
"warnings":null
+ +

重点字段：

+
    +
  • Spans: 为整个Trace包括的Span数组，根据Span信息以及内部Reference形成完整DAG。
    • +
  • process：为全链条涉及到的具体模块信息，在Span中会被引用。这个是否是标准的一部分？
    • +
+
"processes": {
"p1":{
  "serviceName":"driver",
  "tags":[
    {
      "key":"client-uuid",
      "type":"string",
      "value":"5aa0df28d025a501"
    },
    {
      "key":"hostname",
      "type":"string",
      "value":"m-mac"
    },
    {
      "key":"ip",
      "type":"string",
      "value":"192.168.1.1"
    },
    {
      "key":"jaeger.version",
      "type":"string",
      "value":"Go-2.30.0"
    }
  ]
},
}
+ +

Span

表示分布式调用链条中的一个调用，可以理解为一次方法调用或者一次 RPC / 数据库访问。只要是一个具有完整时间周期的程序访问，都可以被认为是一个 Span 。

+

一个 Span 一般会记录这个调用单元内部的一些信息，例如每个 Span 包含的操作名称、开始和结束时间、附加额外信息的 Span Tag、可用于记录 Span 内特殊事件 Span Log 、用于传递 Span 上下文的 SpanContext 和定义 Span 之间关系的 References 。

+

以下为从jaeger中摘录出的span记录：

+
"spans":[
  {
    "traceID":"3b6ca8e6f4b0a696",
    "spanID":"00ad43f5f41c8a69",
    "flags":1,
    "operationName":"/driver.DriverService/FindNearest",
    "references":[
      {
        "refType":"CHILD_OF",
        "traceID":"3b6ca8e6f4b0a696",
        "spanID":"29e6aba07e2ad32f"
      }
    ],
    "startTime":1641536033862574,
    "duration":231910,
    "tags":[
      {
        "key":"span.kind",
        "type":"string",
        "value":"server"
      }
    ],
    "logs":[
      {
        "timestamp":1641536033862601,
        "fields":[
          {
            "key":"event",
            "type":"string",
            "value":"Searching for nearby drivers"
          },
          {
            "key":"level",
            "type":"string",
            "value":"info"
          },
          {
            "key":"location",
            "type":"string",
            "value":"115,277"
          }
        ]
      }
    ],
    "processID":"p1",
    "warnings":null
  },
]
+ +

重点字段：

+
    +

  • 操作名称 (An operation name): operationName

    +
    • +

  • 开始时间 (A start timestamp): startTime

    +
    • +

  • 时长：duration

    +
    • +

  • 标签信息 (Span Tag)：零个或多个键值对（keys:values）组成的 Span Tags。

    +

    规范中也约定了一些通用tag，包括：

    +
      +
    • HTTP Server Tags：作用于基于HTTP的服务入口的span，keys包括http.url、http.method、http.status_code、span.kind等
      • +
    • Peer tags：这些tag可以被客户端或者服务端提供，用于描述远程请求过程中，请求调用的方向。（客户端记录下行访问，服务端记录上行访问）。keys包括peer.hostname, peer.port, peer.service等。
      • +
    +
    • +

  • 日志信息 (Span Log)：零个或多个 Span Logs。每次 log 操作包含一个键值对和一个时间戳。键值对中，键必须为 string类型，值可以是任意类型。但并不是所有的支持 OpenTracing 的 Tracer 都需要支持所有的值类型。

    +
    • +

  • References：该Span引用的其它关联Span，主要有两种引用关系，Childof 和 FollowsFrom。

    +
      +
    • Childof：最常用的一种引用关系，表示 Parent Span 和 Child Span 之间存在直接的依赖关系。例PRC 服务端 Span 和 RPC 客户端Span，或者数据库 SQL 插入 Span 和ORM Save 动作 Span 之间的关系。
      • +
    • FollowsFrom：如果Parent Span 并不依赖 Child Span 的执行结果，则可以用FollowsFrom 表示。例如网上商店购物付款后会向用户发一个邮件通知，但无论邮件通知是否发送成功，都不影响付款成功的状态，这种情况则适用于用FollowsFrom 表示。
      • +
    +
    • +
+

SpanContext

分布式追踪的上下文信息，包括 Trace id，Span id 以及其它需要传递到下游服务的内容。一个 OpenTracing 的实现需要将 SpanContext 通过某种序列化协议 (Wire Protocol) 在进程边界上进行传递，以将不同进程中的 Span 关联到同一个 Trace 上。对于 HTTP 请求来说，SpanContext 一般是采用 HTTP header 进行传递的。

+

SpanContext 是 OpenTracing 中一个让人比较迷惑的概念。在 OpenTracing 的概念模型 SpanContext 用于跨进程边界传递分布式调用的上下文，但实际上 OpenTracing 只定义一个 SpanContext 的抽象接口，该接口封装了分布式调用中一个 Span 的相关上下文内容，包括该 Span 所属的 Trace id，Span id 以及其它需要传递到下游服务的信息。

+

SpanContext 自身并不能实现跨进程的上下文传递，而是需要由 Tracer（Tracer 是一个遵循 OpenTracing 协议的实现，如 Jaeger，Skywalking 的 Tracer） 将 SpanContext 序列化后通过 Wire Protocol 传递到下一个进程中，然后在下一个进程将 SpanContext 反序列化，得到相关的上下文信息，以用于生成 Child Span。

+

为了为各种具体实现提供最大的灵活性，OpenTracing 只是提出了跨进程传递 SpanContext 的要求，并未规定将 SpanContext 进行序列化并在网络中传递的具体实现方式。各个不同的 Tracer 可以根据自己的情况使用不同的 Wire Protocol 来传递 SpanContext。

+

在基于 HTTP 协议的分布式调用中，通常会使用 HTTP Header 来传递， SpanContext 的内容。常见的 Wire Protocol 包含 Zipkin 使用的 b3 HTTP header，Jaeger 使用的 uber-trace-id HTTP Header，LightStep 使用的 “x-ot-span-context” HTTP Header 等。

+

将jaeger Hot R.O.D example中的demo稍作修改，打印出server端收到请求的header信息：

+
 
Header field "Uber-Trace-Id", Value ["29f4561f77c249c3:59ebcdc4f3a29e20:5eeb5a2763093c4d:1"]
Header field "Uberctx-Request", Value ["6146-1"]
Header field "Uberctx-Session", Value ["6146"]
Header field "Accept-Encoding", Value ["gzip"]
+ +

可以看到Uber-Trace-Id中的携带的traceID、spanid等信息。其中spanid包括主调用方（发起http 调用的服务）和被调用方（接收http调用的服务）两部分。

+

主调用方span：

+
"traceID": "29f4561f77c249c3",
"spanID": "59ebcdc4f3a29e20",
"flags": 1,
"operationName": "HTTP GET",
+ +

被调用方span：

+
"traceID": "29f4561f77c249c3",
"spanID": "5eeb5a2763093c4d",
"flags": 1,
"operationName": "HTTP GET: /customer",
+ +

实现

Opentracing不包括具体实现。Jaeger 主要有以下几个组成部分：

+
    +
  • Jaeger Client：为不同语言实现符合 OpenTracing 的 SDK。应用程序通过 API 写入数据，client library 把 trace 信息按照应用程序制定的采样策略传递给 jaeger-agent 。
    • +
  • Agent：一个监听在 UDP 端口上接收 span 数据的网络守护进程，它会将数据批量发送给 collector 。它被设计成一个基础组件，部署到所有的宿主机上。Agent 将 client library 和 collector 解耦，为 client library 屏蔽了路由和发现 collector 的细节。
    • +
  • Collector：接收 jaeger-agent 发送来的数据，然后将数据写入后端存储。Collector 被设计成无状态的组件，因此用户可以运行任意数量的 Collector。
    • +
  • Data Store：后端存储被设计成一个可插拔的组件，支持数据写入 cassandra ， elastic search 等。
    • +
  • Query：接收查询请求，从后端存储系统中检索 tarce 并通过 UI 进行展示。Query 是无状态的，可以启动多个实例并把它们部署在例如 nginx 这样的负载均衡器之后。
    • +
+

一些开源的分布式追踪系统对比：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
名称厂商语言OpenTracing 兼容侵入性时效性可视化消耗
JaegerUberGo是中高中低
ZipkintwitterJava是高高中低
PinpointNAVERJava否低-高低
CAT大众点评Java否高中高低
AppdashsourcegraphGo是低高低不支持大规模部署
SkyWalking华为Java是低中高低
+

相关链接

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2022/01/10/Microservices-in-Action/index.html b/2022/01/10/Microservices-in-Action/index.html new file mode 100644 index 0000000..a8682fd --- /dev/null +++ b/2022/01/10/Microservices-in-Action/index.html @@ -0,0 +1,1076 @@ + + + + + + + + + Microservices in Action | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Microservices in Action +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 3.7k字 + + + + +   |   + + + 阅读时长≈ + 12分 + + +
+ + + +
+ +
+ +

《微服务实战》读书笔记

+ + +

微服务的定义

三大关键特性

    +
  • 每个微服务只负责一个功能
    • +
  • 每个微服务都有自己的数据存储 // 低耦合，只能通过接口访问对方数据
    • +
  • 微服务自己负责编排和协作 // 高内聚？
    • +
+

两个基本特性

    +

  • 可独立部署 // 非庞大的单体应用

    +
    • +

  • 可替代

    +
    • +
+

微服务架构原则

    +

  • 自治性：松耦合，可独立部署

    +
    • +

  • 可恢复性：故障隔离，模块故障仅影响微服务自身。 // 是不是叫“隔离”更加合适

    +
    • +

  • 透明性：每个微服务有完整的日志、监控以及基础设施数据

    +
    • +

  • 自动化：保障系统频繁部署和运维的正确性，通过引入流水线or云函数

    +
    • +

  • 一致性：微服务需要考虑向后兼容，确保不需要强迫其他团队升级或者破坏服务之间的复杂交互。

    +
    • +
+

为何选择微服务

    +

  • 技术差异性：允许根据服务的特性选择不同的技术栈

    +
    • +

  • 系统复杂度会逐步增加：不断缩短的交付周期

    +
    • +

  • 降低重复和风险：灵活性、部署风险

    +
    • +
+

微服务的设计、运维挑战

    +

  • 划定微服务范围需要领域知识：如何划分某个服务的职责需要对领域有充分的理解。

    +
    • +

  • 良好的契约设计 // 多团队设计，需要服务契约保障完整、简洁及可预测（协议定义反映了真实表现）

    +
    • +

  • 分布式带来的风险：网络、带宽

    +
    • +

  • 故障点增多：微服务并不能消除风险，而是将这个成本移到了系统生命周期的后半阶段：降低了开发过程中的冲突，但是增加了运维阶段系统部署、验证以及监控的复杂度。

    +
    • +

  • 运维挑战：难以实现的可观测性、多故障同时出现（需要考虑服务的鲁棒性）

    +
    • +
+

微服务的开发生命周期

    +

  • 设计

    +
    • +

  • 部署

    +
      +
    • 复杂的部署过程就是“通下水道”（plumbing）【用来比喻一些价值不大的脏活累活，而不能为客户创造任何价值】。
      • +
    • 部署需要容器化、流水线化，尽可能的“单调”
      • +
    +
    • +

  • 监控

    +
      +
    • 发现潜在的薄弱环节并进行重构
      • +
    • 重点指标：业务指标、应用日志、运维指标和基础设施指标
      • +
    +
    • +

  • 其他：有责任感和运维意识的工程师文化

    +
    +

    康威定律：组织沟通方式会通过系统设计表达出来（沟通成本随着项目或者组织的人员增加呈指数级增长）

    +
    +
    • +
+

微服务的应用架构

整体架构

    +

  • 应用架构应该包含整个环境

    +
    • +

  • 架构师的职责

    +
      +
    • 准则——为了实现更高一层的技术目标或者组织目标，团队要遵循的一套指南
      • +
    • 概念模型——系统内部相互联系以及应用层面的模式的抽象模型
      • +
    +
    • +
+

四层架构：平台层、服务层、边界层（接入层）、客户端。

    +

  • 平台层：即基础设施，包括容器、LB、日志监控平台、部署流水线、安全解决方案（网络控制、涉密管理、安全加固）、通信信道和服务发现机制

    +
    • +

  • 服务层：

    +
      +

    • 功能分类：业务功能（业务逻辑）和技术能力（公共服务/组件）

      +
      • +

    • 职责分类：聚合器（aggregator，将底层服务数据关联后输出聚合查询结果）与协调器（coordinator，向下游发出各种指令并编配行动）// 感觉差别不大，只是读、写的区别

      +
      • +

    • 重要程度分类：关键路径与非关键路径。

      +
      • +
    +
    • +

  • 边界层（接入层）：

    +
      +

    • 职责：封装抽象底层能力、协议转换、认证鉴权、限流、缓存、日志和指标收集

      +
      • +

    • 几种不同的边界模式：

      +
        +

      • API网关：要避免将业务逻辑渗透到API网关中。

        +
        • +

      • BFF：根据终端来区分网关，API网关的一种变形

        +
        • +

      • 消费者驱动网关：GraphQL，可以把它看作BFF方案的一种进化版：不构建多个API，开发者可以只构建一个“超级”API来让消费者决定他们所需要的响应数据的样子。

        +
        • +
      +
      • +
    +
    • +

  • 客户端：前端单体、微前端

    +
    • +
+

微服务的事务与查询

分布式事务的一致性可选方案

+

分布式系统的查询

    +

  • 保存数据副本：带来的缓存失效问题。高可用容易，一致性难

    +
    • +

  • 命令-查询分离：CQRS架构

    +
      +
    • 优势：构建专门的查询服务，可以针对性优化，关注点分离
      • +
    • 问题：复制延迟（replication lag），需要考虑最终一致性
      • +
    • 可以缓解问题的方案：乐观更新、轮询、发布订阅
      • +
    +
    • +
+

设计高可靠服务

可用性定义

服务正常运行时间uptime/（服务正常运行时间uptime+故障时间downtime）。整体可用性不等于某个微服务的可用性

+

高可靠的通信方案

    +

  • 重试retry

    +
      +
    • 需要服务支持调用幂等性才允许实施。
      • +
    • 实现方案：python的tenacity等库支持，不用自己实现
      • +
    • 防止重试过来的雪崩：
        +
      • 指数退避(exponential back-off)：给系统一个较低负载的时间，用于恢复
        • +
      • 指数退避应包括随机元素（jitter）：避免涟漪效应（大量重试同时执行）
        • +
      • 限制次数、重试环境隔离
        • +
      +
      • +
    +
    • +

  • **后备(fallback)**方案：服务故障时可选的几种后备、替代方案

    +
      +
    • 优雅降级：故障时提供部分基础能力
      • +
    • 缓存：使用缓存数据（本地、远程）替换
      • +
    • 功能冗余：针对故障场景提供独立的服务、数据源来替代
      • +
    +
    • +

  • 超时：避免雪崩

    +
    • +

  • 熔断器（Circuit Breaker）：open、hallf-open、close状态。

    +
      +
    • 断路器需要发送试验性的请求，以判断连接是否恢复到健康状态。在这个试验状态中，断路器处于半开状态（half open）：如果调用成功，断路器就会闭合；否则，继续保持断开状态。
      • +
    +
    • +
+

最大限度地提供单个服务的可用性

    +

  • 负载均衡

    +
    • +

  • 限流

    +
    • +

  • 验证：压力测试和混沌测试

    +
    • +
+

构建可复用的微服务架构

微服务底座的重要性？

+

微服务部署

自动化

    +
  • 自动化的部署方案对于大规模微服务开发而言是必不可少的。
    • +
  • 比如Google的网站可靠性（site reliability）团队认为大概有70%的服务不可用是由于对生产环境的修改导致的
    • +
+

基于容器和调度器的部署

    +

  • 容器并不是使用微服务的必要条件。开发者可以使用许多方法来部署服务，比如使用单虚拟机单服务模型。但是借助调度程序，容器提供了一种特别优雅和灵活的方法来满足我们的两个部署目标：速度和自动化。

    +
    • +

  • 服务容器化：docker

    +
    • +

  • 集群部署：kubernetes

    +

    简化了对任意数量的独立服务的伸缩扩容、健康检查和发布的管理

    +
    • +
+

构建交付流水线

    +

  • 部署流水线是构建持续交付的核心基石

    +
    • +

  • 理想的微服务部署流程应该满足两大目标。

    +
      +
    • 节奏安全——新服务和变更的部署速度越快，开发者迭代开发和向终端用户交付成品的速度也就越快。部署工作应该尽可能提高安全性，开发者应该尽一切可能对给定的变更进行验证，确保其不会对服务的稳定性产生负面影响。
      • +
    • 一致性——不管底层采用哪种技术栈，各个服务都采用同一套部署流程有助于降低技术隔离，并使操作更具可预测性和可扩展性。
      • +
    +
    • +

  • 工具：Jenkins

    +
    • +
+

可观测（Observability）

可度量（Metrics）

Metric 往往是一些聚合的信息，相比 Logging 丧失了一些具体信息，但是占用的空间要比完整日志小的多，可以用于监控和报警，在这方面 Prometheus 已经基本上成为了事实上的标准

+
    +

  • 监控范围：我们讨论了架构层次：客户端、边界层、服务层和平台层。也应该把这4层都监控起来。

    +
    • +

  • 监控维度：四大黄金标志：时延、错误量、通信量（即请求量）和饱和度（承载能力）。

    +
      +
    • 饱和度：主要强调最能影响服务状态的受限制的资源。 例如，如果系统主要受内存影响，那就主要关注系统的内存状态，如果系统主要受限与磁盘I/O，那就主要观测磁盘I/O的状态。因为通常情况下，当这些资源达到饱和后，服务的性能会明显下降。同时还可以利用饱和度对系统做出预测，比如，“磁盘是否可能在4个小时候就满了”。
      • +
    +
    • +

  • 展示方式：聚焦于最重要的部分，还应当为每个指标设定合适的百分位：99分位、95分位、75分位。

    +
    • +
+

日志（Logging）

Logging 主要记录一些离散的事件，应用往往通过将定义好格式的日志信息输出到文件，然后用日志收集程序收集起来用于分析和聚合。虽然可以用时间将所有日志点事件串联起来，但是却很难展示完整的调用关系路径

+
    +

  • 采用一致的、结构化方式以机器可读的格式存储日志，包含时间戳、唯一seq、来源模块、level等信息。可借用外部工具like logstash

    +
    • +

  • 日志基础设施：配置完日志聚合功能后，所有服务就开始同时向中心化系统发送度量指标和日志信息了，这能够提高系统的可观测性。

    +
      +
    • 开源解决方案：ELK（Elasticsearch+Logstash+Kibana）+ Fluentd(收集器)
      • +
    +
    • +
+

分布式链路追踪（Tracing）

Tracing 介于 Logging 和 Metric 之间， 以请求的维度来串联服务间的调用关系并记录调用耗时，即保留了必要的信息，又将分散的日志事件通过 Span 串联，帮助我们更好的理解系统的行为、辅助调试和排查性能问题。

+
    +

  • OpenTracing 旨在标准化 Trace 数据结构和格式，它不是一个标准，OpenTracing API 提供了一个标准的、与供应商无关的框架，是对分布式链路中涉及到的一系列操作的高度抽象集合。

    +
    • +

  • OpenTracing API： 见相关规范

    +
    • +
+

微服务团队建设

限制团队规模

将工程师划分到不同的独立团队是组织发展壮大后很自然的结果。这对于帮助组织高效扩张是非常必要的。

+
    +

  • 小团队优势：

    +
      +
    • 确保沟通渠道保持可控（图13.1展示了沟通关系的增长）。这有助于增强团队的活力和协作，同时缓解冲突。对于团队的“合适规模”存在许多探索，比如JeffBezos的两块披萨规则或Michael Lopp的7+/−3公式。
      • +
    • 清楚地描述了团队的责任和义务，同时提高了独立性和灵活性。
      • +
    +
    • +

  • 带来的问题：

    +
      +
    • 团队之间会出现文化分裂，不同团队遵循和接受的是不同的质量实践或者工程价值观。
      • +
    • 团队在和其他团队协作时，需要投入额外的精力优先来协调存在竞争关系的事项。
      • +
    • 团队划分会造成专业知识的隔离，不利于了解全局或者整体效率
      • +
    • 团队间会存在重复工作，从而导致效率低下
      • +
    +
    • +
+

团队模型：两种组织团队的方式

    +

  • 按职能划分：如UI团队、后端、前端、测试、PMO等

    +
      +
    • 优势：能优化专业知识，有效分享知识和解决方案；职业发展和技能提升更加清晰。
      • +
    • 劣势：
        +
      • 所有权不清晰：没有哪个团队对业务结果或业务价值有明确的所有权，他们只是价值链中的一颗螺钉。
        • +
      • 缺乏自治：这些团队之间是紧密耦合的，而不是自治的。他们的工作优先级是在其他地方制订的，当工作需要跨多个团队时，团队被阻塞和开发工作被阻碍的可能性就会增加
        • +
      • 没有长期责任感：面向项目的方式不利于对所开发的代码或产品质量承担起长期责任。
        • +
      • 竖井风险：目标上出现分歧，不能为对方着想，无法进行有效的协作。
        • +
      +
      • +
    +
    • +

  • 跨职能分组：由具有不同专长和角色的人员组成，旨在实现特定的业务目标。我们可以将这些团队称为市场驱动型团队

    +
      +
    • 更加有利于微服务团队。优势：能更加快速的交付、沟通渠道短、协作本地化、目标一致。
      • +
    • 跨职能的团队应该有一个使命，这个使命是鼓舞人心的：它给团队提供了奋斗目标，但也设定了团队职责的边界
      • +
    +
    • +

  • 平台团队：负责基础设施的建设。构建一个微服务平台——部署流程、底座、工具操作和监控系统

    +
    • +

  • 工程团队要对自己所负责服务产生的告警保持随时待命；平台和基础设施团队要对底层的基础设施或者公享服务（比如部署）保持随时待命；两个团队之间存在的升级途径可以支持对告警进一步调查。

    +
    • +

  • 知识共享：DRY原则

    +
      +
    • 应用了Spotify的分会和协会模式？？？
      • +
    +
    • +
+

实践建议

    +

  • 架构师的角色：架构的最佳起点是设定一些原则，原则是团队为了实现更高级别的目标而应该遵循的指导方针（有时是规则）。这些原则会指导团队实践

    +
    • +

  • 开源模型：将开源原则应用于微服务代码有助于减少争论和缓解技术割裂，同时能够改善知识分享的情况

    +
    • +

  • 设计评审：对于任何新的服务或重要的新特性，负责这部分工作的工程师都会编写一个设计文档（我们称之为RFC或请求评论），并要求评审员进行反馈，这些评审员来自他们自己团队内部和外部团队

    +
    • +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2022/03/02/seckill-md/index.html b/2022/03/02/seckill-md/index.html new file mode 100644 index 0000000..3cbeeef --- /dev/null +++ b/2022/03/02/seckill-md/index.html @@ -0,0 +1,894 @@ + + + + + + + + + 秒杀系统核心设计 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ 秒杀系统核心设计 +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 2k字 + + + + +   |   + + + 阅读时长≈ + 6分 + + +
+ + + +
+ +
+ +

最近阅读量大量关于秒杀系统的介绍文章，包括一些视频讲解，大部分文章都太冗长，没有触及核心设计点，本文主要总结下后台架构的核心设计要点，不讨论架构优化中的常规页面CDN化、隔离部署、数据sharding、缓存优化等常规手段。

+

背景

秒杀系统场景举例：

+
    +
  • 抢购：如双十一，下单量高峰能达到50w+ qps，注意是下单成功，同时参与抢购的人的那就更多一个数量级了。
    • +
  • 红包：直播间红包、微信红包，本质上都是类似的场景，微信红包的处理方案是提前对红包进行个数拆分，会简化扣除库存逻辑，但是本质上跟抢购类似。
    • +
+

此类系统有几个典型特点：

+
    +
  • qps高，tps低：即读多写少，大量的请求（包括非正常请求：如频繁重试、黑产请求等）但是只有少量能成交。
    • +
  • 库存需要精确：涉及金额，不允许超卖
    • +
  • 固定时间：活动时间通常通常很短
    • +
+

其中超卖问题为核心需求点，基于此衍生出如何抗住并发量、用户体验优化等解决方案。

+ + +

简单方案

先考虑一个简单的实现方案，然后基于此方案的问题进行优化。

+

存储模型

以DB为例，考虑拆分如下几个表：

+
    +
  • 秒杀活动信息表： 用于新建秒杀活动，包括活动信息、时间段、秒杀商品等
    • +
  • 商品表：存储商品详细信息
    • +
  • 库存表stock：活动id、活动库存数量。
    • +
+

其中前两个表的信息为静态信息表，基本无变更。库存表stock会随着秒杀过程会频繁更新，直至库存数量耗尽等。

+

前端要点

以web为例，描述前端/终端的设计要点：

+
    +

  • 资源静态化

    +
    • +

  • 倒计时

    +

    非活动时间不允许参与，需要考虑本地时间不精确，需要定期从服务端获取倒计时信息。服务端也需要考虑采用TPN等方案保障各个机器时间的一致性。

    +
    • +

  • 页面拦截

    +

    避免用户频繁发起重复请求，比如提交、库存耗尽时置灰等手段。减少对后端的冲击。

    +
    • +
+

后端流程

后端接收到秒杀请求后的大致处理流程：

+
    +
  • 资格校验：包括uid、ip频控等手段，保障抢购公平性的同时也减少后续流量压力，对异常请求进行拦截。
    • +
  • 扣减库存 ：此过程为重IO逻辑
    • +
  • 下单逻辑：包括订单表等相关的一系列一致性操作，此过程的逻辑也很重。
    • +
  • 返回订单号，给到前端执行(取消)支付相关流程。
    • +
+

扣减库存

为避免超卖，扣减库存通常有两种解决方案：

+
    +
  1. mysql锁：mysql并发update问题有两种解决方案
      +
    • 方案一：依赖db操作的原子性，如”update stock set count = count-1 where product_id=xxx and count > 0”
      • +
    • 方案二：业务自行上锁，如”begin; select * from stock where product_id = xxx; update xxxx; commit”。
      • +
    +
    2. +
  2. redis + lua：lua解法网上较多，此处就不粘贴了。
    3. +
+

这里简单的方案基本就是如上所述，以mysql/redis的性能，支撑个几千的峰值qps并发也没啥问题，核心重点是要考虑好并发可能带来的超卖问题，同时也要保障抢购的公平性。

+

当然进一步的优化方案也可以基于数据sharding的思路，将库存拆分到多个redis/mysql实例中，以提升系统整体吞吐量。

+

问题

从上面的后端流程来看，扣减库存、下单逻辑都是相对较重的IO逻辑，很大可能会成为系统的瓶颈。

+

以mysql为例，假定扣减update的耗时为1ms（数据参考），那每秒支撑的TPS大概在1000左右，超过此数据量时会出现几个问题：

+
    +
  • 页面502：因为已经到达db极限，接入/逻辑层大概率超时了。
    • +
  • 体验问题：假设以排队等方案解决了后端超载的问题，但是大部分用户其实是抢购不到的，但是页面也只能一直轮询（或者长链接等待超时），体验感较差。
    • +
  • 风险高：下单逻辑通常会比较复杂，需要保证数据不丢失等，也是一个重IO的逻辑，放在同步流程中非常危险。
    • +
+

整体看同步处理大量的请求是一个不好的解决方案，需要针对性优化。

+

优化思路

基于前面的问题，优化思路有两点：

+
    +
  • 及早返回，降低资源占用
    • +
  • 同步改异步，提升稳定性，降低风险
    • +
+

将整体流程拆分为2段（不包括支付流程）, 对抢到秒杀资格的用户和被拦截的用户区分处理：

+
    +

  • 抢购

    +

    负责资格校验、库存校验等逻辑，此过程逻辑较轻，且未只读操作。

    +

    此过程同步处理，除了对异常用户的校验外，引入总库存作为拦截手段，对超过库存总量的请求不再处理，及时返回已售罄信息给到前端，避免无意义等待和重试。

    +

    获得抢购资格的用户只有少量，大部分用户无法获得抢购资格，请求会被及时拦截，减少了服务端资源的消耗，也解决了这部分用户的体验问题。

    +

    对于活动抢购资格的用户返回给前端，页面进入轮询查询获取订单信息阶段。这部分用户数量约等于库存数量，并发影响可控。

    +
    • +

  • 下单

    +

    负责实际扣减库存、写订单表等重IO逻辑。

    +

    获得抢购资格的用户，写入mq供下单逻辑消费处理，此处可以根据存储层的压力，动态调整实际消费者实例数量，影响可控。获得抢购资格的用户也是需要轮询等待，但是仅影响这部分用户的体验。

    +

    下单处理完后写入完整订单存储、缓存等，供页面查询及支付使用。

    +
    • +
+

问题：如何保障库存拦截校验精确性

抢购过程如何获得剩余库存的准确性是个问题，但是此处并不需要保障做到精确。因为进入下单流程的用户也不一定能真实的走完下单流程，比如下单失败、活动过期、重复下单等都需要有对应的解决方案。下单失败给到终端做好重试(抢购)或者提示(重复下单)即可。

+

所以抢购时可以根据库存做一个大致的判断，比如总量的两倍作为库存的整体数据限额，或者频控组件定期同步真实库存数据作为本地拦截标准等。

+

问题：少卖

如果下单有大量的失败（比如重复下单、下单失败），或者用户放弃支付导致的库存回退，可能会导致抢购过程已经拦截了，而实际库存没有耗尽。考虑两种解决方案：

+
    +
  • 方案一：前面已经提到了，可以在拦截库存时给予一定的buffer，比如按两倍库存来拦。
    • +
  • 方案二：放弃支付，可能在一段时间库存耗尽后又会冒出剩余库存的问题，这里可以引入库存同步机制通知到抢购模块。
    • +
+

参考

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2022/03/05/Tencent-COS-Image-Service/index.html b/2022/03/05/Tencent-COS-Image-Service/index.html new file mode 100644 index 0000000..87603d0 --- /dev/null +++ b/2022/03/05/Tencent-COS-Image-Service/index.html @@ -0,0 +1,855 @@ + + + + + + + + + 使用腾讯云cos+cdn搭建图片服务器 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ 使用腾讯云cos+cdn搭建图片服务器 +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.6k字 + + + + +   |   + + + 阅读时长≈ + 5分 + + +
+ + + +
+ +
+ +

背景

之前在网上找了不少存储图片的地儿，貌似都不是很靠谱。也研究了一下腾讯云，似乎也没有提供直接可用的图片存储服务。看网上的经验有人使用腾讯云cos+cdn直接搭建了一个个人的图片存储服务，感觉流程也挺简单，于是研究后操作了一番，发现也有不少弯路，于是记录一番。

+ + +

cos

基础

对象存储COS为腾讯云提供的云存储服务，可以简单的理解为云硬盘，可以通过页面、接口上传文件到特定的目录(实为bucket)。具体流程就不介绍了，参考官方文档。

+

创建bucket之后，每个bucket会有一个独立的访问域名，可以通过http域名直接访问文件。注意需要先将存储桶访问权限改为”公有读私有写“。

+

这样一个简单的文件上传、下载服务器就搭建好了。可以直接在文件列表中上传、下载文件以及管理工作。

+

优化上传

通过页面上传肯定不是一个好的方案，上传每次都要通过腾讯云页面操作，成本太高。

+

Mac下有个很方便的工具uPic，可以方便的上传到cos。可以直接从git release下载，应用市场也提供了收费版本。uPic支持多种图床用作存储服务，包括腾讯云cos。我用的git免费版本，cos图床配置大致如下：

+

uPic配置

+

注意点：

+
    +
  • Secret Id/Key：建议为uPic申请独立子账户，且仅允许访问COS数据资源权限”QcloudCOSDataFullControl“。毕竟开源产品的安全性无法保证，主账户秘钥是允许访问所有腾讯云资源的。具体方式在创建秘钥时会给与提示。
    • +
  • 域名：可以先填写cos访问域名，后面接入cdn后使用CDN加速域名替换。
    • +
  • 保存路径：为了两部分，前面部分好理解，后面部分可以先为空，或者为图片处理的样式名称。比如”/1920”。
    • +
+

uPic支持多种上传方法，在Mac可以做到右键一键上传，并自动将下载地址写到粘贴板（看上网会有上传成功的提醒，一直没找到在哪里开启）。

+

此步骤结束就基本满足私人图片存储的基础需求了。

+

图片处理

可以通过腾讯云的数据万象服务，对COS中的图片文件进行裁剪、压缩等处理，比如上传一张图片，可以生成多种不同的样式，以便适配不同的显示要求。终端可以针对不同屏幕大小拉取不同的尺寸图来进行适配，带样式的下载地址即为原（访问/CDN）域名+样式分隔符+样式名。

+

style

+

CDN接入

我的COS在广州区，其实本地访问速度还算不错的，但是为了更好的体验，还是考虑接入CDN。除性能因素外，CDN的下行成本也比COS要便宜不少，索性一次到位，将COS接入腾讯云CDN。

+

整体配置也挺简单的，照着文档执行即可，踩到的几个坑记录一下：

+
    +

  • bucket：最开始时我拿了一个很久之前创建的bucket，具体时间我忘了，照着流程文档一直没有走通，cdn域名一直返回403。折腾大半天放弃了，后面咨询了腾讯云客服，判断为bucket自身原因，让我重新创建bucket后重新走了一遍CDN接入流程后恢复了。

    +
    • +

  • 存储桶权限开启：为了避免从cos接入域名访问，选择了私有读写，接入CDN时需要开启CDN域名的回源鉴权，倒是CDN鉴权可以不用开启，后续有需要再根据实际情况打开。

    +

    回源

    +
    • +

  • 简单起见，这里先使用了COS提供的默认CDN加速域名。

    +
    • +
+

独立域名

长久考虑，决定分配一个独立图片子域名，避免后面的迁移等问题。操作步骤：

+
    +

  1. 在腾讯云CDN管理台添加域名。加速域名命名自定义前缀即可。源站配置即为之前的cos源。

    +

    cdn-cos

    +

    添加完毕后，会分配独立的cname名称。

    +
    2. +

  2. DnsPOD管理台，为主域名解析添加对应的cname记录。在上一步的添加域名时会提醒自动操作，不需要手工输入。

    +
    3. +

  3. 独立域名ssl证书申请。可以在腾讯云ssl证书管理台申请免费的单域名证书，有效期一年。不在乎成本的话也可以考虑买个通配证书。

    +
    4. +

  4. 在CDN中开启对应的https配置，选择对应的证书即可。

    +
    5. +
+

之后就可以改用独立cos域名来访问相关图片资源了。

+

总结

一到两天的时间内边摸索边操作，就搭建了一套完整的图片存储下载服务，包括cos存储、图片裁剪/压缩、CDN下载、独立资源域名接入等基础能力都很完善，基本能满足小型业务的使用场景了。相对若干年前使用架平的图片存储服务需要开发编码接入来说，已经方便不少了。可见云平台的逐步完善，确实能大幅提升生产力。

+

不足点：

+
    +
  • 组件比较零散，第一次会有上手成本。涉及了cos、cdn、ssl、dnspod、万象等等组件的使用，之前没接触过的话还是得精心看看文档。看得出为了便于接入，腾讯云在各组件之间的打通工作上做了不少的优化。
    • +
  • 各种购买流程阻断。比如万象服务，我实在购买cos的过程中采购的，后面发现这个貌似没有多大必要，cdn貌似也提供了图片压缩的能力。当然这个业余个人的流程不熟悉有关。
    • +
+

总之有了云服务的各种Paas服务之后，确实简化了不少自建的流程，能大幅提升小团队的生产效率。

+ + + + + + +
+ +
+ + +
+
+ + +
+ +
    + +
  • + COS +
    • + +
+
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2023/09/18/Introduct-to-go-clean-template/index.html b/2023/09/18/Introduct-to-go-clean-template/index.html new file mode 100644 index 0000000..1d97751 --- /dev/null +++ b/2023/09/18/Introduct-to-go-clean-template/index.html @@ -0,0 +1,906 @@ + + + + + + + + + Introduct to go-clean-template | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Introduct to go-clean-template +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.3k字 + + + + +   |   + + + 阅读时长≈ + 5分 + + +
+ + + +
+ +
+ +

简介

go-clean-template是一个golang的微服务模板，按照Robert Martin《代码整洁之道》的各原则来实现。业务方可以使用该模板来扩展构建自己的微服务。

+

提供的能力项包括：

+
    +
  • 按照DIP、ISP等原则来组织框架层、业务逻辑层以及数据层等代码实现。
    • +
  • 配置文件解析，包括端口号、日志、PG等RabbitMQ配置。
    • +
  • 集成gin框架，提供了几个HTTP接口demo实现。
    • +
  • 集成了RabbitMQ RPC，提供了1个接口的demo实现。
    • +
  • 集成了日志、Swagger、K8s probe、Prometheus上报等能力。
    • +
+

本项目主要是作为模板来演示如何构建可扩展、易于维护的微服务，因此在实现上比较简单，业务方可以根据实际需求进一步改造扩充。

+ + +

工程架构

    +

  • 启动方式

    +

    README中给出了docker的构建方式,也可以将相关代码copy出来之后自行go build构建。

    +

    注意服务依赖RabbitMQ、PostgreSQL，启动前需要搭建对应的容器或者实例。

    +
    • +

  • 目录结构

    +
      +
    • cmd: cmd处理逻辑。
      • +
    • config：配置解析
      • +
    • docker-compose.yml： Image构建
      • +
    • internal：内部服务的代码逻辑，与框架、pkg等实现上完全隔离。
        +
      • app： app的具体实现，包括配置解析、业务逻辑注入、http/RPC启动、signal响应以及退出逻辑
        • +
      • controller：对外的API层实现，包括http、RPC接口的路由以及实现。
        • +
      • entity：entity层，通常用于公共数据结构的声明。
        • +
      • usecase：业务逻辑实现，采用了DIP原则，内容包括了接口声明、业务逻辑实现以及单侧等。
        • +
      +
      • +
    • pkg：独立的模块
        +
      • http server：http服务启动
        • +
      • logger：日志实现，基于zerolog
        • +
      • postgres：封装了golang postgre实现
        • +
      • rabbitmq：封装rabbit RPC。
        • +
      +
      • +
    +
    • +
+

核心设计

代码整洁之道的不少原则在项目中都有体现，包括：

+
    +
  • ISP：接口隔离原则
    • +
+
+

定义：任何层次的软件设计如果依赖了它并不需要的东西，就会带来意料之外的麻烦。

+
+

User case中Repo（缓存存取数据）和WebAPI（拉取外部数据），虽然都属于业务逻辑流程中的一部分，但是在实现上完全隔离，相互间无依赖关系。数据存储不依赖API的实现。

+
    +
  • LSP：里氏替换原则
    • +
+
+

定义1：如果对每一个类型为 T1的对象 o1，都有类型为 T2 的对象o2，使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。
定义2：所有引用基类的地方必须能透明地使用其子类的对象

+
+

pkg中的各个独立模块的实现就有LSP的体验，比如log的实现，log的内部实现上依赖了zerolog，但是zerolog没有扩散到代码的其他部分。理论上log内部实现可以被其他log lib替换，比如glog、zap等，而且上层无需感知。

+
    +
  • DIP：依赖倒置
    • +
+
+

定义：源代码层次的依赖关系中就应该多引用抽象类型，而非具体实现。

+
+

user case的实现就是典型的DIP原则。

+
    +
  1. 声明user case的interface。在代码的其他模块仅仅依赖interface，不依赖interface的具体实现。
    2. +
+
type (
	// Translation -.
	Translation interface {
		Translate(context.Context, entity.Translation) (entity.Translation, error)
		History(context.Context) ([]entity.Translation, error)
	}

	// TranslationRepo -.
	TranslationRepo interface {
		Store(context.Context, entity.Translation) error
		GetHistory(context.Context) ([]entity.Translation, error)
	}

	// TranslationWebAPI -.
	TranslationWebAPI interface {
		Translate(entity.Translation) (entity.Translation, error)
	}
)
+ +
    +
  1. app启动前将业务逻辑的具体实现注入到user case中，供其他业务逻辑使用。
    2. +
+

type TranslationUseCase struct {
	repo   TranslationRepo
	webAPI TranslationWebAPI
}

// New -.
func New(r TranslationRepo, w TranslationWebAPI) *TranslationUseCase {
	return &TranslationUseCase{
		repo:   r,
		webAPI: w,
	}
}

// Use case **Inject**
translationUseCase := usecase.New(
	repo.New(pg),
	webapi.New(),
)
+ +

通过New构造函数，将依赖注入到业务逻辑的结构中. 这使得业务逻辑独立于外部接口。业务逻辑内部实现之间也也是通过Interface来交互，没有直接依赖相互的实现。这样实现后续在业务逻辑的实现变更时，比如更换WebAPI依赖的后台接口，或者将数据存储从Postgre迁移到Mysql时，对其他模块没有任何影响。

+

DIP的另外一大收益为单测，可以自动生成mock，以便进行单元测试。

+
//go:generate mockgen -source=interfaces.go -destination=./mocks_test.go -package=usecase_test
+ +

总结：

+
    +
  • 代码整体上可以分为内网两层，外传主要包括路由、http/RCP API处理、以及PG、MQ等组件的封装。内层主要为业务逻辑的实现。
    • +
  • 各层之间基本没有直接依赖关系，尽量是通过各种Interface进行通信。
    • +
+

+

其他实践

    +
  • 配置解析：使用了cleanenv，一个比较简单的实现。个人感觉可以使用vip等替换。
    • +
  • 文档中推荐后续采用wire来管理依赖关系。没有实际研究过wire，初步感觉有点鸡肋。但是不确定在大型项目中是否有较大收益，后续可以关注。
    • +
  • 业务逻辑的实现（usercase/）中，按应用领域了进行了分组。
    • +
+

Reference

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2023/09/18/Introduct-to-temporalio/index.html b/2023/09/18/Introduct-to-temporalio/index.html new file mode 100644 index 0000000..eab8ac7 --- /dev/null +++ b/2023/09/18/Introduct-to-temporalio/index.html @@ -0,0 +1,890 @@ + + + + + + + + + Introduct to temporalio | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ Introduct to temporalio +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 1.2k字 + + + + +   |   + + + 阅读时长≈ + 4分 + + +
+ + + +
+ +
+ +

Temporalio 简介

简介

引用wiki来介绍工作流引擎的定义：

+
+

A workflow engine manages and monitors the state of activities in a workflow, such as the processing and approval of a loan application form, and determines which new activity to transition to according to defined processes (workflows). The actions may be anything from saving an application form in a document management system to sending a reminder e-mail to users or escalating overdue items to management. A workflow engine facilitates the flow of information, tasks, and events. Workflow engines may also be referred to as Workflow Orchestration Engines.

+
+

Temporal是一个使用golang开发分布式的工作流引擎。Temporal 是原 Cadence 联合创始人离开 Cadence 后基于其 Fork的新分支，从某种程度上来讲，Temporal 可能是 Cadence 的一个更商业化的版本，毕竟后者原先只是 Uber 内部的一个组件。在2022年初Temporal已经是估值15亿美元的独角兽企业。

+ + +

基本概念

    +

  • Temporal System：任务调度平台,负责workflow任务存储、调度等。

    +
    • +

  • Worker Process：Worker Process为任务的执行环境，负责具体任务的执行，任务类型包括workflow和Activity两种。

    +
      +
    • work process启动后需要连接到Temporal服务端，并自行注册需要支持的任务类型及名称、队列等信息。
      • +
    • A Worker Process is responsible for polling a Task Queue, dequeueing a Task, executing your code in response to a Task, and responding to the Temporal Cluster with the results. # worker会一直循环从预定义好的队列中取task并执行后返回结果。
      • +
    +

    调度流程

    +
    • +

  • workflow & Activity:

    +
      +
    • Workflow由多个Activities编排组成，每个Activity只执行一个单一、已定义好的动作，比如调用外部服务、文件转码、发送邮件，可以被各种类型的Workflow复用。
      • +
    • 在Go中Workflow通常就是一个函数，接收workflow Context和输入input参数。
      • +
    +
    • +
+

使用方法

使用官方demo来本地演示下Temporalio的基本使用方法。demo演示了一次完整的转账操作，包括容错处理。

+
    +

  • 安装及启动Temporalio

    +
      +

    • 本地安装（linux）

      + 
      curl -sSf https://temporal.download/cli.sh | sh
      +
      • +

    • 启动Temporalio服务，可以通过ui-ip参数指定本地ip，默认为localhost

      + 
      temporal server start-dev
      • +
    +
    • +

  • 通过SDK实现workflow及activity，代码见官方demo。

    +
      +
    • MoneyTransfer：workflow的具体实现
        +
      • 实现了一个从source到target账号的转账操作。先从source中取（对应Withdraw activity），然后转给target（对应Deposit activity实现）。
        • +
      • 如果deposit失败，为保证事务的原子性，需要回滚前一步的Withdraw操作（Refund activity实现）
        • +
      • 入参：PaymentDetails定义，通常将入参封装在一个struct中，后续在新增参数时会更加方便
        • +
      +
      • +
    • activity定义：3个activity分别实现见withdraw、deposit和refund函数。activity的参数定义与workflow并没有本质的区别。
      • +
    • 重试逻辑：workflow会自动重试，也可以通过RetryPolicy参数指定重试逻辑。注意：
      +

      By default, Temporal retries failed Activities forever, but you can specify some errors that Temporal should not attempt to retry

      +
      +
      • +
    +
    • +

  • 启动workflow

    +
      +
    • 两种方法可以启动workflow：SDK或者命令行工具（tctl）
      • +
    • 代码中已有sdk的视线：start/main.go中使用sdk启动workflow。指定参数（input、队列名称等）以及workflow名称，然后等待结果返回即可。
      • +
    • 启动workflow
      • +
    + 
    go run start/main.go
    +
    • +

  • 查看workflow状态

    +

    启动后就可以在任务面板中看到workflow的基础和详细信息了。

    +

    +

    +

    可见workflow虽然在runing状态，但是并没有被执行，因为还没有对应的worker来承担具体的执行工作。只有worker启动并连接到对应的task queue之后workflow才会被执行。

    +
    • +

  • 启动worker执行task

    +
    • +
+
go run worker/main.go
+ +

启动worker后可以观察到之前启动的workflow任务被立即执行了，并打印了输出。面板中的workflow状态也变成了Completed。

+

+

明细中可以看到有两类task分别被执行：

+
    +
  • WorkflowTask：编排activity的任务
    • +
  • ActivityTask：执行具体动作的任务，此处分别为Withdraw、Deposit。
    • +
+

总结

可见temporalio本质上是将一个workflow拆分为多个可复用的activity，通过消息队列的方式分发到多个work中去调度，这样可以达到代码以及执行资源上的复用，对于业务流程复杂、多变的场景比较合适，比如DevOps流水线、数据分析pipeline等场景，需要根据各种业务需求来自定义特殊处理流程并部署，如果使用工作流引擎来编排各个activity可以快速的满足需求。

+

但是一个workflow的执行过程会被拆解到多个activity，并在分布式环境中去调度，会有多次的RTT操作以及序列化等操作，已定会有一定的性能损耗。对流量大、时延要求高微服务是否适合还没有去深入研究验证。另外对外服务也要考虑资源冲突等带来的影响。

+

相关参考

+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/2023/10/07/Memos-Code-Analyze/index.html b/2023/10/07/Memos-Code-Analyze/index.html new file mode 100644 index 0000000..c0255c7 --- /dev/null +++ b/2023/10/07/Memos-Code-Analyze/index.html @@ -0,0 +1,1114 @@ + + + + + + + + + memos code analyze | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ memos code analyze +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 4.2k字 + + + + +   |   + + + 阅读时长≈ + 19分 + + +
+ + + +
+ +
+ +

简介

Memos是一个开源的支持自托管部署的知识库，类似flomo。作为一个go+react实现的产品，功能齐全，且活跃度一直不错，所以找了个时间阅读了一下代码。
本次仅记录后端及DB设计部分，前端部分后续有时间了再继续。

+ + +

安装方法

方法一：可能是出于部署便捷的考虑，代码中仅支持docker安装，下面解析Dockerfile中镜像构建步骤，属于典型的多阶构建过程：

+
    +

  1. 协议代码生成：安装buf，buf generate生成协议代码。包括后端所需的pb、grpc、grpc-gateway代码以及前端所需的ts代码。详见buf.yml配置

    +
    2. +

  2. 使用pnpm build编译前端文件，详见前端文件夹（web/）下的package.json

    +
    3. +

  3. 将前端打包结果（web/dist）copy到server目录，build后端服务。
    注意：项目中使用了go embed，将前端资源目录一并打包到了二进制memos文件中，并在代码中提供了静态文件的读服务。所以部署时不再需要copy前端目录文件，也无需其他反向代理。

    + 
    //go:embed dist
    var embeddedFiles embed.FS

    func getFileSystem(path string) http.FileSystem {
        fs, err := fs.Sub(embeddedFiles, path)
        if err != nil {
            panic(err)
        }

        return http.FS(fs)
    }

    func embedFrontend(e *echo.Echo) {
        // Use echo static middleware to serve the built dist folder
        // refer: https://github.com/labstack/echo/blob/master/middleware/static.go
        e.Use(middleware.StaticWithConfig(middleware.StaticConfig{
            Skipper:    defaultAPIRequestSkipper,
            HTML5:      true,
            Filesystem: getFileSystem("dist"),
        }))
      //...
    }
    + +
    4. +

  4. 构建服务运行环境

    +
    5. +
+

注意在docker-compose.yml中采用的从远程拉取镜像的方式。如果想使用本地构建，将image改为build指令即可。

+

方法二：本地安装
动手能力强的可以直接本地编译安装，无需依赖docker。但是需要手工安装各类工具。

+
    +
  1. 安装pb、buf等工具，生成协议代码。
    2. +
  2. 前端编译。并将编译结果copy到server/dist目录。
    3. +
  3. go build，编译可执行文件。然后直接执行即可。
    4. +
+

DB存储结构

后台代码分析之前，可以对DB结构有个大致了解，因为其接口大部分是基于DB的CRUD操作。

+

system_setting

存储系统设置。详见系统设置页面配置项（仅ROLE为HOST用户有权限）

+
CREATE TABLE system_setting (
    name TEXT NOT NULL,
    value TEXT NOT NULL,
    description TEXT NOT NULL DEFAULT '',
    UNIQUE(name)
);
+

【用户】 user

注册用户表。

+
-- user
CREATE TABLE user (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    row_status TEXT NOT NULL CHECK (row_status IN ('NORMAL', 'ARCHIVED')) DEFAULT 'NORMAL',
    username TEXT NOT NULL UNIQUE,
    role TEXT NOT NULL CHECK (role IN ('HOST', 'ADMIN', 'USER')) DEFAULT 'USER',
    email TEXT NOT NULL DEFAULT '',
    nickname TEXT NOT NULL DEFAULT '',
    password_hash TEXT NOT NULL,
    avatar_url TEXT NOT NULL DEFAULT ''
);
+

####【用户】 user_setting
用户设置表，存放用户个性化配置。以key-value方式存储，所以部分用户类数据也存放于此，比如用户token。

+
-- user_setting
CREATE TABLE user_setting (
    user_id INTEGER NOT NULL,
    key TEXT NOT NULL,
    value TEXT NOT NULL,
    UNIQUE(user_id, key)
);
+

####【发表】 memo
发表memo记录表，类似tweet、微博记录。

+
CREATE TABLE memo (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    creator_id INTEGER NOT NULL, -- 发表人，关联user.id
    created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    row_status TEXT NOT NULL CHECK (row_status IN ('NORMAL', 'ARCHIVED')) DEFAULT 'NORMAL',
    content TEXT NOT NULL DEFAULT '',
    visibility TEXT NOT NULL CHECK (visibility IN ('PUBLIC', 'PROTECTED', 'PRIVATE')) DEFAULT 'PRIVATE'
);
+

####【发表】 memo_organizer
目前仅记录pin状态的memos记录，后续应该有更多场景。

+
CREATE TABLE memo_organizer (
    memo_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    pinned INTEGER NOT NULL CHECK (pinned IN (0, 1)) DEFAULT 0,
    UNIQUE(memo_id, user_id)
);
+

####【发表】 memo_relation
记录memo记录间关联关系。关系类型：REFERENCE、ADDITIONAL

+
-- memo_relation
CREATE TABLE memo_relation (
    memo_id INTEGER NOT NULL,
    related_memo_id INTEGER NOT NULL,
    type TEXT NOT NULL,
    UNIQUE(memo_id, related_memo_id, type)
);
+

####【资源】 resource
资源存放记录。可以包括资源内容本身，也可能为外部链接、本地文件名等。

+
CREATE TABLE resource (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    creator_id INTEGER NOT NULL,
    created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    filename TEXT NOT NULL DEFAULT '',
    blob BLOB DEFAULT NULL,
    external_link TEXT NOT NULL DEFAULT '',
    type TEXT NOT NULL DEFAULT '',
    size INTEGER NOT NULL DEFAULT 0,
    internal_path TEXT NOT NULL DEFAULT ''
);
+

【资源】 memo_resource

memos记录与资源的关联关系（1:N）。

+
-- memo_resource
CREATE TABLE memo_resource (
    memo_id INTEGER NOT NULL,
    resource_id INTEGER NOT NULL,
    created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    UNIQUE(memo_id, resource_id)
);
+

####【标签】 tag
跟tweet、微博之类的不同，memos使用上需要先创建标签之后才能在发表时使用标签。所以标签有单独的一套接口。

+
-- tag
CREATE TABLE tag (
    name TEXT NOT NULL,
    creator_id INTEGER NOT NULL,
    UNIQUE(name, creator_id)
);
+

idp

没有具体研究，感觉应该是跟外部应用关联时使用。

+
CREATE TABLE idp (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    type TEXT NOT NULL,
    identifier_filter TEXT NOT NULL DEFAULT '',
    config TEXT NOT NULL DEFAULT '{}'
);
+

activity

操作流水日志

+
CREATE TABLE activity (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    creator_id INTEGER NOT NULL,
    created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')),
    type TEXT NOT NULL DEFAULT '',
    level TEXT NOT NULL CHECK (level IN ('INFO', 'WARN', 'ERROR')) DEFAULT 'INFO',
    payload TEXT NOT NULL DEFAULT '{}'
);
+

storage

S3存储配置列表，用于资源文件的存储。注意local、database配置不在此内。

+
-- storage
CREATE TABLE storage (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    type TEXT NOT NULL,
    config TEXT NOT NULL DEFAULT '{}'
);
+ +

后端源码分析

入口文件：cmd/memos.go

+
    +
  • 项目采用了cobra框架，支持几个子命令。此处仅关注root command的主流程。其他子命令参见mvrss、setup。
    • +
  • 初始化init()：项目使用了viper来实现配置的解析，包括mode（dev/prod/demo）、addr、port、data（数据存储目录）参数。相关参数在启动时会输出到console。
      +
    • 注意：db文件名：”memos_+$mode.db”
      • +
    +
    • +
  • open DB。
      +
    • 使用了sqlite作为db driver。为何不将DSN放在配置中支持多个db类型？
      • +
    • Migrate DB：db初始化，包括表构建，新版本db老数据迁移。
      • +
    +
    • +
+

构造echo server对象。核心数据结构包括：

+
    +
  • echo server：项目使用echo作为服务器框架。
    • +
  • 读取、生成 Server ID（唯一，如果只支持单机的话server ID有啥用？）
    • +
  • 读取、生成 secret-session
    • +
  • embedFrontend：为前端资源目录（server/dist、server/dist/asserts）启用静态文件中间件
    • +
  • demo、dev模式时支持echoSwagger，方便查看API。URL：http://ip:port/api/index.html。// swagger确实好用，查看、调试API很方便。
    • +
  • 使用到的echo中间件
      +
    • Logger（日志）、CORS（防cors）、Timeout（30s）、RateLimiter（频控，防止ip恶意访问）
      • +
    • JWT鉴权：token校验通过会在context中写入用户id（key: “user-id”）
      • +
    +
    • +
+

路由

RSS路由，包括

+
    +
  • /explore/rss.xml：提供rss接口，展示所有（max：100条）公开的memos记录
    • +
  • /u/:id/rss.xml：与上面类似，不过进列出该用户的memos记录。
    • +
+

前端REST接口路由apiv1（root path: “/api/v1”）

+
    +

  • system routes

    +
      +
    • /ping：return HTTP 200 code.
      • +
    • /status：some information from system_setting table
      • +
    • /system/vacuum：各表垃圾类记录清理操作，包括memos、resouce、tag表等。
      • +
    +
    • +

  • system setting：system_setting，仅限于role类型为HOST的用户

    +
      +
    • 【GET】/system/setting：拉取配置
      • +
    • 【POST】/system/setting：写配置
      • +
    +
    • +

  • auth：登录鉴权

    +
      +

    • /auth/signin：登录

      +
        +
      • 系统设置为disablePasswordLoginSystemSetting、用户状态为Archived、（加密）密码不匹配，返回错误
        • +
      • 生成JWT token，参数包括：username、userID、expire time、duration。
        • +
      • token写入/更新【追加】存储表（user_setting表，key：详见user_seting.proto），注意用户token可以有多个
        • +
      • 记录操作流水activity表。
        • +
      • 返回用户信息，并设置cookie
        • +
      +
      • +

    • /auth/signin/sso：SSO登录支持？

      +
      • +

    • /auth/signout：登出。删除存储的token，清理cookie

      +
      • +

    • auth/signup：注册

      +
        +
      • 参数：username、password
        • +
      • user中第一个用户默认设置Role为HOST（系统管理员）。其他均为USER用户
        • +
      • 写user表。注意db中存储为hash过的password（防拖库）
        • +
      • 其他登录流程，token生成、写流水等
        • +
      +
      • +
    +
    • +

  • idb IDP相关接口

    +
      +
    • 【GET】/idp
      • +
    • 【POST】/idp
      • +
    • 【GET】/idp/:idpId
      • +
    • 【PATCH】/idp/:idpId
      • +
    • 【DELETE】/idp/:idpId
      • +
    +
    • +

  • user：用户

    +
      +
    • 【GET】/user：Get a list of users
      • +
    • 【POST】/user：Create a user
        +
      • 仅当前用户角色为HOST用户时才可以创建用户。且创建用户的角色不允许为HOST。（可以为admin？）
        • +
      • 与/auth/signup不同的是不需要产生token、种cookie等操作。
        • +
      +
      • +
    • 【GET】/user/me：Get current user
        +
      • user basic info from user
        • +
      • user setting from user_setting
        • +
      +
      • +
    • 【GET】/user/name/:username：Get user by username
        +
      • 根据用户名称查找基础信息。部分敏感字段隐藏
        • +
      • 这里不需要用户鉴权？
        • +
      +
      • +
    • 【GET】/user/:id：Get user by id。与上面基本一致
      • +
    • 【PATCH】/user/:id：更新用户信息。注意仅HOST用户或者更新用户自己才允许操作
      • +
    • 【DELETE】/user/:id：Delete a user from user table.
      • +
    +
    • +

  • user setting

    +
      +
    • 【POST】/user/setting：Upsert user setting for user_setting
      • +
    +
    • +

  • tag

    +
      +
    • 【GET】/tag：Get a list of tags。
        +
      • tag 中有用户id字段，仅拉取用户自己的tagid
        • +
      +
      • +
    • 【POST】/tag：Create a tag into tag
      • +
    • 【GET】/tag/suggestion：Get a list of tags suggested from other memos contents。—— 没看懂使用场景
      • +
    • 【POST】/tag/delete：Delete a tag from tag
      • +
    +
    • +

  • storage：system_setting 中存放的storage-service-id值为当前使用的存储。Local（value: -1)，Database（value：0）两个不可修改、删除，可以新增S3类型的存储。

    +
      +
    • 【GET】/storage：Get a list of storages from storage
      • +
    • 【POST】/storage：Create storage into storage
        +
      • 目前仅支持 “S3” 类型的存储
        • +
      +
      • +
    • 【PATCH】/storage/:storageId：Update a storage by storageId
      • +
    • 【DELETE】/storage/:storageId：Delete a storage by storageId
        +
      • 需要检查 system_setting 的当前storage-service-id值，如果是正在使用的存储，则不允许直接删除。
        • +
      +
      • +
    +
    • +

  • resource：memo发表前可以先上传资源（得到返回的资源id），然后发表时关联对应的资源（id列表）即可。

    +
      +
    • 【GET】/resource：Get a list of resources
        +
      • 拉取用户上传资源列表。注：需要关联memo_resource 表，如果memo记录已删除是否就无法找回了。
        • +
      • 看页面请求，已经走的是v2的接口（ /memos.api.v2.ResourceService/ListResources ）了。v1接口已废弃？
        • +
      +
      • +
    • 【POST】/resource：Create resource into resource table
      • +
    • 【POST】/resource/blob：Upload resource。
        +
      • settingMaxUploadSizeBytes：文件大小限制，默认32M
        • +
      • 根据 system_setting.storage-service-id 的存储类型，选择对应的存储地址
          +
        • database ：直接存储在 resource.blob 字段中
          • +
        • LocalStorage ：存储在本地文件，默认为asserts目录（可修改）。InternalPath字段关联文件存储地址
          • +
        • StorageS3 ：S3远程存储。ExternalLink字段关联下载地址。
          • +
        +
        • +
      +
      • +
    • 【PATCH】/resource/:resourceId：仅更新Filename。业务场景是什么？
      • +
    • 【DELETE】/resource/:resourceId：删除对应的资源。包括文件blob以及 storage 表
      • +
    +
    • +

  • memo：发表相关

    +
      +
    • 【GET】/memo：Get a list of memos matching optional filters。
        +
      • PRIVATE 仅用户自身可见。 PROTECTED 登录用户也可以查看。 PUBLIC 未登录也可见。
        • +
      • system_setting.memo-display-with-updated-ts 开关用于控制是否按按update time排序，否则按create time排序 【desc】
        • +
      • 除 memo 表外，也会将 memo_relation 、 memo_organizer、 memo_resource 等关联字段一起拉出。
        • +
      +
      • +
    • 【POST】/memo：发表。
        +
      • visibility默认继承自 user_setting.memo-visibility or Private。如果 system_setting.disable-public-memos 开启，将USER角色的用户发表改为Private。
        • +
      • 插入 mem 表
        • +
      • 插入 memo_resource 表（if ResourceIDList not null）
        • +
      • 插入 memo_relation 表（if RelationList not null）
        • +
      • 写后立即读？完全没有考虑性能以及db可能的延迟。
        • +
      • 如果 user_setting.telegram-user-id 存在，使用telegram bot同步
        • +
      +
      • +
    • 【GET】/memo/all：跟上面的list接口没啥区别。此处不限用户拉取所有 PUBLIC、 PROTECTED状态的memo。explore场景使用（类似于微博广场的场景）
      • +
    • 【GET】/memo/stats：Get memo stats by creator ID or username。
        +
      • 查询某用户或自己的memo记录的发表/更新时间。首页右侧的heat map使用。
        • +
      +
      • +
    • 【GET】/memo/:memoId：Get memo by ID
      • +
    • 【PATCH】/memo/:memoId：更新 memo 以及 memo_relation 、 memo_resource
      • +
    • 【DELETE】/memo/:memoId：删除 memo。注意 memo_relation 、 memo_resource 、memo_organizer 记录并没有清除。删除后资源应该可见，逻辑不严谨。
      • +
    +
    • +

  • Organize memo (pin/unpin)

    +
      +
    • 【POST】/memo/:memoId/organizer：插入 memo_organizer 表。
        +
      • 注意仅memo的发表人CreatorID才允许执行Pin操作。—— 感觉此处单独一个表有点多余。完全可以在memo中增加一个字段即可。另外也不需要单独接口，完全可以复用update memo接口。
        • +
      • register memo & resource relation.
        • +
      +
      • +
    • 【GET】/memo/:memoId/resource：根据memoID拉取对应的resource列表信息
      • +
    • 【POST】/memo/:memoId/resource：根据memoID更新 memo_resource 中对应的资源id。使用场景是什么？如果是更新memo对应的资源，直接调用更新memo即可。貌似没有必要为资源更新单独保留接口。
      • +
    • 【DELETE】/memo/:memoId/resource/:resourceId：Delete from memo_resource 。也没找找到使用场景。如果是删除资源，直接更新memo即可。
      • +
    +
    • +

  • register memo relation。接口与上面resouce类似，GET、POST、DELETE 操作 memo_relation 表

    +
    • +

  • 公共路由（”/o”）

    +
      +
    • 外部资源
        +
      • 【GET】/get/httpmeta：取外部链接的http meta信息
        • +
      • 【GET】/get/image：拉取外部链接图片，返回给页面，并设置max-age。为啥页面不直接拉取，而需要走服务端代理？
        • +
      +
      • +
    • Resouce
        +
      • 【GET】/r/:resourceId：拉取资源
          +
        • 支持thumbnail拉取。如果资源type为“image/png”、”image/jpeg”，会实时生成512的缩略图（Resouce页面首次拉取会展示缩略图，点击是显示完整图片）
          • +
        +
        • +
      • 【GET】/r/:resourceId/*：与上面接口实现相同。
        • +
      +
      • +
    +
    • +
+

gRPC路由注册

gRPC使用的端口号为 Profile.Port +1，使用gRPC server框架。包括以下gRPC接口：

+
    +
  • gRPC拦截器：与v1中的鉴权流程一致，鉴权完毕会在context中写入username供后续逻辑使用。详见 acl.go 实现。
      +
    • 意味着所有v2接口都需要登录？
      • +
    +
    • +
  • systeminfo：与v1版本的user_setting基本一致。v1版本没有get接口，应该是已经迁移了。
    • +
+ 
service SystemService {
  rpc GetSystemInfo(GetSystemInfoRequest) returns (GetSystemInfoResponse) {
    option (google.api.http) = {get: "/api/v2/system/info"};
  }
  rpc UpdateSystemInfo(UpdateSystemInfoRequest) returns (UpdateSystemInfoResponse) {
    option (google.api.http) = {post: "/api/v2/system/info"};
  }
}
+
    +
  • UserService：包括两部分接口
      +
    • user 中的用户基础信息
      • +
    • 拉取、创建、删除Token列表（ user_setting.UserSettingKey ），注意v1版本API仅在sigin、signout相关流程中有操作token，无直接接口。
      • +
    +
    • +
+
service UserService {
 rpc GetUser(GetUserRequest) returns (GetUserResponse) {
   option (google.api.http) = {get: "/api/v2/users/{username}"};
   option (google.api.method_signature) = "username";
 }
 rpc UpdateUser(UpdateUserRequest) returns (UpdateUserResponse) {
   option (google.api.http) = {
     post: "/api/v2/users/{username}"
     body: "*"
   };
   option (google.api.method_signature) = "username";
 }
 // ListUserAccessTokens returns a list of access tokens for a user.
 rpc ListUserAccessTokens(ListUserAccessTokensRequest) returns (ListUserAccessTokensResponse) {
   option (google.api.http) = {get: "/api/v2/users/{username}/access_tokens"};
   option (google.api.method_signature) = "username";
 }
 // CreateUserAccessToken creates a new access token for a user.
 rpc CreateUserAccessToken(CreateUserAccessTokenRequest) returns (CreateUserAccessTokenResponse) {
   option (google.api.http) = {
     post: "/api/v2/users/{username}/access_tokens"
     body: "*"
   };
   option (google.api.method_signature) = "username";
 }
 // DeleteUserAccessToken deletes an access token for a user.
 rpc DeleteUserAccessToken(DeleteUserAccessTokenRequest) returns (DeleteUserAccessTokenResponse) {
   option (google.api.http) = {delete: "/api/v2/users/{username}/access_tokens/{access_token}"};
   option (google.api.method_signature) = "username,access_token";
 }
}
+
    +
  • memos：提供拉取memos的两个接口（目前应该还没有迁移完毕）
    • +
+
service MemoService {
rpc ListMemos(ListMemosRequest) returns (ListMemosResponse) {
option (google.api.http) = {get: "/api/v2/memos"};
}

rpc GetMemo(GetMemoRequest) returns (GetMemoResponse) {
option (google.api.http) = {get: "/api/v2/memos/{id}"};
option (google.api.method_signature) = "id";
}
}
+ +
    +
  • tag：与/api/v1/tag基本一致。
    • +
+
service TagService {
rpc ListTags(ListTagsRequest) returns (ListTagsResponse) {
option (google.api.http) = {get: "/api/v2/tags"};
}
}
+
    +
  • resource：与 /api/v1/resource 基本一致
    • +
+
service ResourceService {
rpc ListResources(ListResourcesRequest) returns (ListResourcesResponse) {
    option (google.api.http) = {get: "/api/v2/resources"};
}
}
+
    +
  • v2接口也支持reflection，可以通过 grpcurl 查看接口说明。
    • +
+
» grpcurl  -plaintext localhost:8082 list
grpc.reflection.v1.ServerReflection
grpc.reflection.v1alpha.ServerReflection
memos.api.v2.MemoService
memos.api.v2.ResourceService
memos.api.v2.SystemService
memos.api.v2.TagService
memos.api.v2.UserService
+
    +
  • 将所有gRPC接口注册到gRPC gateway，提供v2版本的http API（/api/v2/）。
    • +
  • 另外也注册了GRPC web proxy，供前端gRPC web直接使用。
      +
    • 前端使用了nice-grpc-web 来调用grpc接口。避免通过rest API的转换。
      • +
    • 另外grpc web proxy是依赖http2的，无法在非h2环境下使用？
      • +
    +
    • +
+

路由注册等完成后启动http、gRPC server接口，启动服务。

+

总结

    +
  • 优点
      +
    • 功能结构完整：用户、发表、标签、资源以及鉴权、TEL机器人等功能相关接口，接口近50个。
      • +
    • docker等一键部署能力。不需要开发能力可以完成host部署。
      • +
    +
    • +
  • 不足
      +
    • memo等存储还基于嵌入式数据库sqlite，量大时一定会有性能上的瓶颈。看项目roadmap支持mysql已经在计划中了，支持mysql之后性能应该会有所改善。部分接口实现上也没有考虑性能问题的优化（比如去掉多余的db访问）
      • +
    • 表过多，造成大量的left join之类的查询。如果记录量达到百万级应该也会产生新的性能问题。感觉一些非核心数据（比如pin、relation、resouce）可以使用redis之类的缓存来解决，避免频繁的多表join等操作。
      • +
    • API代码冗长。接口存在一些重复。目前已经在朝v2版本接口迁移中了。后续应该能简化。
      • +
    +
    • +
+ + + + + + +
+ +
+ + +
+
+ + +
+ + +
+ + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/about-site/index.html b/about-site/index.html new file mode 100644 index 0000000..7bed808 --- /dev/null +++ b/about-site/index.html @@ -0,0 +1,774 @@ + + + + + + + + + about-site | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ about-site +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 149字 + + + + +   |   + + + 阅读时长≈ + 1分 + + +
+ + + +
+ +
+ +

本站特性

基于Hexo的技术blog，接入采用Nginx，后续计划迁移到APISix。

+

更新历史

上周发现本地的hexo版本有些老了，于是花了写时间迁移到新版本上。整体程度也不复杂，但是比较费时间，因为之前做过的一些更新操作没有记录，不太记得了。所以计划单独划分一个page出来用于记录更新历史。

+
    +
  • 2018.2.21: 建站，后面陆续做过一些小的修改优化
    • +
  • 2022.2.9: 迁移到新版本hexo，更改模板并优化
    • +
+ + + + + + +
+ +
+ + +
+
+ + + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/02/index.html b/archives/2018/02/index.html new file mode 100644 index 0000000..316ebeb --- /dev/null +++ b/archives/2018/02/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2018/2 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/03/index.html b/archives/2018/03/index.html new file mode 100644 index 0000000..0db45e0 --- /dev/null +++ b/archives/2018/03/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2018/3 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/05/index.html b/archives/2018/05/index.html new file mode 100644 index 0000000..70c060b --- /dev/null +++ b/archives/2018/05/index.html @@ -0,0 +1,659 @@ + + + + + + + + + Archives: 2018/5 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/06/index.html b/archives/2018/06/index.html new file mode 100644 index 0000000..c5b6574 --- /dev/null +++ b/archives/2018/06/index.html @@ -0,0 +1,788 @@ + + + + + + + + + Archives: 2018/6 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + + + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/09/index.html b/archives/2018/09/index.html new file mode 100644 index 0000000..c6d75ac --- /dev/null +++ b/archives/2018/09/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2018/9 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/10/index.html b/archives/2018/10/index.html new file mode 100644 index 0000000..7089686 --- /dev/null +++ b/archives/2018/10/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2018/10 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2018/index.html b/archives/2018/index.html new file mode 100644 index 0000000..72f3b3a --- /dev/null +++ b/archives/2018/index.html @@ -0,0 +1,1007 @@ + + + + + + + + + Archives: 2018 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2019/03/index.html b/archives/2019/03/index.html new file mode 100644 index 0000000..7912b56 --- /dev/null +++ b/archives/2019/03/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2019/3 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2019/08/index.html b/archives/2019/08/index.html new file mode 100644 index 0000000..dbd0a2d --- /dev/null +++ b/archives/2019/08/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2019/8 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2019/09/index.html b/archives/2019/09/index.html new file mode 100644 index 0000000..6f044be --- /dev/null +++ b/archives/2019/09/index.html @@ -0,0 +1,659 @@ + + + + + + + + + Archives: 2019/9 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2019/11/index.html b/archives/2019/11/index.html new file mode 100644 index 0000000..3d5a19d --- /dev/null +++ b/archives/2019/11/index.html @@ -0,0 +1,659 @@ + + + + + + + + + Archives: 2019/11 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2019/12/index.html b/archives/2019/12/index.html new file mode 100644 index 0000000..5ea29f3 --- /dev/null +++ b/archives/2019/12/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2019/12 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2019/index.html b/archives/2019/index.html new file mode 100644 index 0000000..bfc8353 --- /dev/null +++ b/archives/2019/index.html @@ -0,0 +1,835 @@ + + + + + + + + + Archives: 2019 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2020/04/index.html b/archives/2020/04/index.html new file mode 100644 index 0000000..687f202 --- /dev/null +++ b/archives/2020/04/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2020/4 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2020/06/index.html b/archives/2020/06/index.html new file mode 100644 index 0000000..d479b95 --- /dev/null +++ b/archives/2020/06/index.html @@ -0,0 +1,749 @@ + + + + + + + + + Archives: 2020/6 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2020/07/index.html b/archives/2020/07/index.html new file mode 100644 index 0000000..0ce712a --- /dev/null +++ b/archives/2020/07/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2020/7 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2020/10/index.html b/archives/2020/10/index.html new file mode 100644 index 0000000..eca2497 --- /dev/null +++ b/archives/2020/10/index.html @@ -0,0 +1,659 @@ + + + + + + + + + Archives: 2020/10 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2020/12/index.html b/archives/2020/12/index.html new file mode 100644 index 0000000..7aca0fe --- /dev/null +++ b/archives/2020/12/index.html @@ -0,0 +1,663 @@ + + + + + + + + + Archives: 2020/12 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2020/index.html b/archives/2020/index.html new file mode 100644 index 0000000..d26efb8 --- /dev/null +++ b/archives/2020/index.html @@ -0,0 +1,933 @@ + + + + + + + + + Archives: 2020 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2021/10/index.html b/archives/2021/10/index.html new file mode 100644 index 0000000..19293cc --- /dev/null +++ b/archives/2021/10/index.html @@ -0,0 +1,702 @@ + + + + + + + + + Archives: 2021/10 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2021 +
+
+ + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2021/12/index.html b/archives/2021/12/index.html new file mode 100644 index 0000000..c5a8bf2 --- /dev/null +++ b/archives/2021/12/index.html @@ -0,0 +1,655 @@ + + + + + + + + + Archives: 2021/12 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2021 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2021/index.html b/archives/2021/index.html new file mode 100644 index 0000000..949d3d1 --- /dev/null +++ b/archives/2021/index.html @@ -0,0 +1,745 @@ + + + + + + + + + Archives: 2021 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2021 +
+
+ + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2022/01/index.html b/archives/2022/01/index.html new file mode 100644 index 0000000..99c5966 --- /dev/null +++ b/archives/2022/01/index.html @@ -0,0 +1,702 @@ + + + + + + + + + Archives: 2022/1 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2022 +
+
+ + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2022/03/index.html b/archives/2022/03/index.html new file mode 100644 index 0000000..74fb737 --- /dev/null +++ b/archives/2022/03/index.html @@ -0,0 +1,702 @@ + + + + + + + + + Archives: 2022/3 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2022 +
+
+ + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2022/index.html b/archives/2022/index.html new file mode 100644 index 0000000..2d44a1e --- /dev/null +++ b/archives/2022/index.html @@ -0,0 +1,792 @@ + + + + + + + + + Archives: 2022 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2022 +
+
+ + + + + + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2023/09/index.html b/archives/2023/09/index.html new file mode 100644 index 0000000..2a48fa5 --- /dev/null +++ b/archives/2023/09/index.html @@ -0,0 +1,710 @@ + + + + + + + + + Archives: 2023/9 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2023 +
+
+ + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2023/10/index.html b/archives/2023/10/index.html new file mode 100644 index 0000000..94f7e4c --- /dev/null +++ b/archives/2023/10/index.html @@ -0,0 +1,659 @@ + + + + + + + + + Archives: 2023/10 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2023 +
+
+ + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/2023/index.html b/archives/2023/index.html new file mode 100644 index 0000000..1246962 --- /dev/null +++ b/archives/2023/index.html @@ -0,0 +1,757 @@ + + + + + + + + + Archives: 2023 | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2023 +
+
+ + + + + + + + + + + + +
+ + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/index.html b/archives/index.html new file mode 100644 index 0000000..828c651 --- /dev/null +++ b/archives/index.html @@ -0,0 +1,1094 @@ + + + + + + + + + Archives | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2023 +
+
+ + + + + + + + + + + + + + +
+ + +
+
+ 2022 +
+
+ + + + + + + + + + + + + + + + + + +
+ + +
+
+ 2021 +
+
+ + + + + + + + + + + + +
+ + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/page/2/index.html b/archives/page/2/index.html new file mode 100644 index 0000000..aa1e2cd --- /dev/null +++ b/archives/page/2/index.html @@ -0,0 +1,1084 @@ + + + + + + + + + Archives | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2020 +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+
+ 2019 +
+
+ + + + + + + + + + + + +
+ + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/page/3/index.html b/archives/page/3/index.html new file mode 100644 index 0000000..f52cfe2 --- /dev/null +++ b/archives/page/3/index.html @@ -0,0 +1,1064 @@ + + + + + + + + + Archives | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2019 +
+
+ + + + + + + + + + +
+ + +
+
+ 2018 +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/archives/page/4/index.html b/archives/page/4/index.html new file mode 100644 index 0000000..12f2eeb --- /dev/null +++ b/archives/page/4/index.html @@ -0,0 +1,659 @@ + + + + + + + + + Archives | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + + + + + +
+
+ 2018 +
+
+ + + + +
+ + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/categories/index.html b/categories/index.html new file mode 100644 index 0000000..5ec6111 --- /dev/null +++ b/categories/index.html @@ -0,0 +1,768 @@ + + + + + + + + + categories | Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+
+
+ +
+ + +

+ categories +

+ + + + + + + + + + + + +
+ + + + + + 字数统计: + 0字 + + + + +   |   + + + 阅读时长≈ + 1分 + + +
+ + + +
+ +
+ + + + + + + +
+ +
+ + +
+
+ + + + + + + + + + +
+ +

扫一扫，分享到微信

+
+ +
+
+ +
+ + +
+
+
+
+ + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/content.json b/content.json new file mode 100644 index 0000000..43282a6 --- /dev/null +++ b/content.json @@ -0,0 +1 @@ +[{"title":"memos code analyze","date":"2023-10-07T08:04:51.908Z","path":"2023/10/07/Memos-Code-Analyze/","tags":[{"name":"golang","slug":"golang","permalink":"https://www.goroutine.cn/tags/golang/"},{"name":"memos","slug":"memos","permalink":"https://www.goroutine.cn/tags/memos/"}]},{"title":"Introduct to temporalio","date":"2023-09-18T15:42:06.533Z","path":"2023/09/18/Introduct-to-temporalio/","tags":[{"name":"工作流引擎","slug":"工作流引擎","permalink":"https://www.goroutine.cn/tags/%E5%B7%A5%E4%BD%9C%E6%B5%81%E5%BC%95%E6%93%8E/"},{"name":"Golang","slug":"Golang","permalink":"https://www.goroutine.cn/tags/Golang/"}]},{"title":"Introduct to go-clean-template","date":"2023-09-18T15:35:08.677Z","path":"2023/09/18/Introduct-to-go-clean-template/","tags":[{"name":"golang","slug":"golang","permalink":"https://www.goroutine.cn/tags/golang/"},{"name":"Microservices","slug":"Microservices","permalink":"https://www.goroutine.cn/tags/Microservices/"},{"name":"Architecture","slug":"Architecture","permalink":"https://www.goroutine.cn/tags/Architecture/"}]},{"title":"使用腾讯云cos+cdn搭建图片服务器","date":"2022-03-05T13:20:28.000Z","path":"2022/03/05/Tencent-COS-Image-Service/","tags":[{"name":"COS","slug":"COS","permalink":"https://www.goroutine.cn/tags/COS/"}]},{"title":"秒杀系统核心设计","date":"2022-03-02T15:12:44.000Z","path":"2022/03/02/seckill-md/","tags":[{"name":"Architecture","slug":"Architecture","permalink":"https://www.goroutine.cn/tags/Architecture/"},{"name":"秒杀","slug":"秒杀","permalink":"https://www.goroutine.cn/tags/%E7%A7%92%E6%9D%80/"}]},{"title":"Microservices in Action","date":"2022-01-10T12:24:33.000Z","path":"2022/01/10/Microservices-in-Action/","tags":[{"name":"Microservices","slug":"Microservices","permalink":"https://www.goroutine.cn/tags/Microservices/"},{"name":"Readingnotes","slug":"Readingnotes","permalink":"https://www.goroutine.cn/tags/Readingnotes/"}]},{"title":"Open Tracing","date":"2022-01-07T09:45:03.000Z","path":"2022/01/07/Open-Tracing/","tags":[{"name":"可观测","slug":"可观测","permalink":"https://www.goroutine.cn/tags/%E5%8F%AF%E8%A7%82%E6%B5%8B/"}]},{"title":"Application Tracking","date":"2021-12-04T12:41:25.000Z","path":"2021/12/04/Application-Tracking/","tags":[{"name":"可观测","slug":"可观测","permalink":"https://www.goroutine.cn/tags/%E5%8F%AF%E8%A7%82%E6%B5%8B/"}]},{"title":"Reliable Cron across the Planet","date":"2021-10-10T11:29:13.000Z","path":"2021/10/10/Reliable-Cron-across-the-Planet/","tags":[{"name":"分布式","slug":"分布式","permalink":"https://www.goroutine.cn/tags/%E5%88%86%E5%B8%83%E5%BC%8F/"},{"name":"cron","slug":"cron","permalink":"https://www.goroutine.cn/tags/cron/"}]},{"title":"libuv-source","date":"2021-10-04T03:00:51.000Z","path":"2021/10/04/libuv-source/","tags":[{"name":"libuv","slug":"libuv","permalink":"https://www.goroutine.cn/tags/libuv/"}]},{"title":"Introduction-to-memberlist","date":"2020-12-26T15:35:38.000Z","path":"2020/12/26/Introduction-to-memberlist/","tags":[{"name":"memberlist","slug":"memberlist","permalink":"https://www.goroutine.cn/tags/memberlist/"},{"name":"gossip","slug":"gossip","permalink":"https://www.goroutine.cn/tags/gossip/"},{"name":"分布式","slug":"分布式","permalink":"https://www.goroutine.cn/tags/%E5%88%86%E5%B8%83%E5%BC%8F/"}]},{"title":"Vscode Remote Connect failed","date":"2020-10-05T02:23:52.000Z","path":"2020/10/05/Vscode-Remote-Connect-failed/","tags":[{"name":"Vscode","slug":"Vscode","permalink":"https://www.goroutine.cn/tags/Vscode/"},{"name":"远程开发","slug":"远程开发","permalink":"https://www.goroutine.cn/tags/%E8%BF%9C%E7%A8%8B%E5%BC%80%E5%8F%91/"}]},{"title":"Introduction to Go Modules","date":"2020-07-02T11:59:58.000Z","path":"2020/07/02/Introduction-to-Go-Modules/","tags":[{"name":"golang","slug":"golang","permalink":"https://www.goroutine.cn/tags/golang/"}]},{"title":"Tencent Scf Version Manage","date":"2020-06-27T03:39:22.000Z","path":"2020/06/27/Tencent-Scf-Version-Manage/","tags":[{"name":"golang","slug":"golang","permalink":"https://www.goroutine.cn/tags/golang/"},{"name":"云函数","slug":"云函数","permalink":"https://www.goroutine.cn/tags/%E4%BA%91%E5%87%BD%E6%95%B0/"}]},{"title":"Functional options for friendly APIs","date":"2020-06-14T03:56:00.000Z","path":"2020/06/14/Functional-options-for-friendly-APIs/","tags":[{"name":"Configuration","slug":"Configuration","permalink":"https://www.goroutine.cn/tags/Configuration/"}]},{"title":"gomicro-config","date":"2020-06-08T14:41:46.000Z","path":"2020/06/08/gomicro-config/","tags":[{"name":"golang","slug":"golang","permalink":"https://www.goroutine.cn/tags/golang/"},{"name":"Microservices","slug":"Microservices","permalink":"https://www.goroutine.cn/tags/Microservices/"}]},{"title":"intern-recruitment","date":"2020-04-06T01:41:37.000Z","path":"2020/04/06/intern-recruitment/","tags":[{"name":"随笔","slug":"随笔","permalink":"https://www.goroutine.cn/tags/%E9%9A%8F%E7%AC%94/"}]},{"title":"golang viper tips","date":"2019-12-15T03:19:55.000Z","path":"2019/12/15/golang-viper-tips/","tags":[{"name":"Configuration","slug":"Configuration","permalink":"https://www.goroutine.cn/tags/Configuration/"}]},{"title":"docker redis install","date":"2019-11-16T16:02:16.000Z","path":"2019/11/17/docker-redis-install/","tags":[{"name":"docker","slug":"docker","permalink":"https://www.goroutine.cn/tags/docker/"},{"name":"redis","slug":"redis","permalink":"https://www.goroutine.cn/tags/redis/"}]},{"title":"docker nginx install","date":"2019-09-12T16:02:16.000Z","path":"2019/09/13/docker-nginx-install/","tags":[{"name":"docker","slug":"docker","permalink":"https://www.goroutine.cn/tags/docker/"},{"name":"nginx","slug":"nginx","permalink":"https://www.goroutine.cn/tags/nginx/"}]},{"title":"groupcache","date":"2019-08-21T15:31:42.000Z","path":"2019/08/21/groupcache/","tags":[{"name":"groupcache","slug":"groupcache","permalink":"https://www.goroutine.cn/tags/groupcache/"}]},{"title":"golang pprof","date":"2019-03-15T16:22:38.000Z","path":"2019/03/16/golang-pprof/","tags":[{"name":"golang","slug":"golang","permalink":"https://www.goroutine.cn/tags/golang/"}]},{"title":"Puppeteer coverage","date":"2018-10-29T12:24:15.000Z","path":"2018/10/29/Puppeteer-coverage/","tags":[{"name":"Puppeteer","slug":"Puppeteer","permalink":"https://www.goroutine.cn/tags/Puppeteer/"}]},{"title":"upload file via http","date":"2018-09-09T11:02:53.000Z","path":"2018/09/09/upload-file-via-http/","tags":[{"name":"nginx","slug":"nginx","permalink":"https://www.goroutine.cn/tags/nginx/"}]},{"title":"Unique ID generator","date":"2018-06-24T13:15:54.000Z","path":"2018/06/24/Unique-ID-generator/","tags":[{"name":"wechat","slug":"wechat","permalink":"https://www.goroutine.cn/tags/wechat/"},{"name":"UUID","slug":"UUID","permalink":"https://www.goroutine.cn/tags/UUID/"}]},{"title":"HTTPS performacne tips","date":"2018-06-03T10:32:33.000Z","path":"2018/06/03/HTTPS-performacne-tips/","tags":[{"name":"HTTPS","slug":"HTTPS","permalink":"https://www.goroutine.cn/tags/HTTPS/"}]},{"title":"HTTPS explained with carrier pigeons","date":"2018-06-03T08:15:33.000Z","path":"2018/06/03/HTTPS-explained-with-carrier-pigeons/","tags":[{"name":"HTTPS","slug":"HTTPS","permalink":"https://www.goroutine.cn/tags/HTTPS/"}]},{"title":"nginx-forward-http-x-forwarded-proto-header","date":"2018-06-03T00:16:59.000Z","path":"2018/06/03/nginx-forward-http-x-forwarded-proto-header/","tags":[{"name":"nginx","slug":"nginx","permalink":"https://www.goroutine.cn/tags/nginx/"}]},{"title":"nginx-accel-redirect","date":"2018-05-01T06:12:03.000Z","path":"2018/05/01/nginx-accel-redirect/","tags":[{"name":"nginx","slug":"nginx","permalink":"https://www.goroutine.cn/tags/nginx/"},{"name":"Authentication","slug":"Authentication","permalink":"https://www.goroutine.cn/tags/Authentication/"}]},{"title":"RWMutex in go","date":"2018-03-03T11:54:54.000Z","path":"2018/03/03/RWMutex-in-go/","tags":[{"name":"RWMutex","slug":"RWMutex","permalink":"https://www.goroutine.cn/tags/RWMutex/"}]},{"title":"常用 Git 命令清单","date":"2018-02-21T14:04:27.000Z","path":"2018/02/21/git/","tags":[{"name":"git","slug":"git","permalink":"https://www.goroutine.cn/tags/git/"}]}] \ No newline at end of file diff --git a/fonts/default-skin.b257fa.svg b/fonts/default-skin.b257fa.svg new file mode 100644 index 0000000..9d5f0c6 --- /dev/null +++ b/fonts/default-skin.b257fa.svg @@ -0,0 +1 @@ +default-skin 2 \ No newline at end of file diff --git a/fonts/fonteditor.3da1ef.woff b/fonts/fonteditor.3da1ef.woff new file mode 100644 index 0000000..1b4d090 Binary files /dev/null and b/fonts/fonteditor.3da1ef.woff differ diff --git a/fonts/fonteditor.3e0d4a.svg b/fonts/fonteditor.3e0d4a.svg new file mode 100644 index 0000000..8260185 --- /dev/null +++ b/fonts/fonteditor.3e0d4a.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fonts/fonteditor.86c132.eot b/fonts/fonteditor.86c132.eot new file mode 100644 index 0000000..e24809c Binary files /dev/null and b/fonts/fonteditor.86c132.eot differ diff --git a/fonts/fonteditor.bbc4b5.woff2 b/fonts/fonteditor.bbc4b5.woff2 new file mode 100644 index 0000000..798e514 Binary files /dev/null and b/fonts/fonteditor.bbc4b5.woff2 differ diff --git a/fonts/fonteditor.fe4d8a.ttf b/fonts/fonteditor.fe4d8a.ttf new file mode 100644 index 0000000..e0b54da Binary files /dev/null and b/fonts/fonteditor.fe4d8a.ttf differ diff --git a/fonts/tooltip.4004ff.svg b/fonts/tooltip.4004ff.svg new file mode 100644 index 0000000..252cb39 --- /dev/null +++ b/fonts/tooltip.4004ff.svg @@ -0,0 +1,6 @@ + + + + + diff --git a/gitment/APlayer.min.js b/gitment/APlayer.min.js new file mode 100644 index 0000000..b52c3cd --- /dev/null +++ b/gitment/APlayer.min.js @@ -0,0 +1,8 @@ +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define("APlayer",[],t):"object"==typeof exports?exports.APlayer=t():e.APlayer=t()}(this,function(){return function(e){function t(r){if(n[r])return n[r].exports;var a=n[r]={i:r,l:!1,exports:{}};return e[r].call(a.exports,a,a.exports,t),a.l=!0,a.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=13)}([function(e,t,n){var r=n(3);"string"==typeof r&&(r=[[e.i,r,""]]);n(10)(r,{});r.locals&&(e.exports=r.locals)},function(e,t,n){"use strict";function r(e){var t=e.length;if(t%4>0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[t-2]?2:"="===e[t-1]?1:0}function a(e){return 3*e.length/4-r(e)}function i(e){var t,n,a,i,o,l,s=e.length;o=r(e),l=new c(3*s/4-o),a=o>0?s-4:s;var u=0;for(t=0,n=0;t>16&255,l[u++]=i>>8&255,l[u++]=255&i;return 2===o?(i=p[e.charCodeAt(t)]<<2|p[e.charCodeAt(t+1)]>>4,l[u++]=255&i):1===o&&(i=p[e.charCodeAt(t)]<<10|p[e.charCodeAt(t+1)]<<4|p[e.charCodeAt(t+2)]>>2,l[u++]=i>>8&255,l[u++]=255&i),l}function o(e){return u[e>>18&63]+u[e>>12&63]+u[e>>6&63]+u[63&e]}function l(e,t,n){for(var r,a=[],i=t;ip?p:s+o));return 1===r?(t=e[n-1],a+=u[t>>2],a+=u[t<<4&63],a+="=="):2===r&&(t=(e[n-2]<<8)+e[n-1],a+=u[t>>10],a+=u[t>>4&63],a+=u[t<<2&63],a+="="),i.push(a),i.join("")}t.byteLength=a,t.toByteArray=i,t.fromByteArray=s;for(var u=[],p=[],c="undefined"!=typeof Uint8Array?Uint8Array:Array,h="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",f=0,d=h.length;f=a())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a().toString(16)+" bytes");return 0|e}function m(e){return+e!=e&&(e=0),o.alloc(+e)}function g(e,t){if(o.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return G(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return Q(e).length;default:if(r)return G(e).length;t=(""+t).toLowerCase(),r=!0}}function v(e,t,n){var r=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if(n>>>=0,t>>>=0,n<=t)return"";for(e||(e="utf8");;)switch(e){case"hex":return k(this,t,n);case"utf8":case"utf-8":return L(this,t,n);case"ascii":return S(this,t,n);case"latin1":case"binary":return N(this,t,n);case"base64":return I(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return U(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}function b(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function w(e,t,n,r,a){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):n>2147483647?n=2147483647:n<-2147483648&&(n=-2147483648),n=+n,isNaN(n)&&(n=a?0:e.length-1),n<0&&(n=e.length+n),n>=e.length){if(a)return-1;n=e.length-1}else if(n<0){if(!a)return-1;n=0}if("string"==typeof t&&(t=o.from(t,r)),o.isBuffer(t))return 0===t.length?-1:A(e,t,n,r,a);if("number"==typeof t)return t&=255,o.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?a?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):A(e,[t],n,r,a);throw new TypeError("val must be string, number or Buffer")}function A(e,t,n,r,a){function i(e,t){return 1===o?e[t]:e.readUInt16BE(t*o)}var o=1,l=e.length,s=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;o=2,l/=2,s/=2,n/=2}var u;if(a){var p=-1;for(u=n;ul&&(n=l-s),u=n;u>=0;u--){for(var c=!0,h=0;ha&&(r=a):r=a;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");r>i/2&&(r=i/2);for(var o=0;o239?4:i>223?3:i>191?2:1;if(a+l<=n){var s,u,p,c;switch(l){case 1:i<128&&(o=i);break;case 2:s=e[a+1],128==(192&s)&&(c=(31&i)<<6|63&s)>127&&(o=c);break;case 3:s=e[a+1],u=e[a+2],128==(192&s)&&128==(192&u)&&(c=(15&i)<<12|(63&s)<<6|63&u)>2047&&(c<55296||c>57343)&&(o=c);break;case 4:s=e[a+1],u=e[a+2],p=e[a+3],128==(192&s)&&128==(192&u)&&128==(192&p)&&(c=(15&i)<<18|(63&s)<<12|(63&u)<<6|63&p)>65535&&c<1114112&&(o=c)}}null===o?(o=65533,l=1):o>65535&&(o-=65536,r.push(o>>>10&1023|55296),o=56320|1023&o),r.push(o),a+=l}return C(r)}function C(e){var t=e.length;if(t<=ee)return String.fromCharCode.apply(String,e);for(var n="",r=0;rr)&&(n=r);for(var a="",i=t;in)throw new RangeError("Trying to access beyond buffer length")}function Y(e,t,n,r,a,i){if(!o.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>a||te.length)throw new RangeError("Index out of range")}function O(e,t,n,r){t<0&&(t=65535+t+1);for(var a=0,i=Math.min(e.length-n,2);a>>8*(r?a:1-a)}function q(e,t,n,r){t<0&&(t=4294967295+t+1);for(var a=0,i=Math.min(e.length-n,4);a>>8*(r?a:3-a)&255}function j(e,t,n,r,a,i){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function z(e,t,n,r,a){return a||j(e,t,n,4,3.4028234663852886e38,-3.4028234663852886e38),X.write(e,t,n,r,23,4),n+4}function D(e,t,n,r,a){return a||j(e,t,n,8,1.7976931348623157e308,-1.7976931348623157e308),X.write(e,t,n,r,52,8),n+8}function J(e){if(e=H(e).replace(te,""),e.length<2)return"";for(;e.length%4!=0;)e+="=";return e}function H(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function _(e){return e<16?"0"+e.toString(16):e.toString(16)}function G(e,t){t=t||1/0;for(var n,r=e.length,a=null,i=[],o=0;o55295&&n<57344){if(!a){if(n>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(o+1===r){(t-=3)>-1&&i.push(239,191,189);continue}a=n;continue}if(n<56320){(t-=3)>-1&&i.push(239,191,189),a=n;continue}n=65536+(a-55296<<10|n-56320)}else a&&(t-=3)>-1&&i.push(239,191,189);if(a=null,n<128){if((t-=1)<0)break;i.push(n)}else if(n<2048){if((t-=2)<0)break;i.push(n>>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;i.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return i}function Z(e){for(var t=[],n=0;n>8,a=n%256,i.push(a),i.push(r);return i}function Q(e){return W.toByteArray(J(e))}function V(e,t,n,r){for(var a=0;a=t.length||a>=e.length);++a)t[a+n]=e[a];return a}function K(e){return e!==e}/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var W=n(1),X=n(6),$=n(7);t.Buffer=o,t.SlowBuffer=m,t.INSPECT_MAX_BYTES=50,o.TYPED_ARRAY_SUPPORT=void 0!==e.TYPED_ARRAY_SUPPORT?e.TYPED_ARRAY_SUPPORT:r(),t.kMaxLength=a(),o.poolSize=8192,o._augment=function(e){return e.__proto__=o.prototype,e},o.from=function(e,t,n){return l(null,e,t,n)},o.TYPED_ARRAY_SUPPORT&&(o.prototype.__proto__=Uint8Array.prototype,o.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&o[Symbol.species]===o&&Object.defineProperty(o,Symbol.species,{value:null,configurable:!0})),o.alloc=function(e,t,n){return u(null,e,t,n)},o.allocUnsafe=function(e){return p(null,e)},o.allocUnsafeSlow=function(e){return p(null,e)},o.isBuffer=function(e){return!(null==e||!e._isBuffer)},o.compare=function(e,t){if(!o.isBuffer(e)||!o.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var n=e.length,r=t.length,a=0,i=Math.min(n,r);a0&&(e=this.toString("hex",0,n).match(/.{2}/g).join(" "),this.length>n&&(e+=" ... ")),""},o.prototype.compare=function(e,t,n,r,a){if(!o.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===a&&(a=this.length),t<0||n>e.length||r<0||a>this.length)throw new RangeError("out of range index");if(r>=a&&t>=n)return 0;if(r>=a)return-1;if(t>=n)return 1;if(t>>>=0,n>>>=0,r>>>=0,a>>>=0,this===e)return 0;for(var i=a-r,l=n-t,s=Math.min(i,l),u=this.slice(r,a),p=e.slice(t,n),c=0;ca)&&(n=a),e.length>0&&(n<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var i=!1;;)switch(r){case"hex":return E(this,e,t,n);case"utf8":case"utf-8":return x(this,e,t,n);case"ascii":return T(this,e,t,n);case"latin1":case"binary":return B(this,e,t,n);case"base64":return M(this,e,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return R(this,e,t,n);default:if(i)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),i=!0}},o.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var ee=4096;o.prototype.slice=function(e,t){var n=this.length;e=~~e,t=void 0===t?n:~~t,e<0?(e+=n)<0&&(e=0):e>n&&(e=n),t<0?(t+=n)<0&&(t=0):t>n&&(t=n),t0&&(a*=256);)r+=this[e+--t]*a;return r},o.prototype.readUInt8=function(e,t){return t||P(e,1,this.length),this[e]},o.prototype.readUInt16LE=function(e,t){return t||P(e,2,this.length),this[e]|this[e+1]<<8},o.prototype.readUInt16BE=function(e,t){return t||P(e,2,this.length),this[e]<<8|this[e+1]},o.prototype.readUInt32LE=function(e,t){return t||P(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},o.prototype.readUInt32BE=function(e,t){return t||P(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},o.prototype.readIntLE=function(e,t,n){e|=0,t|=0,n||P(e,t,this.length);for(var r=this[e],a=1,i=0;++i=a&&(r-=Math.pow(2,8*t)),r},o.prototype.readIntBE=function(e,t,n){e|=0,t|=0,n||P(e,t,this.length);for(var r=t,a=1,i=this[e+--r];r>0&&(a*=256);)i+=this[e+--r]*a;return a*=128,i>=a&&(i-=Math.pow(2,8*t)),i},o.prototype.readInt8=function(e,t){return t||P(e,1,this.length),128&this[e]?(255-this[e]+1)*-1:this[e]},o.prototype.readInt16LE=function(e,t){t||P(e,2,this.length);var n=this[e]|this[e+1]<<8;return 32768&n?4294901760|n:n},o.prototype.readInt16BE=function(e,t){t||P(e,2,this.length);var n=this[e+1]|this[e]<<8;return 32768&n?4294901760|n:n},o.prototype.readInt32LE=function(e,t){return t||P(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},o.prototype.readInt32BE=function(e,t){return t||P(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},o.prototype.readFloatLE=function(e,t){return t||P(e,4,this.length),X.read(this,e,!0,23,4)},o.prototype.readFloatBE=function(e,t){return t||P(e,4,this.length),X.read(this,e,!1,23,4)},o.prototype.readDoubleLE=function(e,t){return t||P(e,8,this.length),X.read(this,e,!0,52,8)},o.prototype.readDoubleBE=function(e,t){return t||P(e,8,this.length),X.read(this,e,!1,52,8)},o.prototype.writeUIntLE=function(e,t,n,r){if(e=+e,t|=0,n|=0,!r){Y(this,e,t,n,Math.pow(2,8*n)-1,0)}var a=1,i=0;for(this[t]=255&e;++i=0&&(i*=256);)this[t+a]=e/i&255;return t+n},o.prototype.writeUInt8=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,1,255,0),o.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},o.prototype.writeUInt16LE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,2,65535,0),o.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):O(this,e,t,!0),t+2},o.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,2,65535,0),o.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):O(this,e,t,!1),t+2},o.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,4,4294967295,0),o.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):q(this,e,t,!0),t+4},o.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,4,4294967295,0),o.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):q(this,e,t,!1),t+4},o.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var a=Math.pow(2,8*n-1);Y(this,e,t,n,a-1,-a)}var i=0,o=1,l=0;for(this[t]=255&e;++i>0)-l&255;return t+n},o.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var a=Math.pow(2,8*n-1);Y(this,e,t,n,a-1,-a)}var i=n-1,o=1,l=0;for(this[t+i]=255&e;--i>=0&&(o*=256);)e<0&&0===l&&0!==this[t+i+1]&&(l=1),this[t+i]=(e/o>>0)-l&255;return t+n},o.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,1,127,-128),o.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},o.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,2,32767,-32768),o.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):O(this,e,t,!0),t+2},o.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,2,32767,-32768),o.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):O(this,e,t,!1),t+2},o.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,4,2147483647,-2147483648),o.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):q(this,e,t,!0),t+4},o.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||Y(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),o.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):q(this,e,t,!1),t+4},o.prototype.writeFloatLE=function(e,t,n){return z(this,e,t,!0,n)},o.prototype.writeFloatBE=function(e,t,n){return z(this,e,t,!1,n)},o.prototype.writeDoubleLE=function(e,t,n){return D(this,e,t,!0,n)},o.prototype.writeDoubleBE=function(e,t,n){return D(this,e,t,!1,n)},o.prototype.copy=function(e,t,n,r){if(n||(n=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),r>0&&r=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t=0;--a)e[a+t]=this[a+n];else if(i<1e3||!o.TYPED_ARRAY_SUPPORT)for(a=0;a>>=0,n=void 0===n?this.length:n>>>0,e||(e=0);var i;if("number"==typeof e)for(i=t;i>1,p=-7,c=n?a-1:0,h=n?-1:1,f=e[t+c];for(c+=h,i=f&(1<<-p)-1,f>>=-p,p+=l;p>0;i=256*i+e[t+c],c+=h,p-=8);for(o=i&(1<<-p)-1,i>>=-p,p+=r;p>0;o=256*o+e[t+c],c+=h,p-=8);if(0===i)i=1-u;else{if(i===s)return o?NaN:1/0*(f?-1:1);o+=Math.pow(2,r),i-=u}return(f?-1:1)*o*Math.pow(2,i-r)},t.write=function(e,t,n,r,a,i){var o,l,s,u=8*i-a-1,p=(1<>1,h=23===a?Math.pow(2,-24)-Math.pow(2,-77):0,f=r?0:i-1,d=r?1:-1,y=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(l=isNaN(t)?1:0,o=p):(o=Math.floor(Math.log(t)/Math.LN2),t*(s=Math.pow(2,-o))<1&&(o--,s*=2),t+=o+c>=1?h/s:h*Math.pow(2,1-c),t*s>=2&&(o++,s/=2),o+c>=p?(l=0,o=p):o+c>=1?(l=(t*s-1)*Math.pow(2,a),o+=c):(l=t*Math.pow(2,c-1)*Math.pow(2,a),o=0));a>=8;e[n+f]=255&l,f+=d,l/=256,a-=8);for(o=o<0;e[n+f]=255&o,f+=d,o/=256,u-=8);e[n+f-d]|=128*y}},function(e,t){var n={}.toString;e.exports=Array.isArray||function(e){return"[object Array]"==n.call(e)}},function(e,t,n){(function(e){function n(e,t){for(var n=0,r=e.length-1;r>=0;r--){var a=e[r];"."===a?e.splice(r,1):".."===a?(e.splice(r,1),n++):n&&(e.splice(r,1),n--)}if(t)for(;n--;n)e.unshift("..");return e}function r(e,t){if(e.filter)return e.filter(t);for(var n=[],r=0;r=-1&&!a;i--){var o=i>=0?arguments[i]:e.cwd();if("string"!=typeof o)throw new TypeError("Arguments to path.resolve must be strings");o&&(t=o+"/"+t,a="/"===o.charAt(0))}return t=n(r(t.split("/"),function(e){return!!e}),!a).join("/"),(a?"/":"")+t||"."},t.normalize=function(e){var a=t.isAbsolute(e),i="/"===o(e,-1);return e=n(r(e.split("/"),function(e){return!!e}),!a).join("/"),e||a||(e="."),e&&i&&(e+="/"),(a?"/":"")+e},t.isAbsolute=function(e){return"/"===e.charAt(0)},t.join=function(){var e=Array.prototype.slice.call(arguments,0);return t.normalize(r(e,function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e}).join("/"))},t.relative=function(e,n){function r(e){for(var t=0;t=0&&""===e[n];n--);return t>n?[]:e.slice(t,n-t+1)}e=t.resolve(e).substr(1),n=t.resolve(n).substr(1);for(var a=r(e.split("/")),i=r(n.split("/")),o=Math.min(a.length,i.length),l=o,s=0;s1)for(var n=1;n=0&&v.splice(t,1)}function o(e){var t=document.createElement("style");return t.type="text/css",a(e,t),t}function l(e){var t=document.createElement("link");return t.rel="stylesheet",a(e,t),t}function s(e,t){var n,r,a;if(t.singleton){var s=g++;n=m||(m=o(t)),r=u.bind(null,n,s,!1),a=u.bind(null,n,s,!0)}else e.sourceMap&&"function"==typeof URL&&"function"==typeof URL.createObjectURL&&"function"==typeof URL.revokeObjectURL&&"function"==typeof Blob&&"function"==typeof btoa?(n=l(t),r=c.bind(null,n),a=function(){i(n),n.href&&URL.revokeObjectURL(n.href)}):(n=o(t),r=p.bind(null,n),a=function(){i(n)});return r(e),function(t){if(t){if(t.css===e.css&&t.media===e.media&&t.sourceMap===e.sourceMap)return;r(e=t)}else a()}}function u(e,t,n,r){var a=n?"":r.css;if(e.styleSheet)e.styleSheet.cssText=b(t,a);else{var i=document.createTextNode(a),o=e.childNodes;o[t]&&e.removeChild(o[t]),o.length?e.insertBefore(i,o[t]):e.appendChild(i)}}function p(e,t){var n=t.css,r=t.media;if(r&&e.setAttribute("media",r),e.styleSheet)e.styleSheet.cssText=n;else{for(;e.firstChild;)e.removeChild(e.firstChild);e.appendChild(document.createTextNode(n))}}function c(e,t){var n=t.css,r=t.sourceMap;r&&(n+="\n/*# sourceMappingURL=data:application/json;base64,"+btoa(unescape(encodeURIComponent(JSON.stringify(r))))+" */");var a=new Blob([n],{type:"text/css"}),i=e.href;e.href=URL.createObjectURL(a),i&&URL.revokeObjectURL(i)}var h={},f=function(e){var t;return function(){return void 0===t&&(t=e.apply(this,arguments)),t}},d=f(function(){return/msie [6-9]\b/.test(self.navigator.userAgent.toLowerCase())}),y=f(function(){return document.head||document.getElementsByTagName("head")[0]}),m=null,g=0,v=[];e.exports=function(e,t){if("undefined"!=typeof DEBUG&&DEBUG&&"object"!=typeof document)throw new Error("The style-loader cannot be used in a non-browser environment");t=t||{},void 0===t.singleton&&(t.singleton=d()),void 0===t.insertAt&&(t.insertAt="bottom");var a=r(e);return n(a,t),function(e){for(var i=[],o=0;o\n \n \n \n '},this.isMobile=/mobile/i.test(window.navigator.userAgent),this.isMobile&&(t.autoplay=!1);var s={element:document.getElementsByClassName("aplayer")[0],narrow:!1,autoplay:!1,mutex:!0,showlrc:0,theme:"#b7daff",mode:"circulation"};for(var u in s)s.hasOwnProperty(u)&&!t.hasOwnProperty(u)&&(t[u]=s[u]);if(this.option=t,this.audios=[],this.mode=t.mode,this.secondToTime=function(e){if(isNaN(e))return"00:00";var t=function(e){return e<10?"0"+e:""+e},n=parseInt(e/60),r=parseInt(e-60*n),a=parseInt(n/60),i=parseInt(e/60-60*parseInt(e/60/60));return e>=3600?t(a)+":"+t(i)+":"+t(r):t(n)+":"+t(r)},this.element=this.option.element,2===this.option.showlrc||this.option.showlrc===!0){this.savelrc=[];for(var p=0;p0?t:0,t=t<1?t:1,y[e+"Bar"].style[n]=100*t+"%"},this.updateLrc=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:i.audio.currentTime;if(i.lrcIndex>i.lrc.length-1||e=i.lrc[i.lrcIndex+1][0])for(var t=0;t=i.lrc[t][0]&&(!i.lrc[t+1]||e1&&this.element.classList.add("aplayer-withlist"),this.multiple||"circulation"===this.mode||"order"===this.mode||(this.mode="circulation"),this.getRandomOrder();for(var f='\n
\n
\n \n
\n
\n
\n
\n \n \n
\n
\n
\n
\n
\n
\n
\n
\n
\n \n
\n
\n
\n
\n \n - 00:00 / 00:00\n \n
\n \n
\n
\n
\n
\n
\n
\n \n \n
\n
\n
\n
\n
    ',d=0;d\n \n '+(d+1)+'\n '+this.option.music[d].title+'\n '+this.option.music[d].author+"\n ";f+="\n
\n
",this.element.innerHTML=f,this.element.offsetWidth<300&&(this.element.getElementsByClassName("aplayer-icon-mode")[0].style.display="none"),this.ptime=this.element.getElementsByClassName("aplayer-ptime")[0],this.element.getElementsByClassName("aplayer-info")[0].offsetWidth<200&&this.element.getElementsByClassName("aplayer-time")[0].classList.add("aplayer-time-narrow");var y={};y.barWrap=this.element.getElementsByClassName("aplayer-bar-wrap")[0],this.option.narrow&&this.element.classList.add("aplayer-narrow"),this.button=this.element.getElementsByClassName("aplayer-button")[0],this.button.addEventListener("click",function(e){i.toggle()});var m=this.element.getElementsByClassName("aplayer-list")[0];m.addEventListener("click",function(e){var t=void 0;t="LI"===e.target.tagName.toUpperCase()?e.target:e.target.parentElement;var n=parseInt(t.getElementsByClassName("aplayer-list-index")[0].innerHTML)-1;n!==i.playIndex?(i.setMusic(n),i.play()):i.toggle()}),y.playedBar=this.element.getElementsByClassName("aplayer-played")[0],y.loadedBar=this.element.getElementsByClassName("aplayer-loaded")[0];var g=this.element.getElementsByClassName("aplayer-thumb")[0],v=void 0;y.barWrap.addEventListener("click",function(e){var t=e||window.event;v=y.barWrap.clientWidth;var r=(t.clientX-n(y.barWrap))/v;isNaN(i.audio.duration)?i.updateBar("played",0,"width"):(i.updateBar("played",r,"width"),i.element.getElementsByClassName("aplayer-ptime")[0].innerHTML=i.secondToTime(r*i.audio.duration),i.audio.currentTime=parseFloat(y.playedBar.style.width)/100*i.audio.duration)}),g.addEventListener("mouseover",function(){g.style.background=i.option.theme}),g.addEventListener("mouseout",function(){g.style.background="#fff"});var b=function(e){var t=e||window.event,r=(t.clientX-n(y.barWrap))/v;r=r>0?r:0,r=r<1?r:1,i.updateBar("played",r,"width"),i.option.showlrc&&i.updateLrc(parseFloat(y.playedBar.style.width)/100*i.audio.duration),i.element.getElementsByClassName("aplayer-ptime")[0].innerHTML=i.secondToTime(r*i.audio.duration)},w=function e(){document.removeEventListener("mouseup",e),document.removeEventListener("mousemove",b),isNaN(i.audio.duration)?i.updateBar("played",0,"width"):(i.audio.currentTime=parseFloat(y.playedBar.style.width)/100*i.audio.duration,i.playedTime=setInterval(function(){i.updateBar("played",i.audio.currentTime/i.audio.duration,"width"),i.option.showlrc&&i.updateLrc(),i.element.getElementsByClassName("aplayer-ptime")[0].innerHTML=i.secondToTime(i.audio.currentTime),i.trigger("playing")},100))};g.addEventListener("mousedown",function(){v=y.barWrap.clientWidth,clearInterval(i.playedTime),document.addEventListener("mousemove",b),document.addEventListener("mouseup",w)}),y.volumeBar=this.element.getElementsByClassName("aplayer-volume")[0];var A=this.element.getElementsByClassName("aplayer-volume-bar")[0];this.volumeicon=this.element.getElementsByClassName("aplayer-time")[0].getElementsByTagName("button")[0];var E=35;this.element.getElementsByClassName("aplayer-volume-bar-wrap")[0].addEventListener("click",function(e){var t=e||window.event,n=(E-t.clientY+r(A))/E;n=n>0?n:0,n=n<1?n:1,i.volume(n)}),this.volumeicon.addEventListener("click",function(){i.audio.muted?(i.audio.muted=!1,i.volumeicon.className=1===i.audio.volume?"aplayer-icon aplayer-icon-volume-up":"aplayer-icon aplayer-icon-volume-down",1===i.audio.volume?(i.volumeicon.className="aplayer-icon aplayer-icon-volume-up",i.volumeicon.innerHTML=i.getSVG("volume-up")):(i.volumeicon.className="aplayer-icon aplayer-icon-volume-down",i.volumeicon.innerHTML=i.getSVG("volume-down")),i.updateBar("volume",i.audio.volume,"height")):(i.audio.muted=!0,i.volumeicon.className="aplayer-icon aplayer-icon-volume-off",i.volumeicon.innerHTML=i.getSVG("volume-off"),i.updateBar("volume",0,"height"))});var x=this.element.getElementsByClassName("aplayer-icon-mode")[0];x.addEventListener("click",function(){i.multiple?"random"===i.mode?i.mode="single":"single"===i.mode?i.mode="order":"order"===i.mode?i.mode="circulation":"circulation"===i.mode&&(i.mode="random"):"circulation"===i.mode?i.mode="order":i.mode="circulation",x.innerHTML=i.getSVG(i.mode),i.audio.loop=!(i.multiple||"order"===i.mode)}),m.style.height=m.offsetHeight+"px",this.element.getElementsByClassName("aplayer-icon-menu")[0].addEventListener("click",function(){m.classList.contains("aplayer-list-hide")?m.classList.remove("aplayer-list-hide"):m.classList.add("aplayer-list-hide")}),"random"===this.mode?this.setMusic(this.randomOrder[0]):this.setMusic(0),o.push(this)}return i(e,[{key:"setMusic",value:function(e){var t=this;void 0!==e&&(this.playIndex=e);var n=this.playIndex;this.music=this.option.music[n],this.music.pic&&(this.element.getElementsByClassName("aplayer-pic")[0].style.backgroundImage="url('"+this.music.pic+"')"),this.element.getElementsByClassName("aplayer-title")[0].innerHTML=this.music.title,this.element.getElementsByClassName("aplayer-author")[0].innerHTML=" - "+this.music.author,this.element.getElementsByClassName("aplayer-list-light")[0]&&this.element.getElementsByClassName("aplayer-list-light")[0].classList.remove("aplayer-list-light"),this.element.getElementsByClassName("aplayer-list")[0].getElementsByTagName("li")[n].classList.add("aplayer-list-light"),this.audio&&(this.pause(),this.audio.currentTime=0),this.element.getElementsByClassName("aplayer-list")[0].scrollTop=33*n,this.audios[n]?(this.audio=this.audios[n],this.audio.volume=parseInt(this.element.getElementsByClassName("aplayer-volume")[0].style.height)/100,this.audio.currentTime=0):(this.audio=document.createElement("audio"),this.audio.src=this.music.url,this.audio.preload=this.option.preload?this.option.preload:"auto",this.audio.addEventListener("play",function(){if(t.button.classList.contains("aplayer-play")){if(t.button.classList.remove("aplayer-play"),t.button.classList.add("aplayer-pause"),t.button.innerHTML="",setTimeout(function(){t.button.innerHTML='\n "},100),t.option.mutex)for(var e=0;e'+t.getSVG("play")+" "},100),clearInterval(t.playedTime),t.trigger("pause"))}),this.audio.addEventListener("durationchange",function(){1!==t.audio.duration&&(t.element.getElementsByClassName("aplayer-dtime")[0].innerHTML=t.secondToTime(t.audio.duration))}),this.audio.addEventListener("progress",function(){var e=t.audio.buffered.length?t.audio.buffered.end(t.audio.buffered.length-1)/t.audio.duration:0;t.updateBar("loaded",e,"width")}),this.audio.addEventListener("error",function(){t.element.getElementsByClassName("aplayer-author")[0].innerHTML=" - Error happens ╥﹏╥",t.trigger("pause")}),this.audio.addEventListener("canplay",function(){t.trigger("canplay")}),this.ended=!1,this.audio.addEventListener("ended",function(){if(t.multiple){if(t.isMobile)return t.ended=!0,void t.pause();0!==t.audio.currentTime&&("random"===t.mode?t.setMusic(t.nextRandomNum()):"single"===t.mode?t.setMusic(t.playIndex):"order"===t.mode?t.playIndex=200&&l.status<300||304===l.status?(i=l.responseText,t.lrcs[a]=r(i)):(console.log("Request was unsuccessful: "+l.status),t.lrcs[a]=[["00:00","Not available"]]),t.lrc=t.lrcs[a];var e="";t.lrcContents=t.element.getElementsByClassName("aplayer-lrc-contents")[0];for(var n=0;n"+t.lrc[n][1]+"

";t.lrcContents.innerHTML=e,t.lrcIndex||(t.lrcIndex=0),t.lrcContents.getElementsByTagName("p")[0].classList.add("aplayer-lrc-current"),t.lrcContents.style.transform="translateY(0px)",t.lrcContents.style.webkitTransform="translateY(0px)"}};var s=void 0;s=this.option.music[a].lrc,l.open("get",s,!0),l.send(null)}i?this.lrcs[a]=r(i):3===this.option.showlrc?this.lrcs[a]=[["00:00","Loading"]]:this.lrcs[a]=[["00:00","Not available"]]}this.lrc=this.lrcs[a];var u="";this.lrcContents=this.element.getElementsByClassName("aplayer-lrc-contents")[0];for(var p=0;p"+this.lrc[p][1]+"

";this.lrcContents.innerHTML=u,this.lrcIndex||(this.lrcIndex=0),this.lrcContents.getElementsByTagName("p")[0].classList.add("aplayer-lrc-current"),this.lrcContents.style.transform="translateY(0px)",this.lrcContents.style.webkitTransform="translateY(0px)"}1!==this.audio.duration&&(this.element.getElementsByClassName("aplayer-dtime")[0].innerHTML=this.audio.duration?this.secondToTime(this.audio.duration):"00:00"),this.option.autoplay&&!this.isMobile&&this.play(),this.option.autoplay=!0,this.isMobile&&this.pause()}},{key:"play",value:function(e){"[object Number]"===Object.prototype.toString.call(e)&&(this.audio.currentTime=e),this.audio.paused&&this.audio.play()}},{key:"pause",value:function(){this.audio.paused||this.audio.pause()}},{key:"volume",value:function(e){this.updateBar("volume",e,"height"),this.audio.volume=e,this.audio.muted&&(this.audio.muted=!1),1===e?(this.volumeicon.className="aplayer-icon aplayer-icon-volume-up",this.volumeicon.innerHTML=this.getSVG("volume-up")):(this.volumeicon.className="aplayer-icon aplayer-icon-volume-down",this.volumeicon.innerHTML=this.getSVG("volume-down"))}},{key:"on",value:function(e,t){"function"==typeof t&&this.event[e].push(t)}},{key:"toggle",value:function(){this.button.classList.contains("aplayer-play")?this.play():this.button.classList.contains("aplayer-pause")&&this.pause()}},{key:"getRandomOrder",value:function(){function e(e,t){return null==t&&(t=e,e=0),e+Math.floor(Math.random()*(t-e+1))}function t(t){for(var n,r=t.length,a=new Array(r),i=0;i\n \n '+(this.option.music.length-e.length+a+1)+'\n '+e[a].title+'\n '+e[a].author+"\n ";n.innerHTML+=r,this.multiple||(this.multiple=!0,this.element.classList.add("aplayer-withlist"),this.audio.loop=!1),t.style.height="auto",t.style.height=t.offsetHeight+"px",this.getRandomOrder()}}]),e}();e.exports=l}])}); +//# sourceMappingURL=APlayer.min.js.map diff --git a/img/alipay.jpg b/img/alipay.jpg new file mode 100644 index 0000000..a66dfa1 Binary files /dev/null and b/img/alipay.jpg differ diff --git a/img/biubiubiu.gif b/img/biubiubiu.gif new file mode 100644 index 0000000..d7ef2b0 Binary files /dev/null and b/img/biubiubiu.gif differ diff --git a/img/default-skin.png b/img/default-skin.png new file mode 100644 index 0000000..441c502 Binary files /dev/null and b/img/default-skin.png differ diff --git a/img/forkme.png b/img/forkme.png new file mode 100644 index 0000000..c380274 Binary files /dev/null and b/img/forkme.png differ diff --git a/img/gitee.svg b/img/gitee.svg new file mode 100644 index 0000000..626ab00 --- /dev/null +++ b/img/gitee.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/img/head.jpg b/img/head.jpg new file mode 100644 index 0000000..37a86a2 Binary files /dev/null and b/img/head.jpg differ diff --git a/img/preloader.gif b/img/preloader.gif new file mode 100644 index 0000000..b8faa69 Binary files /dev/null and b/img/preloader.gif differ diff --git a/img/scrollbar_arrow.png b/img/scrollbar_arrow.png new file mode 100644 index 0000000..81bba97 Binary files /dev/null and b/img/scrollbar_arrow.png differ diff --git a/img/weixin.png b/img/weixin.png new file mode 100644 index 0000000..b96ad09 Binary files /dev/null and b/img/weixin.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000..a1c295b --- /dev/null +++ b/index.html @@ -0,0 +1,1553 @@ + + + + + + + + + Utopian + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + +
+
+ +
+ +
+
+ + + + Fork me on GitHub + + + + +
+
+
+ +
+
+ + + +
+
+ +
+ + +

+ + memos code analyze + +

+ + + + + + + + + + + + + + +
+ +
+ +

简介

Memos是一个开源的支持自托管部署的知识库，类似flomo。作为一个go+react实现的产品，功能齐全，且活跃度一直不错，所以找了个时间阅读了一下代码。
本次仅记录后端及DB设计部分，前端部分后续有时间了再继续。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + Introduct to temporalio + +

+ + + + + + + + + + + + + + +
+ +
+ +

Temporalio 简介

简介

引用wiki来介绍工作流引擎的定义：

+
+

A workflow engine manages and monitors the state of activities in a workflow, such as the processing and approval of a loan application form, and determines which new activity to transition to according to defined processes (workflows). The actions may be anything from saving an application form in a document management system to sending a reminder e-mail to users or escalating overdue items to management. A workflow engine facilitates the flow of information, tasks, and events. Workflow engines may also be referred to as Workflow Orchestration Engines.

+
+

Temporal是一个使用golang开发分布式的工作流引擎。Temporal 是原 Cadence 联合创始人离开 Cadence 后基于其 Fork的新分支，从某种程度上来讲，Temporal 可能是 Cadence 的一个更商业化的版本，毕竟后者原先只是 Uber 内部的一个组件。在2022年初Temporal已经是估值15亿美元的独角兽企业。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + Introduct to go-clean-template + +

+ + + + + + + + + + + + + + +
+ +
+ +

简介

go-clean-template是一个golang的微服务模板，按照Robert Martin《代码整洁之道》的各原则来实现。业务方可以使用该模板来扩展构建自己的微服务。

+

提供的能力项包括：

+
    +
  • 按照DIP、ISP等原则来组织框架层、业务逻辑层以及数据层等代码实现。
    • +
  • 配置文件解析，包括端口号、日志、PG等RabbitMQ配置。
    • +
  • 集成gin框架，提供了几个HTTP接口demo实现。
    • +
  • 集成了RabbitMQ RPC，提供了1个接口的demo实现。
    • +
  • 集成了日志、Swagger、K8s probe、Prometheus上报等能力。
    • +
+

本项目主要是作为模板来演示如何构建可扩展、易于维护的微服务，因此在实现上比较简单，业务方可以根据实际需求进一步改造扩充。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + 使用腾讯云cos+cdn搭建图片服务器 + +

+ + + + + + + + + + + + + + +
+ +
+ +

背景

之前在网上找了不少存储图片的地儿，貌似都不是很靠谱。也研究了一下腾讯云，似乎也没有提供直接可用的图片存储服务。看网上的经验有人使用腾讯云cos+cdn直接搭建了一个个人的图片存储服务，感觉流程也挺简单，于是研究后操作了一番，发现也有不少弯路，于是记录一番。

+ + more >> + + + + + + + +
+
+ + +
+ +
    + +
  • + COS +
    • + +
+
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + 秒杀系统核心设计 + +

+ + + + + + + + + + + + + + +
+ +
+ +

最近阅读量大量关于秒杀系统的介绍文章，包括一些视频讲解，大部分文章都太冗长，没有触及核心设计点，本文主要总结下后台架构的核心设计要点，不讨论架构优化中的常规页面CDN化、隔离部署、数据sharding、缓存优化等常规手段。

+

背景

秒杀系统场景举例：

+
    +
  • 抢购：如双十一，下单量高峰能达到50w+ qps，注意是下单成功，同时参与抢购的人的那就更多一个数量级了。
    • +
  • 红包：直播间红包、微信红包，本质上都是类似的场景，微信红包的处理方案是提前对红包进行个数拆分，会简化扣除库存逻辑，但是本质上跟抢购类似。
    • +
+

此类系统有几个典型特点：

+
    +
  • qps高，tps低：即读多写少，大量的请求（包括非正常请求：如频繁重试、黑产请求等）但是只有少量能成交。
    • +
  • 库存需要精确：涉及金额，不允许超卖
    • +
  • 固定时间：活动时间通常通常很短
    • +
+

其中超卖问题为核心需求点，基于此衍生出如何抗住并发量、用户体验优化等解决方案。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + + + + + + + + + +
+
+ +
+ + +

+ + Open Tracing + +

+ + + + + + + + + + + + + + +
+ +
+ +

最近在阅读微服务相关书籍时，提到了微服务相关的监控措施，其中分布式追踪就属于其中不可或缺的一部分，恰好之前也有计划在团队内引入，所以就花了两天时间稍微深入了解了一下相关概念和实现。动手实验了一遍jaeger提供All-In-One+HotROD示例，也大致了解了其基本原理和实现思路。时间关系就没有去学习jaeger之类的系统源码了，深入了解其存储方案之类的细节了，感觉必要性不大。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + Application Tracking + +

+ + + + + + + + + + + + + + +
+ +
+ +

整理下目前业务已有的监控能力以及相关指标、维度。大部分开发关注的可能只是自身服务的质量，缺乏对整体链条监控的了解。业务的发展过程中，出现过太多非后端服务质量导致的异常，所以要求开发能对服务整体的监控能力有所了解。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + Reliable Cron across the Planet + +

+ + + + + + + + + + + + + + +
+ +
+ +
+

Written with StackEdit.

+
+

Reliable Cron across the Planet…or How I stopped worrying and learned to love time

Štěpán Davidovič, Kavita Guliani, Google

+

原文: https://queue.acm.org/detail.cfm?id=2745840

+

前段时间预研分布式任务调度系统的方案，了解到了一个比较靠谱的解决方案：dkron，看介绍其实现就是基于基于google的这篇whitepaper 《Reliable Cron across the Planet》。

+

这篇文章也被收录到了书籍《SRE：google运维解密》一书中（第24章），于是将部分内容摘抄了一遍，补充了部分自己的理解，当做自己的读书笔记了。文章较长，部分个人认为不重要的内容就简单跳过了。

+

本文主要介绍了google的cron调度服务的实现机制，重点对实现的难点部分做了详细介绍。详见下文。

+

先对Cron系统的功能做了个简单的介绍。包括单机下crontab格式以及linux下的crond守护进程。此处略。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + +
+
+ +
+ + +

+ + libuv-source + +

+ + + + + + + + + + + + + + +
+ +
+ +

libuv源码简介

习惯了思维图之类的简单整理之后，有一段时间没有认真写写东西了。前段时间为了研究下node的性能指标，特意复习了一下libuv的源码，但是一直懒得去整理，直到今天看到这段话后才决定整理一番：

+
+

学习是一种行动反射，不是为了晓得些『知识』，要切己体察，代入自己要事上琢磨，落实行动，这就是知行合一。否则，读书也是一种玩物尚志。

+
+

定期总结也是学习的一部分。

+ + more >> + + + + + + + +
+
+ + +
+ + +
+ + + + +

+ 展开全文 >> +

+ + + +
+
+
+
+ + + + + + + + + + + + +
+
+
+ + +
+ + + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + +
+
+ +
+
+ + + +
+
+

tag:

+ + +
+
    +

    + 缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    + 3、在根目录_config.yml里添加配置： +

    +  jsonContent:
+    meta: false
+    pages: false
+    posts:
+      title: true
+      date: true
+      path: true
+      text: false
+      raw: false
+      content: false
+      slug: false
+      updated: false
+      comments: false
+      link: false
+      permalink: false
+      excerpt: false
+      categories: false
+      tags: true
+
    +

    +
  • + +

    + + +

    +

    + + +

    +
    • +
+
+ + + +
+ + + +
+ + + +
+ + +
主要涉及技术：
后端开发、微服务、分布式
公众号开发、开源爱好者、Linux
+ +
+ +
+ +
+ + +
+ + + + + + + + + + + + + + diff --git a/lib/busuanzi.pure.js b/lib/busuanzi.pure.js new file mode 100644 index 0000000..2b60732 --- /dev/null +++ b/lib/busuanzi.pure.js @@ -0,0 +1 @@ +var bszCaller,bszTag;!function(){var t,e,n,a=!1,c=[];ready=function(t){return a||"interactive"===document.readyState||"complete"===document.readyState?t.call(document):c.push(function(){return t.call(this)}),this},e=function(){for(var t=0,e=c.length;t:first-child,.gitment-editor-preview>:first-child{margin-top:0!important}.gitment-comment-body>:last-child,.gitment-editor-preview>:last-child{margin-bottom:0!important}.gitment-editor-body textarea{display:block;max-height:500px;resize:vertical;max-width:100%;margin:0;line-height:1.6;background-color:#fff;color:#333;vertical-align:middle;border:none;border-radius:0;outline:0;box-shadow:none;overflow:visible}.gitment-editor-body textarea:focus{background-color:#fff}.gitment-editor-preview{background-color:transparent;line-height:1.5;word-wrap:break-word}.gitment-editor-footer{padding:0;margin-top:10px}.gitment-editor-footer::after{display:table;clear:both;content:""}a.gitment-editor-footer-tip{display:inline-block;padding-top:10px;font-size:12px;color:#666}a.gitment-editor-footer-tip:hover{color:#2196F3;text-decoration:none}.gitment-comments-pagination{list-style:none;text-align:right;border-radius:0;margin:-19px 0 19px}.gitment-comments-page-item{display:inline-block;cursor:pointer;border:1px solid #CFD8DC;margin-left:-1px;padding:.25rem .5rem}.gitment-comments-page-item.gitment-selected,.gitment-comments-page-item:hover{background-color:#f5f5f5}.gitment-comments-init-btn,.gitment-editor-submit{color:#fff;background-color:#00BCD4;position:relative;display:inline-block;padding:7px 13px;font-size:14px;font-weight:600;line-height:20px;white-space:nowrap;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-size:110% 110%;border:none;-webkit-appearance:none;-moz-appearance:none;appearance:none}.gitment-comments-init-btn:hover,.gitment-editor-submit:hover{background-color:#00ACC1}.gitment-comments-init-btn:disabled,.gitment-editor-submit:disabled{color:rgba(255,255,255,.75);background-color:#4DD0E1;box-shadow:none}.gitment-editor-submit{float:right}.gitment-footer-container{margin-top:30px;margin-bottom:20px;text-align:right;font-size:12px}.gitment-markdown{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;color:#333;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol";font-size:16px;line-height:1.5;word-wrap:break-word}.gitment-markdown .pl-c{color:#969896}.gitment-markdown .pl-c1,.gitment-markdown .pl-s .pl-v{color:#0086b3}.gitment-markdown .pl-e,.gitment-markdown .pl-en{color:#795da3}.gitment-markdown .pl-s .pl-s1,.gitment-markdown .pl-smi{color:#333}.gitment-markdown .pl-ent{color:#63a35c}.gitment-markdown .pl-k{color:#a71d5d}.gitment-markdown .pl-pds,.gitment-markdown .pl-s,.gitment-markdown .pl-s .pl-pse .pl-s1,.gitment-markdown .pl-sr,.gitment-markdown .pl-sr .pl-cce,.gitment-markdown .pl-sr .pl-sra,.gitment-markdown .pl-sr .pl-sre{color:#183691}.gitment-markdown .pl-smw,.gitment-markdown .pl-v{color:#ed6a43}.gitment-markdown .pl-bu{color:#b52a1d}.gitment-markdown .pl-c2,.gitment-markdown .pl-ii{color:#f8f8f8;background-color:#b52a1d}.gitment-markdown .pl-c2::before{content:"^M"}.gitment-markdown .pl-sr .pl-cce{font-weight:700;color:#63a35c}.gitment-markdown .pl-ml{color:#693a17}.gitment-markdown .pl-mh,.gitment-markdown .pl-mh .pl-en,.gitment-markdown .pl-ms{font-weight:700;color:#1d3e81}.gitment-markdown .pl-mq{color:teal}.gitment-markdown .pl-mi{font-style:italic;color:#333}.gitment-markdown .pl-mb{font-weight:700;color:#333}.gitment-markdown .pl-md{color:#bd2c00;background-color:#ffecec}.gitment-markdown .pl-mi1{color:#55a532;background-color:#eaffea}.gitment-markdown .pl-mc{color:#ef9700;background-color:#ffe3b4}.gitment-markdown .pl-mi2{color:#d8d8d8;background-color:grey}.gitment-markdown .pl-mdr{font-weight:700;color:#795da3}.gitment-markdown .pl-mo{color:#1d3e81}.gitment-markdown .pl-ba{color:#595e62}.gitment-markdown .pl-sg{color:silver}.gitment-markdown .pl-corl{text-decoration:underline;color:#183691}.gitment-markdown .octicon{display:inline-block;fill:currentColor;vertical-align:text-bottom}.gitment-markdown hr::after,.gitment-markdown hr::before,.gitment-markdown::after,.gitment-markdown::before{display:table;content:""}.gitment-markdown a{background-color:transparent;-webkit-text-decoration-skip:objects;color:#0366d6;text-decoration:none}.gitment-markdown a:active,.gitment-markdown a:hover{outline-width:0}.gitment-markdown h1{margin:.67em 0}.gitment-markdown img{border-style:none}.gitment-markdown svg:not(:root){overflow:hidden}.gitment-markdown hr{box-sizing:content-box}.gitment-markdown input{font:inherit;margin:0;overflow:visible;font-family:inherit;font-size:inherit;line-height:inherit}.gitment-markdown [type=checkbox]{box-sizing:border-box;padding:0}.gitment-markdown *{box-sizing:border-box}.gitment-markdown a:hover{text-decoration:underline}.gitment-markdown strong{font-weight:600}.gitment-markdown td,.gitment-markdown th{padding:0}.gitment-markdown blockquote{margin:0}.gitment-markdown ol ol,.gitment-markdown ul ol{list-style-type:lower-roman}.gitment-markdown ol ol ol,.gitment-markdown ol ul ol,.gitment-markdown ul ol ol,.gitment-markdown ul ul ol{list-style-type:lower-alpha}.gitment-markdown dd{margin-left:0}.gitment-markdown code{font-family:SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace}.gitment-markdown pre{font:12px SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;word-wrap:normal}.gitment-markdown .pl-0{padding-left:0!important}.gitment-markdown .pl-1{padding-left:4px!important}.gitment-markdown .pl-2{padding-left:8px!important}.gitment-markdown .pl-3{padding-left:16px!important}.gitment-markdown .pl-4{padding-left:24px!important}.gitment-markdown .pl-5{padding-left:32px!important}.gitment-markdown .pl-6{padding-left:40px!important}.gitment-markdown>:first-child{margin-top:0!important}.gitment-markdown>:last-child{margin-bottom:0!important}.gitment-markdown a:not([href]){color:inherit;text-decoration:none}.gitment-markdown .anchor{float:left;padding-right:4px;margin-left:-20px;line-height:1}.gitment-markdown .anchor:focus{outline:0}.gitment-markdown blockquote,.gitment-markdown dl,.gitment-markdown ol,.gitment-markdown p,.gitment-markdown pre,.gitment-markdown table,.gitment-markdown ul{margin-top:0;margin-bottom:16px}.gitment-markdown hr{overflow:hidden;background:#e1e4e8;height:.25em;padding:0;margin:24px 0;border:0}.gitment-markdown blockquote{padding:0 1em;color:#6a737d;border-left:.25em solid #dfe2e5}.gitment-markdown h1,.gitment-markdown h2{padding-bottom:.3em;border-bottom:1px solid #eaecef}.gitment-markdown blockquote>:first-child{margin-top:0}.gitment-markdown blockquote>:last-child{margin-bottom:0}.gitment-markdown h1,.gitment-markdown h2,.gitment-markdown h3,.gitment-markdown h4,.gitment-markdown h5,.gitment-markdown h6{margin-top:24px;margin-bottom:16px;font-weight:600;line-height:1.25}.gitment-markdown h1 .octicon-link,.gitment-markdown h2 .octicon-link,.gitment-markdown h3 .octicon-link,.gitment-markdown h4 .octicon-link,.gitment-markdown h5 .octicon-link,.gitment-markdown h6 .octicon-link{color:#1b1f23;vertical-align:middle;visibility:hidden}.gitment-markdown h1:hover .anchor,.gitment-markdown h2:hover .anchor,.gitment-markdown h3:hover .anchor,.gitment-markdown h4:hover .anchor,.gitment-markdown h5:hover .anchor,.gitment-markdown h6:hover .anchor{text-decoration:none}.gitment-markdown h1:hover .anchor .octicon-link,.gitment-markdown h2:hover .anchor .octicon-link,.gitment-markdown h3:hover .anchor .octicon-link,.gitment-markdown h4:hover .anchor .octicon-link,.gitment-markdown h5:hover .anchor .octicon-link,.gitment-markdown h6:hover .anchor .octicon-link{visibility:visible}.gitment-markdown h1{font-size:2em}.gitment-markdown h2{font-size:1.5em}.gitment-markdown h3{font-size:1.25em}.gitment-markdown h4{font-size:1em}.gitment-markdown h5{font-size:.875em}.gitment-markdown h6{font-size:.85em;color:#6a737d}.gitment-markdown ol,.gitment-markdown ul{padding-left:2em}.gitment-markdown ol ol,.gitment-markdown ol ul,.gitment-markdown ul ol,.gitment-markdown ul ul{margin-top:0;margin-bottom:0}.gitment-markdown li>p{margin-top:16px}.gitment-markdown li+li{margin-top:.25em}.gitment-markdown dl{padding:0}.gitment-markdown dl dt{padding:0;margin-top:16px;font-size:1em;font-style:italic;font-weight:600}.gitment-markdown dl dd{padding:0 16px;margin-bottom:16px}.gitment-markdown table{border-spacing:0;border-collapse:collapse;display:block;width:100%;overflow:auto}.gitment-markdown table th{font-weight:600}.gitment-markdown table td,.gitment-markdown table th{padding:6px 13px;border:1px solid #dfe2e5}.gitment-markdown table tr{background-color:#fff;border-top:1px solid #c6cbd1}.gitment-markdown table tr:nth-child(2n){background-color:#f5f5f5}.gitment-markdown img{max-width:100%;box-sizing:content-box;background-color:#fff}.gitment-markdown code{padding:.2em 0;margin:0;font-size:85%;background-color:rgba(27,31,35,.05);border-radius:0}.gitment-markdown code::after,.gitment-markdown code::before{letter-spacing:-.2em;content:"\00a0"}.gitment-markdown pre>code{padding:0;margin:0;font-size:100%;word-break:normal;white-space:pre;background:0 0;border:0}.gitment-markdown .highlight{margin-bottom:16px}.gitment-markdown .highlight pre{margin-bottom:0;word-break:normal}.gitment-markdown .highlight pre,.gitment-markdown pre{padding:16px;overflow:auto;font-size:85%;line-height:1.45;background-color:#f5f5f5;border-radius:0}.gitment-markdown pre code{display:inline;max-width:auto;padding:0;margin:0;overflow:visible;line-height:inherit;word-wrap:normal;background-color:transparent;border:0}.gitment-markdown pre code::after,.gitment-markdown pre code::before{content:normal}.gitment-markdown .full-commit .btn-outline:not(:disabled):hover{color:#005cc5;border-color:#005cc5}.gitment-markdown kbd{display:inline-block;padding:3px 5px;font:11px SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;line-height:10px;color:#444d56;vertical-align:middle;background-color:#fcfcfc;border:1px solid #c6cbd1;border-bottom-color:#959da5;border-radius:0;box-shadow:inset 0 -1px 0 #959da5}.gitment-markdown :checked+.radio-label{position:relative;z-index:1;border-color:#0366d6}.gitment-markdown .task-list-item{list-style-type:none}.gitment-markdown .task-list-item+.task-list-item{margin-top:3px}.gitment-markdown .task-list-item input{margin:0 .2em .25em -1.6em;vertical-align:middle}.gitment-markdown hr{border-bottom-color:#eee}.giteement-role-label{background:grey;color:#fff;border:1px solid #000;cursor:default;border-radius:4px;margin-left:5px}.giteement-at-ol{background:#f7f7f7;color:#40485b;display:inline-block;border:1px solid #DDD;border-radius:3px;box-shadow:0 0 5px rgba(0,0,0,.1);padding:0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Liberation Sans","PingFang SC","Microsoft YaHei","Hiragino Sans GB","Wenquanyi Micro Hei","WenQuanYi Zen Hei","ST Heiti",SimHei,"WenQuanYi Zen Hei Sharp",sans-serif;font-size:14px;line-height:1.33}.giteement-at-li{list-style:none;border-bottom:1px solid #DDD;cursor:pointer;padding:5px 10px}.giteement-at-li-tail{border-bottom:0}.giteement-at-li-select,.giteement-at-li:hover{background:#36F;color:#fff}.giteement-at-div{position:absolute;display:none}.giteement-at-outdiv{position:relative}.textarea-mirror{padding:16px} \ No newline at end of file diff --git a/lib/giteement.browser.js b/lib/giteement.browser.js new file mode 100644 index 0000000..836b642 --- /dev/null +++ b/lib/giteement.browser.js @@ -0,0 +1 @@ +var _typeof3="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},_typeof2="function"==typeof Symbol&&"symbol"==_typeof3(Symbol.iterator)?function(e){return void 0===e?"undefined":_typeof3(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":void 0===e?"undefined":_typeof3(e)},_typeof="function"==typeof Symbol&&"symbol"==_typeof2(Symbol.iterator)?function(e){return void 0===e?"undefined":_typeof2(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":void 0===e?"undefined":_typeof2(e)},Giteement=function(n){var o={};function r(e){if(o[e])return o[e].exports;var t=o[e]={i:e,l:!1,exports:{}};return n[e].call(t.exports,t,t.exports,r),t.l=!0,t.exports}return r.m=n,r.c=o,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(t,e){if(1&e&&(t=r(t)),8&e)return t;if(4&e&&"object"==(void 0===t?"undefined":_typeof(t))&&t&&t.__esModule)return t;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var o in t)r.d(n,o,function(e){return t[e]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=126)}([function(e,o,Jn){(function(In){var e,t,n,Rn="function"==typeof Symbol&&"symbol"==_typeof(Symbol.iterator)?function(e){return void 0===e?"undefined":_typeof(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":void 0===e?"undefined":_typeof(e)};n=function(){var e,r;function M(){return e.apply(null,arguments)}function s(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function d(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function u(e){return void 0===e}function l(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function c(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function _(e,t){var n,o=[];for(n=0;n>>0,o=0;oge(e)?(i=e+1,s-ge(e)):(i=e,s),{year:i,dayOfYear:a}}function Ie(e,t,n){var o,r,i=Fe(e.year(),t,n),a=Math.floor((e.dayOfYear()-i-1)/7)+1;return a<1?o=a+Re(r=e.year()-1,t,n):a>Re(e.year(),t,n)?(o=a-Re(e.year(),t,n),r=e.year()+1):(r=e.year(),o=a),{week:o,year:r}}function Re(e,t,n){var o=Fe(e,t,n),r=Fe(e+1,t,n);return(ge(e)-o+r)/7}R("w",["ww",2],"wo","week"),R("W",["WW",2],"Wo","isoWeek"),O("week","w"),O("isoWeek","W"),C("week",5),C("isoWeek",5),de("w",K),de("ww",K,V),de("W",K),de("WW",K,V),_e(["w","ww","W","WW"],function(e,t,n,o){t[o.substr(0,1)]=k(e)}),R("d",0,"do","day"),R("dd",0,0,function(e){return this.localeData().weekdaysMin(this,e)}),R("ddd",0,0,function(e){return this.localeData().weekdaysShort(this,e)}),R("dddd",0,0,function(e){return this.localeData().weekdays(this,e)}),R("e",0,0,"weekday"),R("E",0,0,"isoWeekday"),O("day","d"),O("weekday","e"),O("isoWeekday","E"),C("day",11),C("weekday",11),C("isoWeekday",11),de("d",K),de("e",K),de("E",K),de("dd",function(e,t){return t.weekdaysMinRegex(e)}),de("ddd",function(e,t){return t.weekdaysShortRegex(e)}),de("dddd",function(e,t){return t.weekdaysRegex(e)}),_e(["dd","ddd","dddd"],function(e,t,n,o){var r=n._locale.weekdaysParse(e,o,n._strict);null!=r?t.d=r:L(n).invalidWeekday=e}),_e(["d","e","E"],function(e,t,n,o){t[o]=k(e)});var Je="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),qe="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),Ue="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),Ve=ae,Be=ae,Ge=ae;function $e(){function e(e,t){return t.length-e.length}var t,n,o,r,i,a=[],s=[],d=[],u=[];for(t=0;t<7;t++)n=f([2e3,1]).day(t),o=this.weekdaysMin(n,""),r=this.weekdaysShort(n,""),i=this.weekdays(n,""),a.push(o),s.push(r),d.push(i),u.push(o),u.push(r),u.push(i);for(a.sort(e),s.sort(e),d.sort(e),u.sort(e),t=0;t<7;t++)s[t]=ue(s[t]),d[t]=ue(d[t]),u[t]=ue(u[t]);this._weekdaysRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+d.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+s.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+a.join("|")+")","i")}function Ke(){return this.hours()%12||12}function Ze(e,t){R(e,0,0,function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)})}function Xe(e,t){return t._meridiemParse}R("H",["HH",2],0,"hour"),R("h",["hh",2],0,Ke),R("k",["kk",2],0,function(){return this.hours()||24}),R("hmm",0,0,function(){return""+Ke.apply(this)+W(this.minutes(),2)}),R("hmmss",0,0,function(){return""+Ke.apply(this)+W(this.minutes(),2)+W(this.seconds(),2)}),R("Hmm",0,0,function(){return""+this.hours()+W(this.minutes(),2)}),R("Hmmss",0,0,function(){return""+this.hours()+W(this.minutes(),2)+W(this.seconds(),2)}),Ze("a",!0),Ze("A",!1),O("hour","h"),C("hour",13),de("a",Xe),de("A",Xe),de("H",K),de("h",K),de("k",K),de("HH",K,V),de("hh",K,V),de("kk",K,V),de("hmm",Z),de("hmmss",X),de("Hmm",Z),de("Hmmss",X),ce(["H","HH"],ye),ce(["k","kk"],function(e,t,n){var o=k(e);t[ye]=24===o?0:o}),ce(["a","A"],function(e,t,n){n._isPm=n._locale.isPM(e),n._meridiem=e}),ce(["h","hh"],function(e,t,n){t[ye]=k(e),L(n).bigHour=!0}),ce("hmm",function(e,t,n){var o=e.length-2;t[ye]=k(e.substr(0,o)),t[he]=k(e.substr(o)),L(n).bigHour=!0}),ce("hmmss",function(e,t,n){var o=e.length-4,r=e.length-2;t[ye]=k(e.substr(0,o)),t[he]=k(e.substr(o,2)),t[Me]=k(e.substr(r)),L(n).bigHour=!0}),ce("Hmm",function(e,t,n){var o=e.length-2;t[ye]=k(e.substr(0,o)),t[he]=k(e.substr(o))}),ce("Hmmss",function(e,t,n){var o=e.length-4,r=e.length-2;t[ye]=k(e.substr(0,o)),t[he]=k(e.substr(o,2)),t[Me]=k(e.substr(r))});var Qe,et=De("Hours",!0),tt={calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},longDateFormat:{LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},invalidDate:"Invalid date",ordinal:"%d",dayOfMonthOrdinalParse:/\d{1,2}/,relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},months:He,monthsShort:Oe,week:{dow:0,doy:6},weekdays:Je,weekdaysMin:Ue,weekdaysShort:qe,meridiemParse:/[ap]\.?m?\.?/i},nt={},ot={};function rt(e){return e?e.toLowerCase().replace("_","-"):e}function it(e){var t=null;if(!nt[e]&&void 0!==In&&In&&In.exports)try{t=Qe._abbr,Jn(131)("./"+e),at(t)}catch(e){}return nt[e]}function at(e,t){var n;return e&&((n=u(t)?dt(e):st(e,t))?Qe=n:"undefined"!=typeof console&&console.warn&&console.warn("Locale "+e+" not found. Did you forget to load it?")),Qe._abbr}function st(e,t){if(null===t)return delete nt[e],null;var n,o=tt;if(t.abbr=e,null!=nt[e])w("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),o=nt[e]._config;else if(null!=t.parentLocale)if(null!=nt[t.parentLocale])o=nt[t.parentLocale]._config;else{if(null==(n=it(t.parentLocale)))return ot[t.parentLocale]||(ot[t.parentLocale]=[]),ot[t.parentLocale].push({name:e,config:t}),null;o=n._config}return nt[e]=new j(x(o,t)),ot[e]&&ot[e].forEach(function(e){st(e.name,e.config)}),at(e),nt[e]}function dt(e){var t;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return Qe;if(!s(e)){if(t=it(e))return t;e=[e]}return function(e){for(var t,n,o,r,i=0;i=t&&a(r,n,!0)>=t-1)break;t--}i++}return Qe}(e)}function ut(e){var t,n=e._a;return n&&-2===L(e).overflow&&(t=n[fe]<0||11xe(n[me],n[fe])?pe:n[ye]<0||24Re(n,i,a)?L(e)._overflowWeeks=!0:null!=d?L(e)._overflowWeekday=!0:(s=ze(n,o,r,i,a),e._a[me]=s.year,e._dayOfYear=s.dayOfYear)}(e),null!=e._dayOfYear&&(i=lt(e._a[me],o[me]),(e._dayOfYear>ge(i)||0===e._dayOfYear)&&(L(e)._overflowDayOfYear=!0),n=Ne(i,0,e._dayOfYear),e._a[fe]=n.getUTCMonth(),e._a[pe]=n.getUTCDate()),t=0;t<3&&null==e._a[t];++t)e._a[t]=d[t]=o[t];for(;t<7;t++)e._a[t]=d[t]=null==e._a[t]?2===t?1:0:e._a[t];24===e._a[ye]&&0===e._a[he]&&0===e._a[Me]&&0===e._a[ve]&&(e._nextDay=!0,e._a[ye]=0),e._d=(e._useUTC?Ne:function(e,t,n,o,r,i,a){var s=new Date(e,t,n,o,r,i,a);return e<100&&0<=e&&isFinite(s.getFullYear())&&s.setFullYear(e),s}).apply(null,d),r=e._useUTC?e._d.getUTCDay():e._d.getDay(),null!=e._tzm&&e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),e._nextDay&&(e._a[ye]=24),e._w&&void 0!==e._w.d&&e._w.d!==r&&(L(e).weekdayMismatch=!0)}}var _t=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,mt=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,ft=/Z|[+-]\d\d(?::?\d\d)?/,pt=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/]],yt=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],ht=/^\/?Date\((\-?\d+)/i;function Mt(e){var t,n,o,r,i,a,s=e._i,d=_t.exec(s)||mt.exec(s);if(d){for(L(e).iso=!0,t=0,n=pt.length;t(i=Re(e,o,r))&&(t=i),function(e,t,n,o,r){var i=ze(e,t,n,o,r),a=Ne(i.year,0,i.dayOfYear);return this.year(a.getUTCFullYear()),this.month(a.getUTCMonth()),this.date(a.getUTCDate()),this}.call(this,e,t,n,o,r))}R(0,["gg",2],0,function(){return this.weekYear()%100}),R(0,["GG",2],0,function(){return this.isoWeekYear()%100}),Xt("gggg","weekYear"),Xt("ggggg","weekYear"),Xt("GGGG","isoWeekYear"),Xt("GGGGG","isoWeekYear"),O("weekYear","gg"),O("isoWeekYear","GG"),C("weekYear",1),C("isoWeekYear",1),de("G",oe),de("g",oe),de("GG",K,V),de("gg",K,V),de("GGGG",ee,G),de("gggg",ee,G),de("GGGGG",te,$),de("ggggg",te,$),_e(["gggg","ggggg","GGGG","GGGGG"],function(e,t,n,o){t[o.substr(0,2)]=k(e)}),_e(["gg","GG"],function(e,t,n,o){t[o]=M.parseTwoDigitYear(e)}),R("Q",0,"Qo","quarter"),O("quarter","Q"),C("quarter",7),de("Q",U),ce("Q",function(e,t){t[fe]=3*(k(e)-1)}),R("D",["DD",2],"Do","date"),O("date","D"),C("date",9),de("D",K),de("DD",K,V),de("Do",function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient}),ce(["D","DD"],pe),ce("Do",function(e,t){t[pe]=k(e.match(K)[0])});var en=De("Date",!0);R("DDD",["DDDD",3],"DDDo","dayOfYear"),O("dayOfYear","DDD"),C("dayOfYear",4),de("DDD",Q),de("DDDD",B),ce(["DDD","DDDD"],function(e,t,n){n._dayOfYear=k(e)}),R("m",["mm",2],0,"minute"),O("minute","m"),C("minute",14),de("m",K),de("mm",K,V),ce(["m","mm"],he);var tn=De("Minutes",!1);R("s",["ss",2],0,"second"),O("second","s"),C("second",15),de("s",K),de("ss",K,V),ce(["s","ss"],Me);var nn,on=De("Seconds",!1);for(R("S",0,0,function(){return~~(this.millisecond()/100)}),R(0,["SS",2],0,function(){return~~(this.millisecond()/10)}),R(0,["SSS",3],0,"millisecond"),R(0,["SSSS",4],0,function(){return 10*this.millisecond()}),R(0,["SSSSS",5],0,function(){return 100*this.millisecond()}),R(0,["SSSSSS",6],0,function(){return 1e3*this.millisecond()}),R(0,["SSSSSSS",7],0,function(){return 1e4*this.millisecond()}),R(0,["SSSSSSSS",8],0,function(){return 1e5*this.millisecond()}),R(0,["SSSSSSSSS",9],0,function(){return 1e6*this.millisecond()}),O("millisecond","ms"),C("millisecond",16),de("S",Q,U),de("SS",Q,V),de("SSS",Q,B),nn="SSSS";nn.length<=9;nn+="S")de(nn,ne);function rn(e,t){t[ve]=k(1e3*("0."+e))}for(nn="S";nn.length<=9;nn+="S")ce(nn,rn);var an=De("Milliseconds",!1);R("z",0,0,"zoneAbbr"),R("zz",0,0,"zoneName");var sn=b.prototype;function dn(e){return e}sn.add=Vt,sn.calendar=function(e,t){var n=e||St(),o=Ct(n,this).startOf("day"),r=M.calendarFormat(this,o)||"sameElse",i=t&&(T(t[r])?t[r].call(this,n):t[r]);return this.format(i||this.localeData().calendar(r,this,St(n)))},sn.clone=function(){return new b(this)},sn.diff=function(e,t,n){var o,r,i;if(!this.isValid())return NaN;if(!(o=Ct(e,this)).isValid())return NaN;switch(r=6e4*(o.utcOffset()-this.utcOffset()),t=E(t)){case"year":i=Gt(this,o)/12;break;case"month":i=Gt(this,o);break;case"quarter":i=Gt(this,o)/3;break;case"second":i=(this-o)/1e3;break;case"minute":i=(this-o)/6e4;break;case"hour":i=(this-o)/36e5;break;case"day":i=(this-o-r)/864e5;break;case"week":i=(this-o-r)/6048e5;break;default:i=this-o}return n?i:Y(i)},sn.endOf=function(e){return void 0===(e=E(e))||"millisecond"===e?this:("date"===e&&(e="day"),this.startOf(e).add(1,"isoWeek"===e?"week":e).subtract(1,"ms"))},sn.format=function(e){e=e||(this.isUtc()?M.defaultFormatUtc:M.defaultFormat);var t=J(this,e);return this.localeData().postformat(t)},sn.from=function(e,t){return this.isValid()&&(g(e)&&e.isValid()||St(e).isValid())?It({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()},sn.fromNow=function(e){return this.from(St(),e)},sn.to=function(e,t){return this.isValid()&&(g(e)&&e.isValid()||St(e).isValid())?It({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()},sn.toNow=function(e){return this.to(St(),e)},sn.get=function(e){return T(this[e=E(e)])?this[e]():this},sn.invalidAt=function(){return L(this).overflow},sn.isAfter=function(e,t){var n=g(e)?e:St(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=E(u(t)?"millisecond":t))?this.valueOf()>n.valueOf():n.valueOf()this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()},sn.isLocal=function(){return!!this.isValid()&&!this._isUTC},sn.isUtcOffset=function(){return!!this.isValid()&&this._isUTC},sn.isUtc=Nt,sn.isUTC=Nt,sn.zoneAbbr=function(){return this._isUTC?"UTC":""},sn.zoneName=function(){return this._isUTC?"Coordinated Universal Time":""},sn.dates=n("dates accessor is deprecated. Use date instead.",en),sn.months=n("months accessor is deprecated. Use month instead",Ae),sn.years=n("years accessor is deprecated. Use year instead",Se),sn.zone=n("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",function(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()}),sn.isDSTShifted=n("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",function(){if(!u(this._isDSTShifted))return this._isDSTShifted;var e={};if(h(e,this),(e=Yt(e))._a){var t=e._isUTC?f(e._a):St(e._a);this._isDSTShifted=this.isValid()&&0=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}}}function l(e,t){var n="function"==typeof Symbol&&e[Symbol.iterator];if(!n)return e;var o,r,i=n.call(e),a=[];try{for(;(void 0===t||0o&&(o=s.dependenciesState);for(n.length=r,e.newObserving=null,i=t.length;i--;)0===(s=t[i]).diffValue&&je(s,e),s.diffValue=0;for(;r--;){var s;1===(s=n[r]).diffValue&&(s.diffValue=0,u=e,(d=s).observers.add(u),d.lowestObserverState>u.dependenciesState&&(d.lowestObserverState=u.dependenciesState))}var d,u;o!==Q.UP_TO_DATE&&(e.dependenciesState=o,e.onBecomeStale())}(e),o}function ve(e){var t=e.observing;e.observing=[];for(var n=t.length;n--;)je(t[n],e);e.dependenciesState=Q.NOT_TRACKING}function Le(e){var t=be();try{return e()}finally{ge(t)}}function be(){var e=De.trackingDerivation;return De.trackingDerivation=null,e}function ge(e){De.trackingDerivation=e}function Ye(e){if(e.dependenciesState!==Q.UP_TO_DATE){e.dependenciesState=Q.UP_TO_DATE;for(var t=e.observing,n=t.length;n--;)t[n].lowestObserverState=Q.UP_TO_DATE}}function ke(){this.version=5,this.trackingDerivation=null,this.computationDepth=0,this.runId=0,this.mobxGuid=0,this.inBatch=0,this.pendingUnobservations=[],this.pendingReactions=[],this.isRunningReactions=!1,this.allowStateChanges=!0,this.enforceActions=!1,this.spyListeners=[],this.globalReactionErrorHandlers=[],this.computedRequiresReaction=!1,this.disableErrorBoundaries=!1}var Se=["mobxGuid","spyListeners","enforceActions","computedRequiresReaction","disableErrorBoundaries","runId"],De=new ke,we=!1,Te=xe();function xe(){return"undefined"!=typeof window?window:e}function je(e,t){e.observers.delete(t),0===e.observers.size&&He(e)}function He(e){!1===e.isPendingUnobservation&&(e.isPendingUnobservation=!0,De.pendingUnobservations.push(e))}function Oe(){De.inBatch++}function Ee(){if(0==--De.inBatch){ze();for(var e=De.pendingUnobservations,t=0;t",e):2===arguments.length&&"function"==typeof t?$(e,t):1===arguments.length&&"string"==typeof e?Ue(e):!0!==o?Ue(t).apply(null,arguments):void h(e,t,$(e.name||t,n.value))};function Be(e,t,n){h(e,t,$(t,n.bind(e)))}function Ge(e,t){void 0===t&&(t=p);var n,o=t&&t.name||e.name||"Autorun@"+y();if(t.scheduler||t.delay){var r=Ke(t),i=!1;n=new Ce(o,function(){i||(i=!0,r(function(){i=!1,n.isDisposed||n.track(a)}))},t.onError)}else n=new Ce(o,function(){this.track(a)},t.onError);function a(){e(n)}return n.schedule(),n.getDisposer()}Ve.bound=function(e,t,n,o){return!0===o?(Be(e,t,n.value),null):n?{configurable:!0,enumerable:!1,get:function(){return Be(this,t,n.value||n.initializer.call(this)),this[t]},set:qe}:{enumerable:!1,configurable:!0,set:function(e){Be(this,t,e)},get:function(){}}};var $e=function(e){return e()};function Ke(t){return t.scheduler?t.scheduler:t.delay?function(e){return setTimeout(e,t.delay)}:$e}function Ze(e,t,n){return Qe("onBecomeObserved",e,t,n)}function Xe(e,t,n){return Qe("onBecomeUnobserved",e,t,n)}function Qe(e,t,n,o){var r="string"==typeof n?Vt(t,n):Vt(t),i="string"==typeof n?o:n,a=r[e];return"function"!=typeof a?d(!1):(r[e]=function(){a.call(this),i.call(this)},function(){r[e]=a})}function et(e,t,n,o){var r=tt(o=W(o));return zt(e,o.name,r.enhancer),t&&nt(e,t,n,r),e}function tt(e){return e.defaultDecorator||(!1===e.deep?z:N)}function nt(e,t,n,o){Oe();try{for(var r in t){var i=Object.getOwnPropertyDescriptor(t,r),a=(n&&r in n?n[r]:i.get?B:o)(e,r,i,!0);a&&Object.defineProperty(e,r,a)}}finally{Ee()}}function ot(e,t){return rt(Vt(e,t))}function rt(e){var t,n,o={name:e.name};return e.observing&&0=e.length&&(e.length=t+1),e[t]=n,Ee()}else{Oe();var r=t;try{for(var i in r)_t(e,i,r[i])}finally{Ee()}}}function mt(e,t){return Ut(e)?Bt(e).has(t):Ct(e)?e.has(t):Et(e)?0<=t&&t";return function(){var s,e=arguments,d=++at,u=Ve(c+" - runid: "+d+" - init",n).apply(this,e),l=void 0,t=new Promise(function(t,n){var o=0;function r(e){var t;l=void 0;try{t=Ve(c+" - runid: "+d+" - yield "+o++,u.next).call(u,e)}catch(e){return n(e)}a(t)}function i(e){var t;l=void 0;try{t=Ve(c+" - runid: "+d+" - yield "+o++,u.throw).call(u,e)}catch(e){return n(e)}a(t)}function a(e){if(!e||"function"!=typeof e.then)return e.done?t(e.value):(l=Promise.resolve(e.value)).then(r,i);e.then(a,n)}s=n,r(void 0)});return t.cancel=Ve(c+" - runid: "+d+" - cancel",function(){try{l&&st(l);var e=u.return(),t=Promise.resolve(e.value);t.then(i,i),st(t),s(new Error("FLOW_CANCELLED"))}catch(e){s(e)}}),t}},en.toJS=function(e,t){return lt(e)?("boolean"==typeof t&&(t={detectCycles:t}),!0===(t=t||ft).detectCycles&&(n=new Map),function n(e,o,r){if(!lt(e))return e;if(!0===o.detectCycles&&null!==e&&"object"===(void 0===e?"undefined":f(e))&&r.has(e))return r.get(e);if(Et(e)){var t=pt(r,e,[],o),i=e.map(function(e){return n(e,o,r)});t.length=i.length;for(var a=0,s=i.length;a"+n.comments+" ":"")+"\n ",o.appendChild(r);var i=document.createElement("a");return i.className="gitment-header-issue-link",i.href=n.html_url,i.target="_blank",i.innerText="Issue Page",o.appendChild(i),o}function i(e,u){var l=e.meta,t=e.comments,n=e.currentPage,o=e.user,r=e.error,i=document.createElement("div");if(i.lang="en-US",i.className="gitment-container gitment-comments-container",r){var a=document.createElement("div");if(a.className="gitment-comments-error",r===L.NOT_INITIALIZED_ERROR&&o.login&&o.login.toLowerCase()===u.owner.toLowerCase()){var s=document.createElement("div"),d=document.createElement("button");d.className="gitment-comments-init-btn",d.onclick=function(){d.setAttribute("disabled",!0),u.init().catch(function(e){d.removeAttribute("disabled"),alert(e)})},d.innerText="初始化评论",s.appendChild(d),a.appendChild(s)}else a.innerText=r;return i.appendChild(a),i}if(void 0===t){var c=document.createElement("div");return c.innerText="Loading comments...",c.className="gitment-comments-loading",i.appendChild(c),i}if(!t.length){var _=document.createElement("div");return _.className="gitment-comments-empty",_.innerText="暂时没有评论！",i.appendChild(_),i}var m=document.createElement("ul");if(m.className="gitment-comments-list",t.forEach(function(e){var t,n,o,r,i=new Date(e.created_at),a=document.createElement("li");a.className="gitment-comment",a.innerHTML='\n \n \n \n
\n
\n \n '+e.user.name+"\n \n "+(l.user.login==e.user.login?' 博主':"")+'\n 评论创建于\n '+(0,b.default)(i).format("YYYY年MM月DD日")+'\n
\n
\n
\n ',t=u,(r=(o=(n=e).body).match(/^@[^ ]*/g))&&0u.maxCommentHeight&&(d.classList.add("gitment-comment-body-folded"),d.style.maxHeight=u.maxCommentHeight+"px",d.title="Click to Expand",d.onclick=function(){d.classList.remove("gitment-comment-body-folded"),d.style.maxHeight="",d.title="",d.onclick=null})},a.appendChild(s),m.appendChild(a)}),i.appendChild(m),l){var f=Math.ceil(l.comments/u.perPage);if(1\n \n ':t.isLoggingIn?'
'+y.spinner+"
":'\n '+y.giteehub+"\n ")+'\n \n
\n
\n \n \n
\n
\n
\n \n
\n
\n
\n
\n
\n
\n
\n \n 支持Markdown的样式\n \n \n
\n ",t.login&&(i.querySelector(".gitment-editor-logout-link").onclick=function(){return n.logout()});var d=i.querySelector(".gitment-editor-write-field"),u=i.querySelector(".gitment-editor-preview-field"),l=d.querySelector("textarea");l.oninput=function(){l.style.height="auto";var e=window.getComputedStyle(l,null),t=parseInt(e.height,10),n=l.clientHeight,o=l.scrollHeight;n"),n=(0,c.default)("
"),o=(0,c.default)("
    "),r={},i=0;i"):(0,c.default)("
  1. ")).text(a.login+" "+a.name),o.append(s)}}n.append(o),t.append(n),(0,c.default)(this.container).append(t),(0,c.default)(document).off("keydown.atwhouser").on("keydown.atwhouser",function(e){if(40===e.keyCode){var t=(0,c.default)(".giteement-at-li-select").next();(0,c.default)(".giteement-at-li-select").removeClass("giteement-at-li-select"),0==t.length?(0,c.default)(".giteement-at-li:first").addClass("giteement-at-li-select"):t.addClass("giteement-at-li-select")}else if(38===e.keyCode){var n=(0,c.default)(".giteement-at-li-select").prev();(0,c.default)(".giteement-at-li-select").removeClass("giteement-at-li-select"),0==n.length?(0,c.default)(".giteement-at-li:last").addClass("giteement-at-li-select"):n.addClass("giteement-at-li-select")}})}}},{key:"init",value:function(){this.addListener()}},{key:"addListener",value:function(){var t=this;t.jqElement.on("compositionstart",function(){console.log("---compositionstart")}).on("compositionend",function(){console.log("---compositionend")}).on("keyup.atwhoInner",function(e){t.onKeyup(e)}).on("keydown.atwhoInner",function(e){t.altflg&&(38!==e.keyCode&&40!==e.keyCode&&13!==e.keyCode||e.preventDefault()),t.onKeydown(e)}).on("blur.atwhoInner",function(){(0,c.default)(".giteement-at-div").hide(),this.altflg=!1}).on("click.atwhoInner",function(){console.log("---click.atwhoInner")}).on("scroll.atwhoInner",function(){console.log("---scroll.atwhoInner")})}},{key:"onKeyup",value:function(e){if("@"===this.jqElement.val().substring(0,this.jqElement[0].selectionEnd)){if(this.altflg){if(13===e.keyCode){var t=(0,c.default)(".giteement-at-li-select").text().split(" ")[1]+" ";this.jqElement[0].setRangeText(t),this.jqElement[0].selectionStart=this.jqElement[0].selectionEnd=this.jqElement.val().length,(0,c.default)(".giteement-at-div").hide(),this.altflg=!1}return}var n=function(e){function t(e){return e.replace(/<|>|`|"|&/g,"?").replace(/\r\n|\r|\n/g,"
    ")}var n=e.selectionEnd,o=e.value.slice(0,n),r=e.value.slice(n),i='
    '+t(o)+'|'+t(r)+"
    ",a=(0,c.default)(i),s=(0,c.default)(e);s.after(a);var d=document.getElementById("cursor").getBoundingClientRect(),u=d.left,l=d.top-s.outerHeight(!0)+7;return a.remove(),{x:u,y:l}}(this.jqElement[0]),o=(0,c.default)(".giteement-at-outdiv")[0].getBoundingClientRect();(0,c.default)(".giteement-at-div").css("left",n.x-o.left+"px"),(0,c.default)(".giteement-at-div").css("top",n.y-o.top+"px"),(0,c.default)(".giteement-at-li-select").removeClass("giteement-at-li-select"),(0,c.default)((0,c.default)(".giteement-at-li")[0]).addClass("giteement-at-li-select"),(0,c.default)(".giteement-at-div").show(),this.altflg=!0}else(0,c.default)(".giteement-at-div").hide(),this.altflg=!1}},{key:"onKeydown",value:function(e){this.altflg&&(38!==e.keyCode&&40!==e.keyCode&&13!==e.keyCode||e.preventDefault())}}]),a);function a(){var e=0>10|55296,1023&o|56320)}function r(){g()}var e,m,L,i,a,f,_,p,b,d,u,g,Y,s,k,y,l,h,M,S="sizzle"+1*new Date,v=n.document,D=0,o=0,w=ae(),T=ae(),x=ae(),j=function(e,t){return e===t&&(u=!0),0},H={}.hasOwnProperty,t=[],O=t.pop,E=t.push,A=t.push,P=t.slice,C=function(e,t){for(var n=0,o=e.length;n+~]|"+N+")"+N+"*"),V=new RegExp("="+N+"*([^\\]'\"]*?)"+N+"*\\]","g"),B=new RegExp(I),G=new RegExp("^"+F+"$"),$={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),TAG:new RegExp("^("+F+"|[*])"),ATTR:new RegExp("^"+z),PSEUDO:new RegExp("^"+I),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+N+"*(even|odd|(([+-]|)(\\d*)n|)"+N+"*(?:([+-]|)"+N+"*(\\d+)|))"+N+"*\\)|)","i"),bool:new RegExp("^(?:"+W+")$","i"),needsContext:new RegExp("^"+N+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+N+"*((?:-\\d)?\\d*)"+N+"*\\)|)(?=[^-]|$)","i")},K=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,X=/^[^{]+\{\s*\[native \w/,Q=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+N+"?|("+N+")|.)","ig"),ne=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,oe=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},re=Me(function(e){return!0===e.disabled&&("form"in e||"label"in e)},{dir:"parentNode",next:"legend"});try{A.apply(t=P.call(v.childNodes),v.childNodes),t[v.childNodes.length].nodeType}catch(n){A={apply:t.length?function(e,t){E.apply(e,P.call(t))}:function(e,t){for(var n=e.length,o=0;e[n++]=t[o++];);e.length=n-1}}}function ie(e,t,n,o){var r,i,a,s,d,u,l,c=t&&t.ownerDocument,_=t?t.nodeType:9;if(n=n||[],"string"!=typeof e||!e||1!==_&&9!==_&&11!==_)return n;if(!o&&((t?t.ownerDocument||t:v)!==Y&&g(t),t=t||Y,k)){if(11!==_&&(d=Q.exec(e)))if(r=d[1]){if(9===_){if(!(a=t.getElementById(r)))return n;if(a.id===r)return n.push(a),n}else if(c&&(a=c.getElementById(r))&&M(t,a)&&a.id===r)return n.push(a),n}else{if(d[2])return A.apply(n,t.getElementsByTagName(e)),n;if((r=d[3])&&m.getElementsByClassName&&t.getElementsByClassName)return A.apply(n,t.getElementsByClassName(r)),n}if(m.qsa&&!x[e+" "]&&(!y||!y.test(e))){if(1!==_)c=t,l=e;else if("object"!==t.nodeName.toLowerCase()){for((s=t.getAttribute("id"))?s=s.replace(ne,oe):t.setAttribute("id",s=S),i=(u=f(e)).length;i--;)u[i]="#"+s+" "+he(u[i]);l=u.join(","),c=ee.test(e)&&pe(t.parentNode)||t}if(l)try{return A.apply(n,c.querySelectorAll(l)),n}catch(e){}finally{s===S&&t.removeAttribute("id")}}}return p(e.replace(J,"$1"),t,n,o)}function ae(){var o=[];return function e(t,n){return o.push(t+" ")>L.cacheLength&&delete e[o.shift()],e[t+" "]=n}}function se(e){return e[S]=!0,e}function de(e){var t=Y.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function ue(e,t){for(var n=e.split("|"),o=n.length;o--;)L.attrHandle[n[o]]=t}function le(e,t){var n=t&&e,o=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(o)return o;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function ce(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function _e(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function me(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&re(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function fe(a){return se(function(i){return i=+i,se(function(e,t){for(var n,o=a([],e.length,i),r=o.length;r--;)e[n=o[r]]&&(e[n]=!(t[n]=e[n]))})})}function pe(e){return e&&void 0!==e.getElementsByTagName&&e}for(e in m=ie.support={},a=ie.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return!!t&&"HTML"!==t.nodeName},g=ie.setDocument=function(e){var t,n,o=e?e.ownerDocument||e:v;return o!==Y&&9===o.nodeType&&o.documentElement&&(s=(Y=o).documentElement,k=!a(Y),v!==Y&&(n=Y.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",r,!1):n.attachEvent&&n.attachEvent("onunload",r)),m.attributes=de(function(e){return e.className="i",!e.getAttribute("className")}),m.getElementsByTagName=de(function(e){return e.appendChild(Y.createComment("")),!e.getElementsByTagName("*").length}),m.getElementsByClassName=X.test(Y.getElementsByClassName),m.getById=de(function(e){return s.appendChild(e).id=S,!Y.getElementsByName||!Y.getElementsByName(S).length}),m.getById?(L.filter.ID=function(e){var t=e.replace(te,c);return function(e){return e.getAttribute("id")===t}},L.find.ID=function(e,t){if(void 0!==t.getElementById&&k){var n=t.getElementById(e);return n?[n]:[]}}):(L.filter.ID=function(e){var n=e.replace(te,c);return function(e){var t=void 0!==e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},L.find.ID=function(e,t){if(void 0!==t.getElementById&&k){var n,o,r,i=t.getElementById(e);if(i){if((n=i.getAttributeNode("id"))&&n.value===e)return[i];for(r=t.getElementsByName(e),o=0;i=r[o++];)if((n=i.getAttributeNode("id"))&&n.value===e)return[i]}return[]}}),L.find.TAG=m.getElementsByTagName?function(e,t){return void 0!==t.getElementsByTagName?t.getElementsByTagName(e):m.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,o=[],r=0,i=t.getElementsByTagName(e);if("*"!==e)return i;for(;n=i[r++];)1===n.nodeType&&o.push(n);return o},L.find.CLASS=m.getElementsByClassName&&function(e,t){if(void 0!==t.getElementsByClassName&&k)return t.getElementsByClassName(e)},l=[],y=[],(m.qsa=X.test(Y.querySelectorAll))&&(de(function(e){s.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&y.push("[*^$]="+N+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||y.push("\\["+N+"*(?:value|"+W+")"),e.querySelectorAll("[id~="+S+"-]").length||y.push("~="),e.querySelectorAll(":checked").length||y.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||y.push(".#.+[+~]")}),de(function(e){e.innerHTML="";var t=Y.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&y.push("name"+N+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&y.push(":enabled",":disabled"),s.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&y.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),y.push(",.*:")})),(m.matchesSelector=X.test(h=s.matches||s.webkitMatchesSelector||s.mozMatchesSelector||s.oMatchesSelector||s.msMatchesSelector))&&de(function(e){m.disconnectedMatch=h.call(e,"*"),h.call(e,"[s!='']:x"),l.push("!=",I)}),y=y.length&&new RegExp(y.join("|")),l=l.length&&new RegExp(l.join("|")),t=X.test(s.compareDocumentPosition),M=t||X.test(s.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,o=t&&t.parentNode;return e===o||!(!o||1!==o.nodeType||!(n.contains?n.contains(o):e.compareDocumentPosition&&16&e.compareDocumentPosition(o)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return u=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!m.sortDetached&&t.compareDocumentPosition(e)===n?e===Y||e.ownerDocument===v&&M(v,e)?-1:t===Y||t.ownerDocument===v&&M(v,t)?1:d?C(d,e)-C(d,t):0:4&n?-1:1)}:function(e,t){if(e===t)return u=!0,0;var n,o=0,r=e.parentNode,i=t.parentNode,a=[e],s=[t];if(!r||!i)return e===Y?-1:t===Y?1:r?-1:i?1:d?C(d,e)-C(d,t):0;if(r===i)return le(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)s.unshift(n);for(;a[o]===s[o];)o++;return o?le(a[o],s[o]):a[o]===v?-1:s[o]===v?1:0}),Y},ie.matches=function(e,t){return ie(e,null,null,t)},ie.matchesSelector=function(e,t){if((e.ownerDocument||e)!==Y&&g(e),t=t.replace(V,"='$1']"),m.matchesSelector&&k&&!x[t+" "]&&(!l||!l.test(t))&&(!y||!y.test(t)))try{var n=h.call(e,t);if(n||m.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,c),e[3]=(e[3]||e[4]||e[5]||"").replace(te,c),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ie.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ie.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return $.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&B.test(n)&&(t=f(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,c).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=w[e+" "];return t||(t=new RegExp("(^|"+N+")"+e+"("+N+"|$)"))&&w(e,function(e){return t.test("string"==typeof e.className&&e.className||void 0!==e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,o,r){return function(e){var t=ie.attr(e,n);return null==t?"!="===o:!o||(t+="","="===o?t===r:"!="===o?t!==r:"^="===o?r&&0===t.indexOf(r):"*="===o?r&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function x(e,n,o){return v(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==o}):n.nodeType?S.grep(e,function(e){return e===n!==o}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var o,r;if(!e)return this;if(n=n||j,"string"!=typeof e)return e.nodeType?(this[0]=e,this.length=1,this):v(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this);if(!(o="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:H.exec(e))||!o[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(o[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(o[1],t&&t.nodeType?t.ownerDocument||t:k,!0)),T.test(o[1])&&S.isPlainObject(t))for(o in t)v(this[o])?this[o](t[o]):this.attr(o,t[o]);return this}return(r=k.getElementById(o[2]))&&(this[0]=r,this.length=1),this}).prototype=S.fn,j=S(k);var O=/^(?:parents|prev(?:Until|All))/,E={children:!0,contents:!0,next:!0,prev:!0};function A(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]+)/i,le=/^$|^module$|\/(?:java|ecma)script/i,ce={option:[1,""],thead:[1,"","
    "],col:[2,"","
    "],tr:[2,"","
    "],td:[3,"","
    "],_default:[0,"",""]};function _e(e,t){var n;return n=void 0!==e.getElementsByTagName?e.getElementsByTagName(t||"*"):void 0!==e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&w(e,t)?S.merge([e],n):n}function me(e,t){for(var n=0,o=e.length;nx",M.noCloneChecked=!!fe.cloneNode(!0).lastChild.defaultValue;var Me=k.documentElement,ve=/^key/,Le=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,be=/^([^.]*)(?:\.(.+)|)/;function ge(){return!0}function Ye(){return!1}function ke(){try{return k.activeElement}catch(e){}}function Se(e,t,n,o,r,i){var a,s;if("object"===(void 0===t?"undefined":rn(t))){for(s in"string"!=typeof n&&(o=o||n,n=void 0),t)Se(e,s,n,o,t[s],i);return e}if(null==o&&null==r?(r=n,o=n=void 0):null==r&&("string"==typeof n?(r=o,o=void 0):(r=o,o=n,n=void 0)),!1===r)r=Ye;else if(!r)return e;return 1===i&&(a=r,(r=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,r,o,n)})}S.event={global:{},add:function(t,e,n,o,r){var i,a,s,d,u,l,c,_,m,f,p,y=$.get(t);if(y)for(n.handler&&(n=(i=n).handler,r=i.selector),r&&S.find.matchesSelector(Me,r),n.guid||(n.guid=S.guid++),(d=y.events)||(d=y.events={}),(a=y.handle)||(a=y.handle=function(e){return void 0!==S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),u=(e=(e||"").match(P)||[""]).length;u--;)m=p=(s=be.exec(e[u])||[])[1],f=(s[2]||"").split(".").sort(),m&&(c=S.event.special[m]||{},m=(r?c.delegateType:c.bindType)||m,c=S.event.special[m]||{},l=S.extend({type:m,origType:p,data:o,handler:n,guid:n.guid,selector:r,needsContext:r&&S.expr.match.needsContext.test(r),namespace:f.join(".")},i),(_=d[m])||((_=d[m]=[]).delegateCount=0,c.setup&&!1!==c.setup.call(t,o,f,a)||t.addEventListener&&t.addEventListener(m,a)),c.add&&(c.add.call(t,l),l.handler.guid||(l.handler.guid=n.guid)),r?_.splice(_.delegateCount++,0,l):_.push(l),S.event.global[m]=!0)},remove:function(e,t,n,o,r){var i,a,s,d,u,l,c,_,m,f,p,y=$.hasData(e)&&$.get(e);if(y&&(d=y.events)){for(u=(t=(t||"").match(P)||[""]).length;u--;)if(m=p=(s=be.exec(t[u])||[])[1],f=(s[2]||"").split(".").sort(),m){for(c=S.event.special[m]||{},_=d[m=(o?c.delegateType:c.bindType)||m]||[],s=s[2]&&new RegExp("(^|\\.)"+f.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=i=_.length;i--;)l=_[i],!r&&p!==l.origType||n&&n.guid!==l.guid||s&&!s.test(l.namespace)||o&&o!==l.selector&&("**"!==o||!l.selector)||(_.splice(i,1),l.selector&&_.delegateCount--,c.remove&&c.remove.call(e,l));a&&!_.length&&(c.teardown&&!1!==c.teardown.call(e,f,y.handle)||S.removeEvent(e,m,y.handle),delete d[m])}else for(m in d)S.event.remove(e,m+t[u],n,o,!0);S.isEmptyObject(d)&&$.remove(e,"handle events")}},dispatch:function(e){var t,n,o,r,i,a,s=S.event.fix(e),d=new Array(arguments.length),u=($.get(this,"events")||{})[s.type]||[],l=S.event.special[s.type]||{};for(d[0]=s,t=1;t\x20\t\r\n\f]*)[^>]*)\/>/gi,we=/\s*$/g;function je(e,t){return w(e,"table")&&w(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function He(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Oe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Ee(e,t){var n,o,r,i,a,s,d,u;if(1===t.nodeType){if($.hasData(e)&&(i=$.access(e),a=$.set(t,i),u=i.events))for(r in delete a.handle,a.events={},u)for(n=0,o=u[r].length;n")},clone:function(e,t,n){var o,r,i,a,s,d,u,l=e.cloneNode(!0),c=S.contains(e.ownerDocument,e);if(!(M.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=_e(l),o=0,r=(i=_e(e)).length;o").prop({charset:n.scriptCharset,src:n.url}).on("load error",r=function(e){o.remove(),r=null,e&&t("error"===e.type?404:200,e.type)}),k.head.appendChild(o[0])},abort:function(){r&&r()}}});var Zt,Xt=[],Qt=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||S.expando+"_"+xt++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var o,r,i,a=!1!==e.jsonp&&(Qt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Qt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return o=e.jsonpCallback=v(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Qt,"$1"+o):!1!==e.jsonp&&(e.url+=(jt.test(e.url)?"&":"?")+e.jsonp+"="+o),e.converters["script json"]=function(){return i||S.error(o+" was not called"),i[0]},e.dataTypes[0]="json",r=Y[o],Y[o]=function(){i=arguments},n.always(function(){void 0===r?S(Y).removeProp(o):Y[o]=r,e[o]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(o)),i&&v(r)&&r(i[0]),i=r=void 0}),"script"}),M.createHTMLDocument=((Zt=k.implementation.createHTMLDocument("").body).innerHTML="
    ",2===Zt.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(M.createHTMLDocument?((o=(t=k.implementation.createHTMLDocument("")).createElement("base")).href=k.location.href,t.head.appendChild(o)):t=k),i=!n&&[],(r=T.exec(e))?[t.createElement(r[1])]:(r=he([e],t,i),i&&i.length&&S(i).remove(),S.merge([],r.childNodes)));var o,r,i},S.fn.load=function(e,t,n){var o,r,i,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(o):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,i||[e.responseText,t,e])})}),this},S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var o,r,i,a,s,d,u=S.css(e,"position"),l=S(e),c={};"static"===u&&(e.style.position="relative"),s=l.offset(),i=S.css(e,"top"),d=S.css(e,"left"),r=("absolute"===u||"fixed"===u)&&-1<(i+d).indexOf("auto")?(a=(o=l.position()).top,o.left):(a=parseFloat(i)||0,parseFloat(d)||0),v(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(c.top=t.top-s.top+a),null!=t.left&&(c.left=t.left-s.left+r),"using"in t?t.using.call(e,c):l.css(c)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,o=this[0];return o?o.getClientRects().length?(e=o.getBoundingClientRect(),n=o.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,o=this[0],r={top:0,left:0};if("fixed"===S.css(o,"position"))t=o.getBoundingClientRect();else{for(t=this.offset(),n=o.ownerDocument,e=o.offsetParent||n.documentElement;e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position");)e=e.parentNode;e&&e!==o&&1===e.nodeType&&((r=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),r.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-r.top-S.css(o,"marginTop",!0),left:t.left-r.left-S.css(o,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){for(var e=this.offsetParent;e&&"static"===S.css(e,"position");)e=e.offsetParent;return e||Me})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,r){var i="pageYOffset"===r;S.fn[t]=function(e){return R(this,function(e,t,n){var o;if(p(e)?o=e:9===e.nodeType&&(o=e.defaultView),void 0===n)return o?o[r]:e[t];o?o.scrollTo(i?o.pageXOffset:n,i?n:o.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Be(M.pixelPosition,function(e,t){if(t)return t=Ve(e,n),Je.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(o,i){S.fn[i]=function(e,t){var n=arguments.length&&(o||"boolean"!=typeof e),r=o||(!0===e||!0===t?"margin":"border");return R(this,function(e,t,n){var o;return p(e)?0===i.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(o=e.documentElement,Math.max(e.body["scroll"+a],o["scroll"+a],e.body["offset"+a],o["offset"+a],o["client"+a])):void 0===n?S.css(e,t,r):S.style(e,t,n,r)},s,n?e:void 0,n)}})}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0:first-child,.gitment-editor-preview>:first-child{margin-top:0!important}.gitment-comment-body>:last-child,.gitment-editor-preview>:last-child{margin-bottom:0!important}.gitment-editor-body textarea{display:block;max-height:500px;resize:vertical;max-width:100%;margin:0;line-height:1.6;background-color:#fff;color:#333;vertical-align:middle;border:none;border-radius:0;outline:0;box-shadow:none;overflow:visible}.gitment-editor-body textarea:focus{background-color:#fff}.gitment-editor-preview{background-color:transparent;line-height:1.5;word-wrap:break-word}.gitment-editor-footer{padding:0;margin-top:10px}.gitment-editor-footer::after{display:table;clear:both;content:""}a.gitment-editor-footer-tip{display:inline-block;padding-top:10px;font-size:12px;color:#666}a.gitment-editor-footer-tip:hover{color:#2196F3;text-decoration:none}.gitment-comments-pagination{list-style:none;text-align:right;border-radius:0;margin:-19px 0 19px}.gitment-comments-page-item{display:inline-block;cursor:pointer;border:1px solid #CFD8DC;margin-left:-1px;padding:.25rem .5rem}.gitment-comments-page-item.gitment-selected,.gitment-comments-page-item:hover{background-color:#f5f5f5}.gitment-comments-init-btn,.gitment-editor-submit{color:#fff;background-color:#00BCD4;position:relative;display:inline-block;padding:7px 13px;font-size:14px;font-weight:600;line-height:20px;white-space:nowrap;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-size:110% 110%;border:none;-webkit-appearance:none;-moz-appearance:none;appearance:none}.gitment-comments-init-btn:hover,.gitment-editor-submit:hover{background-color:#00ACC1}.gitment-comments-init-btn:disabled,.gitment-editor-submit:disabled{color:rgba(255,255,255,.75);background-color:#4DD0E1;box-shadow:none}.gitment-editor-submit{float:right}.gitment-footer-container{margin-top:30px;margin-bottom:20px;text-align:right;font-size:12px}.gitment-markdown{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;color:#333;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol";font-size:16px;line-height:1.5;word-wrap:break-word}.gitment-markdown .pl-c{color:#969896}.gitment-markdown .pl-c1,.gitment-markdown .pl-s .pl-v{color:#0086b3}.gitment-markdown .pl-e,.gitment-markdown .pl-en{color:#795da3}.gitment-markdown .pl-s .pl-s1,.gitment-markdown .pl-smi{color:#333}.gitment-markdown .pl-ent{color:#63a35c}.gitment-markdown .pl-k{color:#a71d5d}.gitment-markdown .pl-pds,.gitment-markdown .pl-s,.gitment-markdown .pl-s .pl-pse .pl-s1,.gitment-markdown .pl-sr,.gitment-markdown .pl-sr .pl-cce,.gitment-markdown .pl-sr .pl-sra,.gitment-markdown .pl-sr .pl-sre{color:#183691}.gitment-markdown .pl-smw,.gitment-markdown .pl-v{color:#ed6a43}.gitment-markdown .pl-bu{color:#b52a1d}.gitment-markdown .pl-c2,.gitment-markdown .pl-ii{color:#f8f8f8;background-color:#b52a1d}.gitment-markdown .pl-c2::before{content:"^M"}.gitment-markdown .pl-sr .pl-cce{font-weight:700;color:#63a35c}.gitment-markdown .pl-ml{color:#693a17}.gitment-markdown .pl-mh,.gitment-markdown .pl-mh .pl-en,.gitment-markdown .pl-ms{font-weight:700;color:#1d3e81}.gitment-markdown .pl-mq{color:teal}.gitment-markdown .pl-mi{font-style:italic;color:#333}.gitment-markdown .pl-mb{font-weight:700;color:#333}.gitment-markdown .pl-md{color:#bd2c00;background-color:#ffecec}.gitment-markdown .pl-mi1{color:#55a532;background-color:#eaffea}.gitment-markdown .pl-mc{color:#ef9700;background-color:#ffe3b4}.gitment-markdown .pl-mi2{color:#d8d8d8;background-color:grey}.gitment-markdown .pl-mdr{font-weight:700;color:#795da3}.gitment-markdown .pl-mo{color:#1d3e81}.gitment-markdown .pl-ba{color:#595e62}.gitment-markdown .pl-sg{color:silver}.gitment-markdown .pl-corl{text-decoration:underline;color:#183691}.gitment-markdown .octicon{display:inline-block;fill:currentColor;vertical-align:text-bottom}.gitment-markdown hr::after,.gitment-markdown hr::before,.gitment-markdown::after,.gitment-markdown::before{display:table;content:""}.gitment-markdown a{background-color:transparent;-webkit-text-decoration-skip:objects;color:#0366d6;text-decoration:none}.gitment-markdown a:active,.gitment-markdown a:hover{outline-width:0}.gitment-markdown h1{margin:.67em 0}.gitment-markdown img{border-style:none}.gitment-markdown svg:not(:root){overflow:hidden}.gitment-markdown hr{box-sizing:content-box}.gitment-markdown input{font:inherit;margin:0;overflow:visible;font-family:inherit;font-size:inherit;line-height:inherit}.gitment-markdown [type=checkbox]{box-sizing:border-box;padding:0}.gitment-markdown *{box-sizing:border-box}.gitment-markdown a:hover{text-decoration:underline}.gitment-markdown strong{font-weight:600}.gitment-markdown td,.gitment-markdown th{padding:0}.gitment-markdown blockquote{margin:0}.gitment-markdown ol ol,.gitment-markdown ul ol{list-style-type:lower-roman}.gitment-markdown ol ol ol,.gitment-markdown ol ul ol,.gitment-markdown ul ol ol,.gitment-markdown ul ul ol{list-style-type:lower-alpha}.gitment-markdown dd{margin-left:0}.gitment-markdown code{font-family:SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace}.gitment-markdown pre{font:12px SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;word-wrap:normal}.gitment-markdown .pl-0{padding-left:0!important}.gitment-markdown .pl-1{padding-left:4px!important}.gitment-markdown .pl-2{padding-left:8px!important}.gitment-markdown .pl-3{padding-left:16px!important}.gitment-markdown .pl-4{padding-left:24px!important}.gitment-markdown .pl-5{padding-left:32px!important}.gitment-markdown .pl-6{padding-left:40px!important}.gitment-markdown>:first-child{margin-top:0!important}.gitment-markdown>:last-child{margin-bottom:0!important}.gitment-markdown a:not([href]){color:inherit;text-decoration:none}.gitment-markdown .anchor{float:left;padding-right:4px;margin-left:-20px;line-height:1}.gitment-markdown .anchor:focus{outline:0}.gitment-markdown blockquote,.gitment-markdown dl,.gitment-markdown ol,.gitment-markdown p,.gitment-markdown pre,.gitment-markdown table,.gitment-markdown ul{margin-top:0;margin-bottom:16px}.gitment-markdown hr{overflow:hidden;background:#e1e4e8;height:.25em;padding:0;margin:24px 0;border:0}.gitment-markdown blockquote{padding:0 1em;color:#6a737d;border-left:.25em solid #dfe2e5}.gitment-markdown h1,.gitment-markdown h2{padding-bottom:.3em;border-bottom:1px solid #eaecef}.gitment-markdown blockquote>:first-child{margin-top:0}.gitment-markdown blockquote>:last-child{margin-bottom:0}.gitment-markdown h1,.gitment-markdown h2,.gitment-markdown h3,.gitment-markdown h4,.gitment-markdown h5,.gitment-markdown h6{margin-top:24px;margin-bottom:16px;font-weight:600;line-height:1.25}.gitment-markdown h1 .octicon-link,.gitment-markdown h2 .octicon-link,.gitment-markdown h3 .octicon-link,.gitment-markdown h4 .octicon-link,.gitment-markdown h5 .octicon-link,.gitment-markdown h6 .octicon-link{color:#1b1f23;vertical-align:middle;visibility:hidden}.gitment-markdown h1:hover .anchor,.gitment-markdown h2:hover .anchor,.gitment-markdown h3:hover .anchor,.gitment-markdown h4:hover .anchor,.gitment-markdown h5:hover .anchor,.gitment-markdown h6:hover .anchor{text-decoration:none}.gitment-markdown h1:hover .anchor .octicon-link,.gitment-markdown h2:hover .anchor .octicon-link,.gitment-markdown h3:hover .anchor .octicon-link,.gitment-markdown h4:hover .anchor .octicon-link,.gitment-markdown h5:hover .anchor .octicon-link,.gitment-markdown h6:hover .anchor .octicon-link{visibility:visible}.gitment-markdown h1{font-size:2em}.gitment-markdown h2{font-size:1.5em}.gitment-markdown h3{font-size:1.25em}.gitment-markdown h4{font-size:1em}.gitment-markdown h5{font-size:.875em}.gitment-markdown h6{font-size:.85em;color:#6a737d}.gitment-markdown ol,.gitment-markdown ul{padding-left:2em}.gitment-markdown ol ol,.gitment-markdown ol ul,.gitment-markdown ul ol,.gitment-markdown ul ul{margin-top:0;margin-bottom:0}.gitment-markdown li>p{margin-top:16px}.gitment-markdown li+li{margin-top:.25em}.gitment-markdown dl{padding:0}.gitment-markdown dl dt{padding:0;margin-top:16px;font-size:1em;font-style:italic;font-weight:600}.gitment-markdown dl dd{padding:0 16px;margin-bottom:16px}.gitment-markdown table{border-spacing:0;border-collapse:collapse;display:block;width:100%;overflow:auto}.gitment-markdown table th{font-weight:600}.gitment-markdown table td,.gitment-markdown table th{padding:6px 13px;border:1px solid #dfe2e5}.gitment-markdown table tr{background-color:#fff;border-top:1px solid #c6cbd1}.gitment-markdown table tr:nth-child(2n){background-color:#f5f5f5}.gitment-markdown img{max-width:100%;box-sizing:content-box;background-color:#fff}.gitment-markdown code{padding:.2em 0;margin:0;font-size:85%;background-color:rgba(27,31,35,.05);border-radius:0}.gitment-markdown code::after,.gitment-markdown code::before{letter-spacing:-.2em;content:"\00a0"}.gitment-markdown pre>code{padding:0;margin:0;font-size:100%;word-break:normal;white-space:pre;background:0 0;border:0}.gitment-markdown .highlight{margin-bottom:16px}.gitment-markdown .highlight pre{margin-bottom:0;word-break:normal}.gitment-markdown .highlight pre,.gitment-markdown pre{padding:16px;overflow:auto;font-size:85%;line-height:1.45;background-color:#f5f5f5;border-radius:0}.gitment-markdown pre code{display:inline;max-width:auto;padding:0;margin:0;overflow:visible;line-height:inherit;word-wrap:normal;background-color:transparent;border:0}.gitment-markdown pre code::after,.gitment-markdown pre code::before{content:normal}.gitment-markdown .full-commit .btn-outline:not(:disabled):hover{color:#005cc5;border-color:#005cc5}.gitment-markdown kbd{display:inline-block;padding:3px 5px;font:11px SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;line-height:10px;color:#444d56;vertical-align:middle;background-color:#fcfcfc;border:1px solid #c6cbd1;border-bottom-color:#959da5;border-radius:0;box-shadow:inset 0 -1px 0 #959da5}.gitment-markdown :checked+.radio-label{position:relative;z-index:1;border-color:#0366d6}.gitment-markdown .task-list-item{list-style-type:none}.gitment-markdown .task-list-item+.task-list-item{margin-top:3px}.gitment-markdown .task-list-item input{margin:0 .2em .25em -1.6em;vertical-align:middle}.gitment-markdown hr{border-bottom-color:#eee} \ No newline at end of file diff --git a/lib/gitment.js b/lib/gitment.js new file mode 100644 index 0000000..804167c --- /dev/null +++ b/lib/gitment.js @@ -0,0 +1,4145 @@ +var Gitment = + /******/ + (function (modules) { // webpackBootstrap + /******/ // The module cache + /******/ + var installedModules = {}; + /******/ + /******/ // The require function + /******/ + function __webpack_require__(moduleId) { + /******/ + /******/ // Check if module is in cache + /******/ + if (installedModules[moduleId]) + /******/ + return installedModules[moduleId].exports; + /******/ + /******/ // Create a new module (and put it into the cache) + /******/ + var module = installedModules[moduleId] = { + /******/ + i: moduleId, + /******/ + l: false, + /******/ + exports: {} + /******/ + }; + /******/ + /******/ // Execute the module function + /******/ + modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + /******/ + /******/ // Flag the module as loaded + /******/ + module.l = true; + /******/ + /******/ // Return the exports of the module + /******/ + return module.exports; + /******/ + } + /******/ + /******/ + /******/ // expose the modules object (__webpack_modules__) + /******/ + __webpack_require__.m = modules; + /******/ + /******/ // expose the module cache + /******/ + __webpack_require__.c = installedModules; + /******/ + /******/ // identity function for calling harmony imports with the correct context + /******/ + __webpack_require__.i = function (value) { + return value; + }; + /******/ + /******/ // define getter function for harmony exports + /******/ + __webpack_require__.d = function (exports, name, getter) { + /******/ + if (!__webpack_require__.o(exports, name)) { + /******/ + Object.defineProperty(exports, name, { + /******/ + configurable: false, + /******/ + enumerable: true, + /******/ + get: getter + /******/ + }); + /******/ + } + /******/ + }; + /******/ + /******/ // getDefaultExport function for compatibility with non-harmony modules + /******/ + __webpack_require__.n = function (module) { + /******/ + var getter = module && module.__esModule ? + /******/ + function getDefault() { + return module['default']; + } : + /******/ + function getModuleExports() { + return module; + }; + /******/ + __webpack_require__.d(getter, 'a', getter); + /******/ + return getter; + /******/ + }; + /******/ + /******/ // Object.prototype.hasOwnProperty.call + /******/ + __webpack_require__.o = function (object, property) { + return Object.prototype.hasOwnProperty.call(object, property); + }; + /******/ + /******/ // __webpack_public_path__ + /******/ + __webpack_require__.p = ""; + /******/ + /******/ // Load entry module and return exports + /******/ + return __webpack_require__(__webpack_require__.s = 5); + /******/ + }) +/************************************************************************/ +/******/ +([ + /* 0 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + var LS_ACCESS_TOKEN_KEY = exports.LS_ACCESS_TOKEN_KEY = 'gitment-comments-token'; + var LS_USER_KEY = exports.LS_USER_KEY = 'gitment-user-info'; + + var NOT_INITIALIZED_ERROR = exports.NOT_INITIALIZED_ERROR = new Error('Comments Not Initialized'); + + /***/ + }), + /* 1 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + /* WEBPACK VAR INJECTION */ + (function (global) { + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + + var __extends = undefined && undefined.__extends || function () { + var extendStatics = Object.setPrototypeOf || { + __proto__: [] + } + instanceof Array && function (d, b) { + d.__proto__ = b; + } || function (d, b) { + for (var p in b) { + if (b.hasOwnProperty(p)) d[p] = b[p]; + } + }; + return function (d, b) { + extendStatics(d, b); + + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + }(); + Object.defineProperty(exports, "__esModule", { + value: true + }); + registerGlobals(); + exports.extras = { + allowStateChanges: allowStateChanges, + deepEqual: deepEqual, + getAtom: getAtom, + getDebugName: getDebugName, + getDependencyTree: getDependencyTree, + getAdministration: getAdministration, + getGlobalState: getGlobalState, + getObserverTree: getObserverTree, + isComputingDerivation: isComputingDerivation, + isSpyEnabled: isSpyEnabled, + onReactionError: onReactionError, + resetGlobalState: resetGlobalState, + shareGlobalState: shareGlobalState, + spyReport: spyReport, + spyReportEnd: spyReportEnd, + spyReportStart: spyReportStart, + setReactionScheduler: setReactionScheduler + }; + if ((typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "undefined" ? "undefined" : _typeof(__MOBX_DEVTOOLS_GLOBAL_HOOK__)) === "object") { + __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx(module.exports); + } + module.exports.default = module.exports; + var actionFieldDecorator = createClassPropertyDecorator(function (target, key, value, args, originalDescriptor) { + var actionName = args && args.length === 1 ? args[0] : value.name || key || ""; + var wrappedAction = action(actionName, value); + addHiddenProp(target, key, wrappedAction); + }, function (key) { + return this[key]; + }, function () { + invariant(false, getMessage("m001")); + }, false, true); + var boundActionDecorator = createClassPropertyDecorator(function (target, key, value) { + defineBoundAction(target, key, value); + }, function (key) { + return this[key]; + }, function () { + invariant(false, getMessage("m001")); + }, false, false); + var action = function action(arg1, arg2, arg3, arg4) { + if (arguments.length === 1 && typeof arg1 === "function") return createAction(arg1.name || "", arg1); + if (arguments.length === 2 && typeof arg2 === "function") return createAction(arg1, arg2); + if (arguments.length === 1 && typeof arg1 === "string") return namedActionDecorator(arg1); + return namedActionDecorator(arg2).apply(null, arguments); + }; + exports.action = action; + action.bound = function boundAction(arg1, arg2, arg3) { + if (typeof arg1 === "function") { + var action_1 = createAction("", arg1); + action_1.autoBind = true; + return action_1; + } + return boundActionDecorator.apply(null, arguments); + }; + + function namedActionDecorator(name) { + return function (target, prop, descriptor) { + if (descriptor && typeof descriptor.value === "function") { + descriptor.value = createAction(name, descriptor.value); + descriptor.enumerable = false; + descriptor.configurable = true; + return descriptor; + } + return actionFieldDecorator(name).apply(this, arguments); + }; + } + + function runInAction(arg1, arg2, arg3) { + var actionName = typeof arg1 === "string" ? arg1 : arg1.name || ""; + var fn = typeof arg1 === "function" ? arg1 : arg2; + var scope = typeof arg1 === "function" ? arg2 : arg3; + invariant(typeof fn === "function", getMessage("m002")); + invariant(fn.length === 0, getMessage("m003")); + invariant(typeof actionName === "string" && actionName.length > 0, "actions should have valid names, got: '" + actionName + "'"); + return executeAction(actionName, fn, scope, undefined); + } + exports.runInAction = runInAction; + + function isAction(thing) { + return typeof thing === "function" && thing.isMobxAction === true; + } + exports.isAction = isAction; + + function defineBoundAction(target, propertyName, fn) { + var res = function res() { + return executeAction(propertyName, fn, target, arguments); + }; + res.isMobxAction = true; + addHiddenProp(target, propertyName, res); + } + + function autorun(arg1, arg2, arg3) { + var name, view, scope; + if (typeof arg1 === "string") { + name = arg1; + view = arg2; + scope = arg3; + } else { + name = arg1.name || "Autorun@" + getNextId(); + view = arg1; + scope = arg2; + } + invariant(typeof view === "function", getMessage("m004")); + invariant(isAction(view) === false, getMessage("m005")); + if (scope) view = view.bind(scope); + var reaction = new Reaction(name, function () { + this.track(reactionRunner); + }); + + function reactionRunner() { + view(reaction); + } + reaction.schedule(); + return reaction.getDisposer(); + } + exports.autorun = autorun; + + function when(arg1, arg2, arg3, arg4) { + var name, predicate, effect, scope; + if (typeof arg1 === "string") { + name = arg1; + predicate = arg2; + effect = arg3; + scope = arg4; + } else { + name = "When@" + getNextId(); + predicate = arg1; + effect = arg2; + scope = arg3; + } + var disposer = autorun(name, function (r) { + if (predicate.call(scope)) { + r.dispose(); + var prevUntracked = untrackedStart(); + effect.call(scope); + untrackedEnd(prevUntracked); + } + }); + return disposer; + } + exports.when = when; + + function autorunAsync(arg1, arg2, arg3, arg4) { + var name, func, delay, scope; + if (typeof arg1 === "string") { + name = arg1; + func = arg2; + delay = arg3; + scope = arg4; + } else { + name = arg1.name || "AutorunAsync@" + getNextId(); + func = arg1; + delay = arg2; + scope = arg3; + } + invariant(isAction(func) === false, getMessage("m006")); + if (delay === void 0) delay = 1; + if (scope) func = func.bind(scope); + var isScheduled = false; + var r = new Reaction(name, function () { + if (!isScheduled) { + isScheduled = true; + setTimeout(function () { + isScheduled = false; + if (!r.isDisposed) r.track(reactionRunner); + }, delay); + } + }); + + function reactionRunner() { + func(r); + } + r.schedule(); + return r.getDisposer(); + } + exports.autorunAsync = autorunAsync; + + function reaction(expression, effect, arg3) { + if (arguments.length > 3) { + fail(getMessage("m007")); + } + if (isModifierDescriptor(expression)) { + fail(getMessage("m008")); + } + var opts; + if ((typeof arg3 === "undefined" ? "undefined" : _typeof(arg3)) === "object") { + opts = arg3; + } else { + opts = {}; + } + opts.name = opts.name || expression.name || effect.name || "Reaction@" + getNextId(); + opts.fireImmediately = arg3 === true || opts.fireImmediately === true; + opts.delay = opts.delay || 0; + opts.compareStructural = opts.compareStructural || opts.struct || false; + effect = action(opts.name, opts.context ? effect.bind(opts.context) : effect); + if (opts.context) { + expression = expression.bind(opts.context); + } + var firstTime = true; + var isScheduled = false; + var nextValue; + var r = new Reaction(opts.name, function () { + if (firstTime || opts.delay < 1) { + reactionRunner(); + } else if (!isScheduled) { + isScheduled = true; + setTimeout(function () { + isScheduled = false; + reactionRunner(); + }, opts.delay); + } + }); + + function reactionRunner() { + if (r.isDisposed) return; + var changed = false; + r.track(function () { + var v = expression(r); + changed = valueDidChange(opts.compareStructural, nextValue, v); + nextValue = v; + }); + if (firstTime && opts.fireImmediately) effect(nextValue, r); + if (!firstTime && changed === true) effect(nextValue, r); + if (firstTime) firstTime = false; + } + r.schedule(); + return r.getDisposer(); + } + exports.reaction = reaction; + + function createComputedDecorator(compareStructural) { + return createClassPropertyDecorator(function (target, name, _, __, originalDescriptor) { + invariant(typeof originalDescriptor !== "undefined", getMessage("m009")); + invariant(typeof originalDescriptor.get === "function", getMessage("m010")); + var adm = asObservableObject(target, ""); + defineComputedProperty(adm, name, originalDescriptor.get, originalDescriptor.set, compareStructural, false); + }, function (name) { + var observable = this.$mobx.values[name]; + if (observable === undefined) return undefined; + return observable.get(); + }, function (name, value) { + this.$mobx.values[name].set(value); + }, false, false); + } + var computedDecorator = createComputedDecorator(false); + var computedStructDecorator = createComputedDecorator(true); + var computed = function computed(arg1, arg2, arg3) { + if (typeof arg2 === "string") { + return computedDecorator.apply(null, arguments); + } + invariant(typeof arg1 === "function", getMessage("m011")); + invariant(arguments.length < 3, getMessage("m012")); + var opts = (typeof arg2 === "undefined" ? "undefined" : _typeof(arg2)) === "object" ? arg2 : {}; + opts.setter = typeof arg2 === "function" ? arg2 : opts.setter; + return new ComputedValue(arg1, opts.context, opts.compareStructural || opts.struct || false, opts.name || arg1.name || "", opts.setter); + }; + exports.computed = computed; + computed.struct = computedStructDecorator; + + function createTransformer(transformer, onCleanup) { + invariant(typeof transformer === "function" && transformer.length < 2, "createTransformer expects a function that accepts one argument"); + var objectCache = {}; + var resetId = globalState.resetId; + var Transformer = function (_super) { + __extends(Transformer, _super); + + function Transformer(sourceIdentifier, sourceObject) { + var _this = _super.call(this, function () { + return transformer(sourceObject); + }, undefined, false, "Transformer-" + transformer.name + "-" + sourceIdentifier, undefined) || this; + _this.sourceIdentifier = sourceIdentifier; + _this.sourceObject = sourceObject; + return _this; + } + Transformer.prototype.onBecomeUnobserved = function () { + var lastValue = this.value; + _super.prototype.onBecomeUnobserved.call(this); + delete objectCache[this.sourceIdentifier]; + if (onCleanup) onCleanup(lastValue, this.sourceObject); + }; + return Transformer; + }(ComputedValue); + return function (object) { + if (resetId !== globalState.resetId) { + objectCache = {}; + resetId = globalState.resetId; + } + var identifier = getMemoizationId(object); + var reactiveTransformer = objectCache[identifier]; + if (reactiveTransformer) return reactiveTransformer.get(); + reactiveTransformer = objectCache[identifier] = new Transformer(identifier, object); + return reactiveTransformer.get(); + }; + } + exports.createTransformer = createTransformer; + + function getMemoizationId(object) { + if (object === null || (typeof object === "undefined" ? "undefined" : _typeof(object)) !== "object") throw new Error("[mobx] transform expected some kind of object, got: " + object); + var tid = object.$transformId; + if (tid === undefined) { + tid = getNextId(); + addHiddenProp(object, "$transformId", tid); + } + return tid; + } + + function expr(expr, scope) { + if (!isComputingDerivation()) console.warn(getMessage("m013")); + return computed(expr, { + context: scope + }).get(); + } + exports.expr = expr; + + function extendObservable(target) { + var properties = []; + for (var _i = 1; _i < arguments.length; _i++) { + properties[_i - 1] = arguments[_i]; + } + return extendObservableHelper(target, deepEnhancer, properties); + } + exports.extendObservable = extendObservable; + + function extendShallowObservable(target) { + var properties = []; + for (var _i = 1; _i < arguments.length; _i++) { + properties[_i - 1] = arguments[_i]; + } + return extendObservableHelper(target, referenceEnhancer, properties); + } + exports.extendShallowObservable = extendShallowObservable; + + function extendObservableHelper(target, defaultEnhancer, properties) { + invariant(arguments.length >= 2, getMessage("m014")); + invariant((typeof target === "undefined" ? "undefined" : _typeof(target)) === "object", getMessage("m015")); + invariant(!isObservableMap(target), getMessage("m016")); + properties.forEach(function (propSet) { + invariant((typeof propSet === "undefined" ? "undefined" : _typeof(propSet)) === "object", getMessage("m017")); + invariant(!isObservable(propSet), getMessage("m018")); + }); + var adm = asObservableObject(target); + var definedProps = {}; + for (var i = properties.length - 1; i >= 0; i--) { + var propSet = properties[i]; + for (var key in propSet) { + if (definedProps[key] !== true && hasOwnProperty(propSet, key)) { + definedProps[key] = true; + if (target === propSet && !isPropertyConfigurable(target, key)) continue; + var descriptor = Object.getOwnPropertyDescriptor(propSet, key); + defineObservablePropertyFromDescriptor(adm, key, descriptor, defaultEnhancer); + } + } + } + return target; + } + + function getDependencyTree(thing, property) { + return nodeToDependencyTree(getAtom(thing, property)); + } + + function nodeToDependencyTree(node) { + var result = { + name: node.name + }; + if (node.observing && node.observing.length > 0) result.dependencies = unique(node.observing).map(nodeToDependencyTree); + return result; + } + + function getObserverTree(thing, property) { + return nodeToObserverTree(getAtom(thing, property)); + } + + function nodeToObserverTree(node) { + var result = { + name: node.name + }; + if (hasObservers(node)) result.observers = getObservers(node).map(nodeToObserverTree); + return result; + } + + function intercept(thing, propOrHandler, handler) { + if (typeof handler === "function") return interceptProperty(thing, propOrHandler, handler); + else return interceptInterceptable(thing, propOrHandler); + } + exports.intercept = intercept; + + function interceptInterceptable(thing, handler) { + return getAdministration(thing).intercept(handler); + } + + function interceptProperty(thing, property, handler) { + return getAdministration(thing, property).intercept(handler); + } + + function isComputed(value, property) { + if (value === null || value === undefined) return false; + if (property !== undefined) { + if (isObservableObject(value) === false) return false; + var atom = getAtom(value, property); + return isComputedValue(atom); + } + return isComputedValue(value); + } + exports.isComputed = isComputed; + + function isObservable(value, property) { + if (value === null || value === undefined) return false; + if (property !== undefined) { + if (isObservableArray(value) || isObservableMap(value)) throw new Error(getMessage("m019")); + else if (isObservableObject(value)) { + var o = value.$mobx; + return o.values && !!o.values[property]; + } + return false; + } + return isObservableObject(value) || !!value.$mobx || isAtom(value) || isReaction(value) || isComputedValue(value); + } + exports.isObservable = isObservable; + var deepDecorator = createDecoratorForEnhancer(deepEnhancer); + var shallowDecorator = createDecoratorForEnhancer(shallowEnhancer); + var refDecorator = createDecoratorForEnhancer(referenceEnhancer); + var deepStructDecorator = createDecoratorForEnhancer(deepStructEnhancer); + var refStructDecorator = createDecoratorForEnhancer(refStructEnhancer); + + function createObservable(v) { + if (v === void 0) { + v = undefined; + } + if (typeof arguments[1] === "string") return deepDecorator.apply(null, arguments); + invariant(arguments.length <= 1, getMessage("m021")); + invariant(!isModifierDescriptor(v), getMessage("m020")); + if (isObservable(v)) return v; + var res = deepEnhancer(v, undefined, undefined); + if (res !== v) return res; + return observable.box(v); + } + var IObservableFactories = function () { + function IObservableFactories() {} + IObservableFactories.prototype.box = function (value, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("box"); + return new ObservableValue(value, deepEnhancer, name); + }; + IObservableFactories.prototype.shallowBox = function (value, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowBox"); + return new ObservableValue(value, referenceEnhancer, name); + }; + IObservableFactories.prototype.array = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("array"); + return new ObservableArray(initialValues, deepEnhancer, name); + }; + IObservableFactories.prototype.shallowArray = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowArray"); + return new ObservableArray(initialValues, referenceEnhancer, name); + }; + IObservableFactories.prototype.map = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("map"); + return new ObservableMap(initialValues, deepEnhancer, name); + }; + IObservableFactories.prototype.shallowMap = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowMap"); + return new ObservableMap(initialValues, referenceEnhancer, name); + }; + IObservableFactories.prototype.object = function (props, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("object"); + var res = {}; + asObservableObject(res, name); + extendObservable(res, props); + return res; + }; + IObservableFactories.prototype.shallowObject = function (props, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowObject"); + var res = {}; + asObservableObject(res, name); + extendShallowObservable(res, props); + return res; + }; + IObservableFactories.prototype.ref = function () { + if (arguments.length < 2) { + return createModifierDescriptor(referenceEnhancer, arguments[0]); + } else { + return refDecorator.apply(null, arguments); + } + }; + IObservableFactories.prototype.shallow = function () { + if (arguments.length < 2) { + return createModifierDescriptor(shallowEnhancer, arguments[0]); + } else { + return shallowDecorator.apply(null, arguments); + } + }; + IObservableFactories.prototype.deep = function () { + if (arguments.length < 2) { + return createModifierDescriptor(deepEnhancer, arguments[0]); + } else { + return deepDecorator.apply(null, arguments); + } + }; + IObservableFactories.prototype.struct = function () { + if (arguments.length < 2) { + return createModifierDescriptor(deepStructEnhancer, arguments[0]); + } else { + return deepStructDecorator.apply(null, arguments); + } + }; + return IObservableFactories; + }(); + exports.IObservableFactories = IObservableFactories; + var observable = createObservable; + exports.observable = observable; + Object.keys(IObservableFactories.prototype).forEach(function (key) { + return observable[key] = IObservableFactories.prototype[key]; + }); + observable.deep.struct = observable.struct; + observable.ref.struct = function () { + if (arguments.length < 2) { + return createModifierDescriptor(refStructEnhancer, arguments[0]); + } else { + return refStructDecorator.apply(null, arguments); + } + }; + + function incorrectlyUsedAsDecorator(methodName) { + fail("Expected one or two arguments to observable." + methodName + ". Did you accidentally try to use observable." + methodName + " as decorator?"); + } + + function createDecoratorForEnhancer(enhancer) { + invariant(!!enhancer, ":("); + return createClassPropertyDecorator(function (target, name, baseValue, _, baseDescriptor) { + assertPropertyConfigurable(target, name); + invariant(!baseDescriptor || !baseDescriptor.get, getMessage("m022")); + var adm = asObservableObject(target, undefined); + defineObservableProperty(adm, name, baseValue, enhancer); + }, function (name) { + var observable = this.$mobx.values[name]; + if (observable === undefined) return undefined; + return observable.get(); + }, function (name, value) { + setPropertyValue(this, name, value); + }, true, false); + } + + function observe(thing, propOrCb, cbOrFire, fireImmediately) { + if (typeof cbOrFire === "function") return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately); + else return observeObservable(thing, propOrCb, cbOrFire); + } + exports.observe = observe; + + function observeObservable(thing, listener, fireImmediately) { + return getAdministration(thing).observe(listener, fireImmediately); + } + + function observeObservableProperty(thing, property, listener, fireImmediately) { + return getAdministration(thing, property).observe(listener, fireImmediately); + } + + function toJS(source, detectCycles, __alreadySeen) { + if (detectCycles === void 0) { + detectCycles = true; + } + if (__alreadySeen === void 0) { + __alreadySeen = []; + } + + function cache(value) { + if (detectCycles) __alreadySeen.push([source, value]); + return value; + } + if (isObservable(source)) { + if (detectCycles && __alreadySeen === null) __alreadySeen = []; + if (detectCycles && source !== null && (typeof source === "undefined" ? "undefined" : _typeof(source)) === "object") { + for (var i = 0, l = __alreadySeen.length; i < l; i++) { + if (__alreadySeen[i][0] === source) return __alreadySeen[i][1]; + } + } + if (isObservableArray(source)) { + var res = cache([]); + var toAdd = source.map(function (value) { + return toJS(value, detectCycles, __alreadySeen); + }); + res.length = toAdd.length; + for (var i = 0, l = toAdd.length; i < l; i++) { + res[i] = toAdd[i]; + } + return res; + } + if (isObservableObject(source)) { + var res = cache({}); + for (var key in source) { + res[key] = toJS(source[key], detectCycles, __alreadySeen); + } + return res; + } + if (isObservableMap(source)) { + var res_1 = cache({}); + source.forEach(function (value, key) { + return res_1[key] = toJS(value, detectCycles, __alreadySeen); + }); + return res_1; + } + if (isObservableValue(source)) return toJS(source.get(), detectCycles, __alreadySeen); + } + return source; + } + exports.toJS = toJS; + + function transaction(action, thisArg) { + if (thisArg === void 0) { + thisArg = undefined; + } + deprecated(getMessage("m023")); + return runInTransaction.apply(undefined, arguments); + } + exports.transaction = transaction; + + function runInTransaction(action, thisArg) { + if (thisArg === void 0) { + thisArg = undefined; + } + return executeAction("", action); + } + + function log(msg) { + console.log(msg); + return msg; + } + + function whyRun(thing, prop) { + switch (arguments.length) { + case 0: + thing = globalState.trackingDerivation; + if (!thing) return log(getMessage("m024")); + break; + case 2: + thing = getAtom(thing, prop); + break; + } + thing = getAtom(thing); + if (isComputedValue(thing)) return log(thing.whyRun()); + else if (isReaction(thing)) return log(thing.whyRun()); + return fail(getMessage("m025")); + } + exports.whyRun = whyRun; + + function createAction(actionName, fn) { + invariant(typeof fn === "function", getMessage("m026")); + invariant(typeof actionName === "string" && actionName.length > 0, "actions should have valid names, got: '" + actionName + "'"); + var res = function res() { + return executeAction(actionName, fn, this, arguments); + }; + res.originalFn = fn; + res.isMobxAction = true; + return res; + } + + function executeAction(actionName, fn, scope, args) { + var runInfo = startAction(actionName, fn, scope, args); + try { + return fn.apply(scope, args); + } finally { + endAction(runInfo); + } + } + + function startAction(actionName, fn, scope, args) { + var notifySpy = isSpyEnabled() && !!actionName; + var startTime = 0; + if (notifySpy) { + startTime = Date.now(); + var l = args && args.length || 0; + var flattendArgs = new Array(l); + if (l > 0) + for (var i = 0; i < l; i++) { + flattendArgs[i] = args[i]; + } + spyReportStart({ + type: "action", + name: actionName, + fn: fn, + object: scope, + arguments: flattendArgs + }); + } + var prevDerivation = untrackedStart(); + startBatch(); + var prevAllowStateChanges = allowStateChangesStart(true); + return { + prevDerivation: prevDerivation, + prevAllowStateChanges: prevAllowStateChanges, + notifySpy: notifySpy, + startTime: startTime + }; + } + + function endAction(runInfo) { + allowStateChangesEnd(runInfo.prevAllowStateChanges); + endBatch(); + untrackedEnd(runInfo.prevDerivation); + if (runInfo.notifySpy) spyReportEnd({ + time: Date.now() - runInfo.startTime + }); + } + + function useStrict(strict) { + invariant(globalState.trackingDerivation === null, getMessage("m028")); + globalState.strictMode = strict; + globalState.allowStateChanges = !strict; + } + exports.useStrict = useStrict; + + function isStrictModeEnabled() { + return globalState.strictMode; + } + exports.isStrictModeEnabled = isStrictModeEnabled; + + function allowStateChanges(allowStateChanges, func) { + var prev = allowStateChangesStart(allowStateChanges); + var res; + try { + res = func(); + } finally { + allowStateChangesEnd(prev); + } + return res; + } + + function allowStateChangesStart(allowStateChanges) { + var prev = globalState.allowStateChanges; + globalState.allowStateChanges = allowStateChanges; + return prev; + } + + function allowStateChangesEnd(prev) { + globalState.allowStateChanges = prev; + } + var BaseAtom = function () { + function BaseAtom(name) { + if (name === void 0) { + name = "Atom@" + getNextId(); + } + this.name = name; + this.isPendingUnobservation = true; + this.observers = []; + this.observersIndexes = {}; + this.diffValue = 0; + this.lastAccessedBy = 0; + this.lowestObserverState = IDerivationState.NOT_TRACKING; + } + BaseAtom.prototype.onBecomeUnobserved = function () {}; + BaseAtom.prototype.reportObserved = function () { + reportObserved(this); + }; + BaseAtom.prototype.reportChanged = function () { + startBatch(); + propagateChanged(this); + endBatch(); + }; + BaseAtom.prototype.toString = function () { + return this.name; + }; + return BaseAtom; + }(); + exports.BaseAtom = BaseAtom; + var Atom = function (_super) { + __extends(Atom, _super); + + function Atom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) { + if (name === void 0) { + name = "Atom@" + getNextId(); + } + if (onBecomeObservedHandler === void 0) { + onBecomeObservedHandler = noop; + } + if (onBecomeUnobservedHandler === void 0) { + onBecomeUnobservedHandler = noop; + } + var _this = _super.call(this, name) || this; + _this.name = name; + _this.onBecomeObservedHandler = onBecomeObservedHandler; + _this.onBecomeUnobservedHandler = onBecomeUnobservedHandler; + _this.isPendingUnobservation = false; + _this.isBeingTracked = false; + return _this; + } + Atom.prototype.reportObserved = function () { + startBatch(); + _super.prototype.reportObserved.call(this); + if (!this.isBeingTracked) { + this.isBeingTracked = true; + this.onBecomeObservedHandler(); + } + endBatch(); + return !!globalState.trackingDerivation; + }; + Atom.prototype.onBecomeUnobserved = function () { + this.isBeingTracked = false; + this.onBecomeUnobservedHandler(); + }; + return Atom; + }(BaseAtom); + exports.Atom = Atom; + var isAtom = createInstanceofPredicate("Atom", BaseAtom); + var ComputedValue = function () { + function ComputedValue(derivation, scope, compareStructural, name, setter) { + this.derivation = derivation; + this.scope = scope; + this.compareStructural = compareStructural; + this.dependenciesState = IDerivationState.NOT_TRACKING; + this.observing = []; + this.newObserving = null; + this.isPendingUnobservation = false; + this.observers = []; + this.observersIndexes = {}; + this.diffValue = 0; + this.runId = 0; + this.lastAccessedBy = 0; + this.lowestObserverState = IDerivationState.UP_TO_DATE; + this.unboundDepsCount = 0; + this.__mapid = "#" + getNextId(); + this.value = undefined; + this.isComputing = false; + this.isRunningSetter = false; + this.name = name || "ComputedValue@" + getNextId(); + if (setter) this.setter = createAction(name + "-setter", setter); + } + ComputedValue.prototype.onBecomeStale = function () { + propagateMaybeChanged(this); + }; + ComputedValue.prototype.onBecomeUnobserved = function () { + invariant(this.dependenciesState !== IDerivationState.NOT_TRACKING, getMessage("m029")); + clearObserving(this); + this.value = undefined; + }; + ComputedValue.prototype.get = function () { + invariant(!this.isComputing, "Cycle detected in computation " + this.name, this.derivation); + if (globalState.inBatch === 0) { + startBatch(); + if (shouldCompute(this)) this.value = this.computeValue(false); + endBatch(); + } else { + reportObserved(this); + if (shouldCompute(this)) + if (this.trackAndCompute()) propagateChangeConfirmed(this); + } + var result = this.value; + if (isCaughtException(result)) throw result.cause; + return result; + }; + ComputedValue.prototype.peek = function () { + var res = this.computeValue(false); + if (isCaughtException(res)) throw res.cause; + return res; + }; + ComputedValue.prototype.set = function (value) { + if (this.setter) { + invariant(!this.isRunningSetter, "The setter of computed value '" + this.name + "' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?"); + this.isRunningSetter = true; + try { + this.setter.call(this.scope, value); + } finally { + this.isRunningSetter = false; + } + } else invariant(false, "[ComputedValue '" + this.name + "'] It is not possible to assign a new value to a computed value."); + }; + ComputedValue.prototype.trackAndCompute = function () { + if (isSpyEnabled()) { + spyReport({ + object: this.scope, + type: "compute", + fn: this.derivation + }); + } + var oldValue = this.value; + var newValue = this.value = this.computeValue(true); + return isCaughtException(newValue) || valueDidChange(this.compareStructural, newValue, oldValue); + }; + ComputedValue.prototype.computeValue = function (track) { + this.isComputing = true; + globalState.computationDepth++; + var res; + if (track) { + res = trackDerivedFunction(this, this.derivation, this.scope); + } else { + try { + res = this.derivation.call(this.scope); + } catch (e) { + res = new CaughtException(e); + } + } + globalState.computationDepth--; + this.isComputing = false; + return res; + };; + ComputedValue.prototype.observe = function (listener, fireImmediately) { + var _this = this; + var firstTime = true; + var prevValue = undefined; + return autorun(function () { + var newValue = _this.get(); + if (!firstTime || fireImmediately) { + var prevU = untrackedStart(); + listener({ + type: "update", + object: _this, + newValue: newValue, + oldValue: prevValue + }); + untrackedEnd(prevU); + } + firstTime = false; + prevValue = newValue; + }); + }; + ComputedValue.prototype.toJSON = function () { + return this.get(); + }; + ComputedValue.prototype.toString = function () { + return this.name + "[" + this.derivation.toString() + "]"; + }; + ComputedValue.prototype.valueOf = function () { + return toPrimitive(this.get()); + };; + ComputedValue.prototype.whyRun = function () { + var isTracking = Boolean(globalState.trackingDerivation); + var observing = unique(this.isComputing ? this.newObserving : this.observing).map(function (dep) { + return dep.name; + }); + var observers = unique(getObservers(this).map(function (dep) { + return dep.name; + })); + return "\nWhyRun? computation '" + this.name + "':\n * Running because: " + (isTracking ? "[active] the value of this computation is needed by a reaction" : this.isComputing ? "[get] The value of this computed was requested outside a reaction" : "[idle] not running at the moment") + "\n" + (this.dependenciesState === IDerivationState.NOT_TRACKING ? getMessage("m032") : " * This computation will re-run if any of the following observables changes:\n " + joinStrings(observing) + "\n " + (this.isComputing && isTracking ? " (... or any observable accessed during the remainder of the current run)" : "") + "\n\t" + getMessage("m038") + "\n\n * If the outcome of this computation changes, the following observers will be re-run:\n " + joinStrings(observers) + "\n"); + }; + return ComputedValue; + }(); + ComputedValue.prototype[primitiveSymbol()] = ComputedValue.prototype.valueOf; + var isComputedValue = createInstanceofPredicate("ComputedValue", ComputedValue); + var IDerivationState; + (function (IDerivationState) { + IDerivationState[IDerivationState["NOT_TRACKING"] = -1] = "NOT_TRACKING"; + IDerivationState[IDerivationState["UP_TO_DATE"] = 0] = "UP_TO_DATE"; + IDerivationState[IDerivationState["POSSIBLY_STALE"] = 1] = "POSSIBLY_STALE"; + IDerivationState[IDerivationState["STALE"] = 2] = "STALE"; + })(IDerivationState || (IDerivationState = {})); + exports.IDerivationState = IDerivationState; + var CaughtException = function () { + function CaughtException(cause) { + this.cause = cause; + } + return CaughtException; + }(); + + function isCaughtException(e) { + return e instanceof CaughtException; + } + + function shouldCompute(derivation) { + switch (derivation.dependenciesState) { + case IDerivationState.UP_TO_DATE: + return false; + case IDerivationState.NOT_TRACKING: + case IDerivationState.STALE: + return true; + case IDerivationState.POSSIBLY_STALE: { + var prevUntracked = untrackedStart(); + var obs = derivation.observing, + l = obs.length; + for (var i = 0; i < l; i++) { + var obj = obs[i]; + if (isComputedValue(obj)) { + try { + obj.get(); + } catch (e) { + untrackedEnd(prevUntracked); + return true; + } + if (derivation.dependenciesState === IDerivationState.STALE) { + untrackedEnd(prevUntracked); + return true; + } + } + } + changeDependenciesStateTo0(derivation); + untrackedEnd(prevUntracked); + return false; + } + } + } + + function isComputingDerivation() { + return globalState.trackingDerivation !== null; + } + + function checkIfStateModificationsAreAllowed(atom) { + var hasObservers = atom.observers.length > 0; + if (globalState.computationDepth > 0 && hasObservers) fail(getMessage("m031") + atom.name); + if (!globalState.allowStateChanges && hasObservers) fail(getMessage(globalState.strictMode ? "m030a" : "m030b") + atom.name); + } + + function trackDerivedFunction(derivation, f, context) { + changeDependenciesStateTo0(derivation); + derivation.newObserving = new Array(derivation.observing.length + 100); + derivation.unboundDepsCount = 0; + derivation.runId = ++globalState.runId; + var prevTracking = globalState.trackingDerivation; + globalState.trackingDerivation = derivation; + var result; + try { + result = f.call(context); + } catch (e) { + result = new CaughtException(e); + } + globalState.trackingDerivation = prevTracking; + bindDependencies(derivation); + return result; + } + + function bindDependencies(derivation) { + var prevObserving = derivation.observing; + var observing = derivation.observing = derivation.newObserving; + derivation.newObserving = null; + var i0 = 0, + l = derivation.unboundDepsCount; + for (var i = 0; i < l; i++) { + var dep = observing[i]; + if (dep.diffValue === 0) { + dep.diffValue = 1; + if (i0 !== i) observing[i0] = dep; + i0++; + } + } + observing.length = i0; + l = prevObserving.length; + while (l--) { + var dep = prevObserving[l]; + if (dep.diffValue === 0) { + removeObserver(dep, derivation); + } + dep.diffValue = 0; + } + while (i0--) { + var dep = observing[i0]; + if (dep.diffValue === 1) { + dep.diffValue = 0; + addObserver(dep, derivation); + } + } + } + + function clearObserving(derivation) { + var obs = derivation.observing; + var i = obs.length; + while (i--) { + removeObserver(obs[i], derivation); + } + derivation.dependenciesState = IDerivationState.NOT_TRACKING; + obs.length = 0; + } + + function untracked(action) { + var prev = untrackedStart(); + var res = action(); + untrackedEnd(prev); + return res; + } + exports.untracked = untracked; + + function untrackedStart() { + var prev = globalState.trackingDerivation; + globalState.trackingDerivation = null; + return prev; + } + + function untrackedEnd(prev) { + globalState.trackingDerivation = prev; + } + + function changeDependenciesStateTo0(derivation) { + if (derivation.dependenciesState === IDerivationState.UP_TO_DATE) return; + derivation.dependenciesState = IDerivationState.UP_TO_DATE; + var obs = derivation.observing; + var i = obs.length; + while (i--) { + obs[i].lowestObserverState = IDerivationState.UP_TO_DATE; + } + } + var persistentKeys = ["mobxGuid", "resetId", "spyListeners", "strictMode", "runId"]; + var MobXGlobals = function () { + function MobXGlobals() { + this.version = 5; + this.trackingDerivation = null; + this.computationDepth = 0; + this.runId = 0; + this.mobxGuid = 0; + this.inBatch = 0; + this.pendingUnobservations = []; + this.pendingReactions = []; + this.isRunningReactions = false; + this.allowStateChanges = true; + this.strictMode = false; + this.resetId = 0; + this.spyListeners = []; + this.globalReactionErrorHandlers = []; + } + return MobXGlobals; + }(); + var globalState = new MobXGlobals(); + + function shareGlobalState() { + var global = getGlobal(); + var ownState = globalState; + if (global.__mobservableTrackingStack || global.__mobservableViewStack) throw new Error("[mobx] An incompatible version of mobservable is already loaded."); + if (global.__mobxGlobal && global.__mobxGlobal.version !== ownState.version) throw new Error("[mobx] An incompatible version of mobx is already loaded."); + if (global.__mobxGlobal) globalState = global.__mobxGlobal; + else global.__mobxGlobal = ownState; + } + + function getGlobalState() { + return globalState; + } + + function registerGlobals() {} + + function resetGlobalState() { + globalState.resetId++; + var defaultGlobals = new MobXGlobals(); + for (var key in defaultGlobals) { + if (persistentKeys.indexOf(key) === -1) globalState[key] = defaultGlobals[key]; + } + globalState.allowStateChanges = !globalState.strictMode; + } + + function hasObservers(observable) { + return observable.observers && observable.observers.length > 0; + } + + function getObservers(observable) { + return observable.observers; + } + + function invariantObservers(observable) { + var list = observable.observers; + var map = observable.observersIndexes; + var l = list.length; + for (var i = 0; i < l; i++) { + var id = list[i].__mapid; + if (i) { + invariant(map[id] === i, "INTERNAL ERROR maps derivation.__mapid to index in list"); + } else { + invariant(!(id in map), "INTERNAL ERROR observer on index 0 shouldnt be held in map."); + } + } + invariant(list.length === 0 || Object.keys(map).length === list.length - 1, "INTERNAL ERROR there is no junk in map"); + } + + function addObserver(observable, node) { + var l = observable.observers.length; + if (l) { + observable.observersIndexes[node.__mapid] = l; + } + observable.observers[l] = node; + if (observable.lowestObserverState > node.dependenciesState) observable.lowestObserverState = node.dependenciesState; + } + + function removeObserver(observable, node) { + if (observable.observers.length === 1) { + observable.observers.length = 0; + queueForUnobservation(observable); + } else { + var list = observable.observers; + var map_1 = observable.observersIndexes; + var filler = list.pop(); + if (filler !== node) { + var index = map_1[node.__mapid] || 0; + if (index) { + map_1[filler.__mapid] = index; + } else { + delete map_1[filler.__mapid]; + } + list[index] = filler; + } + delete map_1[node.__mapid]; + } + } + + function queueForUnobservation(observable) { + if (!observable.isPendingUnobservation) { + observable.isPendingUnobservation = true; + globalState.pendingUnobservations.push(observable); + } + } + + function startBatch() { + globalState.inBatch++; + } + + function endBatch() { + if (--globalState.inBatch === 0) { + runReactions(); + var list = globalState.pendingUnobservations; + for (var i = 0; i < list.length; i++) { + var observable_1 = list[i]; + observable_1.isPendingUnobservation = false; + if (observable_1.observers.length === 0) { + observable_1.onBecomeUnobserved(); + } + } + globalState.pendingUnobservations = []; + } + } + + function reportObserved(observable) { + var derivation = globalState.trackingDerivation; + if (derivation !== null) { + if (derivation.runId !== observable.lastAccessedBy) { + observable.lastAccessedBy = derivation.runId; + derivation.newObserving[derivation.unboundDepsCount++] = observable; + } + } else if (observable.observers.length === 0) { + queueForUnobservation(observable); + } + } + + function invariantLOS(observable, msg) { + var min = getObservers(observable).reduce(function (a, b) { + return Math.min(a, b.dependenciesState); + }, 2); + if (min >= observable.lowestObserverState) return; + throw new Error("lowestObserverState is wrong for " + msg + " because " + min + " < " + observable.lowestObserverState); + } + + function propagateChanged(observable) { + if (observable.lowestObserverState === IDerivationState.STALE) return; + observable.lowestObserverState = IDerivationState.STALE; + var observers = observable.observers; + var i = observers.length; + while (i--) { + var d = observers[i]; + if (d.dependenciesState === IDerivationState.UP_TO_DATE) d.onBecomeStale(); + d.dependenciesState = IDerivationState.STALE; + } + } + + function propagateChangeConfirmed(observable) { + if (observable.lowestObserverState === IDerivationState.STALE) return; + observable.lowestObserverState = IDerivationState.STALE; + var observers = observable.observers; + var i = observers.length; + while (i--) { + var d = observers[i]; + if (d.dependenciesState === IDerivationState.POSSIBLY_STALE) d.dependenciesState = IDerivationState.STALE; + else if (d.dependenciesState === IDerivationState.UP_TO_DATE) observable.lowestObserverState = IDerivationState.UP_TO_DATE; + } + } + + function propagateMaybeChanged(observable) { + if (observable.lowestObserverState !== IDerivationState.UP_TO_DATE) return; + observable.lowestObserverState = IDerivationState.POSSIBLY_STALE; + var observers = observable.observers; + var i = observers.length; + while (i--) { + var d = observers[i]; + if (d.dependenciesState === IDerivationState.UP_TO_DATE) { + d.dependenciesState = IDerivationState.POSSIBLY_STALE; + d.onBecomeStale(); + } + } + } + var Reaction = function () { + function Reaction(name, onInvalidate) { + if (name === void 0) { + name = "Reaction@" + getNextId(); + } + this.name = name; + this.onInvalidate = onInvalidate; + this.observing = []; + this.newObserving = []; + this.dependenciesState = IDerivationState.NOT_TRACKING; + this.diffValue = 0; + this.runId = 0; + this.unboundDepsCount = 0; + this.__mapid = "#" + getNextId(); + this.isDisposed = false; + this._isScheduled = false; + this._isTrackPending = false; + this._isRunning = false; + } + Reaction.prototype.onBecomeStale = function () { + this.schedule(); + }; + Reaction.prototype.schedule = function () { + if (!this._isScheduled) { + this._isScheduled = true; + globalState.pendingReactions.push(this); + runReactions(); + } + }; + Reaction.prototype.isScheduled = function () { + return this._isScheduled; + }; + Reaction.prototype.runReaction = function () { + if (!this.isDisposed) { + startBatch(); + this._isScheduled = false; + if (shouldCompute(this)) { + this._isTrackPending = true; + this.onInvalidate(); + if (this._isTrackPending && isSpyEnabled()) { + spyReport({ + object: this, + type: "scheduled-reaction" + }); + } + } + endBatch(); + } + }; + Reaction.prototype.track = function (fn) { + startBatch(); + var notify = isSpyEnabled(); + var startTime; + if (notify) { + startTime = Date.now(); + spyReportStart({ + object: this, + type: "reaction", + fn: fn + }); + } + this._isRunning = true; + var result = trackDerivedFunction(this, fn, undefined); + this._isRunning = false; + this._isTrackPending = false; + if (this.isDisposed) { + clearObserving(this); + } + if (isCaughtException(result)) this.reportExceptionInDerivation(result.cause); + if (notify) { + spyReportEnd({ + time: Date.now() - startTime + }); + } + endBatch(); + }; + Reaction.prototype.reportExceptionInDerivation = function (error) { + var _this = this; + if (this.errorHandler) { + this.errorHandler(error, this); + return; + } + var message = "[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '" + this; + var messageToUser = getMessage("m037"); + console.error(message || messageToUser, error); + if (isSpyEnabled()) { + spyReport({ + type: "error", + message: message, + error: error, + object: this + }); + } + globalState.globalReactionErrorHandlers.forEach(function (f) { + return f(error, _this); + }); + }; + Reaction.prototype.dispose = function () { + if (!this.isDisposed) { + this.isDisposed = true; + if (!this._isRunning) { + startBatch(); + clearObserving(this); + endBatch(); + } + } + }; + Reaction.prototype.getDisposer = function () { + var r = this.dispose.bind(this); + r.$mobx = this; + r.onError = registerErrorHandler; + return r; + }; + Reaction.prototype.toString = function () { + return "Reaction[" + this.name + "]"; + }; + Reaction.prototype.whyRun = function () { + var observing = unique(this._isRunning ? this.newObserving : this.observing).map(function (dep) { + return dep.name; + }); + return "\nWhyRun? reaction '" + this.name + "':\n * Status: [" + (this.isDisposed ? "stopped" : this._isRunning ? "running" : this.isScheduled() ? "scheduled" : "idle") + "]\n * This reaction will re-run if any of the following observables changes:\n " + joinStrings(observing) + "\n " + (this._isRunning ? " (... or any observable accessed during the remainder of the current run)" : "") + "\n\t" + getMessage("m038") + "\n"; + }; + return Reaction; + }(); + exports.Reaction = Reaction; + + function registerErrorHandler(handler) { + invariant(this && this.$mobx && isReaction(this.$mobx), "Invalid `this`"); + invariant(!this.$mobx.errorHandler, "Only one onErrorHandler can be registered"); + this.$mobx.errorHandler = handler; + } + + function onReactionError(handler) { + globalState.globalReactionErrorHandlers.push(handler); + return function () { + var idx = globalState.globalReactionErrorHandlers.indexOf(handler); + if (idx >= 0) globalState.globalReactionErrorHandlers.splice(idx, 1); + }; + } + var MAX_REACTION_ITERATIONS = 100; + var reactionScheduler = function reactionScheduler(f) { + return f(); + }; + + function runReactions() { + if (globalState.inBatch > 0 || globalState.isRunningReactions) return; + reactionScheduler(runReactionsHelper); + } + + function runReactionsHelper() { + globalState.isRunningReactions = true; + var allReactions = globalState.pendingReactions; + var iterations = 0; + while (allReactions.length > 0) { + if (++iterations === MAX_REACTION_ITERATIONS) { + console.error("Reaction doesn't converge to a stable state after " + MAX_REACTION_ITERATIONS + " iterations." + (" Probably there is a cycle in the reactive function: " + allReactions[0])); + allReactions.splice(0); + } + var remainingReactions = allReactions.splice(0); + for (var i = 0, l = remainingReactions.length; i < l; i++) { + remainingReactions[i].runReaction(); + } + } + globalState.isRunningReactions = false; + } + var isReaction = createInstanceofPredicate("Reaction", Reaction); + + function setReactionScheduler(fn) { + var baseScheduler = reactionScheduler; + reactionScheduler = function reactionScheduler(f) { + return fn(function () { + return baseScheduler(f); + }); + }; + } + + function isSpyEnabled() { + return !!globalState.spyListeners.length; + } + + function spyReport(event) { + if (!globalState.spyListeners.length) return; + var listeners = globalState.spyListeners; + for (var i = 0, l = listeners.length; i < l; i++) { + listeners[i](event); + } + } + + function spyReportStart(event) { + var change = objectAssign({}, event, { + spyReportStart: true + }); + spyReport(change); + } + var END_EVENT = { + spyReportEnd: true + }; + + function spyReportEnd(change) { + if (change) spyReport(objectAssign({}, change, END_EVENT)); + else spyReport(END_EVENT); + } + + function spy(listener) { + globalState.spyListeners.push(listener); + return once(function () { + var idx = globalState.spyListeners.indexOf(listener); + if (idx !== -1) globalState.spyListeners.splice(idx, 1); + }); + } + exports.spy = spy; + + function hasInterceptors(interceptable) { + return interceptable.interceptors && interceptable.interceptors.length > 0; + } + + function registerInterceptor(interceptable, handler) { + var interceptors = interceptable.interceptors || (interceptable.interceptors = []); + interceptors.push(handler); + return once(function () { + var idx = interceptors.indexOf(handler); + if (idx !== -1) interceptors.splice(idx, 1); + }); + } + + function interceptChange(interceptable, change) { + var prevU = untrackedStart(); + try { + var interceptors = interceptable.interceptors; + if (interceptors) + for (var i = 0, l = interceptors.length; i < l; i++) { + change = interceptors[i](change); + invariant(!change || change.type, "Intercept handlers should return nothing or a change object"); + if (!change) break; + } + return change; + } finally { + untrackedEnd(prevU); + } + } + + function hasListeners(listenable) { + return listenable.changeListeners && listenable.changeListeners.length > 0; + } + + function registerListener(listenable, handler) { + var listeners = listenable.changeListeners || (listenable.changeListeners = []); + listeners.push(handler); + return once(function () { + var idx = listeners.indexOf(handler); + if (idx !== -1) listeners.splice(idx, 1); + }); + } + + function notifyListeners(listenable, change) { + var prevU = untrackedStart(); + var listeners = listenable.changeListeners; + if (!listeners) return; + listeners = listeners.slice(); + for (var i = 0, l = listeners.length; i < l; i++) { + listeners[i](change); + } + untrackedEnd(prevU); + } + + function asReference(value) { + deprecated("asReference is deprecated, use observable.ref instead"); + return observable.ref(value); + } + exports.asReference = asReference; + + function asStructure(value) { + deprecated("asStructure is deprecated. Use observable.struct, computed.struct or reaction options instead."); + return observable.struct(value); + } + exports.asStructure = asStructure; + + function asFlat(value) { + deprecated("asFlat is deprecated, use observable.shallow instead"); + return observable.shallow(value); + } + exports.asFlat = asFlat; + + function asMap(data) { + deprecated("asMap is deprecated, use observable.map or observable.shallowMap instead"); + return observable.map(data || {}); + } + exports.asMap = asMap; + + function isModifierDescriptor(thing) { + return (typeof thing === "undefined" ? "undefined" : _typeof(thing)) === "object" && thing !== null && thing.isMobxModifierDescriptor === true; + } + exports.isModifierDescriptor = isModifierDescriptor; + + function createModifierDescriptor(enhancer, initialValue) { + invariant(!isModifierDescriptor(initialValue), "Modifiers cannot be nested"); + return { + isMobxModifierDescriptor: true, + initialValue: initialValue, + enhancer: enhancer + }; + } + + function deepEnhancer(v, _, name) { + if (isModifierDescriptor(v)) fail("You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it"); + if (isObservable(v)) return v; + if (Array.isArray(v)) return observable.array(v, name); + if (isPlainObject(v)) return observable.object(v, name); + if (isES6Map(v)) return observable.map(v, name); + return v; + } + + function shallowEnhancer(v, _, name) { + if (isModifierDescriptor(v)) fail("You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it"); + if (v === undefined || v === null) return v; + if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v)) return v; + if (Array.isArray(v)) return observable.shallowArray(v, name); + if (isPlainObject(v)) return observable.shallowObject(v, name); + if (isES6Map(v)) return observable.shallowMap(v, name); + return fail("The shallow modifier / decorator can only used in combination with arrays, objects and maps"); + } + + function referenceEnhancer(newValue) { + return newValue; + } + + function deepStructEnhancer(v, oldValue, name) { + if (deepEqual(v, oldValue)) return oldValue; + if (isObservable(v)) return v; + if (Array.isArray(v)) return new ObservableArray(v, deepStructEnhancer, name); + if (isES6Map(v)) return new ObservableMap(v, deepStructEnhancer, name); + if (isPlainObject(v)) { + var res = {}; + asObservableObject(res, name); + extendObservableHelper(res, deepStructEnhancer, [v]); + return res; + } + return v; + } + + function refStructEnhancer(v, oldValue, name) { + if (deepEqual(v, oldValue)) return oldValue; + return v; + } + var MAX_SPLICE_SIZE = 10000; + var safariPrototypeSetterInheritanceBug = function () { + var v = false; + var p = {}; + Object.defineProperty(p, "0", { + set: function set() { + v = true; + } + }); + Object.create(p)["0"] = 1; + return v === false; + }(); + var OBSERVABLE_ARRAY_BUFFER_SIZE = 0; + var StubArray = function () { + function StubArray() {} + return StubArray; + }(); + StubArray.prototype = []; + var ObservableArrayAdministration = function () { + function ObservableArrayAdministration(name, enhancer, array, owned) { + this.array = array; + this.owned = owned; + this.lastKnownLength = 0; + this.interceptors = null; + this.changeListeners = null; + this.atom = new BaseAtom(name || "ObservableArray@" + getNextId()); + this.enhancer = function (newV, oldV) { + return enhancer(newV, oldV, name + "[..]"); + }; + } + ObservableArrayAdministration.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + ObservableArrayAdministration.prototype.observe = function (listener, fireImmediately) { + if (fireImmediately === void 0) { + fireImmediately = false; + } + if (fireImmediately) { + listener({ + object: this.array, + type: "splice", + index: 0, + added: this.values.slice(), + addedCount: this.values.length, + removed: [], + removedCount: 0 + }); + } + return registerListener(this, listener); + }; + ObservableArrayAdministration.prototype.getArrayLength = function () { + this.atom.reportObserved(); + return this.values.length; + }; + ObservableArrayAdministration.prototype.setArrayLength = function (newLength) { + if (typeof newLength !== "number" || newLength < 0) throw new Error("[mobx.array] Out of range: " + newLength); + var currentLength = this.values.length; + if (newLength === currentLength) return; + else if (newLength > currentLength) { + var newItems = new Array(newLength - currentLength); + for (var i = 0; i < newLength - currentLength; i++) { + newItems[i] = undefined; + } + this.spliceWithArray(currentLength, 0, newItems); + } else this.spliceWithArray(newLength, currentLength - newLength); + }; + ObservableArrayAdministration.prototype.updateArrayLength = function (oldLength, delta) { + if (oldLength !== this.lastKnownLength) throw new Error("[mobx] Modification exception: the internal structure of an observable array was changed. Did you use peek() to change it?"); + this.lastKnownLength += delta; + if (delta > 0 && oldLength + delta + 1 > OBSERVABLE_ARRAY_BUFFER_SIZE) reserveArrayBuffer(oldLength + delta + 1); + }; + ObservableArrayAdministration.prototype.spliceWithArray = function (index, deleteCount, newItems) { + var _this = this; + checkIfStateModificationsAreAllowed(this.atom); + var length = this.values.length; + if (index === undefined) index = 0; + else if (index > length) index = length; + else if (index < 0) index = Math.max(0, length + index); + if (arguments.length === 1) deleteCount = length - index; + else if (deleteCount === undefined || deleteCount === null) deleteCount = 0; + else deleteCount = Math.max(0, Math.min(deleteCount, length - index)); + if (newItems === undefined) newItems = []; + if (hasInterceptors(this)) { + var change = interceptChange(this, { + object: this.array, + type: "splice", + index: index, + removedCount: deleteCount, + added: newItems + }); + if (!change) return EMPTY_ARRAY; + deleteCount = change.removedCount; + newItems = change.added; + } + newItems = newItems.map(function (v) { + return _this.enhancer(v, undefined); + }); + var lengthDelta = newItems.length - deleteCount; + this.updateArrayLength(length, lengthDelta); + var res = this.spliceItemsIntoValues(index, deleteCount, newItems); + if (deleteCount !== 0 || newItems.length !== 0) this.notifyArraySplice(index, newItems, res); + return res; + }; + ObservableArrayAdministration.prototype.spliceItemsIntoValues = function (index, deleteCount, newItems) { + if (newItems.length < MAX_SPLICE_SIZE) { + return (_a = this.values).splice.apply(_a, [index, deleteCount].concat(newItems)); + } else { + var res = this.values.slice(index, index + deleteCount); + this.values = this.values.slice(0, index).concat(newItems, this.values.slice(index + deleteCount)); + return res; + } + var _a; + }; + ObservableArrayAdministration.prototype.notifyArrayChildUpdate = function (index, newValue, oldValue) { + var notifySpy = !this.owned && isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + object: this.array, + type: "update", + index: index, + newValue: newValue, + oldValue: oldValue + } : null; + if (notifySpy) spyReportStart(change); + this.atom.reportChanged(); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + }; + ObservableArrayAdministration.prototype.notifyArraySplice = function (index, added, removed) { + var notifySpy = !this.owned && isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + object: this.array, + type: "splice", + index: index, + removed: removed, + added: added, + removedCount: removed.length, + addedCount: added.length + } : null; + if (notifySpy) spyReportStart(change); + this.atom.reportChanged(); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + }; + return ObservableArrayAdministration; + }(); + var ObservableArray = function (_super) { + __extends(ObservableArray, _super); + + function ObservableArray(initialValues, enhancer, name, owned) { + if (name === void 0) { + name = "ObservableArray@" + getNextId(); + } + if (owned === void 0) { + owned = false; + } + var _this = _super.call(this) || this; + var adm = new ObservableArrayAdministration(name, enhancer, _this, owned); + addHiddenFinalProp(_this, "$mobx", adm); + if (initialValues && initialValues.length) { + adm.updateArrayLength(0, initialValues.length); + adm.values = initialValues.map(function (v) { + return enhancer(v, undefined, name + "[..]"); + }); + adm.notifyArraySplice(0, adm.values.slice(), EMPTY_ARRAY); + } else { + adm.values = []; + } + if (safariPrototypeSetterInheritanceBug) { + Object.defineProperty(adm.array, "0", ENTRY_0); + } + return _this; + } + ObservableArray.prototype.intercept = function (handler) { + return this.$mobx.intercept(handler); + }; + ObservableArray.prototype.observe = function (listener, fireImmediately) { + if (fireImmediately === void 0) { + fireImmediately = false; + } + return this.$mobx.observe(listener, fireImmediately); + }; + ObservableArray.prototype.clear = function () { + return this.splice(0); + }; + ObservableArray.prototype.concat = function () { + var arrays = []; + for (var _i = 0; _i < arguments.length; _i++) { + arrays[_i] = arguments[_i]; + } + this.$mobx.atom.reportObserved(); + return Array.prototype.concat.apply(this.peek(), arrays.map(function (a) { + return isObservableArray(a) ? a.peek() : a; + })); + }; + ObservableArray.prototype.replace = function (newItems) { + return this.$mobx.spliceWithArray(0, this.$mobx.values.length, newItems); + }; + ObservableArray.prototype.toJS = function () { + return this.slice(); + }; + ObservableArray.prototype.toJSON = function () { + return this.toJS(); + }; + ObservableArray.prototype.peek = function () { + return this.$mobx.values; + }; + ObservableArray.prototype.find = function (predicate, thisArg, fromIndex) { + if (fromIndex === void 0) { + fromIndex = 0; + } + this.$mobx.atom.reportObserved(); + var items = this.$mobx.values, + l = items.length; + for (var i = fromIndex; i < l; i++) { + if (predicate.call(thisArg, items[i], i, this)) return items[i]; + } + return undefined; + }; + ObservableArray.prototype.splice = function (index, deleteCount) { + var newItems = []; + for (var _i = 2; _i < arguments.length; _i++) { + newItems[_i - 2] = arguments[_i]; + } + switch (arguments.length) { + case 0: + return []; + case 1: + return this.$mobx.spliceWithArray(index); + case 2: + return this.$mobx.spliceWithArray(index, deleteCount); + } + return this.$mobx.spliceWithArray(index, deleteCount, newItems); + }; + ObservableArray.prototype.spliceWithArray = function (index, deleteCount, newItems) { + return this.$mobx.spliceWithArray(index, deleteCount, newItems); + }; + ObservableArray.prototype.push = function () { + var items = []; + for (var _i = 0; _i < arguments.length; _i++) { + items[_i] = arguments[_i]; + } + var adm = this.$mobx; + adm.spliceWithArray(adm.values.length, 0, items); + return adm.values.length; + }; + ObservableArray.prototype.pop = function () { + return this.splice(Math.max(this.$mobx.values.length - 1, 0), 1)[0]; + }; + ObservableArray.prototype.shift = function () { + return this.splice(0, 1)[0]; + }; + ObservableArray.prototype.unshift = function () { + var items = []; + for (var _i = 0; _i < arguments.length; _i++) { + items[_i] = arguments[_i]; + } + var adm = this.$mobx; + adm.spliceWithArray(0, 0, items); + return adm.values.length; + }; + ObservableArray.prototype.reverse = function () { + this.$mobx.atom.reportObserved(); + var clone = this.slice(); + return clone.reverse.apply(clone, arguments); + }; + ObservableArray.prototype.sort = function (compareFn) { + this.$mobx.atom.reportObserved(); + var clone = this.slice(); + return clone.sort.apply(clone, arguments); + }; + ObservableArray.prototype.remove = function (value) { + var idx = this.$mobx.values.indexOf(value); + if (idx > -1) { + this.splice(idx, 1); + return true; + } + return false; + }; + ObservableArray.prototype.move = function (fromIndex, toIndex) { + function checkIndex(index) { + if (index < 0) { + throw new Error("[mobx.array] Index out of bounds: " + index + " is negative"); + } + var length = this.$mobx.values.length; + if (index >= length) { + throw new Error("[mobx.array] Index out of bounds: " + index + " is not smaller than " + length); + } + } + checkIndex.call(this, fromIndex); + checkIndex.call(this, toIndex); + if (fromIndex === toIndex) { + return; + } + var oldItems = this.$mobx.values; + var newItems; + if (fromIndex < toIndex) { + newItems = oldItems.slice(0, fromIndex).concat(oldItems.slice(fromIndex + 1, toIndex + 1), [oldItems[fromIndex]], oldItems.slice(toIndex + 1)); + } else { + newItems = oldItems.slice(0, toIndex).concat([oldItems[fromIndex]], oldItems.slice(toIndex, fromIndex), oldItems.slice(fromIndex + 1)); + } + this.replace(newItems); + }; + ObservableArray.prototype.toString = function () { + this.$mobx.atom.reportObserved(); + return Array.prototype.toString.apply(this.$mobx.values, arguments); + }; + ObservableArray.prototype.toLocaleString = function () { + this.$mobx.atom.reportObserved(); + return Array.prototype.toLocaleString.apply(this.$mobx.values, arguments); + }; + return ObservableArray; + }(StubArray); + declareIterator(ObservableArray.prototype, function () { + return arrayAsIterator(this.slice()); + }); + makeNonEnumerable(ObservableArray.prototype, ["constructor", "intercept", "observe", "clear", "concat", "replace", "toJS", "toJSON", "peek", "find", "splice", "spliceWithArray", "push", "pop", "shift", "unshift", "reverse", "sort", "remove", "move", "toString", "toLocaleString"]); + Object.defineProperty(ObservableArray.prototype, "length", { + enumerable: false, + configurable: true, + get: function get() { + return this.$mobx.getArrayLength(); + }, + set: function set(newLength) { + this.$mobx.setArrayLength(newLength); + } + }); + ["every", "filter", "forEach", "indexOf", "join", "lastIndexOf", "map", "reduce", "reduceRight", "slice", "some"].forEach(function (funcName) { + var baseFunc = Array.prototype[funcName]; + invariant(typeof baseFunc === "function", "Base function not defined on Array prototype: '" + funcName + "'"); + addHiddenProp(ObservableArray.prototype, funcName, function () { + this.$mobx.atom.reportObserved(); + return baseFunc.apply(this.$mobx.values, arguments); + }); + }); + var ENTRY_0 = { + configurable: true, + enumerable: false, + set: createArraySetter(0), + get: createArrayGetter(0) + }; + + function createArrayBufferItem(index) { + var set = createArraySetter(index); + var get = createArrayGetter(index); + Object.defineProperty(ObservableArray.prototype, "" + index, { + enumerable: false, + configurable: true, + set: set, + get: get + }); + } + + function createArraySetter(index) { + return function (newValue) { + var adm = this.$mobx; + var values = adm.values; + if (index < values.length) { + checkIfStateModificationsAreAllowed(adm.atom); + var oldValue = values[index]; + if (hasInterceptors(adm)) { + var change = interceptChange(adm, { + type: "update", + object: adm.array, + index: index, + newValue: newValue + }); + if (!change) return; + newValue = change.newValue; + } + newValue = adm.enhancer(newValue, oldValue); + var changed = newValue !== oldValue; + if (changed) { + values[index] = newValue; + adm.notifyArrayChildUpdate(index, newValue, oldValue); + } + } else if (index === values.length) { + adm.spliceWithArray(index, 0, [newValue]); + } else throw new Error("[mobx.array] Index out of bounds, " + index + " is larger than " + values.length); + }; + } + + function createArrayGetter(index) { + return function () { + var impl = this.$mobx; + if (impl) { + if (index < impl.values.length) { + impl.atom.reportObserved(); + return impl.values[index]; + } + console.warn("[mobx.array] Attempt to read an array index (" + index + ") that is out of bounds (" + impl.values.length + "). Please check length first. Out of bound indices will not be tracked by MobX"); + } + return undefined; + }; + } + + function reserveArrayBuffer(max) { + for (var index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max; index++) { + createArrayBufferItem(index); + } + OBSERVABLE_ARRAY_BUFFER_SIZE = max; + } + reserveArrayBuffer(1000); + var isObservableArrayAdministration = createInstanceofPredicate("ObservableArrayAdministration", ObservableArrayAdministration); + + function isObservableArray(thing) { + return isObject(thing) && isObservableArrayAdministration(thing.$mobx); + } + exports.isObservableArray = isObservableArray; + var ObservableMapMarker = {}; + var ObservableMap = function () { + function ObservableMap(initialData, enhancer, name) { + if (enhancer === void 0) { + enhancer = deepEnhancer; + } + if (name === void 0) { + name = "ObservableMap@" + getNextId(); + } + this.enhancer = enhancer; + this.name = name; + this.$mobx = ObservableMapMarker; + this._data = {}; + this._hasMap = {}; + this._keys = new ObservableArray(undefined, referenceEnhancer, this.name + ".keys()", true); + this.interceptors = null; + this.changeListeners = null; + this.merge(initialData); + } + ObservableMap.prototype._has = function (key) { + return typeof this._data[key] !== "undefined"; + }; + ObservableMap.prototype.has = function (key) { + if (!this.isValidKey(key)) return false; + key = "" + key; + if (this._hasMap[key]) return this._hasMap[key].get(); + return this._updateHasMapEntry(key, false).get(); + }; + ObservableMap.prototype.set = function (key, value) { + this.assertValidKey(key); + key = "" + key; + var hasKey = this._has(key); + if (hasInterceptors(this)) { + var change = interceptChange(this, { + type: hasKey ? "update" : "add", + object: this, + newValue: value, + name: key + }); + if (!change) return this; + value = change.newValue; + } + if (hasKey) { + this._updateValue(key, value); + } else { + this._addValue(key, value); + } + return this; + }; + ObservableMap.prototype.delete = function (key) { + var _this = this; + this.assertValidKey(key); + key = "" + key; + if (hasInterceptors(this)) { + var change = interceptChange(this, { + type: "delete", + object: this, + name: key + }); + if (!change) return false; + } + if (this._has(key)) { + var notifySpy = isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + type: "delete", + object: this, + oldValue: this._data[key].value, + name: key + } : null; + if (notifySpy) spyReportStart(change); + runInTransaction(function () { + _this._keys.remove(key); + _this._updateHasMapEntry(key, false); + var observable = _this._data[key]; + observable.setNewValue(undefined); + _this._data[key] = undefined; + }); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + return true; + } + return false; + }; + ObservableMap.prototype._updateHasMapEntry = function (key, value) { + var entry = this._hasMap[key]; + if (entry) { + entry.setNewValue(value); + } else { + entry = this._hasMap[key] = new ObservableValue(value, referenceEnhancer, this.name + "." + key + "?", false); + } + return entry; + }; + ObservableMap.prototype._updateValue = function (name, newValue) { + var observable = this._data[name]; + newValue = observable.prepareNewValue(newValue); + if (newValue !== UNCHANGED) { + var notifySpy = isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + type: "update", + object: this, + oldValue: observable.value, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + observable.setNewValue(newValue); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + } + }; + ObservableMap.prototype._addValue = function (name, newValue) { + var _this = this; + runInTransaction(function () { + var observable = _this._data[name] = new ObservableValue(newValue, _this.enhancer, _this.name + "." + name, false); + newValue = observable.value; + _this._updateHasMapEntry(name, true); + _this._keys.push(name); + }); + var notifySpy = isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + type: "add", + object: this, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + }; + ObservableMap.prototype.get = function (key) { + key = "" + key; + if (this.has(key)) return this._data[key].get(); + return undefined; + }; + ObservableMap.prototype.keys = function () { + return arrayAsIterator(this._keys.slice()); + }; + ObservableMap.prototype.values = function () { + return arrayAsIterator(this._keys.map(this.get, this)); + }; + ObservableMap.prototype.entries = function () { + var _this = this; + return arrayAsIterator(this._keys.map(function (key) { + return [key, _this.get(key)]; + })); + }; + ObservableMap.prototype.forEach = function (callback, thisArg) { + var _this = this; + this.keys().forEach(function (key) { + return callback.call(thisArg, _this.get(key), key, _this); + }); + }; + ObservableMap.prototype.merge = function (other) { + var _this = this; + if (isObservableMap(other)) { + other = other.toJS(); + } + runInTransaction(function () { + if (isPlainObject(other)) Object.keys(other).forEach(function (key) { + return _this.set(key, other[key]); + }); + else if (Array.isArray(other)) other.forEach(function (_a) { + var key = _a[0], + value = _a[1]; + return _this.set(key, value); + }); + else if (isES6Map(other)) other.forEach(function (value, key) { + return _this.set(key, value); + }); + else if (other !== null && other !== undefined) fail("Cannot initialize map from " + other); + }); + return this; + }; + ObservableMap.prototype.clear = function () { + var _this = this; + runInTransaction(function () { + untracked(function () { + _this.keys().forEach(_this.delete, _this); + }); + }); + }; + ObservableMap.prototype.replace = function (values) { + var _this = this; + runInTransaction(function () { + _this.clear(); + _this.merge(values); + }); + return this; + }; + Object.defineProperty(ObservableMap.prototype, "size", { + get: function get() { + return this._keys.length; + }, + enumerable: true, + configurable: true + }); + ObservableMap.prototype.toJS = function () { + var _this = this; + var res = {}; + this.keys().forEach(function (key) { + return res[key] = _this.get(key); + }); + return res; + }; + ObservableMap.prototype.toJSON = function () { + return this.toJS(); + }; + ObservableMap.prototype.isValidKey = function (key) { + if (key === null || key === undefined) return false; + if (typeof key === "string" || typeof key === "number" || typeof key === "boolean") return true; + return false; + }; + ObservableMap.prototype.assertValidKey = function (key) { + if (!this.isValidKey(key)) throw new Error("[mobx.map] Invalid key: '" + key + "', only strings, numbers and booleans are accepted as key in observable maps."); + }; + ObservableMap.prototype.toString = function () { + var _this = this; + return this.name + "[{ " + this.keys().map(function (key) { + return key + ": " + ("" + _this.get(key)); + }).join(", ") + " }]"; + }; + ObservableMap.prototype.observe = function (listener, fireImmediately) { + invariant(fireImmediately !== true, getMessage("m033")); + return registerListener(this, listener); + }; + ObservableMap.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + return ObservableMap; + }(); + exports.ObservableMap = ObservableMap; + declareIterator(ObservableMap.prototype, function () { + return this.entries(); + }); + + function map(initialValues) { + deprecated("`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead"); + return observable.map(initialValues); + } + exports.map = map; + var isObservableMap = createInstanceofPredicate("ObservableMap", ObservableMap); + exports.isObservableMap = isObservableMap; + var ObservableObjectAdministration = function () { + function ObservableObjectAdministration(target, name) { + this.target = target; + this.name = name; + this.values = {}; + this.changeListeners = null; + this.interceptors = null; + } + ObservableObjectAdministration.prototype.observe = function (callback, fireImmediately) { + invariant(fireImmediately !== true, "`observe` doesn't support the fire immediately property for observable objects."); + return registerListener(this, callback); + }; + ObservableObjectAdministration.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + return ObservableObjectAdministration; + }(); + + function asObservableObject(target, name) { + if (isObservableObject(target)) return target.$mobx; + invariant(Object.isExtensible(target), getMessage("m035")); + if (!isPlainObject(target)) name = (target.constructor.name || "ObservableObject") + "@" + getNextId(); + if (!name) name = "ObservableObject@" + getNextId(); + var adm = new ObservableObjectAdministration(target, name); + addHiddenFinalProp(target, "$mobx", adm); + return adm; + } + + function defineObservablePropertyFromDescriptor(adm, propName, descriptor, defaultEnhancer) { + if (adm.values[propName]) { + invariant("value" in descriptor, "The property " + propName + " in " + adm.name + " is already observable, cannot redefine it as computed property"); + adm.target[propName] = descriptor.value; + return; + } + if ("value" in descriptor) { + if (isModifierDescriptor(descriptor.value)) { + var modifierDescriptor = descriptor.value; + defineObservableProperty(adm, propName, modifierDescriptor.initialValue, modifierDescriptor.enhancer); + } else if (isAction(descriptor.value) && descriptor.value.autoBind === true) { + defineBoundAction(adm.target, propName, descriptor.value.originalFn); + } else if (isComputedValue(descriptor.value)) { + defineComputedPropertyFromComputedValue(adm, propName, descriptor.value); + } else { + defineObservableProperty(adm, propName, descriptor.value, defaultEnhancer); + } + } else { + defineComputedProperty(adm, propName, descriptor.get, descriptor.set, false, true); + } + } + + function defineObservableProperty(adm, propName, newValue, enhancer) { + assertPropertyConfigurable(adm.target, propName); + if (hasInterceptors(adm)) { + var change = interceptChange(adm, { + object: adm.target, + name: propName, + type: "add", + newValue: newValue + }); + if (!change) return; + newValue = change.newValue; + } + var observable = adm.values[propName] = new ObservableValue(newValue, enhancer, adm.name + "." + propName, false); + newValue = observable.value; + Object.defineProperty(adm.target, propName, generateObservablePropConfig(propName)); + notifyPropertyAddition(adm, adm.target, propName, newValue); + } + + function defineComputedProperty(adm, propName, getter, setter, compareStructural, asInstanceProperty) { + if (asInstanceProperty) assertPropertyConfigurable(adm.target, propName); + adm.values[propName] = new ComputedValue(getter, adm.target, compareStructural, adm.name + "." + propName, setter); + if (asInstanceProperty) { + Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName)); + } + } + + function defineComputedPropertyFromComputedValue(adm, propName, computedValue) { + var name = adm.name + "." + propName; + computedValue.name = name; + if (!computedValue.scope) computedValue.scope = adm.target; + adm.values[propName] = computedValue; + Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName)); + } + var observablePropertyConfigs = {}; + var computedPropertyConfigs = {}; + + function generateObservablePropConfig(propName) { + return observablePropertyConfigs[propName] || (observablePropertyConfigs[propName] = { + configurable: true, + enumerable: true, + get: function get() { + return this.$mobx.values[propName].get(); + }, + set: function set(v) { + setPropertyValue(this, propName, v); + } + }); + } + + function generateComputedPropConfig(propName) { + return computedPropertyConfigs[propName] || (computedPropertyConfigs[propName] = { + configurable: true, + enumerable: false, + get: function get() { + return this.$mobx.values[propName].get(); + }, + set: function set(v) { + return this.$mobx.values[propName].set(v); + } + }); + } + + function setPropertyValue(instance, name, newValue) { + var adm = instance.$mobx; + var observable = adm.values[name]; + if (hasInterceptors(adm)) { + var change = interceptChange(adm, { + type: "update", + object: instance, + name: name, + newValue: newValue + }); + if (!change) return; + newValue = change.newValue; + } + newValue = observable.prepareNewValue(newValue); + if (newValue !== UNCHANGED) { + var notify = hasListeners(adm); + var notifySpy = isSpyEnabled(); + var change = notify || notifySpy ? { + type: "update", + object: instance, + oldValue: observable.value, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + observable.setNewValue(newValue); + if (notify) notifyListeners(adm, change); + if (notifySpy) spyReportEnd(); + } + } + + function notifyPropertyAddition(adm, object, name, newValue) { + var notify = hasListeners(adm); + var notifySpy = isSpyEnabled(); + var change = notify || notifySpy ? { + type: "add", + object: object, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + if (notify) notifyListeners(adm, change); + if (notifySpy) spyReportEnd(); + } + var isObservableObjectAdministration = createInstanceofPredicate("ObservableObjectAdministration", ObservableObjectAdministration); + + function isObservableObject(thing) { + if (isObject(thing)) { + runLazyInitializers(thing); + return isObservableObjectAdministration(thing.$mobx); + } + return false; + } + exports.isObservableObject = isObservableObject; + var UNCHANGED = {}; + var ObservableValue = function (_super) { + __extends(ObservableValue, _super); + + function ObservableValue(value, enhancer, name, notifySpy) { + if (name === void 0) { + name = "ObservableValue@" + getNextId(); + } + if (notifySpy === void 0) { + notifySpy = true; + } + var _this = _super.call(this, name) || this; + _this.enhancer = enhancer; + _this.hasUnreportedChange = false; + _this.value = enhancer(value, undefined, name); + if (notifySpy && isSpyEnabled()) { + spyReport({ + type: "create", + object: _this, + newValue: _this.value + }); + } + return _this; + } + ObservableValue.prototype.set = function (newValue) { + var oldValue = this.value; + newValue = this.prepareNewValue(newValue); + if (newValue !== UNCHANGED) { + var notifySpy = isSpyEnabled(); + if (notifySpy) { + spyReportStart({ + type: "update", + object: this, + newValue: newValue, + oldValue: oldValue + }); + } + this.setNewValue(newValue); + if (notifySpy) spyReportEnd(); + } + }; + ObservableValue.prototype.prepareNewValue = function (newValue) { + checkIfStateModificationsAreAllowed(this); + if (hasInterceptors(this)) { + var change = interceptChange(this, { + object: this, + type: "update", + newValue: newValue + }); + if (!change) return UNCHANGED; + newValue = change.newValue; + } + newValue = this.enhancer(newValue, this.value, this.name); + return this.value !== newValue ? newValue : UNCHANGED; + }; + ObservableValue.prototype.setNewValue = function (newValue) { + var oldValue = this.value; + this.value = newValue; + this.reportChanged(); + if (hasListeners(this)) { + notifyListeners(this, { + type: "update", + object: this, + newValue: newValue, + oldValue: oldValue + }); + } + }; + ObservableValue.prototype.get = function () { + this.reportObserved(); + return this.value; + }; + ObservableValue.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + ObservableValue.prototype.observe = function (listener, fireImmediately) { + if (fireImmediately) listener({ + object: this, + type: "update", + newValue: this.value, + oldValue: undefined + }); + return registerListener(this, listener); + }; + ObservableValue.prototype.toJSON = function () { + return this.get(); + }; + ObservableValue.prototype.toString = function () { + return this.name + "[" + this.value + "]"; + }; + ObservableValue.prototype.valueOf = function () { + return toPrimitive(this.get()); + }; + return ObservableValue; + }(BaseAtom); + ObservableValue.prototype[primitiveSymbol()] = ObservableValue.prototype.valueOf; + var isObservableValue = createInstanceofPredicate("ObservableValue", ObservableValue); + exports.isBoxedObservable = isObservableValue; + + function getAtom(thing, property) { + if ((typeof thing === "undefined" ? "undefined" : _typeof(thing)) === "object" && thing !== null) { + if (isObservableArray(thing)) { + invariant(property === undefined, getMessage("m036")); + return thing.$mobx.atom; + } + if (isObservableMap(thing)) { + var anyThing = thing; + if (property === undefined) return getAtom(anyThing._keys); + var observable_2 = anyThing._data[property] || anyThing._hasMap[property]; + invariant(!!observable_2, "the entry '" + property + "' does not exist in the observable map '" + getDebugName(thing) + "'"); + return observable_2; + } + runLazyInitializers(thing); + if (isObservableObject(thing)) { + if (!property) return fail("please specify a property"); + var observable_3 = thing.$mobx.values[property]; + invariant(!!observable_3, "no observable property '" + property + "' found on the observable object '" + getDebugName(thing) + "'"); + return observable_3; + } + if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) { + return thing; + } + } else if (typeof thing === "function") { + if (isReaction(thing.$mobx)) { + return thing.$mobx; + } + } + return fail("Cannot obtain atom from " + thing); + } + + function getAdministration(thing, property) { + invariant(thing, "Expecting some object"); + if (property !== undefined) return getAdministration(getAtom(thing, property)); + if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) return thing; + if (isObservableMap(thing)) return thing; + runLazyInitializers(thing); + if (thing.$mobx) return thing.$mobx; + invariant(false, "Cannot obtain administration from " + thing); + } + + function getDebugName(thing, property) { + var named; + if (property !== undefined) named = getAtom(thing, property); + else if (isObservableObject(thing) || isObservableMap(thing)) named = getAdministration(thing); + else named = getAtom(thing); + return named.name; + } + + function createClassPropertyDecorator(onInitialize, _get, _set, enumerable, allowCustomArguments) { + function classPropertyDecorator(target, key, descriptor, customArgs, argLen) { + if (argLen === void 0) { + argLen = 0; + } + invariant(allowCustomArguments || quacksLikeADecorator(arguments), "This function is a decorator, but it wasn't invoked like a decorator"); + if (!descriptor) { + var newDescriptor = { + enumerable: enumerable, + configurable: true, + get: function get() { + if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) typescriptInitializeProperty(this, key, undefined, onInitialize, customArgs, descriptor); + return _get.call(this, key); + }, + set: function set(v) { + if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) { + typescriptInitializeProperty(this, key, v, onInitialize, customArgs, descriptor); + } else { + _set.call(this, key, v); + } + } + }; + if (arguments.length < 3 || arguments.length === 5 && argLen < 3) { + Object.defineProperty(target, key, newDescriptor); + } + return newDescriptor; + } else { + if (!hasOwnProperty(target, "__mobxLazyInitializers")) { + addHiddenProp(target, "__mobxLazyInitializers", target.__mobxLazyInitializers && target.__mobxLazyInitializers.slice() || []); + } + var value_1 = descriptor.value, + initializer_1 = descriptor.initializer; + target.__mobxLazyInitializers.push(function (instance) { + onInitialize(instance, key, initializer_1 ? initializer_1.call(instance) : value_1, customArgs, descriptor); + }); + return { + enumerable: enumerable, + configurable: true, + get: function get() { + if (this.__mobxDidRunLazyInitializers !== true) runLazyInitializers(this); + return _get.call(this, key); + }, + set: function set(v) { + if (this.__mobxDidRunLazyInitializers !== true) runLazyInitializers(this); + _set.call(this, key, v); + } + }; + } + } + if (allowCustomArguments) { + return function () { + if (quacksLikeADecorator(arguments)) return classPropertyDecorator.apply(null, arguments); + var outerArgs = arguments; + var argLen = arguments.length; + return function (target, key, descriptor) { + return classPropertyDecorator(target, key, descriptor, outerArgs, argLen); + }; + }; + } + return classPropertyDecorator; + } + + function typescriptInitializeProperty(instance, key, v, onInitialize, customArgs, baseDescriptor) { + if (!hasOwnProperty(instance, "__mobxInitializedProps")) addHiddenProp(instance, "__mobxInitializedProps", {}); + instance.__mobxInitializedProps[key] = true; + onInitialize(instance, key, v, customArgs, baseDescriptor); + } + + function runLazyInitializers(instance) { + if (instance.__mobxDidRunLazyInitializers === true) return; + if (instance.__mobxLazyInitializers) { + addHiddenProp(instance, "__mobxDidRunLazyInitializers", true); + instance.__mobxDidRunLazyInitializers && instance.__mobxLazyInitializers.forEach(function (initializer) { + return initializer(instance); + }); + } + } + + function quacksLikeADecorator(args) { + return (args.length === 2 || args.length === 3) && typeof args[1] === "string"; + } + + function iteratorSymbol() { + return typeof Symbol === "function" && Symbol.iterator || "@@iterator"; + } + var IS_ITERATING_MARKER = "__$$iterating"; + + function arrayAsIterator(array) { + invariant(array[IS_ITERATING_MARKER] !== true, "Illegal state: cannot recycle array as iterator"); + addHiddenFinalProp(array, IS_ITERATING_MARKER, true); + var idx = -1; + addHiddenFinalProp(array, "next", function next() { + idx++; + return { + done: idx >= this.length, + value: idx < this.length ? this[idx] : undefined + }; + }); + return array; + } + + function declareIterator(prototType, iteratorFactory) { + addHiddenFinalProp(prototType, iteratorSymbol(), iteratorFactory); + } + var messages = { + "m001": "It is not allowed to assign new values to @action fields", + "m002": "`runInAction` expects a function", + "m003": "`runInAction` expects a function without arguments", + "m004": "autorun expects a function", + "m005": "Warning: attempted to pass an action to autorun. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.", + "m006": "Warning: attempted to pass an action to autorunAsync. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.", + "m007": "reaction only accepts 2 or 3 arguments. If migrating from MobX 2, please provide an options object", + "m008": "wrapping reaction expression in `asReference` is no longer supported, use options object instead", + "m009": "@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'. It looks like it was used on a property.", + "m010": "@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'", + "m011": "First argument to `computed` should be an expression. If using computed as decorator, don't pass it arguments", + "m012": "computed takes one or two arguments if used as function", + "m013": "[mobx.expr] 'expr' should only be used inside other reactive functions.", + "m014": "extendObservable expected 2 or more arguments", + "m015": "extendObservable expects an object as first argument", + "m016": "extendObservable should not be used on maps, use map.merge instead", + "m017": "all arguments of extendObservable should be objects", + "m018": "extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540", + "m019": "[mobx.isObservable] isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.", + "m020": "modifiers can only be used for individual object properties", + "m021": "observable expects zero or one arguments", + "m022": "@observable can not be used on getters, use @computed instead", + "m023": "Using `transaction` is deprecated, use `runInAction` or `(@)action` instead.", + "m024": "whyRun() can only be used if a derivation is active, or by passing an computed value / reaction explicitly. If you invoked whyRun from inside a computation; the computation is currently suspended but re-evaluating because somebody requested its value.", + "m025": "whyRun can only be used on reactions and computed values", + "m026": "`action` can only be invoked on functions", + "m028": "It is not allowed to set `useStrict` when a derivation is running", + "m029": "INTERNAL ERROR only onBecomeUnobserved shouldn't be called twice in a row", + "m030a": "Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: ", + "m030b": "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: ", + "m031": "Computed values are not allowed to not cause side effects by changing observables that are already being observed. Tried to modify: ", + "m032": "* This computation is suspended (not in use by any reaction) and won't run automatically.\n Didn't expect this computation to be suspended at this point?\n 1. Make sure this computation is used by a reaction (reaction, autorun, observer).\n 2. Check whether you are using this computation synchronously (in the same stack as they reaction that needs it).", + "m033": "`observe` doesn't support the fire immediately property for observable maps.", + "m034": "`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead", + "m035": "Cannot make the designated object observable; it is not extensible", + "m036": "It is not possible to get index atoms from arrays", + "m037": "Hi there! I'm sorry you have just run into an exception.\nIf your debugger ends up here, know that some reaction (like the render() of an observer component, autorun or reaction)\nthrew an exception and that mobx caught it, to avoid that it brings the rest of your application down.\nThe original cause of the exception (the code that caused this reaction to run (again)), is still in the stack.\n\nHowever, more interesting is the actual stack trace of the error itself.\nHopefully the error is an instanceof Error, because in that case you can inspect the original stack of the error from where it was thrown.\nSee `error.stack` property, or press the very subtle \"(...)\" link you see near the console.error message that probably brought you here.\nThat stack is more interesting than the stack of this console.error itself.\n\nIf the exception you see is an exception you created yourself, make sure to use `throw new Error(\"Oops\")` instead of `throw \"Oops\"`,\nbecause the javascript environment will only preserve the original stack trace in the first form.\n\nYou can also make sure the debugger pauses the next time this very same exception is thrown by enabling \"Pause on caught exception\".\n(Note that it might pause on many other, unrelated exception as well).\n\nIf that all doesn't help you out, feel free to open an issue https://github.com/mobxjs/mobx/issues!\n", + "m038": "Missing items in this list?\n 1. Check whether all used values are properly marked as observable (use isObservable to verify)\n 2. Make sure you didn't dereference values too early. MobX observes props, not primitives. E.g: use 'person.name' instead of 'name' in your computation.\n" + }; + + function getMessage(id) { + return messages[id]; + } + var EMPTY_ARRAY = []; + Object.freeze(EMPTY_ARRAY); + + function getGlobal() { + return global; + } + + function getNextId() { + return ++globalState.mobxGuid; + } + + function fail(message, thing) { + invariant(false, message, thing); + throw "X"; + } + + function invariant(check, message, thing) { + if (!check) throw new Error("[mobx] Invariant failed: " + message + (thing ? " in '" + thing + "'" : "")); + } + var deprecatedMessages = []; + + function deprecated(msg) { + if (deprecatedMessages.indexOf(msg) !== -1) return false; + deprecatedMessages.push(msg); + console.error("[mobx] Deprecated: " + msg); + return true; + } + + function once(func) { + var invoked = false; + return function () { + if (invoked) return; + invoked = true; + return func.apply(this, arguments); + }; + } + var noop = function noop() {}; + + function unique(list) { + var res = []; + list.forEach(function (item) { + if (res.indexOf(item) === -1) res.push(item); + }); + return res; + } + + function joinStrings(things, limit, separator) { + if (limit === void 0) { + limit = 100; + } + if (separator === void 0) { + separator = " - "; + } + if (!things) return ""; + var sliced = things.slice(0, limit); + return "" + sliced.join(separator) + (things.length > limit ? " (... and " + (things.length - limit) + "more)" : ""); + } + + function isObject(value) { + return value !== null && (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object"; + } + + function isPlainObject(value) { + if (value === null || (typeof value === "undefined" ? "undefined" : _typeof(value)) !== "object") return false; + var proto = Object.getPrototypeOf(value); + return proto === Object.prototype || proto === null; + } + + function objectAssign() { + var res = arguments[0]; + for (var i = 1, l = arguments.length; i < l; i++) { + var source = arguments[i]; + for (var key in source) { + if (hasOwnProperty(source, key)) { + res[key] = source[key]; + } + } + } + return res; + } + + function valueDidChange(compareStructural, oldValue, newValue) { + if (typeof oldValue === 'number' && isNaN(oldValue)) { + return typeof newValue !== 'number' || !isNaN(newValue); + } + return compareStructural ? !deepEqual(oldValue, newValue) : oldValue !== newValue; + } + var prototypeHasOwnProperty = Object.prototype.hasOwnProperty; + + function hasOwnProperty(object, propName) { + return prototypeHasOwnProperty.call(object, propName); + } + + function makeNonEnumerable(object, propNames) { + for (var i = 0; i < propNames.length; i++) { + addHiddenProp(object, propNames[i], object[propNames[i]]); + } + } + + function addHiddenProp(object, propName, value) { + Object.defineProperty(object, propName, { + enumerable: false, + writable: true, + configurable: true, + value: value + }); + } + + function addHiddenFinalProp(object, propName, value) { + Object.defineProperty(object, propName, { + enumerable: false, + writable: false, + configurable: true, + value: value + }); + } + + function isPropertyConfigurable(object, prop) { + var descriptor = Object.getOwnPropertyDescriptor(object, prop); + return !descriptor || descriptor.configurable !== false && descriptor.writable !== false; + } + + function assertPropertyConfigurable(object, prop) { + invariant(isPropertyConfigurable(object, prop), "Cannot make property '" + prop + "' observable, it is not configurable and writable in the target object"); + } + + function getEnumerableKeys(obj) { + var res = []; + for (var key in obj) { + res.push(key); + } + return res; + } + + function deepEqual(a, b) { + if (a === null && b === null) return true; + if (a === undefined && b === undefined) return true; + if ((typeof a === "undefined" ? "undefined" : _typeof(a)) !== "object") return a === b; + var aIsArray = isArrayLike(a); + var aIsMap = isMapLike(a); + if (aIsArray !== isArrayLike(b)) { + return false; + } else if (aIsMap !== isMapLike(b)) { + return false; + } else if (aIsArray) { + if (a.length !== b.length) return false; + for (var i = a.length - 1; i >= 0; i--) { + if (!deepEqual(a[i], b[i])) return false; + } + return true; + } else if (aIsMap) { + if (a.size !== b.size) return false; + var equals_1 = true; + a.forEach(function (value, key) { + equals_1 = equals_1 && deepEqual(b.get(key), value); + }); + return equals_1; + } else if ((typeof a === "undefined" ? "undefined" : _typeof(a)) === "object" && (typeof b === "undefined" ? "undefined" : _typeof(b)) === "object") { + if (a === null || b === null) return false; + if (isMapLike(a) && isMapLike(b)) { + if (a.size !== b.size) return false; + return deepEqual(observable.shallowMap(a).entries(), observable.shallowMap(b).entries()); + } + if (getEnumerableKeys(a).length !== getEnumerableKeys(b).length) return false; + for (var prop in a) { + if (!(prop in b)) return false; + if (!deepEqual(a[prop], b[prop])) return false; + } + return true; + } + return false; + } + + function createInstanceofPredicate(name, clazz) { + var propName = "isMobX" + name; + clazz.prototype[propName] = true; + return function (x) { + return isObject(x) && x[propName] === true; + }; + } + + function isArrayLike(x) { + return Array.isArray(x) || isObservableArray(x); + } + exports.isArrayLike = isArrayLike; + + function isMapLike(x) { + return isES6Map(x) || isObservableMap(x); + } + + function isES6Map(thing) { + if (getGlobal().Map !== undefined && thing instanceof getGlobal().Map) return true; + return false; + } + + function primitiveSymbol() { + return typeof Symbol === "function" && Symbol.toPrimitive || "@@toPrimitive"; + } + + function toPrimitive(value) { + return value === null ? null : (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object" ? "" + value : value; + } + /* WEBPACK VAR INJECTION */ + }.call(exports, __webpack_require__(4))) + + /***/ + }), + /* 2 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + return _arr; + } + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + }(); + + var _icons = __webpack_require__(6); + + var _constants = __webpack_require__(0); + + function renderHeader(_ref, instance) { + var meta = _ref.meta, + user = _ref.user, + reactions = _ref.reactions; + + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-header-container'; + + var likeButton = document.createElement('span'); + var likedReaction = reactions.find(function (reaction) { + return reaction.content === 'heart' && reaction.user.login === user.login; + }); + likeButton.className = 'gitment-header-like-btn'; + likeButton.innerHTML = '\n ' + _icons.heart + '\n ' + (likedReaction ? 'Unlike' : 'Like') + '\n ' + (meta.reactions && meta.reactions.heart ? ' \u2022 ' + meta.reactions.heart + ' Liked' : '') + '\n '; + + if (likedReaction) { + likeButton.classList.add('liked'); + likeButton.onclick = function () { + return instance.unlike(); + }; + } else { + likeButton.classList.remove('liked'); + likeButton.onclick = function () { + return instance.like(); + }; + } + container.appendChild(likeButton); + + var commentsCount = document.createElement('span'); + commentsCount.innerHTML = '\n ' + (meta.comments ? ' \u2022 ' + meta.comments + ' Comments' : '') + '\n '; + container.appendChild(commentsCount); + + var issueLink = document.createElement('a'); + issueLink.className = 'gitment-header-issue-link'; + issueLink.href = meta.html_url; + issueLink.target = '_blank'; + issueLink.innerText = 'Issue Page'; + container.appendChild(issueLink); + + return container; + } + + function renderComments(_ref2, instance) { + var meta = _ref2.meta, + comments = _ref2.comments, + commentReactions = _ref2.commentReactions, + currentPage = _ref2.currentPage, + user = _ref2.user, + error = _ref2.error; + + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-comments-container'; + + if (error) { + var errorBlock = document.createElement('div'); + errorBlock.className = 'gitment-comments-error'; + + if (error === _constants.NOT_INITIALIZED_ERROR && user.login && user.login.toLowerCase() === instance.owner.toLowerCase()) { + var initHint = document.createElement('div'); + var initButton = document.createElement('button'); + initButton.className = 'gitment-comments-init-btn'; + initButton.onclick = function () { + initButton.setAttribute('disabled', true); + instance.init().catch(function (e) { + initButton.removeAttribute('disabled'); + alert(e); + }); + }; + initButton.innerText = '初始化评论'; + initHint.appendChild(initButton); + errorBlock.appendChild(initHint); + } else { + errorBlock.innerText = error; + } + container.appendChild(errorBlock); + return container; + } else if (comments === undefined) { + var loading = document.createElement('div'); + loading.innerText = '评论加载中...'; + loading.className = 'gitment-comments-loading'; + container.appendChild(loading); + return container; + } else if (!comments.length) { + var emptyBlock = document.createElement('div'); + emptyBlock.className = 'gitment-comments-empty'; + emptyBlock.innerText = '暂无评论，来过就留点痕迹吧'; + container.appendChild(emptyBlock); + return container; + } + + var commentsList = document.createElement('ul'); + commentsList.className = 'gitment-comments-list'; + + comments.forEach(function (comment) { + var createDate = new Date(comment.created_at); + var updateDate = new Date(comment.updated_at); + var commentItem = document.createElement('li'); + commentItem.className = 'gitment-comment'; + commentItem.innerHTML = '\n \n \n \n
    \n
    \n \n ' + comment.user.login + '\n \n 评论于\n ' + createDate.toDateString() + '\n ' + (createDate.toString() !== updateDate.toString() ? ' \u2022 已编辑' : '') + '\n
    ' + _icons.heart + ' ' + (comment.reactions.heart || '') + '
    \n
    \n
    ' + comment.body_html + '
    \n
    \n '; + var likeButton = commentItem.querySelector('.gitment-comment-like-btn'); + var likedReaction = commentReactions[comment.id] && commentReactions[comment.id].find(function (reaction) { + return reaction.content === 'heart' && reaction.user.login === user.login; + }); + if (likedReaction) { + likeButton.classList.add('liked'); + likeButton.onclick = function () { + return instance.unlikeAComment(comment.id); + }; + } else { + likeButton.classList.remove('liked'); + likeButton.onclick = function () { + return instance.likeAComment(comment.id); + }; + } + + // dirty + // use a blank image to trigger height calculating when element rendered + var imgTrigger = document.createElement('img'); + var markdownBody = commentItem.querySelector('.gitment-comment-body'); + imgTrigger.className = 'gitment-hidden'; + imgTrigger.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="; + imgTrigger.onload = function () { + if (markdownBody.clientHeight > instance.maxCommentHeight) { + markdownBody.classList.add('gitment-comment-body-folded'); + markdownBody.style.maxHeight = instance.maxCommentHeight + 'px'; + markdownBody.title = 'Click to Expand'; + markdownBody.onclick = function () { + markdownBody.classList.remove('gitment-comment-body-folded'); + markdownBody.style.maxHeight = ''; + markdownBody.title = ''; + markdownBody.onclick = null; + }; + } + }; + commentItem.appendChild(imgTrigger); + + commentsList.appendChild(commentItem); + }); + + container.appendChild(commentsList); + + if (meta) { + var pageCount = Math.ceil(meta.comments / instance.perPage); + if (pageCount > 1) { + var pagination = document.createElement('ul'); + pagination.className = 'gitment-comments-pagination'; + + if (currentPage > 1) { + var previousButton = document.createElement('li'); + previousButton.className = 'gitment-comments-page-item'; + previousButton.innerText = 'Previous'; + previousButton.onclick = function () { + return instance.goto(currentPage - 1); + }; + pagination.appendChild(previousButton); + } + + var _loop = function _loop(i) { + var pageItem = document.createElement('li'); + pageItem.className = 'gitment-comments-page-item'; + pageItem.innerText = i; + pageItem.onclick = function () { + return instance.goto(i); + }; + if (currentPage === i) pageItem.classList.add('gitment-selected'); + pagination.appendChild(pageItem); + }; + + for (var i = 1; i <= pageCount; i++) { + _loop(i); + } + + if (currentPage < pageCount) { + var nextButton = document.createElement('li'); + nextButton.className = 'gitment-comments-page-item'; + nextButton.innerText = 'Next'; + nextButton.onclick = function () { + return instance.goto(currentPage + 1); + }; + pagination.appendChild(nextButton); + } + + container.appendChild(pagination); + } + } + + return container; + } + + function renderEditor(_ref3, instance) { + var user = _ref3.user, + error = _ref3.error; + + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-editor-container'; + + var shouldDisable = user.login && !error ? '' : 'disabled'; + var disabledTip = user.login ? '' : 'Login to Comment'; + container.innerHTML = '\n ' + (user.login ? '\n \n ' : user.isLoggingIn ? '
    ' + _icons.spinner + '
    ' : '\n ' + _icons.github + '\n ') + '\n \n
    \n
    \n \n \n
    \n
    \n
    \n \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n \n Styling with Markdown is supported\n \n \n
    \n '; + if (user.login) { + container.querySelector('.gitment-editor-logout-link').onclick = function () { + return instance.logout(); + }; + } + + var writeField = container.querySelector('.gitment-editor-write-field'); + var previewField = container.querySelector('.gitment-editor-preview-field'); + + var textarea = writeField.querySelector('textarea'); + textarea.oninput = function () { + textarea.style.height = 'auto'; + var style = window.getComputedStyle(textarea, null); + var height = parseInt(style.height, 10); + var clientHeight = textarea.clientHeight; + var scrollHeight = textarea.scrollHeight; + if (clientHeight < scrollHeight) { + textarea.style.height = height + scrollHeight - clientHeight + 'px'; + } + }; + + var _container$querySelec = container.querySelectorAll('.gitment-editor-tab'), + _container$querySelec2 = _slicedToArray(_container$querySelec, 2), + writeTab = _container$querySelec2[0], + previewTab = _container$querySelec2[1]; + + writeTab.onclick = function () { + writeTab.classList.add('gitment-selected'); + previewTab.classList.remove('gitment-selected'); + writeField.classList.remove('gitment-hidden'); + previewField.classList.add('gitment-hidden'); + + textarea.focus(); + }; + previewTab.onclick = function () { + previewTab.classList.add('gitment-selected'); + writeTab.classList.remove('gitment-selected'); + previewField.classList.remove('gitment-hidden'); + writeField.classList.add('gitment-hidden'); + + var preview = previewField.querySelector('.gitment-editor-preview'); + var content = textarea.value.trim(); + if (!content) { + preview.innerText = '无可预览内容'; + return; + } + + preview.innerText = '加载预览中...'; + instance.markdown(content).then(function (html) { + return preview.innerHTML = html; + }); + }; + + var submitButton = container.querySelector('.gitment-editor-submit'); + submitButton.onclick = function () { + submitButton.innerText = 'Submitting...'; + submitButton.setAttribute('disabled', true); + instance.post(textarea.value.trim()).then(function (data) { + textarea.value = ''; + textarea.style.height = 'auto'; + submitButton.removeAttribute('disabled'); + submitButton.innerText = '发表评论'; + }).catch(function (e) { + alert(e); + submitButton.removeAttribute('disabled'); + submitButton.innerText = '发表评论'; + }); + }; + + return container; + } + + function renderFooter() { + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-footer-container'; + container.innerHTML = '\n Powered by\n \n Gitment\n \n '; + return container; + } + + function render(state, instance) { + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-root-container'; + container.appendChild(instance.renderHeader(state, instance)); + container.appendChild(instance.renderComments(state, instance)); + container.appendChild(instance.renderEditor(state, instance)); + container.appendChild(instance.renderFooter(state, instance)); + return container; + } + + exports.default = { + render: render, + renderHeader: renderHeader, + renderComments: renderComments, + renderEditor: renderEditor, + renderFooter: renderFooter + }; + + /***/ + }), + /* 3 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.http = exports.Query = exports.isString = undefined; + + var _slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + return _arr; + } + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + }(); + + exports.getTargetContainer = getTargetContainer; + + var _constants = __webpack_require__(0); + + var isString = exports.isString = function isString(s) { + return toString.call(s) === '[object String]'; + }; + + function getTargetContainer(container) { + var targetContainer = void 0; + if (container instanceof Element) { + targetContainer = container; + } else if (isString(container)) { + targetContainer = document.getElementById(container); + } else { + targetContainer = document.createElement('div'); + } + + return targetContainer; + } + + var Query = exports.Query = { + parse: function parse() { + var search = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.location.search; + + if (!search) return {}; + var queryString = search[0] === '?' ? search.substring(1) : search; + var query = {}; + queryString.split('&').forEach(function (queryStr) { + var _queryStr$split = queryStr.split('='), + _queryStr$split2 = _slicedToArray(_queryStr$split, 2), + key = _queryStr$split2[0], + value = _queryStr$split2[1]; + + if (key) query[key] = value; + }); + + return query; + }, + stringify: function stringify(query) { + var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '?'; + + var queryString = Object.keys(query).map(function (key) { + return key + '=' + encodeURIComponent(query[key] || ''); + }).join('&'); + return queryString ? prefix + queryString : ''; + } + }; + + function ajaxFactory(method) { + return function (apiPath) { + var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'https://api.github.com'; + + var req = new XMLHttpRequest(); + var token = localStorage.getItem(_constants.LS_ACCESS_TOKEN_KEY); + + var url = '' + base + apiPath; + var body = null; + if (method === 'GET' || method === 'DELETE') { + url += Query.stringify(data); + } + + var p = new Promise(function (resolve, reject) { + req.addEventListener('load', function () { + var contentType = req.getResponseHeader('content-type'); + var res = req.responseText; + if (!/json/.test(contentType)) { + resolve(res); + return; + } + var data = req.responseText ? JSON.parse(res) : {}; + if (data.message) { + reject(new Error(data.message)); + } else { + resolve(data); + } + }); + req.addEventListener('error', function (error) { + return reject(error); + }); + }); + req.open(method, url, true); + + req.setRequestHeader('Accept', 'application/vnd.github.squirrel-girl-preview, application/vnd.github.html+json'); + if (token) { + req.setRequestHeader('Authorization', 'token ' + token); + } + if (method !== 'GET' && method !== 'DELETE') { + body = JSON.stringify(data); + req.setRequestHeader('Content-Type', 'application/json'); + req.setRequestHeader('Accept', 'application/json'); + } + + req.send(body); + return p; + }; + } + + var http = exports.http = { + get: ajaxFactory('GET'), + post: ajaxFactory('POST'), + delete: ajaxFactory('DELETE'), + put: ajaxFactory('PUT') + }; + + /***/ + }), + /* 4 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + + var g; + + // This works in non-strict mode + g = function () { + return this; + }(); + + try { + // This works if eval is allowed (see CSP) + g = g || Function("return this")() || (1, eval)("this"); + } catch (e) { + // This works if the window reference is available + if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === "object") g = window; + } + + // g can still be undefined, but nothing to do about it... + // We return undefined, instead of nothing here, so it's + // easier to handle this case. if(!global) { ...} + + module.exports = g; + + /***/ + }), + /* 5 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + var _mobx = __webpack_require__(1); + + var _constants = __webpack_require__(0); + + var _utils = __webpack_require__(3); + + var _default = __webpack_require__(2); + + var _default2 = _interopRequireDefault(_default); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var scope = 'public_repo'; + + function extendRenderer(instance, renderer) { + instance[renderer] = function (container) { + var targetContainer = (0, _utils.getTargetContainer)(container); + var render = instance.theme[renderer] || instance.defaultTheme[renderer]; + + (0, _mobx.autorun)(function () { + var e = render(instance.state, instance); + if (targetContainer.firstChild) { + targetContainer.replaceChild(e, targetContainer.firstChild); + } else { + targetContainer.appendChild(e); + } + }); + + return targetContainer; + }; + } + + var Gitment = function () { + _createClass(Gitment, [{ + key: 'accessToken', + get: function get() { + return localStorage.getItem(_constants.LS_ACCESS_TOKEN_KEY); + }, + set: function set(token) { + localStorage.setItem(_constants.LS_ACCESS_TOKEN_KEY, token); + } + }, { + key: 'loginLink', + get: function get() { + var oauthUri = 'https://github.com/login/oauth/authorize'; + var redirect_uri = this.oauth.redirect_uri || window.location.href; + + var oauthParams = Object.assign({ + scope: scope, + redirect_uri: redirect_uri + }, this.oauth); + + return '' + oauthUri + _utils.Query.stringify(oauthParams); + } + }]); + + function Gitment() { + var _this = this; + + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck(this, Gitment); + + this.defaultTheme = _default2.default; + this.useTheme(_default2.default); + + Object.assign(this, { + id: window.location.href, + title: window.document.title, + link: window.location.href, + desc: '', + labels: [], + theme: _default2.default, + oauth: {}, + perPage: 20, + maxCommentHeight: 250 + }, options); + + this.useTheme(this.theme); + + var user = {}; + try { + var userInfo = localStorage.getItem(_constants.LS_USER_KEY); + if (this.accessToken && userInfo) { + Object.assign(user, JSON.parse(userInfo), { + fromCache: true + }); + } + } catch (e) { + localStorage.removeItem(_constants.LS_USER_KEY); + } + + this.state = (0, _mobx.observable)({ + user: user, + error: null, + meta: {}, + comments: undefined, + reactions: [], + commentReactions: {}, + currentPage: 1 + }); + + var query = _utils.Query.parse(); + if (query.code) { + var _oauth = this.oauth, + client_id = _oauth.client_id, + client_secret = _oauth.client_secret; + + var code = query.code; + delete query.code; + var search = _utils.Query.stringify(query); + var replacedUrl = '' + window.location.origin + window.location.pathname + search + window.location.hash; + history.replaceState({}, '', replacedUrl); + + Object.assign(this, { + id: replacedUrl, + link: replacedUrl + }, options); + + this.state.user.isLoggingIn = true; + _utils.http.post('https://cors-anywhere.herokuapp.com/https://github.com/login/oauth/access_token', { + code: code, + client_id: client_id, + client_secret: client_secret + }, '').then(function (data) { + _this.accessToken = data.access_token; + _this.update(); + }).catch(function (e) { + _this.state.user.isLoggingIn = false; + alert(e); + }); + } else { + this.update(); + } + } + + _createClass(Gitment, [{ + key: 'init', + value: function init() { + var _this2 = this; + + return this.createIssue().then(function () { + return _this2.loadComments(); + }).then(function (comments) { + _this2.state.error = null; + return comments; + }); + } + }, { + key: 'useTheme', + value: function useTheme() { + var _this3 = this; + + var theme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + this.theme = theme; + + var renderers = Object.keys(this.theme); + renderers.forEach(function (renderer) { + return extendRenderer(_this3, renderer); + }); + } + }, { + key: 'update', + value: function update() { + var _this4 = this; + + return Promise.all([this.loadMeta(), this.loadUserInfo()]).then(function () { + return Promise.all([_this4.loadComments().then(function () { + return _this4.loadCommentReactions(); + }), _this4.loadReactions()]); + }).catch(function (e) { + return _this4.state.error = e; + }); + } + }, { + key: 'markdown', + value: function markdown(text) { + return _utils.http.post('/markdown', { + text: text, + mode: 'gfm' + }); + } + }, { + key: 'createIssue', + value: function createIssue() { + var _this5 = this; + + var id = this.id, + owner = this.owner, + repo = this.repo, + title = this.title, + link = this.link, + desc = this.desc, + labels = this.labels; + + + return _utils.http.post('/repos/' + owner + '/' + repo + '/issues', { + title: title, + labels: labels.concat(['gitment', id]), + body: link + '\n\n' + desc + }).then(function (meta) { + _this5.state.meta = meta; + return meta; + }); + } + }, { + key: 'getIssue', + value: function getIssue() { + if (this.state.meta.id) return Promise.resolve(this.state.meta); + + return this.loadMeta(); + } + }, { + key: 'post', + value: function post(body) { + var _this6 = this; + + return this.getIssue().then(function (issue) { + return _utils.http.post(issue.comments_url, { + body: body + }, ''); + }).then(function (data) { + _this6.state.meta.comments++; + var pageCount = Math.ceil(_this6.state.meta.comments / _this6.perPage); + if (_this6.state.currentPage === pageCount) { + _this6.state.comments.push(data); + } + return data; + }); + } + }, { + key: 'loadMeta', + value: function loadMeta() { + var _this7 = this; + + var id = this.id, + owner = this.owner, + repo = this.repo; + + return _utils.http.get('/repos/' + owner + '/' + repo + '/issues', { + creator: owner, + labels: id + }).then(function (issues) { + if (!issues.length) return Promise.reject(_constants.NOT_INITIALIZED_ERROR); + _this7.state.meta = issues[0]; + return issues[0]; + }); + } + }, { + key: 'loadComments', + value: function loadComments() { + var _this8 = this; + + var page = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state.currentPage; + + return this.getIssue().then(function (issue) { + return _utils.http.get(issue.comments_url, { + page: page, + per_page: _this8.perPage + }, ''); + }).then(function (comments) { + _this8.state.comments = comments; + return comments; + }); + } + }, { + key: 'loadUserInfo', + value: function loadUserInfo() { + var _this9 = this; + + if (!this.accessToken) { + this.logout(); + return Promise.resolve({}); + } + + return _utils.http.get('/user').then(function (user) { + _this9.state.user = user; + localStorage.setItem(_constants.LS_USER_KEY, JSON.stringify(user)); + return user; + }); + } + }, { + key: 'loadReactions', + value: function loadReactions() { + var _this10 = this; + + if (!this.accessToken) { + this.state.reactions = []; + return Promise.resolve([]); + } + + return this.getIssue().then(function (issue) { + if (!issue.reactions.total_count) return []; + return _utils.http.get(issue.reactions.url, {}, ''); + }).then(function (reactions) { + _this10.state.reactions = reactions; + return reactions; + }); + } + }, { + key: 'loadCommentReactions', + value: function loadCommentReactions() { + var _this11 = this; + + if (!this.accessToken) { + this.state.commentReactions = {}; + return Promise.resolve([]); + } + + var comments = this.state.comments; + var comentReactions = {}; + + return Promise.all(comments.map(function (comment) { + if (!comment.reactions.total_count) return []; + + var owner = _this11.owner, + repo = _this11.repo; + + return _utils.http.get('/repos/' + owner + '/' + repo + '/issues/comments/' + comment.id + '/reactions', {}); + })).then(function (reactionsArray) { + comments.forEach(function (comment, index) { + comentReactions[comment.id] = reactionsArray[index]; + }); + _this11.state.commentReactions = comentReactions; + + return comentReactions; + }); + } + }, { + key: 'login', + value: function login() { + window.location.href = this.loginLink; + } + }, { + key: 'logout', + value: function logout() { + localStorage.removeItem(_constants.LS_ACCESS_TOKEN_KEY); + localStorage.removeItem(_constants.LS_USER_KEY); + this.state.user = {}; + } + }, { + key: 'goto', + value: function goto(page) { + this.state.currentPage = page; + this.state.comments = undefined; + return this.loadComments(page); + } + }, { + key: 'like', + value: function like() { + var _this12 = this; + + if (!this.accessToken) { + alert('Login to Like'); + return Promise.reject(); + } + + var owner = this.owner, + repo = this.repo; + + + return _utils.http.post('/repos/' + owner + '/' + repo + '/issues/' + this.state.meta.number + '/reactions', { + content: 'heart' + }).then(function (reaction) { + _this12.state.reactions.push(reaction); + _this12.state.meta.reactions.heart++; + }); + } + }, { + key: 'unlike', + value: function unlike() { + var _this13 = this; + + if (!this.accessToken) return Promise.reject(); + + var _state = this.state, + user = _state.user, + reactions = _state.reactions; + + var index = reactions.findIndex(function (reaction) { + return reaction.user.login === user.login; + }); + return _utils.http.delete('/reactions/' + reactions[index].id).then(function () { + reactions.splice(index, 1); + _this13.state.meta.reactions.heart--; + }); + } + }, { + key: 'likeAComment', + value: function likeAComment(commentId) { + var _this14 = this; + + if (!this.accessToken) { + alert('Login to Like'); + return Promise.reject(); + } + + var owner = this.owner, + repo = this.repo; + + var comment = this.state.comments.find(function (comment) { + return comment.id === commentId; + }); + + return _utils.http.post('/repos/' + owner + '/' + repo + '/issues/comments/' + commentId + '/reactions', { + content: 'heart' + }).then(function (reaction) { + _this14.state.commentReactions[commentId].push(reaction); + comment.reactions.heart++; + }); + } + }, { + key: 'unlikeAComment', + value: function unlikeAComment(commentId) { + if (!this.accessToken) return Promise.reject(); + + var reactions = this.state.commentReactions[commentId]; + var comment = this.state.comments.find(function (comment) { + return comment.id === commentId; + }); + var user = this.state.user; + + var index = reactions.findIndex(function (reaction) { + return reaction.user.login === user.login; + }); + + return _utils.http.delete('/reactions/' + reactions[index].id).then(function () { + reactions.splice(index, 1); + comment.reactions.heart--; + }); + } + }]); + + return Gitment; + }(); + + module.exports = Gitment; + + /***/ + }), + /* 6 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + /** + * Modified from https://github.com/evil-icons/evil-icons + */ + + var close = exports.close = ''; + var github = exports.github = ''; + var heart = exports.heart = ''; + var spinner = exports.spinner = ''; + + /***/ + }) + /******/ +]); diff --git a/lib/gitment.js.bak b/lib/gitment.js.bak new file mode 100644 index 0000000..83780b8 --- /dev/null +++ b/lib/gitment.js.bak @@ -0,0 +1 @@ +var _typeof3="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},_typeof="function"==typeof Symbol&&"symbol"==_typeof3(Symbol.iterator)?function(e){return void 0===e?"undefined":_typeof3(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":void 0===e?"undefined":_typeof3(e)},_typeof2="function"==typeof Symbol&&"symbol"==_typeof(Symbol.iterator)?function(e){return void 0===e?"undefined":_typeof(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":void 0===e?"undefined":_typeof(e)},Gitment=function(n){var r={};function i(e){if(r[e])return r[e].exports;var t=r[e]={i:e,l:!1,exports:{}};return n[e].call(t.exports,t,t.exports,i),t.l=!0,t.exports}return i.m=n,i.c=r,i.i=function(e){return e},i.d=function(e,t,n){i.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:n})},i.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return i.d(t,"a",t),t},i.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},i.p="",i(i.s=5)}([function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),t.LS_ACCESS_TOKEN_KEY="gitment-comments-token",t.LS_USER_KEY="gitment-user-info",t.NOT_INITIALIZED_ERROR=new Error("该文章评论未初始化")},function(hn,dn,e){(function(e){var r,h="function"==typeof Symbol&&"symbol"===_typeof2(Symbol.iterator)?function(e){return void 0===e?"undefined":_typeof2(e)}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":void 0===e?"undefined":_typeof2(e)},n=(r=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])},function(e,t){function n(){this.constructor=e}r(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)});Object.defineProperty(dn,"__esModule",{value:!0}),dn.extras={allowStateChanges:function(e,t){var n,r=M(e);try{n=t()}finally{D(r)}return n},deepEqual:rn,getAtom:St,getDebugName:kt,getDependencyTree:function(e,t){return b(St(e,t))},getAdministration:Ot,getGlobalState:function(){return se},getObserverTree:function(e,t){return y(St(e,t))},isComputingDerivation:X,isSpyEnabled:xe,onReactionError:function(t){return se.globalReactionErrorHandlers.push(t),function(){var e=se.globalReactionErrorHandlers.indexOf(t);0<=e&&se.globalReactionErrorHandlers.splice(e,1)}},resetGlobalState:function(){se.resetId++;var e=new ae;for(var t in e)-1===oe.indexOf(t)&&(se[t]=e[t]);se.allowStateChanges=!se.strictMode},shareGlobalState:function(){var e=Dt(),t=se;if(e.__mobservableTrackingStack||e.__mobservableViewStack)throw new Error("[mobx] An incompatible version of mobservable is already loaded.");if(e.__mobxGlobal&&e.__mobxGlobal.version!==t.version)throw new Error("[mobx] An incompatible version of mobx is already loaded.");e.__mobxGlobal?se=e.__mobxGlobal:e.__mobxGlobal=t},spyReport:Se,spyReportEnd:Ae,spyReportStart:Oe,setReactionScheduler:function(t){var n=be;be=function(e){return t(function(){return n(e)})}}},"object"===("undefined"==typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__?"undefined":h(__MOBX_DEVTOOLS_GLOBAL_HOOK__))&&__MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx(hn.exports),hn.exports.default=hn.exports;var i=At(function(e,t,n,r,i){var o=r&&1===r.length?r[0]:n.name||t||"";Qt(e,t,c(o,n))},function(e){return this[e]},function(){$t(!1,Pt("m001"))},!1,!0),o=At(function(e,t,n){l(e,t,n)},function(e){return this[e]},function(){$t(!1,Pt("m001"))},!1,!1),c=function(e,t,n,r){return 1===arguments.length&&"function"==typeof e?R(e.name||"",e):2===arguments.length&&"function"==typeof t?R(e,t):1===arguments.length&&"string"==typeof e?a(e):a(t).apply(null,arguments)};function a(r){return function(e,t,n){return n&&"function"==typeof n.value?(n.value=R(r,n.value),n.enumerable=!1,n.configurable=!0,n):i(r).apply(this,arguments)}}function d(e){return"function"==typeof e&&!0===e.isMobxAction}function l(e,t,n){function r(){return P(t,n,e,arguments)}r.isMobxAction=!0,Qt(e,t,r)}function u(e,t,n){var r,i,o;o="string"==typeof e?(r=e,i=t,n):(r=e.name||"Autorun@"+Vt(),i=e,t),$t("function"==typeof i,Pt("m004")),$t(!1===d(i),Pt("m005")),o&&(i=i.bind(o));var a=new fe(r,function(){this.track(s)});function s(){i(a)}return a.schedule(),a.getDisposer()}function t(o){return At(function(e,t,n,r,i){$t(void 0!==i,Pt("m009")),$t("function"==typeof i.get,Pt("m010")),ht(ut(e,""),t,i.get,i.set,o,!1)},function(e){var t=this.$mobx.values[e];if(void 0!==t)return t.get()},function(e,t){this.$mobx.values[e].set(t)},!1,!1)}function s(e,t,n){if("string"==typeof t)return p.apply(null,arguments);$t("function"==typeof e,Pt("m011")),$t(arguments.length<3,Pt("m012"));var r="object"===(void 0===t?"undefined":h(t))?t:{};return r.setter="function"==typeof t?t:r.setter,new H(e,r.context,r.compareStructural||r.struct||!1,r.name||e.name||"",r.setter)}(dn.action=c).bound=function(e,t,n){if("function"!=typeof e)return o.apply(null,arguments);var r=R("",e);return r.autoBind=!0,r},dn.runInAction=function(e,t,n){var r="string"==typeof e?e:e.name||"",i="function"==typeof e?e:t,o="function"==typeof e?t:n;return $t("function"==typeof i,Pt("m002")),$t(0===i.length,Pt("m003")),$t("string"==typeof r&&0n.dependenciesState&&(t.lowestObserverState=n.dependenciesState))}}(e),r}function ee(e){for(var t=e.observing,n=t.length;n--;)ce(t[n],e);e.dependenciesState=G.NOT_TRACKING,t.length=0}function te(e){var t=ne(),n=e();return re(t),n}function ne(){var e=se.trackingDerivation;return se.trackingDerivation=null,e}function re(e){se.trackingDerivation=e}function ie(e){if(e.dependenciesState!==G.UP_TO_DATE){e.dependenciesState=G.UP_TO_DATE;for(var t=e.observing,n=t.length;n--;)t[n].lowestObserverState=G.UP_TO_DATE}}dn.untracked=te;var oe=["mobxGuid","resetId","spyListeners","strictMode","runId"],ae=function(){this.version=5,this.trackingDerivation=null,this.computationDepth=0,this.runId=0,this.mobxGuid=0,this.inBatch=0,this.pendingUnobservations=[],this.pendingReactions=[],this.isRunningReactions=!1,this.allowStateChanges=!0,this.strictMode=!1,this.resetId=0,this.spyListeners=[],this.globalReactionErrorHandlers=[]},se=new ae;function ue(e){return e.observers}function ce(e,t){if(1===e.observers.length)e.observers.length=0,le(e);else{var n=e.observers,r=e.observersIndexes,i=n.pop();if(i!==t){var o=r[t.__mapid]||0;o?r[i.__mapid]=o:delete r[i.__mapid],n[o]=i}delete r[t.__mapid]}}function le(e){e.isPendingUnobservation||(e.isPendingUnobservation=!0,se.pendingUnobservations.push(e))}function he(){se.inBatch++}function de(){if(0==--se.inBatch){ye();for(var e=se.pendingUnobservations,t=0;t=this.length,value:tt?" (... and "+(e.length-t)+"more)":""):""}function Wt(e){return null!==e&&"object"===(void 0===e?"undefined":h(e))}function Yt(e){if(null===e||"object"!==(void 0===e?"undefined":h(e)))return!1;var t=Object.getPrototypeOf(e);return t===Object.prototype||null===t}function qt(e){for(var t=e,n=1,r=arguments.length;n"+n.reactions.heart+" 人喜欢":"")+"\n ",s?(a.classList.add("liked"),a.onclick=function(){return t.unlike()}):(a.classList.remove("liked"),a.onclick=function(){return t.like()}),o.appendChild(a);var u=document.createElement("span");u.innerHTML="\n "+(n.comments?" • "+n.comments+" 条评论":"")+"\n ",o.appendChild(u);var c=document.createElement("a");return c.className="gitment-header-issue-link",console.log("meta.html_url:"+n.html_url),c.href=n.html_url,c.target="_blank",c.innerText="Issue Page",o.appendChild(c),o},renderComments:function(e,s){var t=e.meta,n=e.comments,u=e.commentReactions,r=e.currentPage,c=e.user,i=e.error,o=document.createElement("div");if(o.lang="en-US",o.className="gitment-container gitment-comments-container",i){var a=document.createElement("div");if(a.className="gitment-comments-error",i===x.NOT_INITIALIZED_ERROR&&c.login&&c.login.toLowerCase()===s.owner.toLowerCase()){var l=document.createElement("div"),h=document.createElement("button");h.className="gitment-comments-init-btn",h.onclick=function(){h.setAttribute("disabled",!0),s.init().catch(function(e){h.removeAttribute("disabled"),alert(e)})},h.innerText="初始化评论",l.appendChild(h),a.appendChild(l)}else a.innerText=i;return o.appendChild(a),o}if(void 0===n){var d=document.createElement("div");return d.innerText="评论加载中...",d.className="gitment-comments-loading",o.appendChild(d),o}if(!n.length){var p=document.createElement("div");return p.className="gitment-comments-empty",p.innerText="暂无评论，来过就留点痕迹吧",o.appendChild(p),o}var f=document.createElement("ul");if(f.className="gitment-comments-list",n.forEach(function(e){var t=new Date(e.created_at),n=new Date(e.updated_at),r=document.createElement("li");r.className="gitment-comment",r.innerHTML='\n \n \n \n
    \n
    \n \n '+e.user.login+'\n \n 评论于\n '+t.toDateString()+"\n "+(t.toString()!==n.toString()?' • 已编辑':"")+'\n
    '+_.heart+" "+(e.reactions.heart||"")+'
    \n
    \n
    '+e.body_html+"
    \n
    \n ";var i=r.querySelector(".gitment-comment-like-btn");u[e.id]&&u[e.id].find(function(e){return"heart"===e.content&&e.user.login===c.login})?(i.classList.add("liked"),i.onclick=function(){return s.unlikeAComment(e.id)}):(i.classList.remove("liked"),i.onclick=function(){return s.likeAComment(e.id)});var o=document.createElement("img"),a=r.querySelector(".gitment-comment-body");o.className="gitment-hidden",o.src="data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==",o.onload=function(){a.clientHeight>s.maxCommentHeight&&(a.classList.add("gitment-comment-body-folded"),a.style.maxHeight=s.maxCommentHeight+"px",a.title="点击展开",a.onclick=function(){a.classList.remove("gitment-comment-body-folded"),a.style.maxHeight="",a.title="",a.onclick=null})},r.appendChild(o),f.appendChild(r)}),o.appendChild(f),t){var m=Math.ceil(t.comments/s.perPage);if(1\n \n ':t.isLoggingIn?'
    '+_.spinner+"
    ":'\n '+_.github+"\n ")+'\n \n
    \n
    \n \n \n
    \n
    \n
    \n \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n \n 评论框支持 Markdown 语法\n \n \n
    \n ",t.login&&(i.querySelector(".gitment-editor-logout-link").onclick=function(){return n.logout()});var s=i.querySelector(".gitment-editor-write-field"),u=i.querySelector(".gitment-editor-preview-field"),c=s.querySelector("textarea");c.oninput=function(){c.style.height="auto";var e=window.getComputedStyle(c,null),t=parseInt(e.height,10),n=c.clientHeight,r=c.scrollHeight;n',t.github='',t.heart='',t.spinner=''}]); \ No newline at end of file diff --git a/lib/gitment.js.bak2 b/lib/gitment.js.bak2 new file mode 100644 index 0000000..8fa3d40 --- /dev/null +++ b/lib/gitment.js.bak2 @@ -0,0 +1,4153 @@ +var Gitment = + /******/ + (function (modules) { // webpackBootstrap + /******/ // The module cache + /******/ + var installedModules = {}; + /******/ + /******/ // The require function + /******/ + function __webpack_require__(moduleId) { + /******/ + /******/ // Check if module is in cache + /******/ + if (installedModules[moduleId]) + /******/ + return installedModules[moduleId].exports; + /******/ + /******/ // Create a new module (and put it into the cache) + /******/ + var module = installedModules[moduleId] = { + /******/ + i: moduleId, + /******/ + l: false, + /******/ + exports: {} + /******/ + }; + /******/ + /******/ // Execute the module function + /******/ + modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + /******/ + /******/ // Flag the module as loaded + /******/ + module.l = true; + /******/ + /******/ // Return the exports of the module + /******/ + return module.exports; + /******/ + } + /******/ + /******/ + /******/ // expose the modules object (__webpack_modules__) + /******/ + __webpack_require__.m = modules; + /******/ + /******/ // expose the module cache + /******/ + __webpack_require__.c = installedModules; + /******/ + /******/ // identity function for calling harmony imports with the correct context + /******/ + __webpack_require__.i = function (value) { + return value; + }; + /******/ + /******/ // define getter function for harmony exports + /******/ + __webpack_require__.d = function (exports, name, getter) { + /******/ + if (!__webpack_require__.o(exports, name)) { + /******/ + Object.defineProperty(exports, name, { + /******/ + configurable: false, + /******/ + enumerable: true, + /******/ + get: getter + /******/ + }); + /******/ + } + /******/ + }; + /******/ + /******/ // getDefaultExport function for compatibility with non-harmony modules + /******/ + __webpack_require__.n = function (module) { + /******/ + var getter = module && module.__esModule ? + /******/ + function getDefault() { + return module['default']; + } : + /******/ + function getModuleExports() { + return module; + }; + /******/ + __webpack_require__.d(getter, 'a', getter); + /******/ + return getter; + /******/ + }; + /******/ + /******/ // Object.prototype.hasOwnProperty.call + /******/ + __webpack_require__.o = function (object, property) { + return Object.prototype.hasOwnProperty.call(object, property); + }; + /******/ + /******/ // __webpack_public_path__ + /******/ + __webpack_require__.p = ""; + /******/ + /******/ // Load entry module and return exports + /******/ + return __webpack_require__(__webpack_require__.s = 5); + /******/ + }) +/************************************************************************/ +/******/ +([ + /* 0 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + var LS_ACCESS_TOKEN_KEY = exports.LS_ACCESS_TOKEN_KEY = 'gitment-comments-token'; + var LS_USER_KEY = exports.LS_USER_KEY = 'gitment-user-info'; + + var NOT_INITIALIZED_ERROR = exports.NOT_INITIALIZED_ERROR = new Error('该文章评论未初始化'); + + /***/ + }), + /* 1 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + /* WEBPACK VAR INJECTION */ + (function (global) { + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + + var __extends = undefined && undefined.__extends || function () { + var extendStatics = Object.setPrototypeOf || { + __proto__: [] + } + instanceof Array && function (d, b) { + d.__proto__ = b; + } || function (d, b) { + for (var p in b) { + if (b.hasOwnProperty(p)) d[p] = b[p]; + } + }; + return function (d, b) { + extendStatics(d, b); + + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + }(); + Object.defineProperty(exports, "__esModule", { + value: true + }); + registerGlobals(); + exports.extras = { + allowStateChanges: allowStateChanges, + deepEqual: deepEqual, + getAtom: getAtom, + getDebugName: getDebugName, + getDependencyTree: getDependencyTree, + getAdministration: getAdministration, + getGlobalState: getGlobalState, + getObserverTree: getObserverTree, + isComputingDerivation: isComputingDerivation, + isSpyEnabled: isSpyEnabled, + onReactionError: onReactionError, + resetGlobalState: resetGlobalState, + shareGlobalState: shareGlobalState, + spyReport: spyReport, + spyReportEnd: spyReportEnd, + spyReportStart: spyReportStart, + setReactionScheduler: setReactionScheduler + }; + if ((typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "undefined" ? "undefined" : _typeof(__MOBX_DEVTOOLS_GLOBAL_HOOK__)) === "object") { + __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx(module.exports); + } + module.exports.default = module.exports; + var actionFieldDecorator = createClassPropertyDecorator(function (target, key, value, args, originalDescriptor) { + var actionName = args && args.length === 1 ? args[0] : value.name || key || ""; + var wrappedAction = action(actionName, value); + addHiddenProp(target, key, wrappedAction); + }, function (key) { + return this[key]; + }, function () { + invariant(false, getMessage("m001")); + }, false, true); + var boundActionDecorator = createClassPropertyDecorator(function (target, key, value) { + defineBoundAction(target, key, value); + }, function (key) { + return this[key]; + }, function () { + invariant(false, getMessage("m001")); + }, false, false); + var action = function action(arg1, arg2, arg3, arg4) { + if (arguments.length === 1 && typeof arg1 === "function") return createAction(arg1.name || "", arg1); + if (arguments.length === 2 && typeof arg2 === "function") return createAction(arg1, arg2); + if (arguments.length === 1 && typeof arg1 === "string") return namedActionDecorator(arg1); + return namedActionDecorator(arg2).apply(null, arguments); + }; + exports.action = action; + action.bound = function boundAction(arg1, arg2, arg3) { + if (typeof arg1 === "function") { + var action_1 = createAction("", arg1); + action_1.autoBind = true; + return action_1; + } + return boundActionDecorator.apply(null, arguments); + }; + + function namedActionDecorator(name) { + return function (target, prop, descriptor) { + if (descriptor && typeof descriptor.value === "function") { + descriptor.value = createAction(name, descriptor.value); + descriptor.enumerable = false; + descriptor.configurable = true; + return descriptor; + } + return actionFieldDecorator(name).apply(this, arguments); + }; + } + + function runInAction(arg1, arg2, arg3) { + var actionName = typeof arg1 === "string" ? arg1 : arg1.name || ""; + var fn = typeof arg1 === "function" ? arg1 : arg2; + var scope = typeof arg1 === "function" ? arg2 : arg3; + invariant(typeof fn === "function", getMessage("m002")); + invariant(fn.length === 0, getMessage("m003")); + invariant(typeof actionName === "string" && actionName.length > 0, "actions should have valid names, got: '" + actionName + "'"); + return executeAction(actionName, fn, scope, undefined); + } + exports.runInAction = runInAction; + + function isAction(thing) { + return typeof thing === "function" && thing.isMobxAction === true; + } + exports.isAction = isAction; + + function defineBoundAction(target, propertyName, fn) { + var res = function res() { + return executeAction(propertyName, fn, target, arguments); + }; + res.isMobxAction = true; + addHiddenProp(target, propertyName, res); + } + + function autorun(arg1, arg2, arg3) { + var name, view, scope; + if (typeof arg1 === "string") { + name = arg1; + view = arg2; + scope = arg3; + } else { + name = arg1.name || "Autorun@" + getNextId(); + view = arg1; + scope = arg2; + } + invariant(typeof view === "function", getMessage("m004")); + invariant(isAction(view) === false, getMessage("m005")); + if (scope) view = view.bind(scope); + var reaction = new Reaction(name, function () { + this.track(reactionRunner); + }); + + function reactionRunner() { + view(reaction); + } + reaction.schedule(); + return reaction.getDisposer(); + } + exports.autorun = autorun; + + function when(arg1, arg2, arg3, arg4) { + var name, predicate, effect, scope; + if (typeof arg1 === "string") { + name = arg1; + predicate = arg2; + effect = arg3; + scope = arg4; + } else { + name = "When@" + getNextId(); + predicate = arg1; + effect = arg2; + scope = arg3; + } + var disposer = autorun(name, function (r) { + if (predicate.call(scope)) { + r.dispose(); + var prevUntracked = untrackedStart(); + effect.call(scope); + untrackedEnd(prevUntracked); + } + }); + return disposer; + } + exports.when = when; + + function autorunAsync(arg1, arg2, arg3, arg4) { + var name, func, delay, scope; + if (typeof arg1 === "string") { + name = arg1; + func = arg2; + delay = arg3; + scope = arg4; + } else { + name = arg1.name || "AutorunAsync@" + getNextId(); + func = arg1; + delay = arg2; + scope = arg3; + } + invariant(isAction(func) === false, getMessage("m006")); + if (delay === void 0) delay = 1; + if (scope) func = func.bind(scope); + var isScheduled = false; + var r = new Reaction(name, function () { + if (!isScheduled) { + isScheduled = true; + setTimeout(function () { + isScheduled = false; + if (!r.isDisposed) r.track(reactionRunner); + }, delay); + } + }); + + function reactionRunner() { + func(r); + } + r.schedule(); + return r.getDisposer(); + } + exports.autorunAsync = autorunAsync; + + function reaction(expression, effect, arg3) { + if (arguments.length > 3) { + fail(getMessage("m007")); + } + if (isModifierDescriptor(expression)) { + fail(getMessage("m008")); + } + var opts; + if ((typeof arg3 === "undefined" ? "undefined" : _typeof(arg3)) === "object") { + opts = arg3; + } else { + opts = {}; + } + opts.name = opts.name || expression.name || effect.name || "Reaction@" + getNextId(); + opts.fireImmediately = arg3 === true || opts.fireImmediately === true; + opts.delay = opts.delay || 0; + opts.compareStructural = opts.compareStructural || opts.struct || false; + effect = action(opts.name, opts.context ? effect.bind(opts.context) : effect); + if (opts.context) { + expression = expression.bind(opts.context); + } + var firstTime = true; + var isScheduled = false; + var nextValue; + var r = new Reaction(opts.name, function () { + if (firstTime || opts.delay < 1) { + reactionRunner(); + } else if (!isScheduled) { + isScheduled = true; + setTimeout(function () { + isScheduled = false; + reactionRunner(); + }, opts.delay); + } + }); + + function reactionRunner() { + if (r.isDisposed) return; + var changed = false; + r.track(function () { + var v = expression(r); + changed = valueDidChange(opts.compareStructural, nextValue, v); + nextValue = v; + }); + if (firstTime && opts.fireImmediately) effect(nextValue, r); + if (!firstTime && changed === true) effect(nextValue, r); + if (firstTime) firstTime = false; + } + r.schedule(); + return r.getDisposer(); + } + exports.reaction = reaction; + + function createComputedDecorator(compareStructural) { + return createClassPropertyDecorator(function (target, name, _, __, originalDescriptor) { + invariant(typeof originalDescriptor !== "undefined", getMessage("m009")); + invariant(typeof originalDescriptor.get === "function", getMessage("m010")); + var adm = asObservableObject(target, ""); + defineComputedProperty(adm, name, originalDescriptor.get, originalDescriptor.set, compareStructural, false); + }, function (name) { + var observable = this.$mobx.values[name]; + if (observable === undefined) return undefined; + return observable.get(); + }, function (name, value) { + this.$mobx.values[name].set(value); + }, false, false); + } + var computedDecorator = createComputedDecorator(false); + var computedStructDecorator = createComputedDecorator(true); + var computed = function computed(arg1, arg2, arg3) { + if (typeof arg2 === "string") { + return computedDecorator.apply(null, arguments); + } + invariant(typeof arg1 === "function", getMessage("m011")); + invariant(arguments.length < 3, getMessage("m012")); + var opts = (typeof arg2 === "undefined" ? "undefined" : _typeof(arg2)) === "object" ? arg2 : {}; + opts.setter = typeof arg2 === "function" ? arg2 : opts.setter; + return new ComputedValue(arg1, opts.context, opts.compareStructural || opts.struct || false, opts.name || arg1.name || "", opts.setter); + }; + exports.computed = computed; + computed.struct = computedStructDecorator; + + function createTransformer(transformer, onCleanup) { + invariant(typeof transformer === "function" && transformer.length < 2, "createTransformer expects a function that accepts one argument"); + var objectCache = {}; + var resetId = globalState.resetId; + var Transformer = function (_super) { + __extends(Transformer, _super); + + function Transformer(sourceIdentifier, sourceObject) { + var _this = _super.call(this, function () { + return transformer(sourceObject); + }, undefined, false, "Transformer-" + transformer.name + "-" + sourceIdentifier, undefined) || this; + _this.sourceIdentifier = sourceIdentifier; + _this.sourceObject = sourceObject; + return _this; + } + Transformer.prototype.onBecomeUnobserved = function () { + var lastValue = this.value; + _super.prototype.onBecomeUnobserved.call(this); + delete objectCache[this.sourceIdentifier]; + if (onCleanup) onCleanup(lastValue, this.sourceObject); + }; + return Transformer; + }(ComputedValue); + return function (object) { + if (resetId !== globalState.resetId) { + objectCache = {}; + resetId = globalState.resetId; + } + var identifier = getMemoizationId(object); + var reactiveTransformer = objectCache[identifier]; + if (reactiveTransformer) return reactiveTransformer.get(); + reactiveTransformer = objectCache[identifier] = new Transformer(identifier, object); + return reactiveTransformer.get(); + }; + } + exports.createTransformer = createTransformer; + + function getMemoizationId(object) { + if (object === null || (typeof object === "undefined" ? "undefined" : _typeof(object)) !== "object") throw new Error("[mobx] transform expected some kind of object, got: " + object); + var tid = object.$transformId; + if (tid === undefined) { + tid = getNextId(); + addHiddenProp(object, "$transformId", tid); + } + return tid; + } + + function expr(expr, scope) { + if (!isComputingDerivation()) console.warn(getMessage("m013")); + return computed(expr, { + context: scope + }).get(); + } + exports.expr = expr; + + function extendObservable(target) { + var properties = []; + for (var _i = 1; _i < arguments.length; _i++) { + properties[_i - 1] = arguments[_i]; + } + return extendObservableHelper(target, deepEnhancer, properties); + } + exports.extendObservable = extendObservable; + + function extendShallowObservable(target) { + var properties = []; + for (var _i = 1; _i < arguments.length; _i++) { + properties[_i - 1] = arguments[_i]; + } + return extendObservableHelper(target, referenceEnhancer, properties); + } + exports.extendShallowObservable = extendShallowObservable; + + function extendObservableHelper(target, defaultEnhancer, properties) { + invariant(arguments.length >= 2, getMessage("m014")); + invariant((typeof target === "undefined" ? "undefined" : _typeof(target)) === "object", getMessage("m015")); + invariant(!isObservableMap(target), getMessage("m016")); + properties.forEach(function (propSet) { + invariant((typeof propSet === "undefined" ? "undefined" : _typeof(propSet)) === "object", getMessage("m017")); + invariant(!isObservable(propSet), getMessage("m018")); + }); + var adm = asObservableObject(target); + var definedProps = {}; + for (var i = properties.length - 1; i >= 0; i--) { + var propSet = properties[i]; + for (var key in propSet) { + if (definedProps[key] !== true && hasOwnProperty(propSet, key)) { + definedProps[key] = true; + if (target === propSet && !isPropertyConfigurable(target, key)) continue; + var descriptor = Object.getOwnPropertyDescriptor(propSet, key); + defineObservablePropertyFromDescriptor(adm, key, descriptor, defaultEnhancer); + } + } + } + return target; + } + + function getDependencyTree(thing, property) { + return nodeToDependencyTree(getAtom(thing, property)); + } + + function nodeToDependencyTree(node) { + var result = { + name: node.name + }; + if (node.observing && node.observing.length > 0) result.dependencies = unique(node.observing).map(nodeToDependencyTree); + return result; + } + + function getObserverTree(thing, property) { + return nodeToObserverTree(getAtom(thing, property)); + } + + function nodeToObserverTree(node) { + var result = { + name: node.name + }; + if (hasObservers(node)) result.observers = getObservers(node).map(nodeToObserverTree); + return result; + } + + function intercept(thing, propOrHandler, handler) { + if (typeof handler === "function") return interceptProperty(thing, propOrHandler, handler); + else return interceptInterceptable(thing, propOrHandler); + } + exports.intercept = intercept; + + function interceptInterceptable(thing, handler) { + return getAdministration(thing).intercept(handler); + } + + function interceptProperty(thing, property, handler) { + return getAdministration(thing, property).intercept(handler); + } + + function isComputed(value, property) { + if (value === null || value === undefined) return false; + if (property !== undefined) { + if (isObservableObject(value) === false) return false; + var atom = getAtom(value, property); + return isComputedValue(atom); + } + return isComputedValue(value); + } + exports.isComputed = isComputed; + + function isObservable(value, property) { + if (value === null || value === undefined) return false; + if (property !== undefined) { + if (isObservableArray(value) || isObservableMap(value)) throw new Error(getMessage("m019")); + else if (isObservableObject(value)) { + var o = value.$mobx; + return o.values && !!o.values[property]; + } + return false; + } + return isObservableObject(value) || !!value.$mobx || isAtom(value) || isReaction(value) || isComputedValue(value); + } + exports.isObservable = isObservable; + var deepDecorator = createDecoratorForEnhancer(deepEnhancer); + var shallowDecorator = createDecoratorForEnhancer(shallowEnhancer); + var refDecorator = createDecoratorForEnhancer(referenceEnhancer); + var deepStructDecorator = createDecoratorForEnhancer(deepStructEnhancer); + var refStructDecorator = createDecoratorForEnhancer(refStructEnhancer); + + function createObservable(v) { + if (v === void 0) { + v = undefined; + } + if (typeof arguments[1] === "string") return deepDecorator.apply(null, arguments); + invariant(arguments.length <= 1, getMessage("m021")); + invariant(!isModifierDescriptor(v), getMessage("m020")); + if (isObservable(v)) return v; + var res = deepEnhancer(v, undefined, undefined); + if (res !== v) return res; + return observable.box(v); + } + var IObservableFactories = function () { + function IObservableFactories() {} + IObservableFactories.prototype.box = function (value, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("box"); + return new ObservableValue(value, deepEnhancer, name); + }; + IObservableFactories.prototype.shallowBox = function (value, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowBox"); + return new ObservableValue(value, referenceEnhancer, name); + }; + IObservableFactories.prototype.array = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("array"); + return new ObservableArray(initialValues, deepEnhancer, name); + }; + IObservableFactories.prototype.shallowArray = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowArray"); + return new ObservableArray(initialValues, referenceEnhancer, name); + }; + IObservableFactories.prototype.map = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("map"); + return new ObservableMap(initialValues, deepEnhancer, name); + }; + IObservableFactories.prototype.shallowMap = function (initialValues, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowMap"); + return new ObservableMap(initialValues, referenceEnhancer, name); + }; + IObservableFactories.prototype.object = function (props, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("object"); + var res = {}; + asObservableObject(res, name); + extendObservable(res, props); + return res; + }; + IObservableFactories.prototype.shallowObject = function (props, name) { + if (arguments.length > 2) incorrectlyUsedAsDecorator("shallowObject"); + var res = {}; + asObservableObject(res, name); + extendShallowObservable(res, props); + return res; + }; + IObservableFactories.prototype.ref = function () { + if (arguments.length < 2) { + return createModifierDescriptor(referenceEnhancer, arguments[0]); + } else { + return refDecorator.apply(null, arguments); + } + }; + IObservableFactories.prototype.shallow = function () { + if (arguments.length < 2) { + return createModifierDescriptor(shallowEnhancer, arguments[0]); + } else { + return shallowDecorator.apply(null, arguments); + } + }; + IObservableFactories.prototype.deep = function () { + if (arguments.length < 2) { + return createModifierDescriptor(deepEnhancer, arguments[0]); + } else { + return deepDecorator.apply(null, arguments); + } + }; + IObservableFactories.prototype.struct = function () { + if (arguments.length < 2) { + return createModifierDescriptor(deepStructEnhancer, arguments[0]); + } else { + return deepStructDecorator.apply(null, arguments); + } + }; + return IObservableFactories; + }(); + exports.IObservableFactories = IObservableFactories; + var observable = createObservable; + exports.observable = observable; + Object.keys(IObservableFactories.prototype).forEach(function (key) { + return observable[key] = IObservableFactories.prototype[key]; + }); + observable.deep.struct = observable.struct; + observable.ref.struct = function () { + if (arguments.length < 2) { + return createModifierDescriptor(refStructEnhancer, arguments[0]); + } else { + return refStructDecorator.apply(null, arguments); + } + }; + + function incorrectlyUsedAsDecorator(methodName) { + fail("Expected one or two arguments to observable." + methodName + ". Did you accidentally try to use observable." + methodName + " as decorator?"); + } + + function createDecoratorForEnhancer(enhancer) { + invariant(!!enhancer, ":("); + return createClassPropertyDecorator(function (target, name, baseValue, _, baseDescriptor) { + assertPropertyConfigurable(target, name); + invariant(!baseDescriptor || !baseDescriptor.get, getMessage("m022")); + var adm = asObservableObject(target, undefined); + defineObservableProperty(adm, name, baseValue, enhancer); + }, function (name) { + var observable = this.$mobx.values[name]; + if (observable === undefined) return undefined; + return observable.get(); + }, function (name, value) { + setPropertyValue(this, name, value); + }, true, false); + } + + function observe(thing, propOrCb, cbOrFire, fireImmediately) { + if (typeof cbOrFire === "function") return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately); + else return observeObservable(thing, propOrCb, cbOrFire); + } + exports.observe = observe; + + function observeObservable(thing, listener, fireImmediately) { + return getAdministration(thing).observe(listener, fireImmediately); + } + + function observeObservableProperty(thing, property, listener, fireImmediately) { + return getAdministration(thing, property).observe(listener, fireImmediately); + } + + function toJS(source, detectCycles, __alreadySeen) { + if (detectCycles === void 0) { + detectCycles = true; + } + if (__alreadySeen === void 0) { + __alreadySeen = []; + } + + function cache(value) { + if (detectCycles) __alreadySeen.push([source, value]); + return value; + } + if (isObservable(source)) { + if (detectCycles && __alreadySeen === null) __alreadySeen = []; + if (detectCycles && source !== null && (typeof source === "undefined" ? "undefined" : _typeof(source)) === "object") { + for (var i = 0, l = __alreadySeen.length; i < l; i++) { + if (__alreadySeen[i][0] === source) return __alreadySeen[i][1]; + } + } + if (isObservableArray(source)) { + var res = cache([]); + var toAdd = source.map(function (value) { + return toJS(value, detectCycles, __alreadySeen); + }); + res.length = toAdd.length; + for (var i = 0, l = toAdd.length; i < l; i++) { + res[i] = toAdd[i]; + } + return res; + } + if (isObservableObject(source)) { + var res = cache({}); + for (var key in source) { + res[key] = toJS(source[key], detectCycles, __alreadySeen); + } + return res; + } + if (isObservableMap(source)) { + var res_1 = cache({}); + source.forEach(function (value, key) { + return res_1[key] = toJS(value, detectCycles, __alreadySeen); + }); + return res_1; + } + if (isObservableValue(source)) return toJS(source.get(), detectCycles, __alreadySeen); + } + return source; + } + exports.toJS = toJS; + + function transaction(action, thisArg) { + if (thisArg === void 0) { + thisArg = undefined; + } + deprecated(getMessage("m023")); + return runInTransaction.apply(undefined, arguments); + } + exports.transaction = transaction; + + function runInTransaction(action, thisArg) { + if (thisArg === void 0) { + thisArg = undefined; + } + return executeAction("", action); + } + + function log(msg) { + console.log(msg); + return msg; + } + + function whyRun(thing, prop) { + switch (arguments.length) { + case 0: + thing = globalState.trackingDerivation; + if (!thing) return log(getMessage("m024")); + break; + case 2: + thing = getAtom(thing, prop); + break; + } + thing = getAtom(thing); + if (isComputedValue(thing)) return log(thing.whyRun()); + else if (isReaction(thing)) return log(thing.whyRun()); + return fail(getMessage("m025")); + } + exports.whyRun = whyRun; + + function createAction(actionName, fn) { + invariant(typeof fn === "function", getMessage("m026")); + invariant(typeof actionName === "string" && actionName.length > 0, "actions should have valid names, got: '" + actionName + "'"); + var res = function res() { + return executeAction(actionName, fn, this, arguments); + }; + res.originalFn = fn; + res.isMobxAction = true; + return res; + } + + function executeAction(actionName, fn, scope, args) { + var runInfo = startAction(actionName, fn, scope, args); + try { + return fn.apply(scope, args); + } finally { + endAction(runInfo); + } + } + + function startAction(actionName, fn, scope, args) { + var notifySpy = isSpyEnabled() && !!actionName; + var startTime = 0; + if (notifySpy) { + startTime = Date.now(); + var l = args && args.length || 0; + var flattendArgs = new Array(l); + if (l > 0) + for (var i = 0; i < l; i++) { + flattendArgs[i] = args[i]; + } + spyReportStart({ + type: "action", + name: actionName, + fn: fn, + object: scope, + arguments: flattendArgs + }); + } + var prevDerivation = untrackedStart(); + startBatch(); + var prevAllowStateChanges = allowStateChangesStart(true); + return { + prevDerivation: prevDerivation, + prevAllowStateChanges: prevAllowStateChanges, + notifySpy: notifySpy, + startTime: startTime + }; + } + + function endAction(runInfo) { + allowStateChangesEnd(runInfo.prevAllowStateChanges); + endBatch(); + untrackedEnd(runInfo.prevDerivation); + if (runInfo.notifySpy) spyReportEnd({ + time: Date.now() - runInfo.startTime + }); + } + + function useStrict(strict) { + invariant(globalState.trackingDerivation === null, getMessage("m028")); + globalState.strictMode = strict; + globalState.allowStateChanges = !strict; + } + exports.useStrict = useStrict; + + function isStrictModeEnabled() { + return globalState.strictMode; + } + exports.isStrictModeEnabled = isStrictModeEnabled; + + function allowStateChanges(allowStateChanges, func) { + var prev = allowStateChangesStart(allowStateChanges); + var res; + try { + res = func(); + } finally { + allowStateChangesEnd(prev); + } + return res; + } + + function allowStateChangesStart(allowStateChanges) { + var prev = globalState.allowStateChanges; + globalState.allowStateChanges = allowStateChanges; + return prev; + } + + function allowStateChangesEnd(prev) { + globalState.allowStateChanges = prev; + } + var BaseAtom = function () { + function BaseAtom(name) { + if (name === void 0) { + name = "Atom@" + getNextId(); + } + this.name = name; + this.isPendingUnobservation = true; + this.observers = []; + this.observersIndexes = {}; + this.diffValue = 0; + this.lastAccessedBy = 0; + this.lowestObserverState = IDerivationState.NOT_TRACKING; + } + BaseAtom.prototype.onBecomeUnobserved = function () {}; + BaseAtom.prototype.reportObserved = function () { + reportObserved(this); + }; + BaseAtom.prototype.reportChanged = function () { + startBatch(); + propagateChanged(this); + endBatch(); + }; + BaseAtom.prototype.toString = function () { + return this.name; + }; + return BaseAtom; + }(); + exports.BaseAtom = BaseAtom; + var Atom = function (_super) { + __extends(Atom, _super); + + function Atom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) { + if (name === void 0) { + name = "Atom@" + getNextId(); + } + if (onBecomeObservedHandler === void 0) { + onBecomeObservedHandler = noop; + } + if (onBecomeUnobservedHandler === void 0) { + onBecomeUnobservedHandler = noop; + } + var _this = _super.call(this, name) || this; + _this.name = name; + _this.onBecomeObservedHandler = onBecomeObservedHandler; + _this.onBecomeUnobservedHandler = onBecomeUnobservedHandler; + _this.isPendingUnobservation = false; + _this.isBeingTracked = false; + return _this; + } + Atom.prototype.reportObserved = function () { + startBatch(); + _super.prototype.reportObserved.call(this); + if (!this.isBeingTracked) { + this.isBeingTracked = true; + this.onBecomeObservedHandler(); + } + endBatch(); + return !!globalState.trackingDerivation; + }; + Atom.prototype.onBecomeUnobserved = function () { + this.isBeingTracked = false; + this.onBecomeUnobservedHandler(); + }; + return Atom; + }(BaseAtom); + exports.Atom = Atom; + var isAtom = createInstanceofPredicate("Atom", BaseAtom); + var ComputedValue = function () { + function ComputedValue(derivation, scope, compareStructural, name, setter) { + this.derivation = derivation; + this.scope = scope; + this.compareStructural = compareStructural; + this.dependenciesState = IDerivationState.NOT_TRACKING; + this.observing = []; + this.newObserving = null; + this.isPendingUnobservation = false; + this.observers = []; + this.observersIndexes = {}; + this.diffValue = 0; + this.runId = 0; + this.lastAccessedBy = 0; + this.lowestObserverState = IDerivationState.UP_TO_DATE; + this.unboundDepsCount = 0; + this.__mapid = "#" + getNextId(); + this.value = undefined; + this.isComputing = false; + this.isRunningSetter = false; + this.name = name || "ComputedValue@" + getNextId(); + if (setter) this.setter = createAction(name + "-setter", setter); + } + ComputedValue.prototype.onBecomeStale = function () { + propagateMaybeChanged(this); + }; + ComputedValue.prototype.onBecomeUnobserved = function () { + invariant(this.dependenciesState !== IDerivationState.NOT_TRACKING, getMessage("m029")); + clearObserving(this); + this.value = undefined; + }; + ComputedValue.prototype.get = function () { + invariant(!this.isComputing, "Cycle detected in computation " + this.name, this.derivation); + if (globalState.inBatch === 0) { + startBatch(); + if (shouldCompute(this)) this.value = this.computeValue(false); + endBatch(); + } else { + reportObserved(this); + if (shouldCompute(this)) + if (this.trackAndCompute()) propagateChangeConfirmed(this); + } + var result = this.value; + if (isCaughtException(result)) throw result.cause; + return result; + }; + ComputedValue.prototype.peek = function () { + var res = this.computeValue(false); + if (isCaughtException(res)) throw res.cause; + return res; + }; + ComputedValue.prototype.set = function (value) { + if (this.setter) { + invariant(!this.isRunningSetter, "The setter of computed value '" + this.name + "' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?"); + this.isRunningSetter = true; + try { + this.setter.call(this.scope, value); + } finally { + this.isRunningSetter = false; + } + } else invariant(false, "[ComputedValue '" + this.name + "'] It is not possible to assign a new value to a computed value."); + }; + ComputedValue.prototype.trackAndCompute = function () { + if (isSpyEnabled()) { + spyReport({ + object: this.scope, + type: "compute", + fn: this.derivation + }); + } + var oldValue = this.value; + var newValue = this.value = this.computeValue(true); + return isCaughtException(newValue) || valueDidChange(this.compareStructural, newValue, oldValue); + }; + ComputedValue.prototype.computeValue = function (track) { + this.isComputing = true; + globalState.computationDepth++; + var res; + if (track) { + res = trackDerivedFunction(this, this.derivation, this.scope); + } else { + try { + res = this.derivation.call(this.scope); + } catch (e) { + res = new CaughtException(e); + } + } + globalState.computationDepth--; + this.isComputing = false; + return res; + };; + ComputedValue.prototype.observe = function (listener, fireImmediately) { + var _this = this; + var firstTime = true; + var prevValue = undefined; + return autorun(function () { + var newValue = _this.get(); + if (!firstTime || fireImmediately) { + var prevU = untrackedStart(); + listener({ + type: "update", + object: _this, + newValue: newValue, + oldValue: prevValue + }); + untrackedEnd(prevU); + } + firstTime = false; + prevValue = newValue; + }); + }; + ComputedValue.prototype.toJSON = function () { + return this.get(); + }; + ComputedValue.prototype.toString = function () { + return this.name + "[" + this.derivation.toString() + "]"; + }; + ComputedValue.prototype.valueOf = function () { + return toPrimitive(this.get()); + };; + ComputedValue.prototype.whyRun = function () { + var isTracking = Boolean(globalState.trackingDerivation); + var observing = unique(this.isComputing ? this.newObserving : this.observing).map(function (dep) { + return dep.name; + }); + var observers = unique(getObservers(this).map(function (dep) { + return dep.name; + })); + return "\nWhyRun? computation '" + this.name + "':\n * Running because: " + (isTracking ? "[active] the value of this computation is needed by a reaction" : this.isComputing ? "[get] The value of this computed was requested outside a reaction" : "[idle] not running at the moment") + "\n" + (this.dependenciesState === IDerivationState.NOT_TRACKING ? getMessage("m032") : " * This computation will re-run if any of the following observables changes:\n " + joinStrings(observing) + "\n " + (this.isComputing && isTracking ? " (... or any observable accessed during the remainder of the current run)" : "") + "\n\t" + getMessage("m038") + "\n\n * If the outcome of this computation changes, the following observers will be re-run:\n " + joinStrings(observers) + "\n"); + }; + return ComputedValue; + }(); + ComputedValue.prototype[primitiveSymbol()] = ComputedValue.prototype.valueOf; + var isComputedValue = createInstanceofPredicate("ComputedValue", ComputedValue); + var IDerivationState; + (function (IDerivationState) { + IDerivationState[IDerivationState["NOT_TRACKING"] = -1] = "NOT_TRACKING"; + IDerivationState[IDerivationState["UP_TO_DATE"] = 0] = "UP_TO_DATE"; + IDerivationState[IDerivationState["POSSIBLY_STALE"] = 1] = "POSSIBLY_STALE"; + IDerivationState[IDerivationState["STALE"] = 2] = "STALE"; + })(IDerivationState || (IDerivationState = {})); + exports.IDerivationState = IDerivationState; + var CaughtException = function () { + function CaughtException(cause) { + this.cause = cause; + } + return CaughtException; + }(); + + function isCaughtException(e) { + return e instanceof CaughtException; + } + + function shouldCompute(derivation) { + switch (derivation.dependenciesState) { + case IDerivationState.UP_TO_DATE: + return false; + case IDerivationState.NOT_TRACKING: + case IDerivationState.STALE: + return true; + case IDerivationState.POSSIBLY_STALE: { + var prevUntracked = untrackedStart(); + var obs = derivation.observing, + l = obs.length; + for (var i = 0; i < l; i++) { + var obj = obs[i]; + if (isComputedValue(obj)) { + try { + obj.get(); + } catch (e) { + untrackedEnd(prevUntracked); + return true; + } + if (derivation.dependenciesState === IDerivationState.STALE) { + untrackedEnd(prevUntracked); + return true; + } + } + } + changeDependenciesStateTo0(derivation); + untrackedEnd(prevUntracked); + return false; + } + } + } + + function isComputingDerivation() { + return globalState.trackingDerivation !== null; + } + + function checkIfStateModificationsAreAllowed(atom) { + var hasObservers = atom.observers.length > 0; + if (globalState.computationDepth > 0 && hasObservers) fail(getMessage("m031") + atom.name); + if (!globalState.allowStateChanges && hasObservers) fail(getMessage(globalState.strictMode ? "m030a" : "m030b") + atom.name); + } + + function trackDerivedFunction(derivation, f, context) { + changeDependenciesStateTo0(derivation); + derivation.newObserving = new Array(derivation.observing.length + 100); + derivation.unboundDepsCount = 0; + derivation.runId = ++globalState.runId; + var prevTracking = globalState.trackingDerivation; + globalState.trackingDerivation = derivation; + var result; + try { + result = f.call(context); + } catch (e) { + result = new CaughtException(e); + } + globalState.trackingDerivation = prevTracking; + bindDependencies(derivation); + return result; + } + + function bindDependencies(derivation) { + var prevObserving = derivation.observing; + var observing = derivation.observing = derivation.newObserving; + derivation.newObserving = null; + var i0 = 0, + l = derivation.unboundDepsCount; + for (var i = 0; i < l; i++) { + var dep = observing[i]; + if (dep.diffValue === 0) { + dep.diffValue = 1; + if (i0 !== i) observing[i0] = dep; + i0++; + } + } + observing.length = i0; + l = prevObserving.length; + while (l--) { + var dep = prevObserving[l]; + if (dep.diffValue === 0) { + removeObserver(dep, derivation); + } + dep.diffValue = 0; + } + while (i0--) { + var dep = observing[i0]; + if (dep.diffValue === 1) { + dep.diffValue = 0; + addObserver(dep, derivation); + } + } + } + + function clearObserving(derivation) { + var obs = derivation.observing; + var i = obs.length; + while (i--) { + removeObserver(obs[i], derivation); + } + derivation.dependenciesState = IDerivationState.NOT_TRACKING; + obs.length = 0; + } + + function untracked(action) { + var prev = untrackedStart(); + var res = action(); + untrackedEnd(prev); + return res; + } + exports.untracked = untracked; + + function untrackedStart() { + var prev = globalState.trackingDerivation; + globalState.trackingDerivation = null; + return prev; + } + + function untrackedEnd(prev) { + globalState.trackingDerivation = prev; + } + + function changeDependenciesStateTo0(derivation) { + if (derivation.dependenciesState === IDerivationState.UP_TO_DATE) return; + derivation.dependenciesState = IDerivationState.UP_TO_DATE; + var obs = derivation.observing; + var i = obs.length; + while (i--) { + obs[i].lowestObserverState = IDerivationState.UP_TO_DATE; + } + } + var persistentKeys = ["mobxGuid", "resetId", "spyListeners", "strictMode", "runId"]; + var MobXGlobals = function () { + function MobXGlobals() { + this.version = 5; + this.trackingDerivation = null; + this.computationDepth = 0; + this.runId = 0; + this.mobxGuid = 0; + this.inBatch = 0; + this.pendingUnobservations = []; + this.pendingReactions = []; + this.isRunningReactions = false; + this.allowStateChanges = true; + this.strictMode = false; + this.resetId = 0; + this.spyListeners = []; + this.globalReactionErrorHandlers = []; + } + return MobXGlobals; + }(); + var globalState = new MobXGlobals(); + + function shareGlobalState() { + var global = getGlobal(); + var ownState = globalState; + if (global.__mobservableTrackingStack || global.__mobservableViewStack) throw new Error("[mobx] An incompatible version of mobservable is already loaded."); + if (global.__mobxGlobal && global.__mobxGlobal.version !== ownState.version) throw new Error("[mobx] An incompatible version of mobx is already loaded."); + if (global.__mobxGlobal) globalState = global.__mobxGlobal; + else global.__mobxGlobal = ownState; + } + + function getGlobalState() { + return globalState; + } + + function registerGlobals() {} + + function resetGlobalState() { + globalState.resetId++; + var defaultGlobals = new MobXGlobals(); + for (var key in defaultGlobals) { + if (persistentKeys.indexOf(key) === -1) globalState[key] = defaultGlobals[key]; + } + globalState.allowStateChanges = !globalState.strictMode; + } + + function hasObservers(observable) { + return observable.observers && observable.observers.length > 0; + } + + function getObservers(observable) { + return observable.observers; + } + + function invariantObservers(observable) { + var list = observable.observers; + var map = observable.observersIndexes; + var l = list.length; + for (var i = 0; i < l; i++) { + var id = list[i].__mapid; + if (i) { + invariant(map[id] === i, "INTERNAL ERROR maps derivation.__mapid to index in list"); + } else { + invariant(!(id in map), "INTERNAL ERROR observer on index 0 shouldnt be held in map."); + } + } + invariant(list.length === 0 || Object.keys(map).length === list.length - 1, "INTERNAL ERROR there is no junk in map"); + } + + function addObserver(observable, node) { + var l = observable.observers.length; + if (l) { + observable.observersIndexes[node.__mapid] = l; + } + observable.observers[l] = node; + if (observable.lowestObserverState > node.dependenciesState) observable.lowestObserverState = node.dependenciesState; + } + + function removeObserver(observable, node) { + if (observable.observers.length === 1) { + observable.observers.length = 0; + queueForUnobservation(observable); + } else { + var list = observable.observers; + var map_1 = observable.observersIndexes; + var filler = list.pop(); + if (filler !== node) { + var index = map_1[node.__mapid] || 0; + if (index) { + map_1[filler.__mapid] = index; + } else { + delete map_1[filler.__mapid]; + } + list[index] = filler; + } + delete map_1[node.__mapid]; + } + } + + function queueForUnobservation(observable) { + if (!observable.isPendingUnobservation) { + observable.isPendingUnobservation = true; + globalState.pendingUnobservations.push(observable); + } + } + + function startBatch() { + globalState.inBatch++; + } + + function endBatch() { + if (--globalState.inBatch === 0) { + runReactions(); + var list = globalState.pendingUnobservations; + for (var i = 0; i < list.length; i++) { + var observable_1 = list[i]; + observable_1.isPendingUnobservation = false; + if (observable_1.observers.length === 0) { + observable_1.onBecomeUnobserved(); + } + } + globalState.pendingUnobservations = []; + } + } + + function reportObserved(observable) { + var derivation = globalState.trackingDerivation; + if (derivation !== null) { + if (derivation.runId !== observable.lastAccessedBy) { + observable.lastAccessedBy = derivation.runId; + derivation.newObserving[derivation.unboundDepsCount++] = observable; + } + } else if (observable.observers.length === 0) { + queueForUnobservation(observable); + } + } + + function invariantLOS(observable, msg) { + var min = getObservers(observable).reduce(function (a, b) { + return Math.min(a, b.dependenciesState); + }, 2); + if (min >= observable.lowestObserverState) return; + throw new Error("lowestObserverState is wrong for " + msg + " because " + min + " < " + observable.lowestObserverState); + } + + function propagateChanged(observable) { + if (observable.lowestObserverState === IDerivationState.STALE) return; + observable.lowestObserverState = IDerivationState.STALE; + var observers = observable.observers; + var i = observers.length; + while (i--) { + var d = observers[i]; + if (d.dependenciesState === IDerivationState.UP_TO_DATE) d.onBecomeStale(); + d.dependenciesState = IDerivationState.STALE; + } + } + + function propagateChangeConfirmed(observable) { + if (observable.lowestObserverState === IDerivationState.STALE) return; + observable.lowestObserverState = IDerivationState.STALE; + var observers = observable.observers; + var i = observers.length; + while (i--) { + var d = observers[i]; + if (d.dependenciesState === IDerivationState.POSSIBLY_STALE) d.dependenciesState = IDerivationState.STALE; + else if (d.dependenciesState === IDerivationState.UP_TO_DATE) observable.lowestObserverState = IDerivationState.UP_TO_DATE; + } + } + + function propagateMaybeChanged(observable) { + if (observable.lowestObserverState !== IDerivationState.UP_TO_DATE) return; + observable.lowestObserverState = IDerivationState.POSSIBLY_STALE; + var observers = observable.observers; + var i = observers.length; + while (i--) { + var d = observers[i]; + if (d.dependenciesState === IDerivationState.UP_TO_DATE) { + d.dependenciesState = IDerivationState.POSSIBLY_STALE; + d.onBecomeStale(); + } + } + } + var Reaction = function () { + function Reaction(name, onInvalidate) { + if (name === void 0) { + name = "Reaction@" + getNextId(); + } + this.name = name; + this.onInvalidate = onInvalidate; + this.observing = []; + this.newObserving = []; + this.dependenciesState = IDerivationState.NOT_TRACKING; + this.diffValue = 0; + this.runId = 0; + this.unboundDepsCount = 0; + this.__mapid = "#" + getNextId(); + this.isDisposed = false; + this._isScheduled = false; + this._isTrackPending = false; + this._isRunning = false; + } + Reaction.prototype.onBecomeStale = function () { + this.schedule(); + }; + Reaction.prototype.schedule = function () { + if (!this._isScheduled) { + this._isScheduled = true; + globalState.pendingReactions.push(this); + runReactions(); + } + }; + Reaction.prototype.isScheduled = function () { + return this._isScheduled; + }; + Reaction.prototype.runReaction = function () { + if (!this.isDisposed) { + startBatch(); + this._isScheduled = false; + if (shouldCompute(this)) { + this._isTrackPending = true; + this.onInvalidate(); + if (this._isTrackPending && isSpyEnabled()) { + spyReport({ + object: this, + type: "scheduled-reaction" + }); + } + } + endBatch(); + } + }; + Reaction.prototype.track = function (fn) { + startBatch(); + var notify = isSpyEnabled(); + var startTime; + if (notify) { + startTime = Date.now(); + spyReportStart({ + object: this, + type: "reaction", + fn: fn + }); + } + this._isRunning = true; + var result = trackDerivedFunction(this, fn, undefined); + this._isRunning = false; + this._isTrackPending = false; + if (this.isDisposed) { + clearObserving(this); + } + if (isCaughtException(result)) this.reportExceptionInDerivation(result.cause); + if (notify) { + spyReportEnd({ + time: Date.now() - startTime + }); + } + endBatch(); + }; + Reaction.prototype.reportExceptionInDerivation = function (error) { + var _this = this; + if (this.errorHandler) { + this.errorHandler(error, this); + return; + } + var message = "[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '" + this; + var messageToUser = getMessage("m037"); + console.error(message || messageToUser, error); + if (isSpyEnabled()) { + spyReport({ + type: "error", + message: message, + error: error, + object: this + }); + } + globalState.globalReactionErrorHandlers.forEach(function (f) { + return f(error, _this); + }); + }; + Reaction.prototype.dispose = function () { + if (!this.isDisposed) { + this.isDisposed = true; + if (!this._isRunning) { + startBatch(); + clearObserving(this); + endBatch(); + } + } + }; + Reaction.prototype.getDisposer = function () { + var r = this.dispose.bind(this); + r.$mobx = this; + r.onError = registerErrorHandler; + return r; + }; + Reaction.prototype.toString = function () { + return "Reaction[" + this.name + "]"; + }; + Reaction.prototype.whyRun = function () { + var observing = unique(this._isRunning ? this.newObserving : this.observing).map(function (dep) { + return dep.name; + }); + return "\nWhyRun? reaction '" + this.name + "':\n * Status: [" + (this.isDisposed ? "stopped" : this._isRunning ? "running" : this.isScheduled() ? "scheduled" : "idle") + "]\n * This reaction will re-run if any of the following observables changes:\n " + joinStrings(observing) + "\n " + (this._isRunning ? " (... or any observable accessed during the remainder of the current run)" : "") + "\n\t" + getMessage("m038") + "\n"; + }; + return Reaction; + }(); + exports.Reaction = Reaction; + + function registerErrorHandler(handler) { + invariant(this && this.$mobx && isReaction(this.$mobx), "Invalid `this`"); + invariant(!this.$mobx.errorHandler, "Only one onErrorHandler can be registered"); + this.$mobx.errorHandler = handler; + } + + function onReactionError(handler) { + globalState.globalReactionErrorHandlers.push(handler); + return function () { + var idx = globalState.globalReactionErrorHandlers.indexOf(handler); + if (idx >= 0) globalState.globalReactionErrorHandlers.splice(idx, 1); + }; + } + var MAX_REACTION_ITERATIONS = 100; + var reactionScheduler = function reactionScheduler(f) { + return f(); + }; + + function runReactions() { + if (globalState.inBatch > 0 || globalState.isRunningReactions) return; + reactionScheduler(runReactionsHelper); + } + + function runReactionsHelper() { + globalState.isRunningReactions = true; + var allReactions = globalState.pendingReactions; + var iterations = 0; + while (allReactions.length > 0) { + if (++iterations === MAX_REACTION_ITERATIONS) { + console.error("Reaction doesn't converge to a stable state after " + MAX_REACTION_ITERATIONS + " iterations." + (" Probably there is a cycle in the reactive function: " + allReactions[0])); + allReactions.splice(0); + } + var remainingReactions = allReactions.splice(0); + for (var i = 0, l = remainingReactions.length; i < l; i++) { + remainingReactions[i].runReaction(); + } + } + globalState.isRunningReactions = false; + } + var isReaction = createInstanceofPredicate("Reaction", Reaction); + + function setReactionScheduler(fn) { + var baseScheduler = reactionScheduler; + reactionScheduler = function reactionScheduler(f) { + return fn(function () { + return baseScheduler(f); + }); + }; + } + + function isSpyEnabled() { + return !!globalState.spyListeners.length; + } + + function spyReport(event) { + if (!globalState.spyListeners.length) return; + var listeners = globalState.spyListeners; + for (var i = 0, l = listeners.length; i < l; i++) { + listeners[i](event); + } + } + + function spyReportStart(event) { + var change = objectAssign({}, event, { + spyReportStart: true + }); + spyReport(change); + } + var END_EVENT = { + spyReportEnd: true + }; + + function spyReportEnd(change) { + if (change) spyReport(objectAssign({}, change, END_EVENT)); + else spyReport(END_EVENT); + } + + function spy(listener) { + globalState.spyListeners.push(listener); + return once(function () { + var idx = globalState.spyListeners.indexOf(listener); + if (idx !== -1) globalState.spyListeners.splice(idx, 1); + }); + } + exports.spy = spy; + + function hasInterceptors(interceptable) { + return interceptable.interceptors && interceptable.interceptors.length > 0; + } + + function registerInterceptor(interceptable, handler) { + var interceptors = interceptable.interceptors || (interceptable.interceptors = []); + interceptors.push(handler); + return once(function () { + var idx = interceptors.indexOf(handler); + if (idx !== -1) interceptors.splice(idx, 1); + }); + } + + function interceptChange(interceptable, change) { + var prevU = untrackedStart(); + try { + var interceptors = interceptable.interceptors; + if (interceptors) + for (var i = 0, l = interceptors.length; i < l; i++) { + change = interceptors[i](change); + invariant(!change || change.type, "Intercept handlers should return nothing or a change object"); + if (!change) break; + } + return change; + } finally { + untrackedEnd(prevU); + } + } + + function hasListeners(listenable) { + return listenable.changeListeners && listenable.changeListeners.length > 0; + } + + function registerListener(listenable, handler) { + var listeners = listenable.changeListeners || (listenable.changeListeners = []); + listeners.push(handler); + return once(function () { + var idx = listeners.indexOf(handler); + if (idx !== -1) listeners.splice(idx, 1); + }); + } + + function notifyListeners(listenable, change) { + var prevU = untrackedStart(); + var listeners = listenable.changeListeners; + if (!listeners) return; + listeners = listeners.slice(); + for (var i = 0, l = listeners.length; i < l; i++) { + listeners[i](change); + } + untrackedEnd(prevU); + } + + function asReference(value) { + deprecated("asReference is deprecated, use observable.ref instead"); + return observable.ref(value); + } + exports.asReference = asReference; + + function asStructure(value) { + deprecated("asStructure is deprecated. Use observable.struct, computed.struct or reaction options instead."); + return observable.struct(value); + } + exports.asStructure = asStructure; + + function asFlat(value) { + deprecated("asFlat is deprecated, use observable.shallow instead"); + return observable.shallow(value); + } + exports.asFlat = asFlat; + + function asMap(data) { + deprecated("asMap is deprecated, use observable.map or observable.shallowMap instead"); + return observable.map(data || {}); + } + exports.asMap = asMap; + + function isModifierDescriptor(thing) { + return (typeof thing === "undefined" ? "undefined" : _typeof(thing)) === "object" && thing !== null && thing.isMobxModifierDescriptor === true; + } + exports.isModifierDescriptor = isModifierDescriptor; + + function createModifierDescriptor(enhancer, initialValue) { + invariant(!isModifierDescriptor(initialValue), "Modifiers cannot be nested"); + return { + isMobxModifierDescriptor: true, + initialValue: initialValue, + enhancer: enhancer + }; + } + + function deepEnhancer(v, _, name) { + if (isModifierDescriptor(v)) fail("You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it"); + if (isObservable(v)) return v; + if (Array.isArray(v)) return observable.array(v, name); + if (isPlainObject(v)) return observable.object(v, name); + if (isES6Map(v)) return observable.map(v, name); + return v; + } + + function shallowEnhancer(v, _, name) { + if (isModifierDescriptor(v)) fail("You tried to assign a modifier wrapped value to a collection, please define modifiers when creating the collection, not when modifying it"); + if (v === undefined || v === null) return v; + if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v)) return v; + if (Array.isArray(v)) return observable.shallowArray(v, name); + if (isPlainObject(v)) return observable.shallowObject(v, name); + if (isES6Map(v)) return observable.shallowMap(v, name); + return fail("The shallow modifier / decorator can only used in combination with arrays, objects and maps"); + } + + function referenceEnhancer(newValue) { + return newValue; + } + + function deepStructEnhancer(v, oldValue, name) { + if (deepEqual(v, oldValue)) return oldValue; + if (isObservable(v)) return v; + if (Array.isArray(v)) return new ObservableArray(v, deepStructEnhancer, name); + if (isES6Map(v)) return new ObservableMap(v, deepStructEnhancer, name); + if (isPlainObject(v)) { + var res = {}; + asObservableObject(res, name); + extendObservableHelper(res, deepStructEnhancer, [v]); + return res; + } + return v; + } + + function refStructEnhancer(v, oldValue, name) { + if (deepEqual(v, oldValue)) return oldValue; + return v; + } + var MAX_SPLICE_SIZE = 10000; + var safariPrototypeSetterInheritanceBug = function () { + var v = false; + var p = {}; + Object.defineProperty(p, "0", { + set: function set() { + v = true; + } + }); + Object.create(p)["0"] = 1; + return v === false; + }(); + var OBSERVABLE_ARRAY_BUFFER_SIZE = 0; + var StubArray = function () { + function StubArray() {} + return StubArray; + }(); + StubArray.prototype = []; + var ObservableArrayAdministration = function () { + function ObservableArrayAdministration(name, enhancer, array, owned) { + this.array = array; + this.owned = owned; + this.lastKnownLength = 0; + this.interceptors = null; + this.changeListeners = null; + this.atom = new BaseAtom(name || "ObservableArray@" + getNextId()); + this.enhancer = function (newV, oldV) { + return enhancer(newV, oldV, name + "[..]"); + }; + } + ObservableArrayAdministration.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + ObservableArrayAdministration.prototype.observe = function (listener, fireImmediately) { + if (fireImmediately === void 0) { + fireImmediately = false; + } + if (fireImmediately) { + listener({ + object: this.array, + type: "splice", + index: 0, + added: this.values.slice(), + addedCount: this.values.length, + removed: [], + removedCount: 0 + }); + } + return registerListener(this, listener); + }; + ObservableArrayAdministration.prototype.getArrayLength = function () { + this.atom.reportObserved(); + return this.values.length; + }; + ObservableArrayAdministration.prototype.setArrayLength = function (newLength) { + if (typeof newLength !== "number" || newLength < 0) throw new Error("[mobx.array] Out of range: " + newLength); + var currentLength = this.values.length; + if (newLength === currentLength) return; + else if (newLength > currentLength) { + var newItems = new Array(newLength - currentLength); + for (var i = 0; i < newLength - currentLength; i++) { + newItems[i] = undefined; + } + this.spliceWithArray(currentLength, 0, newItems); + } else this.spliceWithArray(newLength, currentLength - newLength); + }; + ObservableArrayAdministration.prototype.updateArrayLength = function (oldLength, delta) { + if (oldLength !== this.lastKnownLength) throw new Error("[mobx] Modification exception: the internal structure of an observable array was changed. Did you use peek() to change it?"); + this.lastKnownLength += delta; + if (delta > 0 && oldLength + delta + 1 > OBSERVABLE_ARRAY_BUFFER_SIZE) reserveArrayBuffer(oldLength + delta + 1); + }; + ObservableArrayAdministration.prototype.spliceWithArray = function (index, deleteCount, newItems) { + var _this = this; + checkIfStateModificationsAreAllowed(this.atom); + var length = this.values.length; + if (index === undefined) index = 0; + else if (index > length) index = length; + else if (index < 0) index = Math.max(0, length + index); + if (arguments.length === 1) deleteCount = length - index; + else if (deleteCount === undefined || deleteCount === null) deleteCount = 0; + else deleteCount = Math.max(0, Math.min(deleteCount, length - index)); + if (newItems === undefined) newItems = []; + if (hasInterceptors(this)) { + var change = interceptChange(this, { + object: this.array, + type: "splice", + index: index, + removedCount: deleteCount, + added: newItems + }); + if (!change) return EMPTY_ARRAY; + deleteCount = change.removedCount; + newItems = change.added; + } + newItems = newItems.map(function (v) { + return _this.enhancer(v, undefined); + }); + var lengthDelta = newItems.length - deleteCount; + this.updateArrayLength(length, lengthDelta); + var res = this.spliceItemsIntoValues(index, deleteCount, newItems); + if (deleteCount !== 0 || newItems.length !== 0) this.notifyArraySplice(index, newItems, res); + return res; + }; + ObservableArrayAdministration.prototype.spliceItemsIntoValues = function (index, deleteCount, newItems) { + if (newItems.length < MAX_SPLICE_SIZE) { + return (_a = this.values).splice.apply(_a, [index, deleteCount].concat(newItems)); + } else { + var res = this.values.slice(index, index + deleteCount); + this.values = this.values.slice(0, index).concat(newItems, this.values.slice(index + deleteCount)); + return res; + } + var _a; + }; + ObservableArrayAdministration.prototype.notifyArrayChildUpdate = function (index, newValue, oldValue) { + var notifySpy = !this.owned && isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + object: this.array, + type: "update", + index: index, + newValue: newValue, + oldValue: oldValue + } : null; + if (notifySpy) spyReportStart(change); + this.atom.reportChanged(); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + }; + ObservableArrayAdministration.prototype.notifyArraySplice = function (index, added, removed) { + var notifySpy = !this.owned && isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + object: this.array, + type: "splice", + index: index, + removed: removed, + added: added, + removedCount: removed.length, + addedCount: added.length + } : null; + if (notifySpy) spyReportStart(change); + this.atom.reportChanged(); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + }; + return ObservableArrayAdministration; + }(); + var ObservableArray = function (_super) { + __extends(ObservableArray, _super); + + function ObservableArray(initialValues, enhancer, name, owned) { + if (name === void 0) { + name = "ObservableArray@" + getNextId(); + } + if (owned === void 0) { + owned = false; + } + var _this = _super.call(this) || this; + var adm = new ObservableArrayAdministration(name, enhancer, _this, owned); + addHiddenFinalProp(_this, "$mobx", adm); + if (initialValues && initialValues.length) { + adm.updateArrayLength(0, initialValues.length); + adm.values = initialValues.map(function (v) { + return enhancer(v, undefined, name + "[..]"); + }); + adm.notifyArraySplice(0, adm.values.slice(), EMPTY_ARRAY); + } else { + adm.values = []; + } + if (safariPrototypeSetterInheritanceBug) { + Object.defineProperty(adm.array, "0", ENTRY_0); + } + return _this; + } + ObservableArray.prototype.intercept = function (handler) { + return this.$mobx.intercept(handler); + }; + ObservableArray.prototype.observe = function (listener, fireImmediately) { + if (fireImmediately === void 0) { + fireImmediately = false; + } + return this.$mobx.observe(listener, fireImmediately); + }; + ObservableArray.prototype.clear = function () { + return this.splice(0); + }; + ObservableArray.prototype.concat = function () { + var arrays = []; + for (var _i = 0; _i < arguments.length; _i++) { + arrays[_i] = arguments[_i]; + } + this.$mobx.atom.reportObserved(); + return Array.prototype.concat.apply(this.peek(), arrays.map(function (a) { + return isObservableArray(a) ? a.peek() : a; + })); + }; + ObservableArray.prototype.replace = function (newItems) { + return this.$mobx.spliceWithArray(0, this.$mobx.values.length, newItems); + }; + ObservableArray.prototype.toJS = function () { + return this.slice(); + }; + ObservableArray.prototype.toJSON = function () { + return this.toJS(); + }; + ObservableArray.prototype.peek = function () { + return this.$mobx.values; + }; + ObservableArray.prototype.find = function (predicate, thisArg, fromIndex) { + if (fromIndex === void 0) { + fromIndex = 0; + } + this.$mobx.atom.reportObserved(); + var items = this.$mobx.values, + l = items.length; + for (var i = fromIndex; i < l; i++) { + if (predicate.call(thisArg, items[i], i, this)) return items[i]; + } + return undefined; + }; + ObservableArray.prototype.splice = function (index, deleteCount) { + var newItems = []; + for (var _i = 2; _i < arguments.length; _i++) { + newItems[_i - 2] = arguments[_i]; + } + switch (arguments.length) { + case 0: + return []; + case 1: + return this.$mobx.spliceWithArray(index); + case 2: + return this.$mobx.spliceWithArray(index, deleteCount); + } + return this.$mobx.spliceWithArray(index, deleteCount, newItems); + }; + ObservableArray.prototype.spliceWithArray = function (index, deleteCount, newItems) { + return this.$mobx.spliceWithArray(index, deleteCount, newItems); + }; + ObservableArray.prototype.push = function () { + var items = []; + for (var _i = 0; _i < arguments.length; _i++) { + items[_i] = arguments[_i]; + } + var adm = this.$mobx; + adm.spliceWithArray(adm.values.length, 0, items); + return adm.values.length; + }; + ObservableArray.prototype.pop = function () { + return this.splice(Math.max(this.$mobx.values.length - 1, 0), 1)[0]; + }; + ObservableArray.prototype.shift = function () { + return this.splice(0, 1)[0]; + }; + ObservableArray.prototype.unshift = function () { + var items = []; + for (var _i = 0; _i < arguments.length; _i++) { + items[_i] = arguments[_i]; + } + var adm = this.$mobx; + adm.spliceWithArray(0, 0, items); + return adm.values.length; + }; + ObservableArray.prototype.reverse = function () { + this.$mobx.atom.reportObserved(); + var clone = this.slice(); + return clone.reverse.apply(clone, arguments); + }; + ObservableArray.prototype.sort = function (compareFn) { + this.$mobx.atom.reportObserved(); + var clone = this.slice(); + return clone.sort.apply(clone, arguments); + }; + ObservableArray.prototype.remove = function (value) { + var idx = this.$mobx.values.indexOf(value); + if (idx > -1) { + this.splice(idx, 1); + return true; + } + return false; + }; + ObservableArray.prototype.move = function (fromIndex, toIndex) { + function checkIndex(index) { + if (index < 0) { + throw new Error("[mobx.array] Index out of bounds: " + index + " is negative"); + } + var length = this.$mobx.values.length; + if (index >= length) { + throw new Error("[mobx.array] Index out of bounds: " + index + " is not smaller than " + length); + } + } + checkIndex.call(this, fromIndex); + checkIndex.call(this, toIndex); + if (fromIndex === toIndex) { + return; + } + var oldItems = this.$mobx.values; + var newItems; + if (fromIndex < toIndex) { + newItems = oldItems.slice(0, fromIndex).concat(oldItems.slice(fromIndex + 1, toIndex + 1), [oldItems[fromIndex]], oldItems.slice(toIndex + 1)); + } else { + newItems = oldItems.slice(0, toIndex).concat([oldItems[fromIndex]], oldItems.slice(toIndex, fromIndex), oldItems.slice(fromIndex + 1)); + } + this.replace(newItems); + }; + ObservableArray.prototype.toString = function () { + this.$mobx.atom.reportObserved(); + return Array.prototype.toString.apply(this.$mobx.values, arguments); + }; + ObservableArray.prototype.toLocaleString = function () { + this.$mobx.atom.reportObserved(); + return Array.prototype.toLocaleString.apply(this.$mobx.values, arguments); + }; + return ObservableArray; + }(StubArray); + declareIterator(ObservableArray.prototype, function () { + return arrayAsIterator(this.slice()); + }); + makeNonEnumerable(ObservableArray.prototype, ["constructor", "intercept", "observe", "clear", "concat", "replace", "toJS", "toJSON", "peek", "find", "splice", "spliceWithArray", "push", "pop", "shift", "unshift", "reverse", "sort", "remove", "move", "toString", "toLocaleString"]); + Object.defineProperty(ObservableArray.prototype, "length", { + enumerable: false, + configurable: true, + get: function get() { + return this.$mobx.getArrayLength(); + }, + set: function set(newLength) { + this.$mobx.setArrayLength(newLength); + } + }); + ["every", "filter", "forEach", "indexOf", "join", "lastIndexOf", "map", "reduce", "reduceRight", "slice", "some"].forEach(function (funcName) { + var baseFunc = Array.prototype[funcName]; + invariant(typeof baseFunc === "function", "Base function not defined on Array prototype: '" + funcName + "'"); + addHiddenProp(ObservableArray.prototype, funcName, function () { + this.$mobx.atom.reportObserved(); + return baseFunc.apply(this.$mobx.values, arguments); + }); + }); + var ENTRY_0 = { + configurable: true, + enumerable: false, + set: createArraySetter(0), + get: createArrayGetter(0) + }; + + function createArrayBufferItem(index) { + var set = createArraySetter(index); + var get = createArrayGetter(index); + Object.defineProperty(ObservableArray.prototype, "" + index, { + enumerable: false, + configurable: true, + set: set, + get: get + }); + } + + function createArraySetter(index) { + return function (newValue) { + var adm = this.$mobx; + var values = adm.values; + if (index < values.length) { + checkIfStateModificationsAreAllowed(adm.atom); + var oldValue = values[index]; + if (hasInterceptors(adm)) { + var change = interceptChange(adm, { + type: "update", + object: adm.array, + index: index, + newValue: newValue + }); + if (!change) return; + newValue = change.newValue; + } + newValue = adm.enhancer(newValue, oldValue); + var changed = newValue !== oldValue; + if (changed) { + values[index] = newValue; + adm.notifyArrayChildUpdate(index, newValue, oldValue); + } + } else if (index === values.length) { + adm.spliceWithArray(index, 0, [newValue]); + } else throw new Error("[mobx.array] Index out of bounds, " + index + " is larger than " + values.length); + }; + } + + function createArrayGetter(index) { + return function () { + var impl = this.$mobx; + if (impl) { + if (index < impl.values.length) { + impl.atom.reportObserved(); + return impl.values[index]; + } + console.warn("[mobx.array] Attempt to read an array index (" + index + ") that is out of bounds (" + impl.values.length + "). Please check length first. Out of bound indices will not be tracked by MobX"); + } + return undefined; + }; + } + + function reserveArrayBuffer(max) { + for (var index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max; index++) { + createArrayBufferItem(index); + } + OBSERVABLE_ARRAY_BUFFER_SIZE = max; + } + reserveArrayBuffer(1000); + var isObservableArrayAdministration = createInstanceofPredicate("ObservableArrayAdministration", ObservableArrayAdministration); + + function isObservableArray(thing) { + return isObject(thing) && isObservableArrayAdministration(thing.$mobx); + } + exports.isObservableArray = isObservableArray; + var ObservableMapMarker = {}; + var ObservableMap = function () { + function ObservableMap(initialData, enhancer, name) { + if (enhancer === void 0) { + enhancer = deepEnhancer; + } + if (name === void 0) { + name = "ObservableMap@" + getNextId(); + } + this.enhancer = enhancer; + this.name = name; + this.$mobx = ObservableMapMarker; + this._data = {}; + this._hasMap = {}; + this._keys = new ObservableArray(undefined, referenceEnhancer, this.name + ".keys()", true); + this.interceptors = null; + this.changeListeners = null; + this.merge(initialData); + } + ObservableMap.prototype._has = function (key) { + return typeof this._data[key] !== "undefined"; + }; + ObservableMap.prototype.has = function (key) { + if (!this.isValidKey(key)) return false; + key = "" + key; + if (this._hasMap[key]) return this._hasMap[key].get(); + return this._updateHasMapEntry(key, false).get(); + }; + ObservableMap.prototype.set = function (key, value) { + this.assertValidKey(key); + key = "" + key; + var hasKey = this._has(key); + if (hasInterceptors(this)) { + var change = interceptChange(this, { + type: hasKey ? "update" : "add", + object: this, + newValue: value, + name: key + }); + if (!change) return this; + value = change.newValue; + } + if (hasKey) { + this._updateValue(key, value); + } else { + this._addValue(key, value); + } + return this; + }; + ObservableMap.prototype.delete = function (key) { + var _this = this; + this.assertValidKey(key); + key = "" + key; + if (hasInterceptors(this)) { + var change = interceptChange(this, { + type: "delete", + object: this, + name: key + }); + if (!change) return false; + } + if (this._has(key)) { + var notifySpy = isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + type: "delete", + object: this, + oldValue: this._data[key].value, + name: key + } : null; + if (notifySpy) spyReportStart(change); + runInTransaction(function () { + _this._keys.remove(key); + _this._updateHasMapEntry(key, false); + var observable = _this._data[key]; + observable.setNewValue(undefined); + _this._data[key] = undefined; + }); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + return true; + } + return false; + }; + ObservableMap.prototype._updateHasMapEntry = function (key, value) { + var entry = this._hasMap[key]; + if (entry) { + entry.setNewValue(value); + } else { + entry = this._hasMap[key] = new ObservableValue(value, referenceEnhancer, this.name + "." + key + "?", false); + } + return entry; + }; + ObservableMap.prototype._updateValue = function (name, newValue) { + var observable = this._data[name]; + newValue = observable.prepareNewValue(newValue); + if (newValue !== UNCHANGED) { + var notifySpy = isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + type: "update", + object: this, + oldValue: observable.value, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + observable.setNewValue(newValue); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + } + }; + ObservableMap.prototype._addValue = function (name, newValue) { + var _this = this; + runInTransaction(function () { + var observable = _this._data[name] = new ObservableValue(newValue, _this.enhancer, _this.name + "." + name, false); + newValue = observable.value; + _this._updateHasMapEntry(name, true); + _this._keys.push(name); + }); + var notifySpy = isSpyEnabled(); + var notify = hasListeners(this); + var change = notify || notifySpy ? { + type: "add", + object: this, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + if (notify) notifyListeners(this, change); + if (notifySpy) spyReportEnd(); + }; + ObservableMap.prototype.get = function (key) { + key = "" + key; + if (this.has(key)) return this._data[key].get(); + return undefined; + }; + ObservableMap.prototype.keys = function () { + return arrayAsIterator(this._keys.slice()); + }; + ObservableMap.prototype.values = function () { + return arrayAsIterator(this._keys.map(this.get, this)); + }; + ObservableMap.prototype.entries = function () { + var _this = this; + return arrayAsIterator(this._keys.map(function (key) { + return [key, _this.get(key)]; + })); + }; + ObservableMap.prototype.forEach = function (callback, thisArg) { + var _this = this; + this.keys().forEach(function (key) { + return callback.call(thisArg, _this.get(key), key, _this); + }); + }; + ObservableMap.prototype.merge = function (other) { + var _this = this; + if (isObservableMap(other)) { + other = other.toJS(); + } + runInTransaction(function () { + if (isPlainObject(other)) Object.keys(other).forEach(function (key) { + return _this.set(key, other[key]); + }); + else if (Array.isArray(other)) other.forEach(function (_a) { + var key = _a[0], + value = _a[1]; + return _this.set(key, value); + }); + else if (isES6Map(other)) other.forEach(function (value, key) { + return _this.set(key, value); + }); + else if (other !== null && other !== undefined) fail("Cannot initialize map from " + other); + }); + return this; + }; + ObservableMap.prototype.clear = function () { + var _this = this; + runInTransaction(function () { + untracked(function () { + _this.keys().forEach(_this.delete, _this); + }); + }); + }; + ObservableMap.prototype.replace = function (values) { + var _this = this; + runInTransaction(function () { + _this.clear(); + _this.merge(values); + }); + return this; + }; + Object.defineProperty(ObservableMap.prototype, "size", { + get: function get() { + return this._keys.length; + }, + enumerable: true, + configurable: true + }); + ObservableMap.prototype.toJS = function () { + var _this = this; + var res = {}; + this.keys().forEach(function (key) { + return res[key] = _this.get(key); + }); + return res; + }; + ObservableMap.prototype.toJSON = function () { + return this.toJS(); + }; + ObservableMap.prototype.isValidKey = function (key) { + if (key === null || key === undefined) return false; + if (typeof key === "string" || typeof key === "number" || typeof key === "boolean") return true; + return false; + }; + ObservableMap.prototype.assertValidKey = function (key) { + if (!this.isValidKey(key)) throw new Error("[mobx.map] Invalid key: '" + key + "', only strings, numbers and booleans are accepted as key in observable maps."); + }; + ObservableMap.prototype.toString = function () { + var _this = this; + return this.name + "[{ " + this.keys().map(function (key) { + return key + ": " + ("" + _this.get(key)); + }).join(", ") + " }]"; + }; + ObservableMap.prototype.observe = function (listener, fireImmediately) { + invariant(fireImmediately !== true, getMessage("m033")); + return registerListener(this, listener); + }; + ObservableMap.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + return ObservableMap; + }(); + exports.ObservableMap = ObservableMap; + declareIterator(ObservableMap.prototype, function () { + return this.entries(); + }); + + function map(initialValues) { + deprecated("`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead"); + return observable.map(initialValues); + } + exports.map = map; + var isObservableMap = createInstanceofPredicate("ObservableMap", ObservableMap); + exports.isObservableMap = isObservableMap; + var ObservableObjectAdministration = function () { + function ObservableObjectAdministration(target, name) { + this.target = target; + this.name = name; + this.values = {}; + this.changeListeners = null; + this.interceptors = null; + } + ObservableObjectAdministration.prototype.observe = function (callback, fireImmediately) { + invariant(fireImmediately !== true, "`observe` doesn't support the fire immediately property for observable objects."); + return registerListener(this, callback); + }; + ObservableObjectAdministration.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + return ObservableObjectAdministration; + }(); + + function asObservableObject(target, name) { + if (isObservableObject(target)) return target.$mobx; + invariant(Object.isExtensible(target), getMessage("m035")); + if (!isPlainObject(target)) name = (target.constructor.name || "ObservableObject") + "@" + getNextId(); + if (!name) name = "ObservableObject@" + getNextId(); + var adm = new ObservableObjectAdministration(target, name); + addHiddenFinalProp(target, "$mobx", adm); + return adm; + } + + function defineObservablePropertyFromDescriptor(adm, propName, descriptor, defaultEnhancer) { + if (adm.values[propName]) { + invariant("value" in descriptor, "The property " + propName + " in " + adm.name + " is already observable, cannot redefine it as computed property"); + adm.target[propName] = descriptor.value; + return; + } + if ("value" in descriptor) { + if (isModifierDescriptor(descriptor.value)) { + var modifierDescriptor = descriptor.value; + defineObservableProperty(adm, propName, modifierDescriptor.initialValue, modifierDescriptor.enhancer); + } else if (isAction(descriptor.value) && descriptor.value.autoBind === true) { + defineBoundAction(adm.target, propName, descriptor.value.originalFn); + } else if (isComputedValue(descriptor.value)) { + defineComputedPropertyFromComputedValue(adm, propName, descriptor.value); + } else { + defineObservableProperty(adm, propName, descriptor.value, defaultEnhancer); + } + } else { + defineComputedProperty(adm, propName, descriptor.get, descriptor.set, false, true); + } + } + + function defineObservableProperty(adm, propName, newValue, enhancer) { + assertPropertyConfigurable(adm.target, propName); + if (hasInterceptors(adm)) { + var change = interceptChange(adm, { + object: adm.target, + name: propName, + type: "add", + newValue: newValue + }); + if (!change) return; + newValue = change.newValue; + } + var observable = adm.values[propName] = new ObservableValue(newValue, enhancer, adm.name + "." + propName, false); + newValue = observable.value; + Object.defineProperty(adm.target, propName, generateObservablePropConfig(propName)); + notifyPropertyAddition(adm, adm.target, propName, newValue); + } + + function defineComputedProperty(adm, propName, getter, setter, compareStructural, asInstanceProperty) { + if (asInstanceProperty) assertPropertyConfigurable(adm.target, propName); + adm.values[propName] = new ComputedValue(getter, adm.target, compareStructural, adm.name + "." + propName, setter); + if (asInstanceProperty) { + Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName)); + } + } + + function defineComputedPropertyFromComputedValue(adm, propName, computedValue) { + var name = adm.name + "." + propName; + computedValue.name = name; + if (!computedValue.scope) computedValue.scope = adm.target; + adm.values[propName] = computedValue; + Object.defineProperty(adm.target, propName, generateComputedPropConfig(propName)); + } + var observablePropertyConfigs = {}; + var computedPropertyConfigs = {}; + + function generateObservablePropConfig(propName) { + return observablePropertyConfigs[propName] || (observablePropertyConfigs[propName] = { + configurable: true, + enumerable: true, + get: function get() { + return this.$mobx.values[propName].get(); + }, + set: function set(v) { + setPropertyValue(this, propName, v); + } + }); + } + + function generateComputedPropConfig(propName) { + return computedPropertyConfigs[propName] || (computedPropertyConfigs[propName] = { + configurable: true, + enumerable: false, + get: function get() { + return this.$mobx.values[propName].get(); + }, + set: function set(v) { + return this.$mobx.values[propName].set(v); + } + }); + } + + function setPropertyValue(instance, name, newValue) { + var adm = instance.$mobx; + var observable = adm.values[name]; + if (hasInterceptors(adm)) { + var change = interceptChange(adm, { + type: "update", + object: instance, + name: name, + newValue: newValue + }); + if (!change) return; + newValue = change.newValue; + } + newValue = observable.prepareNewValue(newValue); + if (newValue !== UNCHANGED) { + var notify = hasListeners(adm); + var notifySpy = isSpyEnabled(); + var change = notify || notifySpy ? { + type: "update", + object: instance, + oldValue: observable.value, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + observable.setNewValue(newValue); + if (notify) notifyListeners(adm, change); + if (notifySpy) spyReportEnd(); + } + } + + function notifyPropertyAddition(adm, object, name, newValue) { + var notify = hasListeners(adm); + var notifySpy = isSpyEnabled(); + var change = notify || notifySpy ? { + type: "add", + object: object, + name: name, + newValue: newValue + } : null; + if (notifySpy) spyReportStart(change); + if (notify) notifyListeners(adm, change); + if (notifySpy) spyReportEnd(); + } + var isObservableObjectAdministration = createInstanceofPredicate("ObservableObjectAdministration", ObservableObjectAdministration); + + function isObservableObject(thing) { + if (isObject(thing)) { + runLazyInitializers(thing); + return isObservableObjectAdministration(thing.$mobx); + } + return false; + } + exports.isObservableObject = isObservableObject; + var UNCHANGED = {}; + var ObservableValue = function (_super) { + __extends(ObservableValue, _super); + + function ObservableValue(value, enhancer, name, notifySpy) { + if (name === void 0) { + name = "ObservableValue@" + getNextId(); + } + if (notifySpy === void 0) { + notifySpy = true; + } + var _this = _super.call(this, name) || this; + _this.enhancer = enhancer; + _this.hasUnreportedChange = false; + _this.value = enhancer(value, undefined, name); + if (notifySpy && isSpyEnabled()) { + spyReport({ + type: "create", + object: _this, + newValue: _this.value + }); + } + return _this; + } + ObservableValue.prototype.set = function (newValue) { + var oldValue = this.value; + newValue = this.prepareNewValue(newValue); + if (newValue !== UNCHANGED) { + var notifySpy = isSpyEnabled(); + if (notifySpy) { + spyReportStart({ + type: "update", + object: this, + newValue: newValue, + oldValue: oldValue + }); + } + this.setNewValue(newValue); + if (notifySpy) spyReportEnd(); + } + }; + ObservableValue.prototype.prepareNewValue = function (newValue) { + checkIfStateModificationsAreAllowed(this); + if (hasInterceptors(this)) { + var change = interceptChange(this, { + object: this, + type: "update", + newValue: newValue + }); + if (!change) return UNCHANGED; + newValue = change.newValue; + } + newValue = this.enhancer(newValue, this.value, this.name); + return this.value !== newValue ? newValue : UNCHANGED; + }; + ObservableValue.prototype.setNewValue = function (newValue) { + var oldValue = this.value; + this.value = newValue; + this.reportChanged(); + if (hasListeners(this)) { + notifyListeners(this, { + type: "update", + object: this, + newValue: newValue, + oldValue: oldValue + }); + } + }; + ObservableValue.prototype.get = function () { + this.reportObserved(); + return this.value; + }; + ObservableValue.prototype.intercept = function (handler) { + return registerInterceptor(this, handler); + }; + ObservableValue.prototype.observe = function (listener, fireImmediately) { + if (fireImmediately) listener({ + object: this, + type: "update", + newValue: this.value, + oldValue: undefined + }); + return registerListener(this, listener); + }; + ObservableValue.prototype.toJSON = function () { + return this.get(); + }; + ObservableValue.prototype.toString = function () { + return this.name + "[" + this.value + "]"; + }; + ObservableValue.prototype.valueOf = function () { + return toPrimitive(this.get()); + }; + return ObservableValue; + }(BaseAtom); + ObservableValue.prototype[primitiveSymbol()] = ObservableValue.prototype.valueOf; + var isObservableValue = createInstanceofPredicate("ObservableValue", ObservableValue); + exports.isBoxedObservable = isObservableValue; + + function getAtom(thing, property) { + if ((typeof thing === "undefined" ? "undefined" : _typeof(thing)) === "object" && thing !== null) { + if (isObservableArray(thing)) { + invariant(property === undefined, getMessage("m036")); + return thing.$mobx.atom; + } + if (isObservableMap(thing)) { + var anyThing = thing; + if (property === undefined) return getAtom(anyThing._keys); + var observable_2 = anyThing._data[property] || anyThing._hasMap[property]; + invariant(!!observable_2, "the entry '" + property + "' does not exist in the observable map '" + getDebugName(thing) + "'"); + return observable_2; + } + runLazyInitializers(thing); + if (isObservableObject(thing)) { + if (!property) return fail("please specify a property"); + var observable_3 = thing.$mobx.values[property]; + invariant(!!observable_3, "no observable property '" + property + "' found on the observable object '" + getDebugName(thing) + "'"); + return observable_3; + } + if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) { + return thing; + } + } else if (typeof thing === "function") { + if (isReaction(thing.$mobx)) { + return thing.$mobx; + } + } + return fail("Cannot obtain atom from " + thing); + } + + function getAdministration(thing, property) { + invariant(thing, "Expecting some object"); + if (property !== undefined) return getAdministration(getAtom(thing, property)); + if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) return thing; + if (isObservableMap(thing)) return thing; + runLazyInitializers(thing); + if (thing.$mobx) return thing.$mobx; + invariant(false, "Cannot obtain administration from " + thing); + } + + function getDebugName(thing, property) { + var named; + if (property !== undefined) named = getAtom(thing, property); + else if (isObservableObject(thing) || isObservableMap(thing)) named = getAdministration(thing); + else named = getAtom(thing); + return named.name; + } + + function createClassPropertyDecorator(onInitialize, _get, _set, enumerable, allowCustomArguments) { + function classPropertyDecorator(target, key, descriptor, customArgs, argLen) { + if (argLen === void 0) { + argLen = 0; + } + invariant(allowCustomArguments || quacksLikeADecorator(arguments), "This function is a decorator, but it wasn't invoked like a decorator"); + if (!descriptor) { + var newDescriptor = { + enumerable: enumerable, + configurable: true, + get: function get() { + if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) typescriptInitializeProperty(this, key, undefined, onInitialize, customArgs, descriptor); + return _get.call(this, key); + }, + set: function set(v) { + if (!this.__mobxInitializedProps || this.__mobxInitializedProps[key] !== true) { + typescriptInitializeProperty(this, key, v, onInitialize, customArgs, descriptor); + } else { + _set.call(this, key, v); + } + } + }; + if (arguments.length < 3 || arguments.length === 5 && argLen < 3) { + Object.defineProperty(target, key, newDescriptor); + } + return newDescriptor; + } else { + if (!hasOwnProperty(target, "__mobxLazyInitializers")) { + addHiddenProp(target, "__mobxLazyInitializers", target.__mobxLazyInitializers && target.__mobxLazyInitializers.slice() || []); + } + var value_1 = descriptor.value, + initializer_1 = descriptor.initializer; + target.__mobxLazyInitializers.push(function (instance) { + onInitialize(instance, key, initializer_1 ? initializer_1.call(instance) : value_1, customArgs, descriptor); + }); + return { + enumerable: enumerable, + configurable: true, + get: function get() { + if (this.__mobxDidRunLazyInitializers !== true) runLazyInitializers(this); + return _get.call(this, key); + }, + set: function set(v) { + if (this.__mobxDidRunLazyInitializers !== true) runLazyInitializers(this); + _set.call(this, key, v); + } + }; + } + } + if (allowCustomArguments) { + return function () { + if (quacksLikeADecorator(arguments)) return classPropertyDecorator.apply(null, arguments); + var outerArgs = arguments; + var argLen = arguments.length; + return function (target, key, descriptor) { + return classPropertyDecorator(target, key, descriptor, outerArgs, argLen); + }; + }; + } + return classPropertyDecorator; + } + + function typescriptInitializeProperty(instance, key, v, onInitialize, customArgs, baseDescriptor) { + if (!hasOwnProperty(instance, "__mobxInitializedProps")) addHiddenProp(instance, "__mobxInitializedProps", {}); + instance.__mobxInitializedProps[key] = true; + onInitialize(instance, key, v, customArgs, baseDescriptor); + } + + function runLazyInitializers(instance) { + if (instance.__mobxDidRunLazyInitializers === true) return; + if (instance.__mobxLazyInitializers) { + addHiddenProp(instance, "__mobxDidRunLazyInitializers", true); + instance.__mobxDidRunLazyInitializers && instance.__mobxLazyInitializers.forEach(function (initializer) { + return initializer(instance); + }); + } + } + + function quacksLikeADecorator(args) { + return (args.length === 2 || args.length === 3) && typeof args[1] === "string"; + } + + function iteratorSymbol() { + return typeof Symbol === "function" && Symbol.iterator || "@@iterator"; + } + var IS_ITERATING_MARKER = "__$$iterating"; + + function arrayAsIterator(array) { + invariant(array[IS_ITERATING_MARKER] !== true, "Illegal state: cannot recycle array as iterator"); + addHiddenFinalProp(array, IS_ITERATING_MARKER, true); + var idx = -1; + addHiddenFinalProp(array, "next", function next() { + idx++; + return { + done: idx >= this.length, + value: idx < this.length ? this[idx] : undefined + }; + }); + return array; + } + + function declareIterator(prototType, iteratorFactory) { + addHiddenFinalProp(prototType, iteratorSymbol(), iteratorFactory); + } + var messages = { + "m001": "It is not allowed to assign new values to @action fields", + "m002": "`runInAction` expects a function", + "m003": "`runInAction` expects a function without arguments", + "m004": "autorun expects a function", + "m005": "Warning: attempted to pass an action to autorun. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.", + "m006": "Warning: attempted to pass an action to autorunAsync. Actions are untracked and will not trigger on state changes. Use `reaction` or wrap only your state modification code in an action.", + "m007": "reaction only accepts 2 or 3 arguments. If migrating from MobX 2, please provide an options object", + "m008": "wrapping reaction expression in `asReference` is no longer supported, use options object instead", + "m009": "@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'. It looks like it was used on a property.", + "m010": "@computed can only be used on getter functions, like: '@computed get myProps() { return ...; }'", + "m011": "First argument to `computed` should be an expression. If using computed as decorator, don't pass it arguments", + "m012": "computed takes one or two arguments if used as function", + "m013": "[mobx.expr] 'expr' should only be used inside other reactive functions.", + "m014": "extendObservable expected 2 or more arguments", + "m015": "extendObservable expects an object as first argument", + "m016": "extendObservable should not be used on maps, use map.merge instead", + "m017": "all arguments of extendObservable should be objects", + "m018": "extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540", + "m019": "[mobx.isObservable] isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.", + "m020": "modifiers can only be used for individual object properties", + "m021": "observable expects zero or one arguments", + "m022": "@observable can not be used on getters, use @computed instead", + "m023": "Using `transaction` is deprecated, use `runInAction` or `(@)action` instead.", + "m024": "whyRun() can only be used if a derivation is active, or by passing an computed value / reaction explicitly. If you invoked whyRun from inside a computation; the computation is currently suspended but re-evaluating because somebody requested its value.", + "m025": "whyRun can only be used on reactions and computed values", + "m026": "`action` can only be invoked on functions", + "m028": "It is not allowed to set `useStrict` when a derivation is running", + "m029": "INTERNAL ERROR only onBecomeUnobserved shouldn't be called twice in a row", + "m030a": "Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: ", + "m030b": "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: ", + "m031": "Computed values are not allowed to not cause side effects by changing observables that are already being observed. Tried to modify: ", + "m032": "* This computation is suspended (not in use by any reaction) and won't run automatically.\n Didn't expect this computation to be suspended at this point?\n 1. Make sure this computation is used by a reaction (reaction, autorun, observer).\n 2. Check whether you are using this computation synchronously (in the same stack as they reaction that needs it).", + "m033": "`observe` doesn't support the fire immediately property for observable maps.", + "m034": "`mobx.map` is deprecated, use `new ObservableMap` or `mobx.observable.map` instead", + "m035": "Cannot make the designated object observable; it is not extensible", + "m036": "It is not possible to get index atoms from arrays", + "m037": "Hi there! I'm sorry you have just run into an exception.\nIf your debugger ends up here, know that some reaction (like the render() of an observer component, autorun or reaction)\nthrew an exception and that mobx caught it, to avoid that it brings the rest of your application down.\nThe original cause of the exception (the code that caused this reaction to run (again)), is still in the stack.\n\nHowever, more interesting is the actual stack trace of the error itself.\nHopefully the error is an instanceof Error, because in that case you can inspect the original stack of the error from where it was thrown.\nSee `error.stack` property, or press the very subtle \"(...)\" link you see near the console.error message that probably brought you here.\nThat stack is more interesting than the stack of this console.error itself.\n\nIf the exception you see is an exception you created yourself, make sure to use `throw new Error(\"Oops\")` instead of `throw \"Oops\"`,\nbecause the javascript environment will only preserve the original stack trace in the first form.\n\nYou can also make sure the debugger pauses the next time this very same exception is thrown by enabling \"Pause on caught exception\".\n(Note that it might pause on many other, unrelated exception as well).\n\nIf that all doesn't help you out, feel free to open an issue https://github.com/mobxjs/mobx/issues!\n", + "m038": "Missing items in this list?\n 1. Check whether all used values are properly marked as observable (use isObservable to verify)\n 2. Make sure you didn't dereference values too early. MobX observes props, not primitives. E.g: use 'person.name' instead of 'name' in your computation.\n" + }; + + function getMessage(id) { + return messages[id]; + } + var EMPTY_ARRAY = []; + Object.freeze(EMPTY_ARRAY); + + function getGlobal() { + return global; + } + + function getNextId() { + return ++globalState.mobxGuid; + } + + function fail(message, thing) { + invariant(false, message, thing); + throw "X"; + } + + function invariant(check, message, thing) { + if (!check) throw new Error("[mobx] Invariant failed: " + message + (thing ? " in '" + thing + "'" : "")); + } + var deprecatedMessages = []; + + function deprecated(msg) { + if (deprecatedMessages.indexOf(msg) !== -1) return false; + deprecatedMessages.push(msg); + console.error("[mobx] Deprecated: " + msg); + return true; + } + + function once(func) { + var invoked = false; + return function () { + if (invoked) return; + invoked = true; + return func.apply(this, arguments); + }; + } + var noop = function noop() {}; + + function unique(list) { + var res = []; + list.forEach(function (item) { + if (res.indexOf(item) === -1) res.push(item); + }); + return res; + } + + function joinStrings(things, limit, separator) { + if (limit === void 0) { + limit = 100; + } + if (separator === void 0) { + separator = " - "; + } + if (!things) return ""; + var sliced = things.slice(0, limit); + return "" + sliced.join(separator) + (things.length > limit ? " (... and " + (things.length - limit) + "more)" : ""); + } + + function isObject(value) { + return value !== null && (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object"; + } + + function isPlainObject(value) { + if (value === null || (typeof value === "undefined" ? "undefined" : _typeof(value)) !== "object") return false; + var proto = Object.getPrototypeOf(value); + return proto === Object.prototype || proto === null; + } + + function objectAssign() { + var res = arguments[0]; + for (var i = 1, l = arguments.length; i < l; i++) { + var source = arguments[i]; + for (var key in source) { + if (hasOwnProperty(source, key)) { + res[key] = source[key]; + } + } + } + return res; + } + + function valueDidChange(compareStructural, oldValue, newValue) { + if (typeof oldValue === 'number' && isNaN(oldValue)) { + return typeof newValue !== 'number' || !isNaN(newValue); + } + return compareStructural ? !deepEqual(oldValue, newValue) : oldValue !== newValue; + } + var prototypeHasOwnProperty = Object.prototype.hasOwnProperty; + + function hasOwnProperty(object, propName) { + return prototypeHasOwnProperty.call(object, propName); + } + + function makeNonEnumerable(object, propNames) { + for (var i = 0; i < propNames.length; i++) { + addHiddenProp(object, propNames[i], object[propNames[i]]); + } + } + + function addHiddenProp(object, propName, value) { + Object.defineProperty(object, propName, { + enumerable: false, + writable: true, + configurable: true, + value: value + }); + } + + function addHiddenFinalProp(object, propName, value) { + Object.defineProperty(object, propName, { + enumerable: false, + writable: false, + configurable: true, + value: value + }); + } + + function isPropertyConfigurable(object, prop) { + var descriptor = Object.getOwnPropertyDescriptor(object, prop); + return !descriptor || descriptor.configurable !== false && descriptor.writable !== false; + } + + function assertPropertyConfigurable(object, prop) { + invariant(isPropertyConfigurable(object, prop), "Cannot make property '" + prop + "' observable, it is not configurable and writable in the target object"); + } + + function getEnumerableKeys(obj) { + var res = []; + for (var key in obj) { + res.push(key); + } + return res; + } + + function deepEqual(a, b) { + if (a === null && b === null) return true; + if (a === undefined && b === undefined) return true; + if ((typeof a === "undefined" ? "undefined" : _typeof(a)) !== "object") return a === b; + var aIsArray = isArrayLike(a); + var aIsMap = isMapLike(a); + if (aIsArray !== isArrayLike(b)) { + return false; + } else if (aIsMap !== isMapLike(b)) { + return false; + } else if (aIsArray) { + if (a.length !== b.length) return false; + for (var i = a.length - 1; i >= 0; i--) { + if (!deepEqual(a[i], b[i])) return false; + } + return true; + } else if (aIsMap) { + if (a.size !== b.size) return false; + var equals_1 = true; + a.forEach(function (value, key) { + equals_1 = equals_1 && deepEqual(b.get(key), value); + }); + return equals_1; + } else if ((typeof a === "undefined" ? "undefined" : _typeof(a)) === "object" && (typeof b === "undefined" ? "undefined" : _typeof(b)) === "object") { + if (a === null || b === null) return false; + if (isMapLike(a) && isMapLike(b)) { + if (a.size !== b.size) return false; + return deepEqual(observable.shallowMap(a).entries(), observable.shallowMap(b).entries()); + } + if (getEnumerableKeys(a).length !== getEnumerableKeys(b).length) return false; + for (var prop in a) { + if (!(prop in b)) return false; + if (!deepEqual(a[prop], b[prop])) return false; + } + return true; + } + return false; + } + + function createInstanceofPredicate(name, clazz) { + var propName = "isMobX" + name; + clazz.prototype[propName] = true; + return function (x) { + return isObject(x) && x[propName] === true; + }; + } + + function isArrayLike(x) { + return Array.isArray(x) || isObservableArray(x); + } + exports.isArrayLike = isArrayLike; + + function isMapLike(x) { + return isES6Map(x) || isObservableMap(x); + } + + function isES6Map(thing) { + if (getGlobal().Map !== undefined && thing instanceof getGlobal().Map) return true; + return false; + } + + function primitiveSymbol() { + return typeof Symbol === "function" && Symbol.toPrimitive || "@@toPrimitive"; + } + + function toPrimitive(value) { + return value === null ? null : (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object" ? "" + value : value; + } + /* WEBPACK VAR INJECTION */ + }.call(exports, __webpack_require__(4))) + + /***/ + }), + /* 2 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + return _arr; + } + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + }(); + + var _icons = __webpack_require__(6); + + var _constants = __webpack_require__(0); + + function renderHeader(_ref, instance) { + var meta = _ref.meta, + user = _ref.user, + reactions = _ref.reactions; + + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-header-container'; + + var likeButton = document.createElement('span'); + var likedReaction = reactions.find(function (reaction) { + return reaction.content === 'heart' && reaction.user.login === user.login; + }); + likeButton.className = 'gitment-header-like-btn'; + likeButton.innerHTML = '\n ' + _icons.heart + '\n ' + (likedReaction ? '取消喜欢' : '喜欢') + '\n ' + (meta.reactions && meta.reactions.heart ? ' \u2022 ' + meta.reactions.heart + ' 人喜欢' : '') + '\n '; + + if (likedReaction) { + likeButton.classList.add('liked'); + likeButton.onclick = function () { + return instance.unlike(); + }; + } else { + likeButton.classList.remove('liked'); + likeButton.onclick = function () { + return instance.like(); + }; + } + container.appendChild(likeButton); + + var commentsCount = document.createElement('span'); + commentsCount.innerHTML = '\n ' + (meta.comments ? ' \u2022 ' + meta.comments + ' 条评论' : '') + '\n '; + container.appendChild(commentsCount); + + var issueLink = document.createElement('a'); + issueLink.className = 'gitment-header-issue-link'; + console.log("meta.html_url:" + meta.html_url); + issueLink.href = meta.html_url; + issueLink.target = '_blank'; + issueLink.innerText = 'Issue Page'; + container.appendChild(issueLink); + + return container; + } + + function renderComments(_ref2, instance) { + var meta = _ref2.meta, + comments = _ref2.comments, + commentReactions = _ref2.commentReactions, + currentPage = _ref2.currentPage, + user = _ref2.user, + error = _ref2.error; + + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-comments-container'; + + if (error) { + var errorBlock = document.createElement('div'); + errorBlock.className = 'gitment-comments-error'; + + if (error === _constants.NOT_INITIALIZED_ERROR && user.login && user.login.toLowerCase() === instance.owner.toLowerCase()) { + var initHint = document.createElement('div'); + var initButton = document.createElement('button'); + initButton.className = 'gitment-comments-init-btn'; + initButton.onclick = function () { + initButton.setAttribute('disabled', true); + instance.init().catch(function (e) { + initButton.removeAttribute('disabled'); + alert(e); + }); + }; + initButton.innerText = '初始化评论'; + initHint.appendChild(initButton); + errorBlock.appendChild(initHint); + } else { + errorBlock.innerText = error; + } + container.appendChild(errorBlock); + return container; + } else if (comments === undefined) { + var loading = document.createElement('div'); + loading.innerText = '评论加载中...'; + loading.className = 'gitment-comments-loading'; + container.appendChild(loading); + return container; + } else if (!comments.length) { + var emptyBlock = document.createElement('div'); + emptyBlock.className = 'gitment-comments-empty'; + emptyBlock.innerText = '暂无评论，来过就留点痕迹吧'; + container.appendChild(emptyBlock); + return container; + } + + var commentsList = document.createElement('ul'); + commentsList.className = 'gitment-comments-list'; + + comments.forEach(function (comment) { + var createDate = new Date(comment.created_at); + var updateDate = new Date(comment.updated_at); + var commentItem = document.createElement('li'); + commentItem.className = 'gitment-comment'; + commentItem.innerHTML = '\n \n \n \n
    \n
    \n \n ' + comment.user.login + '\n \n 评论于\n ' + createDate.toDateString() + '\n ' + (createDate.toString() !== updateDate.toString() ? ' \u2022 已编辑' : '') + '\n
    ' + _icons.heart + ' ' + (comment.reactions.heart || '') + '
    \n
    \n
    ' + comment.body_html + '
    \n
    \n '; + var likeButton = commentItem.querySelector('.gitment-comment-like-btn'); + var likedReaction = commentReactions[comment.id] && commentReactions[comment.id].find(function (reaction) { + return reaction.content === 'heart' && reaction.user.login === user.login; + }); + if (likedReaction) { + likeButton.classList.add('liked'); + likeButton.onclick = function () { + return instance.unlikeAComment(comment.id); + }; + } else { + likeButton.classList.remove('liked'); + likeButton.onclick = function () { + return instance.likeAComment(comment.id); + }; + } + + // dirty + // use a blank image to trigger height calculating when element rendered + var imgTrigger = document.createElement('img'); + var markdownBody = commentItem.querySelector('.gitment-comment-body'); + imgTrigger.className = 'gitment-hidden'; + imgTrigger.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="; + imgTrigger.onload = function () { + if (markdownBody.clientHeight > instance.maxCommentHeight) { + markdownBody.classList.add('gitment-comment-body-folded'); + markdownBody.style.maxHeight = instance.maxCommentHeight + 'px'; + markdownBody.title = '点击展开'; + markdownBody.onclick = function () { + markdownBody.classList.remove('gitment-comment-body-folded'); + markdownBody.style.maxHeight = ''; + markdownBody.title = ''; + markdownBody.onclick = null; + }; + } + }; + commentItem.appendChild(imgTrigger); + + commentsList.appendChild(commentItem); + }); + + container.appendChild(commentsList); + + if (meta) { + var pageCount = Math.ceil(meta.comments / instance.perPage); + if (pageCount > 1) { + var pagination = document.createElement('ul'); + pagination.className = 'gitment-comments-pagination'; + + if (currentPage > 1) { + var previousButton = document.createElement('li'); + previousButton.className = 'gitment-comments-page-item'; + previousButton.innerText = 'Previous'; + previousButton.onclick = function () { + return instance.goto(currentPage - 1); + }; + pagination.appendChild(previousButton); + } + + var _loop = function _loop(i) { + var pageItem = document.createElement('li'); + pageItem.className = 'gitment-comments-page-item'; + pageItem.innerText = i; + pageItem.onclick = function () { + return instance.goto(i); + }; + if (currentPage === i) pageItem.classList.add('gitment-selected'); + pagination.appendChild(pageItem); + }; + + for (var i = 1; i <= pageCount; i++) { + _loop(i); + } + + if (currentPage < pageCount) { + var nextButton = document.createElement('li'); + nextButton.className = 'gitment-comments-page-item'; + nextButton.innerText = 'Next'; + nextButton.onclick = function () { + return instance.goto(currentPage + 1); + }; + pagination.appendChild(nextButton); + } + + container.appendChild(pagination); + } + } + + return container; + } + + function renderEditor(_ref3, instance) { + var user = _ref3.user, + error = _ref3.error; + + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-editor-container'; + + var shouldDisable = user.login && !error ? '' : 'disabled'; + var disabledTip = user.login ? '' : '登录即可评论'; + container.innerHTML = '\n ' + (user.login ? '\n \n ' : user.isLoggingIn ? '
    ' + _icons.spinner + '
    ' : '\n ' + _icons.github + '\n ') + '\n \n
    \n
    \n \n \n
    \n
    \n
    \n \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n \n 评论框支持 Markdown 语法\n \n \n
    \n '; + if (user.login) { + container.querySelector('.gitment-editor-logout-link').onclick = function () { + return instance.logout(); + }; + } + + var writeField = container.querySelector('.gitment-editor-write-field'); + var previewField = container.querySelector('.gitment-editor-preview-field'); + + var textarea = writeField.querySelector('textarea'); + textarea.oninput = function () { + textarea.style.height = 'auto'; + var style = window.getComputedStyle(textarea, null); + var height = parseInt(style.height, 10); + var clientHeight = textarea.clientHeight; + var scrollHeight = textarea.scrollHeight; + if (clientHeight < scrollHeight) { + textarea.style.height = height + scrollHeight - clientHeight + 'px'; + } + }; + + var _container$querySelec = container.querySelectorAll('.gitment-editor-tab'), + _container$querySelec2 = _slicedToArray(_container$querySelec, 2), + writeTab = _container$querySelec2[0], + previewTab = _container$querySelec2[1]; + + writeTab.onclick = function () { + writeTab.classList.add('gitment-selected'); + previewTab.classList.remove('gitment-selected'); + writeField.classList.remove('gitment-hidden'); + previewField.classList.add('gitment-hidden'); + + textarea.focus(); + }; + previewTab.onclick = function () { + previewTab.classList.add('gitment-selected'); + writeTab.classList.remove('gitment-selected'); + previewField.classList.remove('gitment-hidden'); + writeField.classList.add('gitment-hidden'); + + var preview = previewField.querySelector('.gitment-editor-preview'); + var content = textarea.value.trim(); + if (!content) { + preview.innerText = '无可预览内容'; + return; + } + + preview.innerText = '加载预览中...'; + instance.markdown(content).then(function (html) { + return preview.innerHTML = html; + }); + }; + + var submitButton = container.querySelector('.gitment-editor-submit'); + submitButton.onclick = function () { + submitButton.innerText = '评论正在上传...'; + submitButton.setAttribute('disabled', true); + instance.post(textarea.value.trim()).then(function (data) { + textarea.value = ''; + textarea.style.height = 'auto'; + submitButton.removeAttribute('disabled'); + submitButton.innerText = '发表评论'; + }).catch(function (e) { + alert(e); + submitButton.removeAttribute('disabled'); + submitButton.innerText = '发表评论'; + }); + }; + + return container; + } + + function renderFooter() { + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-footer-container'; + //container.innerHTML = '\n 由\n \n Gitment\n 强力驱动\n · 码农BTS 汉化 '; + return container; + } + + function render(state, instance) { + var container = document.createElement('div'); + container.lang = "en-US"; + container.className = 'gitment-container gitment-root-container'; + container.appendChild(instance.renderHeader(state, instance)); + container.appendChild(instance.renderComments(state, instance)); + container.appendChild(instance.renderEditor(state, instance)); + container.appendChild(instance.renderFooter(state, instance)); + return container; + } + + exports.default = { + render: render, + renderHeader: renderHeader, + renderComments: renderComments, + renderEditor: renderEditor, + renderFooter: renderFooter + }; + + /***/ + }), + /* 3 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.http = exports.Query = exports.isString = undefined; + + var _slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + return _arr; + } + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + }(); + + exports.getTargetContainer = getTargetContainer; + + var _constants = __webpack_require__(0); + + var isString = exports.isString = function isString(s) { + return toString.call(s) === '[object String]'; + }; + + function getTargetContainer(container) { + var targetContainer = void 0; + if (container instanceof Element) { + targetContainer = container; + } else if (isString(container)) { + targetContainer = document.getElementById(container); + } else { + targetContainer = document.createElement('div'); + } + + return targetContainer; + } + + var Query = exports.Query = { + parse: function parse() { + var search = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.location.search; + + if (!search) return {}; + var queryString = search[0] === '?' ? search.substring(1) : search; + var query = {}; + queryString.split('&').forEach(function (queryStr) { + var _queryStr$split = queryStr.split('='), + _queryStr$split2 = _slicedToArray(_queryStr$split, 2), + key = _queryStr$split2[0], + value = _queryStr$split2[1]; + + if (key) query[key] = value; + }); + + return query; + }, + stringify: function stringify(query) { + var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '?'; + + var queryString = Object.keys(query).map(function (key) { + return key + '=' + encodeURIComponent(query[key] || ''); + }).join('&'); + return queryString ? prefix + queryString : ''; + } + }; + + function ajaxFactory(method) { + return function (apiPath) { + var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'https://api.github.com'; + + var req = new XMLHttpRequest(); + var token = localStorage.getItem(_constants.LS_ACCESS_TOKEN_KEY); + + var url = '' + base + apiPath; + var body = null; + if (method === 'GET' || method === 'DELETE') { + url += Query.stringify(data); + } + + var p = new Promise(function (resolve, reject) { + req.addEventListener('load', function () { + var contentType = req.getResponseHeader('content-type'); + var res = req.responseText; + if (!/json/.test(contentType)) { + resolve(res); + return; + } + var data = req.responseText ? JSON.parse(res) : {}; + if (data.message) { + reject(new Error(data.message)); + } else { + resolve(data); + } + }); + req.addEventListener('error', function (error) { + return reject(error); + }); + }); + req.open(method, url, true); + + req.setRequestHeader('Accept', 'application/vnd.github.squirrel-girl-preview, application/vnd.github.html+json'); + if (token) { + req.setRequestHeader('Authorization', 'token ' + token); + } + if (method !== 'GET' && method !== 'DELETE') { + body = JSON.stringify(data); + req.setRequestHeader('Content-Type', 'application/json'); + } + + req.send(body); + return p; + }; + } + + var http = exports.http = { + get: ajaxFactory('GET'), + post: ajaxFactory('POST'), + delete: ajaxFactory('DELETE'), + put: ajaxFactory('PUT') + }; + + /***/ + }), + /* 4 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + + var g; + + // This works in non-strict mode + g = function () { + return this; + }(); + + try { + // This works if eval is allowed (see CSP) + g = g || Function("return this")() || (1, eval)("this"); + } catch (e) { + // This works if the window reference is available + if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === "object") g = window; + } + + // g can still be undefined, but nothing to do about it... + // We return undefined, instead of nothing here, so it's + // easier to handle this case. if(!global) { ...} + + module.exports = g; + + /***/ + }), + /* 5 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + var _createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + + var _mobx = __webpack_require__(1); + + var _constants = __webpack_require__(0); + + var _utils = __webpack_require__(3); + + var _default = __webpack_require__(2); + + var _default2 = _interopRequireDefault(_default); + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + var scope = 'public_repo'; + + function extendRenderer(instance, renderer) { + instance[renderer] = function (container) { + var targetContainer = (0, _utils.getTargetContainer)(container); + var render = instance.theme[renderer] || instance.defaultTheme[renderer]; + + (0, _mobx.autorun)(function () { + var e = render(instance.state, instance); + if (targetContainer.firstChild) { + targetContainer.replaceChild(e, targetContainer.firstChild); + } else { + targetContainer.appendChild(e); + } + }); + + return targetContainer; + }; + } + + var Gitment = function () { + _createClass(Gitment, [{ + key: 'accessToken', + get: function get() { + return localStorage.getItem(_constants.LS_ACCESS_TOKEN_KEY); + }, + set: function set(token) { + localStorage.setItem(_constants.LS_ACCESS_TOKEN_KEY, token); + } + }, { + key: 'loginLink', + get: function get() { + var oauthUri = 'https://github.com/login/oauth/authorize'; + var redirect_uri = this.oauth.redirect_uri || window.location.href; + + var oauthParams = Object.assign({ + scope: scope, + redirect_uri: redirect_uri + }, this.oauth); + + return '' + oauthUri + _utils.Query.stringify(oauthParams); + } + }]); + + function Gitment() { + var _this = this; + + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck(this, Gitment); + + this.defaultTheme = _default2.default; + this.useTheme(_default2.default); + + Object.assign(this, { + id: window.location.href, + title: window.document.title, + link: window.location.href, + desc: '', + labels: [], + theme: _default2.default, + oauth: {}, + perPage: 20, + maxCommentHeight: 400 + }, options); + + this.useTheme(this.theme); + + var user = {}; + try { + var userInfo = localStorage.getItem(_constants.LS_USER_KEY); + if (this.accessToken && userInfo) { + Object.assign(user, JSON.parse(userInfo), { + fromCache: true + }); + } + } catch (e) { + localStorage.removeItem(_constants.LS_USER_KEY); + } + + this.state = (0, _mobx.observable)({ + user: user, + error: null, + meta: {}, + comments: undefined, + reactions: [], + commentReactions: {}, + currentPage: 1 + }); + + var query = _utils.Query.parse(); + if (query.code) { + var _oauth = this.oauth, + client_id = _oauth.client_id, + client_secret = _oauth.client_secret; + + var code = query.code; + delete query.code; + var search = _utils.Query.stringify(query); + var replacedUrl = '' + window.location.origin + window.location.pathname + search + window.location.hash; + history.replaceState({}, '', replacedUrl); + + Object.assign(this, { + id: replacedUrl, + link: replacedUrl + }, options); + + this.state.user.isLoggingIn = true; + //_utils.http.post('https://gh-oauth.imsun.net', { + //_utils.http.post('https://auth.baixiaotu.cc', { + //_utils.http.post('https://bak.smalbox.club', { + //_utils.http.post('https://cors.wenjunjiang.win', { + // https://cdn.jsdelivr.net/gh/theme-next/theme-next-gitment@1/gitment.browser.js + //_utils.http.post('https://cors-anywhere.herokuapp.com/https://github.com/login/oauth/access_token', { + // https://www.wenjunjiang.win/js/gitment.js + _utils.http.post('https://cors.wenjunjiang.win/?remoteUrl=https://github.com/login/oauth/access_token', { + code: code, + client_id: client_id, + client_secret: client_secret + }, '').then(function (data) { + _this.accessToken = data.access_token; + _this.update(); + }).catch(function (e) { + _this.state.user.isLoggingIn = false; + alert(e); + }); + } else { + this.update(); + } + } + + _createClass(Gitment, [{ + key: 'init', + value: function init() { + var _this2 = this; + + return this.createIssue().then(function () { + return _this2.loadComments(); + }).then(function (comments) { + _this2.state.error = null; + return comments; + }); + } + }, { + key: 'useTheme', + value: function useTheme() { + var _this3 = this; + + var theme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + this.theme = theme; + + var renderers = Object.keys(this.theme); + renderers.forEach(function (renderer) { + return extendRenderer(_this3, renderer); + }); + } + }, { + key: 'update', + value: function update() { + var _this4 = this; + + return Promise.all([this.loadMeta(), this.loadUserInfo()]).then(function () { + return Promise.all([_this4.loadComments().then(function () { + return _this4.loadCommentReactions(); + }), _this4.loadReactions()]); + }).catch(function (e) { + return _this4.state.error = e; + }); + } + }, { + key: 'markdown', + value: function markdown(text) { + return _utils.http.post('/markdown', { + text: text, + mode: 'gfm' + }); + } + }, { + key: 'createIssue', + value: function createIssue() { + var _this5 = this; + + var id = this.id, + owner = this.owner, + repo = this.repo, + title = this.title, + link = this.link, + desc = this.desc, + labels = this.labels; + + + return _utils.http.post('/repos/' + owner + '/' + repo + '/issues', { + title: title, + labels: labels.concat(['gitment', id]), + body: link + '\n\n' + desc + }).then(function (meta) { + _this5.state.meta = meta; + return meta; + }); + } + }, { + key: 'getIssue', + value: function getIssue() { + if (this.state.meta.id) return Promise.resolve(this.state.meta); + + return this.loadMeta(); + } + }, { + key: 'post', + value: function post(body) { + var _this6 = this; + + return this.getIssue().then(function (issue) { + return _utils.http.post(issue.comments_url, { + body: body + }, ''); + }).then(function (data) { + _this6.state.meta.comments++; + var pageCount = Math.ceil(_this6.state.meta.comments / _this6.perPage); + if (_this6.state.currentPage === pageCount) { + _this6.state.comments.push(data); + } + return data; + }); + } + }, { + key: 'loadMeta', + value: function loadMeta() { + var _this7 = this; + + var id = this.id, + owner = this.owner, + repo = this.repo; + + return _utils.http.get('/repos/' + owner + '/' + repo + '/issues', { + creator: owner, + labels: id + }).then(function (issues) { + if (!issues.length) return Promise.reject(_constants.NOT_INITIALIZED_ERROR); + _this7.state.meta = issues[0]; + return issues[0]; + }); + } + }, { + key: 'loadComments', + value: function loadComments() { + var _this8 = this; + + var page = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state.currentPage; + + return this.getIssue().then(function (issue) { + return _utils.http.get(issue.comments_url, { + page: page, + per_page: _this8.perPage + }, ''); + }).then(function (comments) { + _this8.state.comments = comments; + return comments; + }); + } + }, { + key: 'loadUserInfo', + value: function loadUserInfo() { + var _this9 = this; + + if (!this.accessToken) { + this.logout(); + return Promise.resolve({}); + } + + return _utils.http.get('/user').then(function (user) { + _this9.state.user = user; + localStorage.setItem(_constants.LS_USER_KEY, JSON.stringify(user)); + return user; + }); + } + }, { + key: 'loadReactions', + value: function loadReactions() { + var _this10 = this; + + if (!this.accessToken) { + this.state.reactions = []; + return Promise.resolve([]); + } + + return this.getIssue().then(function (issue) { + if (!issue.reactions.total_count) return []; + return _utils.http.get(issue.reactions.url, {}, ''); + }).then(function (reactions) { + _this10.state.reactions = reactions; + return reactions; + }); + } + }, { + key: 'loadCommentReactions', + value: function loadCommentReactions() { + var _this11 = this; + + if (!this.accessToken) { + this.state.commentReactions = {}; + return Promise.resolve([]); + } + + var comments = this.state.comments; + var comentReactions = {}; + + return Promise.all(comments.map(function (comment) { + if (!comment.reactions.total_count) return []; + + var owner = _this11.owner, + repo = _this11.repo; + + return _utils.http.get('/repos/' + owner + '/' + repo + '/issues/comments/' + comment.id + '/reactions', {}); + })).then(function (reactionsArray) { + comments.forEach(function (comment, index) { + comentReactions[comment.id] = reactionsArray[index]; + }); + _this11.state.commentReactions = comentReactions; + + return comentReactions; + }); + } + }, { + key: 'login', + value: function login() { + window.location.href = this.loginLink; + } + }, { + key: 'logout', + value: function logout() { + localStorage.removeItem(_constants.LS_ACCESS_TOKEN_KEY); + localStorage.removeItem(_constants.LS_USER_KEY); + this.state.user = {}; + } + }, { + key: 'goto', + value: function goto(page) { + this.state.currentPage = page; + this.state.comments = undefined; + return this.loadComments(page); + } + }, { + key: 'like', + value: function like() { + var _this12 = this; + + if (!this.accessToken) { + alert('登录即可喜欢'); + return Promise.reject(); + } + + var owner = this.owner, + repo = this.repo; + + + return _utils.http.post('/repos/' + owner + '/' + repo + '/issues/' + this.state.meta.number + '/reactions', { + content: 'heart' + }).then(function (reaction) { + _this12.state.reactions.push(reaction); + _this12.state.meta.reactions.heart++; + }); + } + }, { + key: 'unlike', + value: function unlike() { + var _this13 = this; + + if (!this.accessToken) return Promise.reject(); + + var _state = this.state, + user = _state.user, + reactions = _state.reactions; + + var index = reactions.findIndex(function (reaction) { + return reaction.user.login === user.login; + }); + return _utils.http.delete('/reactions/' + reactions[index].id).then(function () { + reactions.splice(index, 1); + _this13.state.meta.reactions.heart--; + }); + } + }, { + key: 'likeAComment', + value: function likeAComment(commentId) { + var _this14 = this; + + if (!this.accessToken) { + alert('登录即可喜欢'); + return Promise.reject(); + } + + var owner = this.owner, + repo = this.repo; + + var comment = this.state.comments.find(function (comment) { + return comment.id === commentId; + }); + + return _utils.http.post('/repos/' + owner + '/' + repo + '/issues/comments/' + commentId + '/reactions', { + content: 'heart' + }).then(function (reaction) { + _this14.state.commentReactions[commentId].push(reaction); + comment.reactions.heart++; + }); + } + }, { + key: 'unlikeAComment', + value: function unlikeAComment(commentId) { + if (!this.accessToken) return Promise.reject(); + + var reactions = this.state.commentReactions[commentId]; + var comment = this.state.comments.find(function (comment) { + return comment.id === commentId; + }); + var user = this.state.user; + + var index = reactions.findIndex(function (reaction) { + return reaction.user.login === user.login; + }); + + return _utils.http.delete('/reactions/' + reactions[index].id).then(function () { + reactions.splice(index, 1); + comment.reactions.heart--; + }); + } + }]); + + return Gitment; + }(); + + module.exports = Gitment; + + /***/ + }), + /* 6 */ + /***/ + (function (module, exports, __webpack_require__) { + + "use strict"; + + + Object.defineProperty(exports, "__esModule", { + value: true + }); + /** + * Modified from https://github.com/evil-icons/evil-icons + */ + + var close = exports.close = ''; + var github = exports.github = ''; + var heart = exports.heart = ''; + var spinner = exports.spinner = ''; + + /***/ + }) + /******/ +]); +//# sourceMappingURL=gitment.browser.js.map diff --git a/lib/jquery-2.1.4.min.js b/lib/jquery-2.1.4.min.js new file mode 100644 index 0000000..49990d6 --- /dev/null +++ b/lib/jquery-2.1.4.min.js @@ -0,0 +1,4 @@ +/*! jQuery v2.1.4 | (c) 2005, 2015 jQuery Foundation, Inc. | jquery.org/license */ +!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k={},l=a.document,m="2.1.4",n=function(a,b){return new n.fn.init(a,b)},o=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,p=/^-ms-/,q=/-([\da-z])/gi,r=function(a,b){return b.toUpperCase()};n.fn=n.prototype={jquery:m,constructor:n,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=n.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return n.each(this,a,b)},map:function(a){return this.pushStack(n.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},n.extend=n.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||n.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(n.isPlainObject(d)||(e=n.isArray(d)))?(e?(e=!1,f=c&&n.isArray(c)?c:[]):f=c&&n.isPlainObject(c)?c:{},g[b]=n.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},n.extend({expando:"jQuery"+(m+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===n.type(a)},isArray:Array.isArray,isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){return!n.isArray(a)&&a-parseFloat(a)+1>=0},isPlainObject:function(a){return"object"!==n.type(a)||a.nodeType||n.isWindow(a)?!1:a.constructor&&!j.call(a.constructor.prototype,"isPrototypeOf")?!1:!0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(a){var b,c=eval;a=n.trim(a),a&&(1===a.indexOf("use strict")?(b=l.createElement("script"),b.text=a,l.head.appendChild(b).parentNode.removeChild(b)):c(a))},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=s(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(o,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?n.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:g.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;c>d;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=s(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(c=a[b],b=a,a=c),n.isFunction(a)?(e=d.call(arguments,2),f=function(){return a.apply(b||this,e.concat(d.call(arguments)))},f.guid=a.guid=a.guid||n.guid++,f):void 0},now:Date.now,support:k}),n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function s(a){var b="length"in a&&a.length,c=n.type(a);return"function"===c||n.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C=1<<31,D={}.hasOwnProperty,E=[],F=E.pop,G=E.push,H=E.push,I=E.slice,J=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},K="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",L="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",N=M.replace("w","w#"),O="\\["+L+"*("+M+")(?:"+L+"*([*^$|!~]?=)"+L+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+N+"))|)"+L+"*\\]",P=":("+M+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+O+")*)|.*)\\)|)",Q=new RegExp(L+"+","g"),R=new RegExp("^"+L+"+|((?:^|[^\\\\])(?:\\\\.)*)"+L+"+$","g"),S=new RegExp("^"+L+"*,"+L+"*"),T=new RegExp("^"+L+"*([>+~]|"+L+")"+L+"*"),U=new RegExp("="+L+"*([^\\]'\"]*?)"+L+"*\\]","g"),V=new RegExp(P),W=new RegExp("^"+N+"$"),X={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),TAG:new RegExp("^("+M.replace("w","w*")+")"),ATTR:new RegExp("^"+O),PSEUDO:new RegExp("^"+P),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+L+"*(even|odd|(([+-]|)(\\d*)n|)"+L+"*(?:([+-]|)"+L+"*(\\d+)|))"+L+"*\\)|)","i"),bool:new RegExp("^(?:"+K+")$","i"),needsContext:new RegExp("^"+L+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+L+"*((?:-\\d)?\\d*)"+L+"*\\)|)(?=[^-]|$)","i")},Y=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,$=/^[^{]+\{\s*\[native \w/,_=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,aa=/[+~]/,ba=/'|\\/g,ca=new RegExp("\\\\([\\da-f]{1,6}"+L+"?|("+L+")|.)","ig"),da=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ea=function(){m()};try{H.apply(E=I.call(v.childNodes),v.childNodes),E[v.childNodes.length].nodeType}catch(fa){H={apply:E.length?function(a,b){G.apply(a,I.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s,w,x;if((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,d=d||[],k=b.nodeType,"string"!=typeof a||!a||1!==k&&9!==k&&11!==k)return d;if(!e&&p){if(11!==k&&(f=_.exec(a)))if(j=f[1]){if(9===k){if(h=b.getElementById(j),!h||!h.parentNode)return d;if(h.id===j)return d.push(h),d}else if(b.ownerDocument&&(h=b.ownerDocument.getElementById(j))&&t(b,h)&&h.id===j)return d.push(h),d}else{if(f[2])return H.apply(d,b.getElementsByTagName(a)),d;if((j=f[3])&&c.getElementsByClassName)return H.apply(d,b.getElementsByClassName(j)),d}if(c.qsa&&(!q||!q.test(a))){if(s=r=u,w=b,x=1!==k&&a,1===k&&"object"!==b.nodeName.toLowerCase()){o=g(a),(r=b.getAttribute("id"))?s=r.replace(ba,"\\$&"):b.setAttribute("id",s),s="[id='"+s+"'] ",l=o.length;while(l--)o[l]=s+ra(o[l]);w=aa.test(a)&&pa(b.parentNode)||b,x=o.join(",")}if(x)try{return H.apply(d,w.querySelectorAll(x)),d}catch(y){}finally{r||b.removeAttribute("id")}}}return i(a.replace(R,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||C)-(~a.sourceIndex||C);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function pa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=g.documentElement,e=g.defaultView,e&&e!==e.top&&(e.addEventListener?e.addEventListener("unload",ea,!1):e.attachEvent&&e.attachEvent("onunload",ea)),p=!f(g),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(g.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=$.test(g.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!g.getElementsByName||!g.getElementsByName(u).length}),c.getById?(d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return p?b.getElementsByClassName(a):void 0},r=[],q=[],(c.qsa=$.test(g.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+L+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+L+"*(?:value|"+K+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){var b=g.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+L+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=$.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"div"),s.call(a,"[s!='']:x"),r.push("!=",P)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=$.test(o.compareDocumentPosition),t=b||$.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===g||a.ownerDocument===v&&t(v,a)?-1:b===g||b.ownerDocument===v&&t(v,b)?1:k?J(k,a)-J(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,h=[a],i=[b];if(!e||!f)return a===g?-1:b===g?1:e?-1:f?1:k?J(k,a)-J(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)i.unshift(c);while(h[d]===i[d])d++;return d?la(h[d],i[d]):h[d]===v?-1:i[d]===v?1:0},g):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(U,"='$1']"),!(!c.matchesSelector||!p||r&&r.test(b)||q&&q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&D.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:X,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ca,da),a[3]=(a[3]||a[4]||a[5]||"").replace(ca,da),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return X.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&V.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ca,da).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+L+")"+a+"("+L+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(Q," ")+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){k=q[u]||(q[u]={}),j=k[a]||[],n=j[0]===w&&j[1],m=j[0]===w&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[w,n,m];break}}else if(s&&(j=(b[u]||(b[u]={}))[a])&&j[0]===w)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(s&&((l[u]||(l[u]={}))[a]=[w,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=J(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(R,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(ca,da),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return W.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(ca,da).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return Z.test(a.nodeName)},input:function(a){return Y.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:oa(function(){return[0]}),last:oa(function(a,b){return[b-1]}),eq:oa(function(a,b,c){return[0>c?c+b:c]}),even:oa(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:oa(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:oa(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:oa(function(a,b,c){for(var d=0>c?c+b:c;++db;b++)d+=a[b].value;return d}function sa(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=x++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[w,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[u]||(b[u]={}),(h=i[d])&&h[0]===w&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function ta(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function ua(a,b,c){for(var d=0,e=b.length;e>d;d++)ga(a,b[d],c);return c}function va(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function wa(a,b,c,d,e,f){return d&&!d[u]&&(d=wa(d)),e&&!e[u]&&(e=wa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||ua(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:va(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=va(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?J(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=va(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):H.apply(g,r)})}function xa(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=sa(function(a){return a===b},h,!0),l=sa(function(a){return J(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];f>i;i++)if(c=d.relative[a[i].type])m=[sa(ta(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;f>e;e++)if(d.relative[a[e].type])break;return wa(i>1&&ta(m),i>1&&ra(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(R,"$1"),c,e>i&&xa(a.slice(i,e)),f>e&&xa(a=a.slice(e)),f>e&&ra(a))}m.push(c)}return ta(m)}function ya(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,m,o,p=0,q="0",r=f&&[],s=[],t=j,u=f||e&&d.find.TAG("*",k),v=w+=null==t?1:Math.random()||.1,x=u.length;for(k&&(j=g!==n&&g);q!==x&&null!=(l=u[q]);q++){if(e&&l){m=0;while(o=a[m++])if(o(l,g,h)){i.push(l);break}k&&(w=v)}c&&((l=!o&&l)&&p--,f&&r.push(l))}if(p+=q,c&&q!==p){m=0;while(o=b[m++])o(r,s,g,h);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=F.call(i));s=va(s)}H.apply(i,s),k&&!f&&s.length>0&&p+b.length>1&&ga.uniqueSort(i)}return k&&(w=v,j=t),r};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=xa(b[c]),f[u]?d.push(f):e.push(f);f=A(a,ya(e,d)),f.selector=a}return f},i=ga.select=function(a,b,e,f){var i,j,k,l,m,n="function"==typeof a&&a,o=!f&&g(a=n.selector||a);if(e=e||[],1===o.length){if(j=o[0]=o[0].slice(0),j.length>2&&"ID"===(k=j[0]).type&&c.getById&&9===b.nodeType&&p&&d.relative[j[1].type]){if(b=(d.find.ID(k.matches[0].replace(ca,da),b)||[])[0],!b)return e;n&&(b=b.parentNode),a=a.slice(j.shift().value.length)}i=X.needsContext.test(a)?0:j.length;while(i--){if(k=j[i],d.relative[l=k.type])break;if((m=d.find[l])&&(f=m(k.matches[0].replace(ca,da),aa.test(j[0].type)&&pa(b.parentNode)||b))){if(j.splice(i,1),a=f.length&&ra(j),!a)return H.apply(e,f),e;break}}}return(n||h(a,o))(f,b,!p,e,aa.test(a)&&pa(b.parentNode)||b),e},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("div"))}),ja(function(a){return a.innerHTML="","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(K,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);n.find=t,n.expr=t.selectors,n.expr[":"]=n.expr.pseudos,n.unique=t.uniqueSort,n.text=t.getText,n.isXMLDoc=t.isXML,n.contains=t.contains;var u=n.expr.match.needsContext,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^.[^:#\[\.,]*$/;function x(a,b,c){if(n.isFunction(b))return n.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return n.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(w.test(b))return n.filter(b,a,c);b=n.filter(b,a)}return n.grep(a,function(a){return g.call(b,a)>=0!==c})}n.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?n.find.matchesSelector(d,a)?[d]:[]:n.find.matches(a,n.grep(b,function(a){return 1===a.nodeType}))},n.fn.extend({find:function(a){var b,c=this.length,d=[],e=this;if("string"!=typeof a)return this.pushStack(n(a).filter(function(){for(b=0;c>b;b++)if(n.contains(e[b],this))return!0}));for(b=0;c>b;b++)n.find(a,e[b],d);return d=this.pushStack(c>1?n.unique(d):d),d.selector=this.selector?this.selector+" "+a:a,d},filter:function(a){return this.pushStack(x(this,a||[],!1))},not:function(a){return this.pushStack(x(this,a||[],!0))},is:function(a){return!!x(this,"string"==typeof a&&u.test(a)?n(a):a||[],!1).length}});var y,z=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,A=n.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:z.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||y).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof n?b[0]:b,n.merge(this,n.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:l,!0)),v.test(c[1])&&n.isPlainObject(b))for(c in b)n.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}return d=l.getElementById(c[2]),d&&d.parentNode&&(this.length=1,this[0]=d),this.context=l,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):n.isFunction(a)?"undefined"!=typeof y.ready?y.ready(a):a(n):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),n.makeArray(a,this))};A.prototype=n.fn,y=n(l);var B=/^(?:parents|prev(?:Until|All))/,C={children:!0,contents:!0,next:!0,prev:!0};n.extend({dir:function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&n(a).is(c))break;d.push(a)}return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),n.fn.extend({has:function(a){var b=n(a,this),c=b.length;return this.filter(function(){for(var a=0;c>a;a++)if(n.contains(this,b[a]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=u.test(a)||"string"!=typeof a?n(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&n.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?n.unique(f):f)},index:function(a){return a?"string"==typeof a?g.call(n(a),this[0]):g.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(n.unique(n.merge(this.get(),n(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function D(a,b){while((a=a[b])&&1!==a.nodeType);return a}n.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return n.dir(a,"parentNode")},parentsUntil:function(a,b,c){return n.dir(a,"parentNode",c)},next:function(a){return D(a,"nextSibling")},prev:function(a){return D(a,"previousSibling")},nextAll:function(a){return n.dir(a,"nextSibling")},prevAll:function(a){return n.dir(a,"previousSibling")},nextUntil:function(a,b,c){return n.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return n.dir(a,"previousSibling",c)},siblings:function(a){return n.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return n.sibling(a.firstChild)},contents:function(a){return a.contentDocument||n.merge([],a.childNodes)}},function(a,b){n.fn[a]=function(c,d){var e=n.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=n.filter(d,e)),this.length>1&&(C[a]||n.unique(e),B.test(a)&&e.reverse()),this.pushStack(e)}});var E=/\S+/g,F={};function G(a){var b=F[a]={};return n.each(a.match(E)||[],function(a,c){b[c]=!0}),b}n.Callbacks=function(a){a="string"==typeof a?F[a]||G(a):n.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(b=a.memory&&l,c=!0,g=e||0,e=0,f=h.length,d=!0;h&&f>g;g++)if(h[g].apply(l[0],l[1])===!1&&a.stopOnFalse){b=!1;break}d=!1,h&&(i?i.length&&j(i.shift()):b?h=[]:k.disable())},k={add:function(){if(h){var c=h.length;!function g(b){n.each(b,function(b,c){var d=n.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&g(c)})}(arguments),d?f=h.length:b&&(e=c,j(b))}return this},remove:function(){return h&&n.each(arguments,function(a,b){var c;while((c=n.inArray(b,h,c))>-1)h.splice(c,1),d&&(f>=c&&f--,g>=c&&g--)}),this},has:function(a){return a?n.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],f=0,this},disable:function(){return h=i=b=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,b||k.disable(),this},locked:function(){return!i},fireWith:function(a,b){return!h||c&&!i||(b=b||[],b=[a,b.slice?b.slice():b],d?i.push(b):j(b)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!c}};return k},n.extend({Deferred:function(a){var b=[["resolve","done",n.Callbacks("once memory"),"resolved"],["reject","fail",n.Callbacks("once memory"),"rejected"],["notify","progress",n.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return n.Deferred(function(c){n.each(b,function(b,f){var g=n.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&n.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?n.extend(a,d):d}},e={};return d.pipe=d.then,n.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&n.isFunction(a.promise)?e:0,g=1===f?a:n.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&n.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var H;n.fn.ready=function(a){return n.ready.promise().done(a),this},n.extend({isReady:!1,readyWait:1,holdReady:function(a){a?n.readyWait++:n.ready(!0)},ready:function(a){(a===!0?--n.readyWait:n.isReady)||(n.isReady=!0,a!==!0&&--n.readyWait>0||(H.resolveWith(l,[n]),n.fn.triggerHandler&&(n(l).triggerHandler("ready"),n(l).off("ready"))))}});function I(){l.removeEventListener("DOMContentLoaded",I,!1),a.removeEventListener("load",I,!1),n.ready()}n.ready.promise=function(b){return H||(H=n.Deferred(),"complete"===l.readyState?setTimeout(n.ready):(l.addEventListener("DOMContentLoaded",I,!1),a.addEventListener("load",I,!1))),H.promise(b)},n.ready.promise();var J=n.access=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===n.type(c)){e=!0;for(h in c)n.access(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,n.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(n(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f};n.acceptData=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function K(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=n.expando+K.uid++}K.uid=1,K.accepts=n.acceptData,K.prototype={key:function(a){if(!K.accepts(a))return 0;var b={},c=a[this.expando];if(!c){c=K.uid++;try{b[this.expando]={value:c},Object.defineProperties(a,b)}catch(d){b[this.expando]=c,n.extend(a,b)}}return this.cache[c]||(this.cache[c]={}),c},set:function(a,b,c){var d,e=this.key(a),f=this.cache[e];if("string"==typeof b)f[b]=c;else if(n.isEmptyObject(f))n.extend(this.cache[e],b);else for(d in b)f[d]=b[d];return f},get:function(a,b){var c=this.cache[this.key(a)];return void 0===b?c:c[b]},access:function(a,b,c){var d;return void 0===b||b&&"string"==typeof b&&void 0===c?(d=this.get(a,b),void 0!==d?d:this.get(a,n.camelCase(b))):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d,e,f=this.key(a),g=this.cache[f];if(void 0===b)this.cache[f]={};else{n.isArray(b)?d=b.concat(b.map(n.camelCase)):(e=n.camelCase(b),b in g?d=[b,e]:(d=e,d=d in g?[d]:d.match(E)||[])),c=d.length;while(c--)delete g[d[c]]}},hasData:function(a){return!n.isEmptyObject(this.cache[a[this.expando]]||{})},discard:function(a){a[this.expando]&&delete this.cache[a[this.expando]]}};var L=new K,M=new K,N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(O,"-$1").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?n.parseJSON(c):c}catch(e){}M.set(a,b,c)}else c=void 0;return c}n.extend({hasData:function(a){return M.hasData(a)||L.hasData(a)},data:function(a,b,c){ +return M.access(a,b,c)},removeData:function(a,b){M.remove(a,b)},_data:function(a,b,c){return L.access(a,b,c)},_removeData:function(a,b){L.remove(a,b)}}),n.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=M.get(f),1===f.nodeType&&!L.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=n.camelCase(d.slice(5)),P(f,d,e[d])));L.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){M.set(this,a)}):J(this,function(b){var c,d=n.camelCase(a);if(f&&void 0===b){if(c=M.get(f,a),void 0!==c)return c;if(c=M.get(f,d),void 0!==c)return c;if(c=P(f,d,void 0),void 0!==c)return c}else this.each(function(){var c=M.get(this,d);M.set(this,d,b),-1!==a.indexOf("-")&&void 0!==c&&M.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){M.remove(this,a)})}}),n.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=L.get(a,b),c&&(!d||n.isArray(c)?d=L.access(a,b,n.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=n.queue(a,b),d=c.length,e=c.shift(),f=n._queueHooks(a,b),g=function(){n.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return L.get(a,c)||L.access(a,c,{empty:n.Callbacks("once memory").add(function(){L.remove(a,[b+"queue",c])})})}}),n.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.lengthx",k.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var U="undefined";k.focusinBubbles="onfocusin"in a;var V=/^key/,W=/^(?:mouse|pointer|contextmenu)|click/,X=/^(?:focusinfocus|focusoutblur)$/,Y=/^([^.]*)(?:\.(.+)|)$/;function Z(){return!0}function $(){return!1}function _(){try{return l.activeElement}catch(a){}}n.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=L.get(a);if(r){c.handler&&(f=c,c=f.handler,e=f.selector),c.guid||(c.guid=n.guid++),(i=r.events)||(i=r.events={}),(g=r.handle)||(g=r.handle=function(b){return typeof n!==U&&n.event.triggered!==b.type?n.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(E)||[""],j=b.length;while(j--)h=Y.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o&&(l=n.event.special[o]||{},o=(e?l.delegateType:l.bindType)||o,l=n.event.special[o]||{},k=n.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&n.expr.match.needsContext.test(e),namespace:p.join(".")},f),(m=i[o])||(m=i[o]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,p,g)!==!1||a.addEventListener&&a.addEventListener(o,g,!1)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),n.event.global[o]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=L.hasData(a)&&L.get(a);if(r&&(i=r.events)){b=(b||"").match(E)||[""],j=b.length;while(j--)if(h=Y.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=n.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,m=i[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&q!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||n.removeEvent(a,o,r.handle),delete i[o])}else for(o in i)n.event.remove(a,o+b[j],c,d,!0);n.isEmptyObject(i)&&(delete r.handle,L.remove(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,m,o,p=[d||l],q=j.call(b,"type")?b.type:b,r=j.call(b,"namespace")?b.namespace.split("."):[];if(g=h=d=d||l,3!==d.nodeType&&8!==d.nodeType&&!X.test(q+n.event.triggered)&&(q.indexOf(".")>=0&&(r=q.split("."),q=r.shift(),r.sort()),k=q.indexOf(":")<0&&"on"+q,b=b[n.expando]?b:new n.Event(q,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=r.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+r.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:n.makeArray(c,[b]),o=n.event.special[q]||{},e||!o.trigger||o.trigger.apply(d,c)!==!1)){if(!e&&!o.noBubble&&!n.isWindow(d)){for(i=o.delegateType||q,X.test(i+q)||(g=g.parentNode);g;g=g.parentNode)p.push(g),h=g;h===(d.ownerDocument||l)&&p.push(h.defaultView||h.parentWindow||a)}f=0;while((g=p[f++])&&!b.isPropagationStopped())b.type=f>1?i:o.bindType||q,m=(L.get(g,"events")||{})[b.type]&&L.get(g,"handle"),m&&m.apply(g,c),m=k&&g[k],m&&m.apply&&n.acceptData(g)&&(b.result=m.apply(g,c),b.result===!1&&b.preventDefault());return b.type=q,e||b.isDefaultPrevented()||o._default&&o._default.apply(p.pop(),c)!==!1||!n.acceptData(d)||k&&n.isFunction(d[q])&&!n.isWindow(d)&&(h=d[k],h&&(d[k]=null),n.event.triggered=q,d[q](),n.event.triggered=void 0,h&&(d[k]=h)),b.result}},dispatch:function(a){a=n.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(L.get(this,"events")||{})[a.type]||[],k=n.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=n.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,c=0;while((g=f.handlers[c++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(g.namespace))&&(a.handleObj=g,a.data=g.data,e=((n.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(a.result=e)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!==this;i=i.parentNode||this)if(i.disabled!==!0||"click"!==a.type){for(d=[],c=0;h>c;c++)f=b[c],e=f.selector+" ",void 0===d[e]&&(d[e]=f.needsContext?n(e,this).index(i)>=0:n.find(e,this,null,[i]).length),d[e]&&d.push(f);d.length&&g.push({elem:i,handlers:d})}return h]*)\/>/gi,ba=/<([\w:]+)/,ca=/<|&#?\w+;/,da=/<(?:script|style|link)/i,ea=/checked\s*(?:[^=]|=\s*.checked.)/i,fa=/^$|\/(?:java|ecma)script/i,ga=/^true\/(.*)/,ha=/^\s*\s*$/g,ia={option:[1,""],thead:[1,"","
    "],col:[2,"","
    "],tr:[2,"","
    "],td:[3,"","
    "],_default:[0,"",""]};ia.optgroup=ia.option,ia.tbody=ia.tfoot=ia.colgroup=ia.caption=ia.thead,ia.th=ia.td;function ja(a,b){return n.nodeName(a,"table")&&n.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function ka(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function la(a){var b=ga.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function ma(a,b){for(var c=0,d=a.length;d>c;c++)L.set(a[c],"globalEval",!b||L.get(b[c],"globalEval"))}function na(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(L.hasData(a)&&(f=L.access(a),g=L.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;d>c;c++)n.event.add(b,e,j[e][c])}M.hasData(a)&&(h=M.access(a),i=n.extend({},h),M.set(b,i))}}function oa(a,b){var c=a.getElementsByTagName?a.getElementsByTagName(b||"*"):a.querySelectorAll?a.querySelectorAll(b||"*"):[];return void 0===b||b&&n.nodeName(a,b)?n.merge([a],c):c}function pa(a,b){var c=b.nodeName.toLowerCase();"input"===c&&T.test(a.type)?b.checked=a.checked:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}n.extend({clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=n.contains(a.ownerDocument,a);if(!(k.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||n.isXMLDoc(a)))for(g=oa(h),f=oa(a),d=0,e=f.length;e>d;d++)pa(f[d],g[d]);if(b)if(c)for(f=f||oa(a),g=g||oa(h),d=0,e=f.length;e>d;d++)na(f[d],g[d]);else na(a,h);return g=oa(h,"script"),g.length>0&&ma(g,!i&&oa(a,"script")),h},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,k=b.createDocumentFragment(),l=[],m=0,o=a.length;o>m;m++)if(e=a[m],e||0===e)if("object"===n.type(e))n.merge(l,e.nodeType?[e]:e);else if(ca.test(e)){f=f||k.appendChild(b.createElement("div")),g=(ba.exec(e)||["",""])[1].toLowerCase(),h=ia[g]||ia._default,f.innerHTML=h[1]+e.replace(aa,"<$1>")+h[2],j=h[0];while(j--)f=f.lastChild;n.merge(l,f.childNodes),f=k.firstChild,f.textContent=""}else l.push(b.createTextNode(e));k.textContent="",m=0;while(e=l[m++])if((!d||-1===n.inArray(e,d))&&(i=n.contains(e.ownerDocument,e),f=oa(k.appendChild(e),"script"),i&&ma(f),c)){j=0;while(e=f[j++])fa.test(e.type||"")&&c.push(e)}return k},cleanData:function(a){for(var b,c,d,e,f=n.event.special,g=0;void 0!==(c=a[g]);g++){if(n.acceptData(c)&&(e=c[L.expando],e&&(b=L.cache[e]))){if(b.events)for(d in b.events)f[d]?n.event.remove(c,d):n.removeEvent(c,d,b.handle);L.cache[e]&&delete L.cache[e]}delete M.cache[c[M.expando]]}}}),n.fn.extend({text:function(a){return J(this,function(a){return void 0===a?n.text(this):this.empty().each(function(){(1===this.nodeType||11===this.nodeType||9===this.nodeType)&&(this.textContent=a)})},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=ja(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=ja(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?n.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||n.cleanData(oa(c)),c.parentNode&&(b&&n.contains(c.ownerDocument,c)&&ma(oa(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(n.cleanData(oa(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return n.clone(this,a,b)})},html:function(a){return J(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!da.test(a)&&!ia[(ba.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(aa,"<$1>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(n.cleanData(oa(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,n.cleanData(oa(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,l=this.length,m=this,o=l-1,p=a[0],q=n.isFunction(p);if(q||l>1&&"string"==typeof p&&!k.checkClone&&ea.test(p))return this.each(function(c){var d=m.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(l&&(c=n.buildFragment(a,this[0].ownerDocument,!1,this),d=c.firstChild,1===c.childNodes.length&&(c=d),d)){for(f=n.map(oa(c,"script"),ka),g=f.length;l>j;j++)h=c,j!==o&&(h=n.clone(h,!0,!0),g&&n.merge(f,oa(h,"script"))),b.call(this[j],h,j);if(g)for(i=f[f.length-1].ownerDocument,n.map(f,la),j=0;g>j;j++)h=f[j],fa.test(h.type||"")&&!L.access(h,"globalEval")&&n.contains(i,h)&&(h.src?n._evalUrl&&n._evalUrl(h.src):n.globalEval(h.textContent.replace(ha,"")))}return this}}),n.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){n.fn[a]=function(a){for(var c,d=[],e=n(a),g=e.length-1,h=0;g>=h;h++)c=h===g?this:this.clone(!0),n(e[h])[b](c),f.apply(d,c.get());return this.pushStack(d)}});var qa,ra={};function sa(b,c){var d,e=n(c.createElement(b)).appendTo(c.body),f=a.getDefaultComputedStyle&&(d=a.getDefaultComputedStyle(e[0]))?d.display:n.css(e[0],"display");return e.detach(),f}function ta(a){var b=l,c=ra[a];return c||(c=sa(a,b),"none"!==c&&c||(qa=(qa||n("