Raincal's Blog

Gogs 与主机共享 22 端口

Sat, 10 Mar 2018 00:00:00 GMT

在使用 Docker 安装 Gogs 时，一般会把容器的 22 端口映射到主机的其它端口(比如 10022) 在以 SSH 方式 clone 项目时，URL 长这样

ssh://git@git.example.com:10022:username/project.git

但我们想要的是类似于 GitHub 那样的，这时需要把 Gogs 的 SSH 端口设置为 22

git@git.example.com:username/project.git

下面说一下主要步骤

创建 git 用户

[root]$ useradd git
[root]$ id git    # 获取uid和gid
uid=1002(git) gid=1002(git) groups=1002(git)
[root]$ usermod -aG docker git    # 把git用户加入docker组
[root]$ su git
[git]$ mkdir -p ~/gogs/data   # 在git用户下创建gogs/data文件夹，作为gogs容器主要数据的挂载目录

安装 Gogs

[git]$ docker run -d --name=gogs -p 10022:22 -p 10080:3000 -v ~/gogs/data:/data -e "PUID=1002" -e "PGID=1002" --restart=always gogs/gogs     # PUID PGID与上面获取的uid gid保持一致
[git]$ ln -s ~/gogs/data/git/.ssh ~/    # 将gogs的.ssh目录软连接到本地的.ssh

现在可以通过服务器外网 ip:10080 进入安装页面，也可以等反代设置好后通过域名进行访问我用的数据库是 Sqlite3，不需要额外配置，如果你选择的是其它数据库，可以参考这篇文章相关配置可以参考官方文档

生成 SSH key

[git]$ ssh-keygen -t rsa -b 4096 -C "git@git.example.com"
[git]$ cd ~/.ssh
[git]$ cat id_rsa.pub >> authorized_keys
[git]$ chmod 600 authorized_keys

在 authorized_keys 最前面添加

no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa AAAAB3NzaC1y..........YGedddqAN6w== git@git.example.com

Caddy 反向代理

[root]$ mkdir caddy && cd $_

在 caddy 目录下创建 Caddyfile 文件，下面是参考配置

git.example.com {
    tls git@example.com     # 填写你的邮箱，用于申请证书
    proxy / your-ip:10080
    header / Strict-Transport-Security "max-age=31536000;"      # 开启HSTS
    gzip
}

启动 caddy

[root]$ docker run -d --name=caddy -v ~/caddy/Caddyfile:/etc/Caddyfile -v ~/.caddy:/root/.caddy -p 80:80 -p 443:443 --restart=always abiosoft/caddy

配置 git 用户登录问题

[root]$ mkdir -p /app/gogs/
[root]$ cat >/app/gogs/gogs <<'END'
#!/bin/sh
ssh -p 10022 -o StrictHostKeyChecking=no git@127.0.0.1 \
"SSH_ORIGINAL_COMMAND=\"$SSH_ORIGINAL_COMMAND\" $0 $@"
END
[root]$ chmod 755 /app/gogs/gogs

这样就差不多完成了，下面需要在本地生成 SSH 密匙，然后在 web 端把密匙添加到 Gogs 如果需要修改 Gogs 的配置，比如安装的时候 DOMAIN 写的 IP 现在要修改为域名，可以到/home/git/gogs/data/gogs/conf/找到 app.ini，修改完后重启 gogs 容器

参考文章

安装 Gogs 并共享主机 22 端口

Share port 22 between Gogs inside Docker & the local system

NexT 主题优化：重构 leancloud 阅读量统计模块

Sun, 11 Feb 2018 00:00:00 GMT

为什么要重构

从去年 10 月份开始，LeanCloud 国内节点 API 的老版域名 api.leancloud.cn 在国外一些地区和国内少数地区会出现一定概率的解析错误（DNS 污染），这导致我们的博客阅读量无法正常显示

官方解决方案

如果使用的是原生 SDK，请尽快升级到以下版本：

Android 3.16.4 及更高版本
iOS 5.0.0 及更高版本
JavaScript 3.0.0 及更高版本

如果使用 REST API 来访问 api.leancloud.cn，请通过以下地址来动态获取应用专属的二级域名：

https://app-router.leancloud.cn/2/route?appId= <替换为 appId>

然后使用 api_server 指示的域名来访问我们的 API 服务，即可正常获得结果。

NexT 主题里使用的 SDK 是 av-core-mini-0.6.4，这个库 gzip 后有 28.5KB 对于一个只有几个请求的小模块来说，完全没必要用 SDK，可以手动请求官方 API 完成目的

重构后的代码可以到我的GitHub查看

grub rescue 模式下修复 Linux 引导

Wed, 22 Nov 2017 00:00:00 GMT

前些天把很久没用的 Windows10 更新了下，更新后就进不了 Linux 系统了，提示 "file '/boot/grub/x86_64-efi/normal.mod' not found"，之后就进入 grub rescue 模式了

解决方法很简单，在 grub rescue 模式下找到系统的启动分区，手动启动系统，之后重新安装 grub 到 efi 分区即可

grub rescue 下的操作

# 查看设备和分区情况
grub rescue> ls
(hd0) (hd0, gpt2) (hd0, gpt1) ...
# 查看分区文件确定启动分区位置
grub rescue> ls (hd1, gpt10)/
# 设置启动分区，载入启动需要的模块
grub rescue> set root=(hd1, gpt10)
grub rescue> set prefix=(hd1, gpt10)/boot/grub
grub rescue> insmod normal
grub rescue> normal

执行完 normal 命令后，顺利的话就能进入系统了

查找 boot/efi

通过命令 df 查看 boot/efi 所在挂载点

重新安装 grub

➜ sudo grub-install /dev/sda1

VSCode icon 分享

Thu, 12 Oct 2017 00:00:00 GMT

Icon created for Visual Studio Code

Reference iiroj/public

Download

Raincal/vscode-icon

使用 Docker 部署 FlarumChina

Mon, 07 Aug 2017 00:00:00 GMT

前期准备

服务器安装 Docker 和 Docker Compose

参考教程： http://get.daocloud.io/#install-docker

没有服务器的可以在本地安装 Docker 或使用 DaoCloud 的胶囊主机, 能免费体验 120 分钟，足够学习使用

路径：自有主机 -> 集群管理 -> 添加主机

安装 Flarum

我们使用到的镜像是 raincal/docker-flarum-china

Ports

8888

Volume

/flarum/app/assets : FlarumChina 资源目录
/flarum/app/extensions : FlarumChina 插件目录

环境变量

变量	描述	类型	默认值
UID	Flarum user id	optional	991
GID	Flarum group id	optional	991
DEBUG	Flarum debug mode	optional	false
FORUM_URL	Forum URL	required	none
DB_HOST	MariaDB instance ip/hostname	optional	mariadb
DB_USER	MariaDB database username	optional	flarum
DB_NAME	MariaDB database name	optional	flarum
DB_PASS	MariaDB database password	required	none
DB_PREF	Flarum tables prefix	optional	none
UPLOAD_MAX_SIZE	The maximum size of an uploaded file	optional	50M
MEMORY_LIMIT	maximum amount of memory used by php	optional	128M

编写 docker-compose.yml 文件

mkdir flarum && cd flarum
vi docker-compose.yml

根据自身情况修改

FORUM_URL

DB_PASS

MYSQL_ROOT_PASSWORD

MYSQL_PASSWORD

等环境变量

flarum:
  image: raincal/docker-flarum-china:0.1.0-beta.7-stable
  container_name: flarum
  links:
    - mariadb:mariadb
  environment:
    - FORUM_URL=https://forum.domain.tld
    - DB_PASS=123456
  volumes:
    - /mnt/docker/flarum/assets:/flarum/app/assets
    - /mnt/docker/flarum/extensions:/flarum/app/extensions

mariadb:
  image: mariadb:10.1
  container_name: mariadb
  volumes:
    - /mnt/docker/mysql/db:/var/lib/mysql
  environment:
    - MYSQL_ROOT_PASSWORD=123456
    - MYSQL_DATABASE=flarum
    - MYSQL_USER=flarum
    - MYSQL_PASSWORD=123456

nginx:
  image: wonderfall/boring-nginx
  container_name: nginx
  links:
    - flarum:flarum
  ports:
    - "80:8000"
    - "443:4430"
  volumes:
    - /mnt/docker/nginx/sites-enabled:/sites-enabled
    - /mnt/docker/nginx/conf:/conf.d
    - /mnt/docker/nginx/log:/var/log/nginx
    - /mnt/docker/nginx/certs:/certs

启动应用

docker-compose up -d

若使用胶囊主机，可以到自有主机 -> Stack -> 创建新 Stack

设置 nginx 反向代理

通过 ssh 连接到胶囊主机

ssh ubuntu@52.80.37.119

docker exec -it nginx ngxproxy

Welcome to ngxproxy utility.
We're about to create a new virtual host (AKA server block).

Name: flarum
Domain: forum.domain.tld
Webroot (default is /):
Container: flarum
Port (default is 80): 8888
HTTPS [y/n]: n
Max body size in MB (integer/null): 50

Done! flarum.conf has been generated.
Reload nginx now? [y/n]: y
nginx successfully reloaded.

完成后访问外网IP 52.80.37.119，本地环境的话访问 localhost 开始安装 flarum

管理员密码需要大于8位

10 个可用 ES6 替代的 Lodash 特性

Thu, 30 Jun 2016 00:00:00 GMT

本文转载自：众成翻译译者：少年阿布 DX 链接：http://www.zcfy.cc/article/467 原文：https://www.sitepoint.com/lodash-features-replace-es6/

Dan Prince

本文由 Mark Brown 协助审查。感谢所有 SitePoint 的审稿人使 SitePoint 的内容能达到最佳。

Lodash 现在是 npm 上被依赖最多的包，但如果你在使用 ES6 的话，实际上你可能不再需要它了。在本文中，我们将使用原生的集合方法与箭头函数还有一些其它新的特性来帮我们更简便地实现许多热门的用例。

1. Map, Filter, Reduce

这些集合方法使数据转化变得轻而易举。由于普遍地对此特性的支持，我们可以将它与箭头函数组合起来，以助我们使用比 Lodash 的实现更简便的方法来实现。

_.map([1, 2, 3], function(n) {
  return n * 3
})
// [3, 6, 9]
_.reduce(
  [1, 2, 3],
  function(total, n) {
    return total + n
  },
  0
)
// 6
_.filter([1, 2, 3], function(n) {
  return n <= 2
})
// [1, 2]

// 变为

;[1, 2, 3].map(n => n * 3)
;[1, 2, 3].reduce((total, n) => total + n)
;[1, 2, 3].filter(n => n <= 2)

不止于此，如果我们使用 ES6 的 polyfill，我们也能使用 find、some、every 和 reduceRight

2. Head & Tail

解构语法让我们可以获取一个列表的头（head）和尾（tail），而无需工具函数。

_.head([1, 2, 3])
// 1
_.tail([1, 2, 3])
// [2, 3]

// 变为

const [head, ...tail] = [1, 2, 3]

也可以用相似的方式获得列表最后一个元素（last）以及除其之外的元素（initial）

_.initial([1, 2, 3])
// -> [1, 2]
_.last([1, 2, 3])
// 3

// 变为

const [last, ...initial] = [1, 2, 3].reverse()

如果你讨厌 reverse 会改变数据结构，那你可以在调用 reverse 之前使用延展操作符（spread operator）来复制一个数组。

const xs = [1, 2, 3]
const [last, ...initial] = [...xs].reverse()

3. Rest & Spread

rest 和 spread 函数能让我们定义与调用能接受参数数量不定的函数。ES6 为这两种操作引入了专用的语法。

var say = _.rest(function(what, names) {
  var last = _.last(names)
  var initial = _.initial(names)
  var finalSeparator = _.size(names) > 1 ? ', & ' : ''
  return what + ' ' + initial.join(', ') + finalSeparator + _.last(names)
})

say('hello', 'fred', 'barney', 'pebbles')
// "hello fred, barney, & pebbles"

// 变为

const say = (what, ...names) => {
  const [last, ...initial] = names.reverse()
  const finalSeparator = names.length > 1 ? ', &' : ''
  return `${what} ${initial.join(', ')} ${finalSeparator} ${last}`
}

say('hello', 'fred', 'barney', 'pebbles')
// "hello fred, barney, & pebbles"

4. Curry

如果没有更高级的语言如 TypeScript 和 Flow 的支持，我们不能给函数设置类型签名，这使得函数的柯里化（currying）非常困难。当我们接收一个柯里化的函数时，很难知道已经应用了多少参数以及我们接下来该提供什么参数。通过箭头函数，我们能显示地定义柯里化函数，使得它们对其他程序员来说非常易于理解。

function add(a, b) {
  return a + b
}
var curriedAdd = _.curry(add)
var add2 = curriedAdd(2)
add2(1)
// 3

// 变为

const add = a => b => a + b
const add2 = add(2)
add2(1)
// 3

这些显式的柯里化箭头函数对调试非常重要。

var lodashAdd = _.curry(function(a, b) {
  return a + b
})
var add3 = lodashAdd(3)
console.log(add3.length)
// 0
console.log(add3)
//function wrapper() {
//  var length = arguments.length,
//  args = Array(length),
//  index = length;
//
//  while (index--) {
//    args[index] = arguments[index];
//  }…

// 变为

const es6Add = a => b => a + b
const add3 = es6Add(3)
console.log(add3.length)
// 1
console.log(add3)
// function b => a + b

如果我们使用函数式的库如 lodash/fp 和 ramda，那我们也能使用箭头函数来免除对自动柯里化风格的需要。

_.map(_.prop('name'))(people)

// 变为

people.map(person => person.name)

5. Partial

正如柯里化一样，我们也能使用箭头函数来简化显式化偏函数用法。

var greet = function(greeting, name) {
  return greeting + ' ' + name
}

var sayHelloTo = _.partial(greet, 'hello')
sayHelloTo('fred')
// "hello fred"

// 变为

const sayHelloTo = name => greet('hello', name)
sayHelloTo('fred')
// "hello fred"

我们也能结合剩余参数与延展操作符来部分地应用可变参数函数、

const sayHelloTo = (name, ...args) => greet('hello', name, ...args)
sayHelloTo('fred', 1, 2, 3)
// "hello fred"

6. Operators

Lodash 把很多句法操作符重新实现成了函数，所以它们可以被传入集合方法。

在大多数情况下，箭头函数能让它们定义地足够简单精炼，一行足矣。

_.eq(3, 3)
// true
_.add(10, 1)
// 11
_.map([1, 2, 3], function(n) {
  return _.multiply(n, 10)
})
// [10, 20, 30]
_.reduce([1, 2, 3], _.add)
// 6

// 变为

3 === 3
10 + (1)[(1, 2, 3)].map(n => n * 10)
;[1, 2, 3].reduce((total, n) => total + n)

7. Paths

许多 Lodash 的函数把路径当做字符串或者数组。然而我们可以使用箭头函数来创建更多可重用的路径。

var object = { a: [{ b: { c: 3 } }, 4] }

_.at(object, ['a[0].b.c', 'a[1]'])
// [3, 4]
_.at(['a', 'b', 'c'], 0, 2)
// ['a', 'c']

// 变为

;[obj => obj.a[0].b.c, obj => obj.a[1]].map(path => path(object))

;[arr => arr[0], arr => arr[2]].map(path => path(['a', 'b', 'c']))

因为这些路径“只是函数”，所以我们也能复合它们。

const getFirstPerson = people => people[0]
const getPostCode = person => person.address.postcode
const getFirstPostCode = people => getPostCode(getFirstPerson(people))

我们甚至能创建更高阶能接收参数的路径。

const getFirstNPeople = n => people => people.slice(0, n)

const getFirst5People = getFirstNPeople(5)
const getFirst5PostCodes = people => getFirst5People(people).map(getPostCode)

8. Pick

pick 工具能让我们从一个对象中选择我们想要的属性。我们也能通过解构与对象字面量简写来获取同样的结果。

var object = { a: 1, b: '2', c: 3 }

return _.pick(object, ['a', 'c'])
// { a: 1, c: 3 }

// 变为

const { a, c } = { a: 1, b: 2, c: 3 }

return { a, c }

9. Constant, Identity, Noop

Lodash 提供了一些工具函数来创建简单的具某一特定行为的函数。

_.constant({ a: 1 })()
// { a: 1 }
_.identity({ user: 'fred' })
// { user: 'fred' }
_.noop()
// undefined

我们也能使用箭头函数行内定义这些函数。

const constant = x => () => x
const identity = x => x
const noop = () => undefined

或者我们也能把上面的例子重写为：

;(() => ({ a: 1 }))()
// { a: 1 }
;(x => x)({ user: 'fred' })
// { user: 'fred' }
;(() => undefined)()
// undefined

10. Chaining & Flow

Lodash 提供了一些函数来帮我们编写链式的语句。在大多情况下，内置的集合函数会返回一个数组实例，能直接被链式调用。但某些情况下，这些方法会改变这个集合，这样就不可能再直接地链式调用了（译者注：需要自己返回实例）。

然而我们也能以一个箭头函数数组来定义同样的转化。

_([1, 2, 3])
  .tap(function(array) {
    // 修改输入函数
    array.pop()
  })
  .reverse()
  .value()
// [2, 1]

// 变为

const pipeline = [
  array => {
    array.pop()
    return array
  },
  array => array.reverse(),
]

pipeline.reduce((xs, f) => f(xs), [1, 2, 3])

这样的话，我们甚至不需要去思考 tap 和 thru 的不同。把这个归约包装成工具函数能创造出一个非常有用的多功能工具。

const pipe = functions => data => {
  return functions.reduce((value, func) => func(value), data)
}

const pipeline = pipe([x => x * 2, x => x / 3, x => x > 5, b => !b])

pipeline(5)
// true
pipeline(20)
// false

总结

Lodash 仍然还是一个非常优秀的库，这篇文章只提供了一个新鲜的观点，JavaScript 的进化版是如何让我们在一些我们之前可能不得不依赖一些工具模块的场景里允许我们直接解决问题的。

不要忽略它（译者注：Lodash），但——下次你需求一个抽象时——思考一下是否一个简单的函数就能办到了！

mongoDB 常用命令

Fri, 10 Jul 2015 00:00:00 GMT

安装

mongoDB 官网下载安装（Windows 安装方法）

基础知识

集合——对应关系数据库中的表

文档——对应关系数据库中的行

启动数据库服务

定位到安装目录下的 bin 文件夹里后

> mongod --dbpath ../data/db

如没有data/db文件夹，需先创建，dbpath用于指定数据存放位置

开启一个客户端访问数据库

同样的 bin 文件夹下执行

> mongo

默认连接至test数据库

显示帮助

> help

显示所有数据库名称

> show dbs

切换数据库

> use test

显示当前连接的数据库名称

> db

显示当前数据库所有集合

> show collections

显示数据库支持的方法

> db.help()

显示集合支持的方法

> db.users.help()

创建集合

> db.createCollection("users")

插入操作 insert

> db.users.insert({"name":"kiinlam","age":28})

查询操作 find

查找所有文档

> db.users.find()

查找指定文档

> db.users.find({"name":"kiinlam"})

查询一条

> db.users.findOne({"name":"kiinlam"})

大于\$gt

> db.users.find({"age":{$gt:22}})

大于等于\$gte

> db.users.find({"age":{$gte:22}})

小于\$lt

> db.users.find({"age":{$lt:22}})

小于等于\$gte

> db.users.find({"age":{$lte:22}})

不等于\$ne

> db.users.find("age":{$ne:22})

或\$or

> db.users.find({$or:[{"name":"kiinlam"},{"name":"cheungkiinlam"}]})

在集合中\$in

> db.users.find("name":{$in:["kiinlam","cheungkiinlam"]})

不在集合中\$nin

> db.users.find("name":{$nin:["kiinlam","cheungkiinlam"]})

正则查询

> db.users.find({"name":/^k/,"name":/m$/})

筛选查询\$where

// 使用js function作为筛选条件
> db.users.find({$where: function(){return this.name=='kiinlam'}})

限制查询数量 limit

> db.users.find({"age":22}).limit(10)

更新操作 update

指定文档全部更新，等于覆盖

> db.users.update({"name":"kiinlam"}, {"name":"cheungkiinlam","age":27})

局部更新一：增量更新\$inc

// age增加2，其他不变
> db.users.update({"name":"kiinlam"}, {$inc:{"age":2}})

局部更新二：字段修改\$set

// age改为20
> db.users.update({"name":"kiinlam"}, {$set:{"age":20}})

新增更新：如果不存在，就新增一条

// 第三个参数为true
> db.users.update({"name":"kiinlam"}, {$set:{"age":18}}, true)

批量更新

// 如果匹配多条，默认只改第一条，将第四个参数设为true可全部更新
> db.users.update({"name":"kiinlam"}, {$set:{"age":18}}, true, true)

保存操作 save

// 插入新文档，如果不提供"_id"字段
> db.users.save({"name":"kiinlam", "age":28})
// 更新已存在的文档
> db.users.save({"_id":"xxx","name":"kiinlam", "age":28})

删除操作 remove

删除操作不可恢复

删除所有，但不删除索引

> db.users.remove({})

删除指定文档

> db.users.remove({"name":"kiinlam"})

删除一条指定文档，如果有多条结果

> db.users.remove({"name":"kiinlam"}, true)

完全删除集合，包括索引，应当使用drop

大量删除时，采用复制需要保留的文档到新集合，再用drop删除集合。

删除数据库

> db.dropDatabase()

删除集合

> db.users.drop()

计数操作 count

> db.users.count()
> db.users.count({"age":29})

唯一值查询 distinct

指定字段有多个相同时，只取一个，返回指定字段的值组合成的数组

> db.users.distinct("age")

分组操作 group

按照age进行分组操作，分组结果存放在user中，值为对应age的 name 值的数组

key：分组依据

initial：初始化函数，每个不同的 age 组共享同一个函数

$reduce：第一个参数为当前文档，第二参数为前一次函数操作的累计对象，第一次为initial对应的对象

> db.users.group({
                    "key": {"age": true},
                    "initial": {"user": []},
                    "$reduce": function(cur,prev){
                        prev.user.push(cur.name);
                    }
                })

假设有数据如下：

{ "_id" : ObjectId("55910457607379845607d9e2"), "name" : "kiinlam", "age" : 29 }
{ "_id" : ObjectId("55910468607379845607d9e3"), "name" : "shadow", "age" : 26 }
{ "_id" : ObjectId("55910992607379845607d9e5"), "name" : "foo", "age" : 29 }
{ "_id" : ObjectId("55911fca607379845607d9e6"), "name" : "dd", "age" : 22 }
{ "_id" : ObjectId("55911fd3607379845607d9e7"), "name" : "mm", "age" : 22 }
{ "_id" : ObjectId("55911fdf607379845607d9e8"), "name" : "gg", "age" : 22 }
{ "_id" : ObjectId("55911feb607379845607d9e9"), "name" : "jj", "age" : 22 }
{ "_id" : ObjectId("55920545ff40738c1fd0a839"), "name" : "zz", "age" : 1 }

分组结果为：

[
        {
                "age" : 29,
                "user" : [
                        "kiinlam",
                        "foo"
                ]
        },
        {
                "age" : 26,
                "user" : [
                        "shadow"
                ]
        },
        {
                "age" : 22,
                "user" : [
                        "dd",
                        "mm",
                        "gg",
                        "jj"
                ]
        },
        {
                "age" : 1,
                "user" : [
                        "zz"
                ]
        }
]

mapReduce

map：映射函数，内部调用emit(key,value)，集合按照key进行映射分组。

reduce：简化函数，对map分组后的数据进行分组简化，reduce(key,value)中的key是emit中的key，而value则是emit分组结果的集合。

mapReduce：最后执行的函数，参数为map、reduce和一些可选参数。

> db.users.mapReduce
function ( map , reduce , optionsOrOutString ){
    var c = { mapreduce : this._shortName , map : map , reduce : reduce };
    assert( optionsOrOutString , "need to supply an optionsOrOutString" )

    if ( typeof( optionsOrOutString ) == "string" )
        c["out"] = optionsOrOutString;
    else
        Object.extend( c , optionsOrOutString );

    var raw = this._db.runCommand( c );
    if ( ! raw.ok ){
        __mrerror__ = raw;
        throw Error( "map reduce failed:" + tojson(raw) );
    }
    return new MapReduceResult( this._db , raw );

}

创建map函数

function (){
    emit(this.name,{count:1});
}

创建reduce函数

function (key,value){
    var result = {count:0};
    for(var i = 0; i < value.length; i++){
        result.count += value[i].count;
    }
    return result;
}

执行mapReduce操作

> db.users.mapReduce(map,reduce,{"out":"collection"})

假设有数据如下

{ "_id" : ObjectId("55910457607379845607d9e2"), "name" : "kiinlam", "age" : 29 }
{ "_id" : ObjectId("55910468607379845607d9e3"), "name" : "shadow", "age" : 26 }
{ "_id" : ObjectId("55910992607379845607d9e5"), "name" : "foo", "age" : 29 }
{ "_id" : ObjectId("55920545ff40738c1fd0a839"), "name" : "zz", "age" : 1 }
{ "_id" : ObjectId("55911fca607379845607d9e6"), "name" : "foo", "age" : 22 }
{ "_id" : ObjectId("55911fd3607379845607d9e7"), "name" : "foo", "age" : 22 }
{ "_id" : ObjectId("55911fdf607379845607d9e8"), "name" : "foo", "age" : 22 }
{ "_id" : ObjectId("55911feb607379845607d9e9"), "name" : "foo", "age" : 22 }

输出结果

{
        "result" : "collection",    // 存放最终结果的集合名
        "timeMillis" : 28,
        "counts" : {
                "input" : 8,    // 传入文档的次数
                "emit" : 8,    // emit函数被调用次数
                "reduce" : 1,    // reduce函数被调用次数
                "output" : 4    // 最后返回文档的个数
        },
        "ok" : 1
}

查看集合collection中的结果

> db.collection.find()

输出结果

{ "_id" : "foo", "value" : { "count" : 5 } }
{ "_id" : "kiinlam", "value" : { "count" : 1 } }
{ "_id" : "shadow", "value" : { "count" : 1 } }
{ "_id" : "zz", "value" : { "count" : 1 } }

游标

游标只表示一个引用，并不是真正的执行，在需要的时候，通过 for 循环或next()方法进行遍历读取，枚举结束后，游标销毁，不再返回数据。

申明一个游标

> var list = db.collection.find()

通过forEach遍历游标

> list.forEach(function(i){
      print(i._id);
  })

输出结果

foo
kiinlam
shadow
zz

或者通过next遍历集合

> var list = db.collection.find()
> list.next()
{ "_id" : "foo", "value" : { "count" : 5 } }
> list.next()
{ "_id" : "kiinlam", "value" : { "count" : 1 } }
> list.next()
{ "_id" : "shadow", "value" : { "count" : 1 } }
> list.next()
{ "_id" : "zz", "value" : { "count" : 1 } }
> list.next()
2015-07-01T11:27:38.186+0800 E QUERY    Error: error hasNext: false
    at Error (<anonymous>)
    at DBQuery.next (src/mongo/shell/query.js:255:15)
    at (shell):1:6 at src/mongo/shell/query.js:255
> list
>

索引 ensureIndex

建立索引

// 1为升序，-1为降序
> db.users.ensureIndex({"name":1})

唯一索引

> db.users.ensureIndex({"name":1},{"unique":true})

组合索引

> db.users.ensureIndex({"name":1, "age":-1})

查看索引

> db.users.getIndexes()

按指定索引查询

> db.users.find({"name":"kiinlam"}).hint({"name":1,"age":1})

删除索引

// 删除所有自定义索引
> db.users.dropIndexes()
// 删除指定索引
> db.users.dropIndex("name_1")

性能分析函数 explain

> db.users.find().explain("executionStats")

主从数据库部署

创建主数据库 master

> mongod --dbpath=XXX --master

创建从数据库 slave

// 指定从数据库端口--port
// 指定主数据库源--source
> mongod --dbpath=XXX --port=8888 --slave --source=127.0.0.1:27017

后期指定主数据库源

> mongod --dbpath=XXX --port=8888 --slave
// 后期添加源
// 切换到local数据库
> use local
// 在sources中加入源地址
> db.sources.insert({"host":"127.0.0.1:27017"})

副本集 replSet

该架构没有特定的主数据库，一个数据库宕机了，另一个数据库会顶上

创建第一个数据库服务器

// 需要指定集群名及下一个数据库地址
> mongod --dbpath=XXX --port 2222 --replSet mySet/127.0.0.1:3333

创建第二个数据库服务器

> mongod --dbpath=XXX --port 3333 --replSet mySet/127.0.0.1:2222

初始化副本集

// 进入任一数据库的admin集合
> mongo 127.0.0.1:2222/admin
// 执行初始化操作
> db.runCommand({
                    "replSetInitiate":{
                        "_id":"mySet",
                        "members":[
                            {
                                "_id":1,
                                "host":"127.0.0.1:2222"
                            },
                            {
                                "_id":2,
                                "host":"127.0.0.1:3333"
                            }
                        ]
                    }
                })

仲裁服务器

// 启动仲裁服务器
> mongod --dbpath=XXX --port 4444 --replSet mySet/127.0.0.1:2222
// 回到admin集合中添加仲裁服务器
> mongo 127.0.0.1:2222/admin
> rs.addArb("127.0.0.1:4444")
// 查看服务器集群状态
> rs.status()

分片技术

将集合进行拆分，将拆分的数据均摊到几个分片上。

主要参与者：

客户端
路由服务器 mongos
配置服务器
分片数据库实例

开启配置服务器 config

> mongod --dbpath=XXX --port 2222

开启路由服务器 mongos

// 指定配置服务器
> mongos --port 3333 --configdb=127.0.0.1:2222

开启分片数据库服务器 mongod

> mongod --dbpath=XXX --port 4444
> mongod --dbpath=XXX --port 5555

服务配置

// 进入mongos数据库admin集合
> mongo 127.0.0.1:3333/admin
// 添加分片服务器addshard
> db.runCommand({
                    "addshard":"127.0.0.1:4444",
                    "allowLocal":true
                })
> db.runCommand({
                    "addshard":"127.0.0.1:5555",
                    "allowLocal":true
                })
// 开启数据库test的分片功能enablesharding
> db.runCommand({"enablesharding":"test"})
// 指定集合中分片的片键users.name
> db.runCommand({"shardcollection":"test.users","key":{"name":1}})
// 在mongos中查看数据分片情况
> use test
> db.printShardingStatus()

运维

运维通常会涉及到以下 4 个方面

安装部署
状态监控
安全认证
备份和恢复

安装部署为 windows 服务

// 指定日志路径，添加install参数
> mongod --dbpath=XXX --logpath=XXX --port=2222 --install
// 启动服务
> net start MongoDB

状态监控

静态统计

db.stats()

// 查看单个数据库状态
> db.stats()

stats比较简单，可以参考db.stats()一文

db.serverStatus()

// 查看整个mongodb的状态
// 进入admin集合
> mongo 127.0.0.1:2222/admin
// 查看状态
> db.serverStatus()

serverStatus的参数很多，可以参考db.serverStatus()一文

实时统计

> mongostat --port 2222

安全认证

TODO

有点复杂，偷懒了，参考安全认证

备份和恢复

// 备份test数据库到D:\mongodb\backup
> mongodump --port 2222 -d test -o D:\mongodb\backup
// 恢复数据，drop表示恢复前删除原有数据
> mongorestore --port 2222 -d test --drop D:\mongodb\backup

参考资料

Mac OS 终端使用 subl 运行 Sublime Text 3

Sat, 09 May 2015 00:00:00 GMT

1.添加 link

ln -s /Applications/Sublime\ Text.app/Contents/SharedSupport/bin/subl /usr/local/bin/subl

2.编辑 PATH

vim ~/.bash_profile

3.添加 PATH

export PATH=/usr/local/bin:$PATH

esc -> shift + : -> wq保存退出

4.应用

source ~/.bash_profile