GOLANG中DEFER, PANIC, RECOVER用法

回复

haohongfan 发起了问题 • 1 人关注 • 0 个回复 • 286 次浏览 • 2017-07-21 11:37 • 来自相关话题

Go面试题答案与解析

ysqi 发表了文章 • 13 个评论 • 760 次浏览 • 2017-07-20 12:59 • 来自相关话题

pprof简单教程

caibirdme 发表了文章 • 4 个评论 • 677 次浏览 • 2017-07-20 11:24 • 来自相关话题

昨晚写了个pprof的简单教程放在了github上,结合一个比较脑残例子通过pprof找到瓶颈并进行优化,翔见 查看全部

昨晚写了个pprof的简单教程放在了github上,结合一个比较脑残例子通过pprof找到瓶颈并进行优化,翔见 hand-to-hand-optimize-go

glide从入门到使用教程

qiangmzsx 发表了文章 • 3 个评论 • 423 次浏览 • 2017-07-19 18:58 • 来自相关话题

介绍

不论是开发Java还是你正在学习的Golang,都会遇到依赖管理问题。Java有牛逼轰轰的Maven和Gradle。 Golang亦有godep、govendor、glide、gvt、gopack... 查看全部

介绍


不论是开发Java还是你正在学习的Golang,都会遇到依赖管理问题。Java有牛逼轰轰的Maven和Gradle。
Golang亦有godep、govendor、glide、gvt、gopack等等,本文主要给大家介绍gilde
glide是Golang的包管理工具,是为了解决Golang依赖问题的。
为什么需要glide?
原因很简单,Go 语言原生包管理的缺陷。罗列一下golang的 get 子命令管理依赖有很多大缺陷:



  • 能拉取源码的平台很有限,绝大多数依赖的是 github.com

  • 不能区分版本,以至于令开发者以最后一项包名作为版本划分

  • 依赖 列表/关系 无法持久化到本地,需要找出所有依赖包然后一个个 go get

  • 只能依赖本地全局仓库(GOPATH/GOROOT),无法将库放置于局部仓库($PROJECT_HOME/vendor)


安装


Golang环境设置


采用vendor目录特性,Go 1.5 做为试验特性加入(需要指定 GO15VENDOREXPERIMENT=1 环境变量),并在 Go 1.6 正式引入的一个概念。多数 go 依赖解决方案都基于它的。GO15VENDOREXPERIMENT 是 Go 1.5 版本新增的一个环境变量,如果将值改为 1 则表示启用。它可以将项目根目录名为 vendor 的目录添加到 Go 的库搜寻路径中,实现一个局部依赖的效果。

特性在 1.5 版本作为实验特性被添加,1.6 中默认被启用,1.7 移除变量加入标准中。

Go 提供了原始的 go get ,让第三方包管理可以基于 go get 做扩展。GO15VENDOREXPERIMENT 特性让局部依赖成为现实。Go 官方在给第三方包管理营造条件以及引导开发者用户至所推荐的方向,促进社区的繁荣。证明了一个语言技术的生态不仅仅只能靠官方或者取决于官方的完善程度。


//设置环境变量 使用vendor目录
GO15VENDOREXPERIMENT=1

为什么要选择glide?
Glide 是众多实现 GO15VENDOREXPERIMENT 特性的包管理工具之一,但它是本文最为推荐的,具体为什么推荐它,原因很简单,因为它目前最受关注。
几大主要功能:



  • 持久化依赖列表至配置文件中,包括依赖版本(支持范围限定)以及私人仓库等

  • 持久化关系树至 lock 文件中(类似于 yarn 和 cargo),以重复拉取相同版本依赖

  • 兼容 go get 所支持的版本控制系统:Git, Bzr, HG, and SVN

  • 支持 GO15VENDOREXPERIMENT 特性,使得不同项目可以依赖相同项目的不同版本

  • 可以导入其他工具配置,例如: Godep, GPM, Gom, and GB


安装glide


$ go get github.com/Masterminds/glide
$ go install github.com/Masterminds/glide

验证


$ glide
NAME:
glide - Vendor Package Management for your Go projects.

Each project should have a 'glide.yaml' file in the project directory. Files
look something like this:

package: github.com/Masterminds/glide
imports:
- package: github.com/Masterminds/cookoo
version: 1.1.0
- package: github.com/kylelemons/go-gypsy
subpackages:
- yaml

For more details on the 'glide.yaml' files see the documentation at
https://glide.sh/docs/glide.yaml

USAGE:
glide [global options] command [command options] [arguments...]

VERSION:
0.13.0-dev

COMMANDS:
create, init Initialize a new project, creating a glide.yaml file
config-wizard, cw Wizard that makes optional suggestions to improve config in a glide.yaml file.
get Install one or more packages into `vendor/` and add dependency to glide.yaml.
remove, rm Remove a package from the glide.yaml file, and regenerate the lock file.
import Import files from other dependency management systems.
name Print the name of this project.
novendor, nv List all non-vendor paths in a directory.
rebuild Rebuild ('go build') the dependencies
install, i Install a project's dependencies
update, up Update a project's dependencies
tree (Deprecated) Tree prints the dependencies of this project as a tree.
list List prints all dependencies that the present code references.
info Info prints information about this project
cache-clear, cc Clears the Glide cache.
about Learn about Glide
mirror Manage mirrors
help, h Shows a list of commands or help for one command

GLOBAL OPTIONS:
--yaml value, -y value Set a YAML configuration file. (default: "glide.yaml")
--quiet, -q Quiet (no info or debug messages)
--debug Print debug verbose informational messages
--home value The location of Glide files (default: "/home/users/qiangmzsx/.glide") [$GLIDE_HOME]
--tmp value The temp directory to use. Defaults to systems temp [$GLIDE_TMP]
--no-color Turn off colored output for log messages
--help, -h show help
--version, -v print the version

看到这样,那就恭喜你,已经安装成功了!!!


使用


篇幅有限,我只介绍经常使用到的。
先进入在GOPATH的一个项目中。


cd $GOPATH/src/foor

初始化 (glide init)


$ glide init
[INFO] Generating a YAML configuration file and guessing the dependencies
[INFO] Attempting to import from other package managers (use --skip-import to skip)
[INFO] Scanning code to look for dependencies
[INFO] --> Found reference to github.com/urfave/cli
[INFO] Writing configuration file (glide.yaml)
[INFO] Would you like Glide to help you find ways to improve your glide.yaml configuration?
[INFO] If you want to revisit this step you can use the config-wizard command at any time.
[INFO] Yes (Y) or No (N)?
Y
[INFO] Loading mirrors from mirrors.yaml file
[INFO] Looking for dependencies to make suggestions on
[INFO] --> Scanning for dependencies not using version ranges
[INFO] --> Scanning for dependencies using commit ids
[INFO] Gathering information on each dependency
[INFO] --> This may take a moment. Especially on a codebase with many dependencies
[INFO] --> Gathering release information for dependencies
[INFO] --> Looking for dependency imports where versions are commit ids
[INFO] Here are some suggestions...
[INFO] The package github.com/urfave/cli appears to have Semantic Version releases (http://semver.org).
[INFO] The latest release is v1.19.1. You are currently not using a release. Would you like
[INFO] to use this release? Yes (Y) or No (N)
Y
[INFO] Would you like to remember the previous decision and apply it to future
[INFO] dependencies? Yes (Y) or No (N)
Y
[INFO] Updating github.com/urfave/cli to use the release v1.19.1 instead of no release
[INFO] The package github.com/urfave/cli appears to use semantic versions (http://semver.org).
[INFO] Would you like to track the latest minor or patch releases (major.minor.patch)?
[INFO] Tracking minor version releases would use '>= 1.19.1, < 2.0.0' ('^1.19.1'). Tracking patch version
[INFO] releases would use '>= 1.19.1, < 1.20.0' ('~1.19.1'). For more information on Glide versions
[INFO] and ranges see https://glide.sh/docs/versions
[INFO] Minor (M), Patch (P), or Skip Ranges (S)?
P
[INFO] Would you like to remember the previous decision and apply it to future
[INFO] dependencies? Yes (Y) or No (N)
Y
[INFO] Updating github.com/urfave/cli to use the range ~1.19.1 instead of commit id v1.19.1
[INFO] Configuration changes have been made. Would you like to write these
[INFO] changes to your configuration file? Yes (Y) or No (N)
Y
[INFO] Writing updates to configuration file (glide.yaml)
[INFO] You can now edit the glide.yaml file.:
[INFO] --> For more information on versions and ranges see https://glide.sh/docs/versions/
[INFO] --> For details on additional metadata see https://glide.sh/docs/glide.yaml/
$ ll
glide.yaml
$ cat glide.yaml
package: foor
import: []

在初始化过程中, glide 会询问一些问题。
glide.yaml记载了依赖包的列表及其更新规则,每次执行 glide up 时,都会按照指定的规则(如只下载补丁(patch)不下载升级(minor))下载新版。


一个完整的gilde.yaml


package: foor
homepage: https://github.com/qiangmzsx
license: MIT
owners:
- name: qiangmzsx
email: qiangmzsx@hotmail.com
homepage: https://github.com/qiangmzsx
# 去除包
ignore:
- appengine
- golang.org/x/net
# 排除目录
excludeDirs:
- node_modules
# 导入包
import:
- package: github.com/astaxie/beego
version: 1.8.0
- package: github.com/coocood/freecache
- package: github.com/garyburd/redigo/redis
- package: github.com/go-sql-driver/mysql
- package: github.com/bitly/go-simplejson
- package: git.oschina.net/qiangmzsx/beegofreecache
testImport:
- package: github.com/smartystreets/goconvey
subpackages:
- convey

很多人看着yaml很不习惯,没事,我转一下json给大家看看。


{
"excludeDirs": [
"node_modules"
],
"owners": [
{
"homepage": "https://github.com/qiangmzsx",
"name": "qiangmzsx",
"email": "qiangmzsx@hotmail.com"
}
],

"license": "MIT",
"package": "foor",
"ignore": [
"appengine",
"golang.org/x/net"
],
"import": [
{
"version": "1.8.0",
"package": "github.com/astaxie/beego"
},
{
"package": "github.com/coocood/freecache"
},
{
"package": "github.com/garyburd/redigo/redis"
},
{
"package": "github.com/go-sql-driver/mysql"
},
{
"package": "github.com/bitly/go-simplejson"
},
{
"package": "git.oschina.net/qiangmzsx/beegofreecache"
}
],
"testImport": [
{
"subpackages": [
"convey"
],
"package": "github.com/smartystreets/goconvey"
}
],
"homepage": "https://github.com/qiangmzsx"
}

版本号指定规则


=: equal (aliased to no operator)
!=: not equal
>: greater than
<: less than
>=: greater than or equal to
<=: less than or equal to

1.2 - 1.4.5 which is equivalent to >= 1.2, <= 1.4.5
2.3.4 - 4.5 which is equivalent to >= 2.3.4, <= 4.5
1.2.x is equivalent to >= 1.2.0, < 1.3.0

>= 1.2.x is equivalent to >= 1.2.0
<= 2.x is equivalent to < 3
* is equivalent to >= 0.0.0

~1.2.3 is equivalent to >= 1.2.3, < 1.3.0
~1 is equivalent to >= 1, < 2
~2.3 is equivalent to >= 2.3, < 2.4
~1.2.x is equivalent to >= 1.2.0, < 1.3.0
~1.x is equivalent to >= 1, < 2

^1.2.3 is equivalent to >= 1.2.3, < 2.0.0
^1.2.x is equivalent to >= 1.2.0, < 2.0.0
^2.3 is equivalent to >= 2.3, < 3
^2.x is equivalent to >= 2.0.0, < 3

''指定版本报错,需要用''指定的可以不填写


安装依赖 (glide install)


glide.yaml我们已经准备好了,现在就改安装一下试试。


$ glide install
[ERROR] Failed to parse /home/users/xxxx/golang/src/foor/glide.yaml: yaml: invalid leading UTF-8 octet

报错了!别担心看看你的yaml文件是否为utf-8编码,不是就转换一下就好啦!


$ glide install
[INFO] Lock file (glide.lock) does not exist. Performing update.
[INFO] Downloading dependencies. Please wait...
[INFO] --> Fetching updates for github.com/go-sql-driver/mysql
[INFO] --> Fetching updates for github.com/astaxie/beego
[INFO] --> Fetching updates for github.com/coocood/freecache
[INFO] --> Fetching updates for git.oschina.net/qiangmzsx/beegofreecache
[INFO] --> Fetching updates for github.com/bitly/go-simplejson
[INFO] --> Fetching updates for github.com/garyburd/redigo
[INFO] --> Fetching updates for github.com/smartystreets/goconvey
[INFO] --> Detected semantic version. Setting version for github.com/astaxie/beego to v1.8.0
[INFO] Resolving imports
[INFO] Downloading dependencies. Please wait...
[INFO] Setting references for remaining imports
[INFO] Exporting resolved dependencies...
[INFO] --> Exporting github.com/astaxie/beego
[INFO] --> Exporting github.com/coocood/freecache
[INFO] --> Exporting github.com/bitly/go-simplejson
[INFO] --> Exporting github.com/go-sql-driver/mysql
[INFO] --> Exporting github.com/garyburd/redigo
[INFO] --> Exporting github.com/smartystreets/goconvey
[INFO] --> Exporting git.oschina.net/qiangmzsx/beegofreecache
[INFO] Replacing existing vendor dependencies
[INFO] Project relies on 6 dependencies.
$ ll
total 12
glide.lock
glide.yaml
vendor
$ ll vendor/
git.oschina.net
github.com

看到glide.look了吗,这个文件记载了依赖包确定的revision, 下次再执行 glide install 时,会直接读这个文件下载确定的版本。


升级版本 (glide up)


glide up 会按照语义化版本规则更新依赖包代码,开发过程中如果需要使用新版代码,可以执行这个命令:
修改一下glide.yaml中的一个Package.


- package: github.com/astaxie/beego
version: 1.8.3

执行glide up。


$ glide up
[INFO] Downloading dependencies. Please wait...
[INFO] --> Fetching updates for git.oschina.net/qiangmzsx/beegofreecache
[INFO] --> Fetching updates for github.com/garyburd/redigo
[INFO] --> Fetching updates for github.com/go-sql-driver/mysql
[INFO] --> Fetching updates for github.com/astaxie/beego
[INFO] --> Fetching updates for github.com/bitly/go-simplejson
[INFO] --> Fetching updates for github.com/coocood/freecache
[INFO] --> Fetching updates for github.com/smartystreets/goconvey
[INFO] --> Detected semantic version. Setting version for github.com/astaxie/beego to v1.8.3
[INFO] Resolving imports
[INFO] Downloading dependencies. Please wait...
[INFO] Setting references for remaining imports
[INFO] Exporting resolved dependencies...
[INFO] --> Exporting github.com/astaxie/beego
[INFO] --> Exporting github.com/bitly/go-simplejson
[INFO] --> Exporting github.com/garyburd/redigo
[INFO] --> Exporting github.com/go-sql-driver/mysql
[INFO] --> Exporting github.com/coocood/freecache
[INFO] --> Exporting github.com/smartystreets/goconvey
[INFO] --> Exporting git.oschina.net/qiangmzsx/beegofreecache
[INFO] Replacing existing vendor dependencies
[INFO] Project relies on 6 dependencies.

添加并下载依赖 (glide get)


除了自动从代码中解析 import 外,glide 还可以通过 glide get 直接下载代码中没有的依赖,与 go get 的用法基本一致:


$ glide get github.com/orcaman/concurrent-map
[INFO] Preparing to install 1 package.
[INFO] Attempting to get package github.com/orcaman/concurrent-map
[INFO] --> Gathering release information for github.com/orcaman/concurrent-map
[INFO] --> Adding github.com/orcaman/concurrent-map to your configuration
[INFO] Downloading dependencies. Please wait...
[INFO] --> Fetching updates for github.com/garyburd/redigo
[INFO] --> Fetching updates for github.com/astaxie/beego
[INFO] --> Fetching updates for github.com/go-sql-driver/mysql
[INFO] --> Fetching updates for git.oschina.net/qiangmzsx/beegofreecache
[INFO] --> Fetching updates for github.com/bitly/go-simplejson
[INFO] --> Fetching github.com/orcaman/concurrent-map
[INFO] --> Fetching updates for github.com/coocood/freecache
[INFO] --> Fetching updates for github.com/smartystreets/goconvey
[INFO] Resolving imports
[INFO] Downloading dependencies. Please wait...
[INFO] --> Detected semantic version. Setting version for github.com/astaxie/beego to v1.8.3
[INFO] Exporting resolved dependencies...
[INFO] --> Exporting github.com/smartystreets/goconvey
[INFO] --> Exporting github.com/garyburd/redigo
[INFO] --> Exporting github.com/go-sql-driver/mysql
[INFO] --> Exporting github.com/orcaman/concurrent-map
[INFO] --> Exporting github.com/astaxie/beego
[INFO] --> Exporting github.com/bitly/go-simplejson
[INFO] --> Exporting github.com/coocood/freecache
[INFO] --> Exporting git.oschina.net/qiangmzsx/beegofreecache
[INFO] Replacing existing vendor dependencies

使用镜像 (glide mirror)


[WARN]  Unable to checkout golang.org/x/crypto
[ERROR] Update failed for golang.org/x/crypto: Cannot detect VCS
[ERROR] Failed to do initial checkout of config: Cannot detect VCS

这几行信息估计很多人都是遇到过的。在我天朝或者在公司内部都可能不能访问一些站点,导致很Golang的依赖包不能通过go get下载。此时也就是glide大发神威的时候到了,可以通过配置将墙了的版本库 URL 映射到没被墙的 URL,甚至也可以映射到本地版本库。
将golang.org映射到github:
修改glide.yaml加入


- package: golang.org/x/crypto

如果你的网络可以访问就不需要使用glide镜像功能,可以跳过。


$ glide mirror set golang.org/x/crypto github.com/golang/crypto
[INFO] golang.org/x/crypto being set to github.com/golang/crypto
[INFO] mirrors.yaml written with changes
$ glide up
[INFO] Loading mirrors from mirrors.yaml file
[INFO] Downloading dependencies. Please wait...
[INFO] --> Fetching updates for github.com/orcaman/concurrent-map
[INFO] --> Fetching golang.org/x/crypto
[INFO] --> Fetching updates for github.com/astaxie/beego
[INFO] --> Fetching updates for github.com/go-sql-driver/mysql
[INFO] --> Fetching updates for github.com/garyburd/redigo
[INFO] --> Fetching updates for github.com/coocood/freecache
[INFO] --> Fetching updates for github.com/bitly/go-simplejson
[INFO] --> Fetching updates for git.oschina.net/qiangmzsx/beegofreecache
[INFO] --> Fetching updates for github.com/smartystreets/goconvey
[INFO] --> Detected semantic version. Setting version for github.com/astaxie/beego to v1.8.3
[INFO] Resolving imports
[INFO] Downloading dependencies. Please wait...
[INFO] Setting references for remaining imports
[INFO] Exporting resolved dependencies...
[INFO] --> Exporting github.com/astaxie/beego
[INFO] --> Exporting github.com/coocood/freecache
[INFO] --> Exporting github.com/smartystreets/goconvey
[INFO] --> Exporting github.com/garyburd/redigo
[INFO] --> Exporting github.com/go-sql-driver/mysql
[INFO] --> Exporting github.com/bitly/go-simplejson
[INFO] --> Exporting github.com/orcaman/concurrent-map
[INFO] --> Exporting golang.org/x/crypto
[INFO] --> Exporting git.oschina.net/qiangmzsx/beegofreecache
[INFO] Replacing existing vendor dependencies
[INFO] Project relies on 8 dependencies.
$ ll vendor/
git.oschina.net
github.com
golang.org

终于看到golang.org啦!!!
细心的你一定已经发现了


[INFO]  mirrors.yaml written with changes

说明执行glide mirror时候镜像配置写入到的是$HOME/.glide/mirrors.yaml中,打开看看。


repos:
- original: golang.org/x/crypto
repo: github.com/golang/crypto

还可以映射到本地目录。
推荐大家可以去https://www.golangtc.com/download/package下载很多Golang类库。
现在我去下载了:https://www.golangtc.com/static/download/packages/golang.org.x.text.tar.gz,解压到本地目录/home/users/qiangmzsx/var/golang/golang.org/x/text


$ glide mirror set golang.org/x/text /home/users/qiangmzsx/var/golang/golang.org/x/text
[INFO] golang.org/x/text being set to /home/users/qiangmzsx/var/golang/golang.org/x/text
[INFO] mirrors.yaml written with changes
$ glide up
[INFO] Loading mirrors from mirrors.yaml file
[INFO] Downloading dependencies. Please wait...
[INFO] --> Fetching golang.org/x/text
[INFO] --> Fetching updates for github.com/garyburd/redigo
[INFO] --> Fetching updates for git.oschina.net/qiangmzsx/beegofreecache
[INFO] --> Fetching updates for github.com/astaxie/beego
[INFO] --> Fetching updates for github.com/bitly/go-simplejson
[INFO] --> Fetching updates for github.com/go-sql-driver/mysql
[INFO] --> Fetching updates for github.com/coocood/freecache
[INFO] --> Fetching updates for github.com/orcaman/concurrent-map
[INFO] --> Fetching updates for golang.org/x/crypto
[INFO] --> Fetching updates for github.com/smartystreets/goconvey
[INFO] --> Detected semantic version. Setting version for github.com/astaxie/beego to v1.8.3
[INFO] Resolving imports
[INFO] Downloading dependencies. Please wait...
[INFO] Setting references for remaining imports
[INFO] Exporting resolved dependencies...
[INFO] --> Exporting github.com/astaxie/beego
[INFO] --> Exporting github.com/go-sql-driver/mysql
[INFO] --> Exporting github.com/bitly/go-simplejson
[INFO] --> Exporting github.com/coocood/freecache
[INFO] --> Exporting github.com/smartystreets/goconvey
[INFO] --> Exporting github.com/garyburd/redigo
[INFO] --> Exporting github.com/orcaman/concurrent-map
[INFO] --> Exporting golang.org/x/text
[INFO] --> Exporting golang.org/x/crypto
[INFO] --> Exporting git.oschina.net/qiangmzsx/beegofreecache
[INFO] Replacing existing vendor dependencies
[INFO] Project relies on 9 dependencies.

全局选项


运行glide,在最后就可以看到


GLOBAL OPTIONS:
--yaml value, -y value Set a YAML configuration file. (default: "glide.yaml")
--quiet, -q Quiet (no info or debug messages)
--debug Print debug verbose informational messages
--home value The location of Glide files (default: "/home/users/qiangmzsx/.glide") [$GLIDE_HOME]
--tmp value The temp directory to use. Defaults to systems temp [$GLIDE_TMP]
--no-color Turn off colored output for log messages
--help, -h show help
--version, -v print the version

如果大家想把glide的yaml文件换别的默认名称可以执行


 $ glide -y qiangmzsx.yaml

在官网中会看到一个GLIDE_HOME变量,该变量就是/home/users/qiangmzsx/.glide
这个目录之前有提到过,除了包含有mirrors.yaml还有一个很重要的目录cache本地 cache,每次更新代码时, glide 都会在本地保存 cache,以备下次 glide install 使用 。


GLIDE_HOME可以通过如下命令修改。


 $ glide  --home /home/glide 

总结


除了上述说到的功能,glide还有很多好的功能,后续有机会在写出来吧。

总结一下,glide是一款功能丰富,完全满足需求的依赖管理工具,强烈大家使用。

beego & bee 1.9.0 released

astaxie 发表了文章 • 0 个评论 • 474 次浏览 • 2017-07-19 01:07 • 来自相关话题

beego:

  1. Fix the new repo address for casbin #2654
  2. Fix cache/memory fatal error: concurrent map iteration a... 查看全部

beego:



  1. Fix the new repo address for casbin #2654

  2. Fix cache/memory fatal error: concurrent map iteration and map write #2726

  3. AddAPPStartHook func modify #2724

  4. Fix panic: sync: negative WaitGroup counter #2717

  5. incorrect error rendering (wrong status) #2712

  6. validation: support int64 int32 int16 and int8 type #2728

  7. validation: support required option for some struct tag valids #2741

  8. Fix big form parse issue #2725

  9. File log add RotatePerm #2683

  10. Fix Oracle placehold #2749

  11. Supported gzip for req.Header has Content-Encoding: gzip #2754

  12. Add new Database Migrations #2744

  13. Beego auto generate sort ControllerComments #2766

  14. added statusCode and pattern to FilterMonitorFunc #2692

  15. fix the bugs in the "ParseBool" function in the file of config.go #2740


Bee



  1. Added MySQL year data type #443

  2. support multiple http methods #445

  3. The DDL migration can now be generated by adding a -ddl and a proper "alter" or "create" as argument value. #455

  4. Fix: docs generator skips everything containing 'vendor' #454

  5. get these tables information in custom the option #441

  6. read ref(pk) #444

  7. Add command bee server to server static folder.


https://github.com/astaxie/beego/pull/2771

给httprouter添加pprof功能

narutoinfo 发表了文章 • 0 个评论 • 187 次浏览 • 2017-07-18 19:40 • 来自相关话题

给httprouter添加pprof

1:获取包

go get github.com/feixiao/htt... 			查看全部
					

给httprouter添加pprof


1:获取包


go get github.com/feixiao/httpprof

2:进入所在目录,获取依赖


 govendor sync

3:编译运行example


go build

4:外部项目添加使用,只需要参考example的使用即可


func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
fmt.Fprint(w, "Welcome!\n")
}

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
}

func main() {
router := httprouter.New()

// 在原来的httprouter的使用基础只是添加了这一句代码
router = httpprof.WrapRouter(router)

router.GET("/", Index)
router.GET("/hello/:name", Hello)

log.Fatal(http.ListenAndServe(":8080", router))
}

【Go大咖说】 分享第一期——姜家志《比特币、区块链和Go开发》

astaxie 发表了文章 • 9 个评论 • 1436 次浏览 • 2017-07-17 16:37 • 来自相关话题

GoCN社区最近打算推出全新的栏目《Go大咖说》,第一期我们邀请到了来自比特大陆的高级工程师姜家志给我们带来分享《比特币、区块链和Go开发》

个人介绍: 姜家志,2013年开始接触比特币,之后开发了比太钱包,现在在比特大陆从事比特币相关的开... 查看全部

GoCN社区最近打算推出全新的栏目《Go大咖说》,第一期我们邀请到了来自比特大陆的高级工程师姜家志给我们带来分享《比特币、区块链和Go开发》


个人介绍:
姜家志,2013年开始接触比特币,之后开发了比太钱包,现在在比特大陆从事比特币相关的开发工作。



大纲:



  • 比特币是什么

  • 区块链是什么以及区块链行业现状

  • Go语言在区块链行业的应用以及优势


我们的分享会在我们的Go实战群直播,会同步转发到全部的实战群,大家可以加微信群或者QQ群,


直播时间:周二(2017-07-18) 晚上8点开始


微信:请加fuxiaohei,备注:Go实战群
QQ: 148647580


后续会整理成文发布在Go中国微信公众号,大家可以关注我们的公众号:

golang结构体json的时间格式化解决方案

qiangmzsx 发表了文章 • 4 个评论 • 794 次浏览 • 2017-07-15 23:40 • 来自相关话题

最近开发项目时候发现一个结构体的Json转换的时间格式问题。 即这种1993-01-01T20:08:23.000000028+08:00 这种表示UTC方法。从我们习惯来说,更喜欢希望的是 1993-01-01 20:08:23这种格式。 重新复现代码... 查看全部

最近开发项目时候发现一个结构体的Json转换的时间格式问题。
即这种1993-01-01T20:08:23.000000028+08:00 这种表示UTC方法。从我们习惯来说,更喜欢希望的是
1993-01-01 20:08:23这种格式。
重新复现代码如下:



package main

import (
"time"
"encoding/json"
)

type Student struct {
Name string `json:"name"`
Brith time.Time `json:"brith"`
}

func main() {
stu:=Student{
Name:"qiangmzsx",
Brith:time.Date(1993, 1, 1, 20, 8, 23, 28, time.Local),
}

b,err:=json.Marshal(stu)
if err!=nil {
println(err)
}

println(string(b))//{"name":"qiangmzsx","brith":"1993-01-01T20:08:23.000000028+08:00"}
}

遇到这样的问题,那么Golang是如何解决的呢?
有两种解决方案,下面我们一个个来看看。


通过time.Time类型别名


type JsonTime time.Time
// 实现它的json序列化方法
func (this JsonTime) MarshalJSON() ([]byte, error) {
var stamp = fmt.Sprintf("\"%s\"", time.Time(this).Format("2006-01-02 15:04:05"))
return []byte(stamp), nil
}
type Student1 struct {
Name string `json:"name"`
Brith JsonTime `json:"brith"`
}
func main() {

stu1:=Student1{
Name:"qiangmzsx",
Brith:JsonTime(time.Date(1993, 1, 1, 20, 8, 23, 28, time.Local)),
}
b1,err:=json.Marshal(stu1)
if err!=nil {
println(err)
}

println(string(b1))//{"name":"qiangmzsx","brith":"1993-01-01 20:08:23"}
}

使用结构体组合方式


相较于第一种方式,该方式显得复杂一些,我也不是很推荐使用,就当做是一个扩展教程吧。


type Student2 struct {
Name string `json:"name"`
// 一定要将json的tag设置忽略掉不解析出来
Brith time.Time `json:"-"`
}
// 实现它的json序列化方法
func (this Student2) MarshalJSON() ([]byte, error) {
// 定义一个该结构体的别名
type AliasStu Student2
// 定义一个新的结构体
tmpStudent:= struct {
AliasStu
Brith string `json:"brith"`
}{
AliasStu:(AliasStu)(this),
Brith:this.Brith.Format("2006-01-02 15:04:05"),
}
return json.Marshal(tmpStudent)
}
func main() {
stu2:=Student2{
Name:"qiangmzsx",
Brith:time.Date(1993, 1, 1, 20, 8, 23, 28, time.Local),
}

b2,err:=json.Marshal(stu2)
if err!=nil {
println(err)
}

println(string(b2))//{"name":"qiangmzsx","brith":"1993-01-01 20:08:23"}
}

该方法使用了Golang的结构体的组合方式,可以实现OOP的继承,也是体现Golang灵活。


整体代码


下面把上面的代码组成整体贴出来。



package main

import (
"time"
"encoding/json"
//"fmt"
"fmt"
)

type Student struct {
Name string `json:"name"`
Brith time.Time `json:"brith"`
}

type JsonTime time.Time
// 实现它的json序列化方法
func (this JsonTime) MarshalJSON() ([]byte, error) {
var stamp = fmt.Sprintf("\"%s\"", time.Time(this).Format("2006-01-02 15:04:05"))
return []byte(stamp), nil
}
type Student1 struct {
Name string `json:"name"`
Brith JsonTime `json:"brith"`
}

type Student2 struct {
Name string `json:"name"`
// 一定要将json的tag设置忽略掉不解析出来
Brith time.Time `json:"-"`
}
// 实现它的json序列化方法
func (this Student2) MarshalJSON() ([]byte, error) {
// 定义一个该结构体的别名
type AliasStu Student2
// 定义一个新的结构体
tmpStudent:= struct {
AliasStu
Brith string `json:"brith"`
}{
AliasStu:(AliasStu)(this),
Brith:this.Brith.Format("2006-01-02 15:04:05"),
}
return json.Marshal(tmpStudent)
}

func main() {
stu:=Student{
Name:"qiangmzsx",
Brith:time.Date(1993, 1, 1, 20, 8, 23, 28, time.Local),
}

b,err:=json.Marshal(stu)
if err!=nil {
println(err)
}

println(string(b))//{"name":"qiangmzsx","brith":"1993-01-01T20:08:23.000000028+08:00"}

println("===================")

stu1:=Student1{
Name:"qiangmzsx",
Brith:JsonTime(time.Date(1993, 1, 1, 20, 8, 23, 28, time.Local)),
}
b1,err:=json.Marshal(stu1)
if err!=nil {
println(err)
}

println(string(b1))//{"name":"qiangmzsx","brith":"1993-01-01 20:08:23"}

println("===================")
stu2:=Student2{
Name:"qiangmzsx",
Brith:time.Date(1993, 1, 1, 20, 8, 23, 28, time.Local),
}

b2,err:=json.Marshal(stu2)
if err!=nil {
println(err)
}

println(string(b2))//{"name":"qiangmzsx","brith":"1993-01-01 20:08:23"}
}

值得一提的是,对任意struct增加 MarshalJSON ,UnmarshalJSON , String 方法,实现自定义json输出格式与打印方式。

Gopher社区的第一件众筹T恤来了

CodyGuo 回复了问题 • 6 人关注 • 7 个回复 • 806 次浏览 • 2017-06-29 09:10 • 来自相关话题

udp编程的那些事与golang udp的实践

sheepbao 发表了文章 • 0 个评论 • 1039 次浏览 • 2017-06-26 10:30 • 来自相关话题

udp编程的那些事与golang udp的实践

tcp/ip大协议中,tcp编程大家应该比较熟,应用的场景也很多,但是udp在现实中,应用也不少,而在大部分博文中,都很少对udp的编程进行研究,最近研究了一下udp编程,正好做个记录。<... 查看全部

udp编程的那些事与golang udp的实践


tcp/ip大协议中,tcp编程大家应该比较熟,应用的场景也很多,但是udp在现实中,应用也不少,而在大部分博文中,都很少对udp的编程进行研究,最近研究了一下udp编程,正好做个记录。

sheepbao 2017.06.15


tcp Vs udp


tcp和udp都是著名的传输协议,他们都是基于ip协议,都在OSI模型中传输层。tcp我们都很清楚,它提供了可靠的数据传输,而udp我们也知道,它不提供数据传输的可靠性,只是尽力传输。
他们的特性决定了它们很大的不同,tcp提供可靠性传输,有三次握手,4次分手,相当于具有逻辑上的连接,可以知道这个tcp连接的状态,所以我们都说tcp是面向连接的socket,而udp没有握手,没有分手,也不存在逻辑上的连接,所以我们也都说udp是非面向连接的socket。

我们都畏惧不知道状态的东西,所以即使tcp的协议比udp复杂很多,但对于系统应用层的编程来说,tcp编程其实比udp编程容易。而udp相对比较灵活,所以对于udp编程反而没那么容易,但其实掌握后udp编程也并不难。


udp协议


udp的首部


        2               2       (byte)
+---+---+---+---+---+---+---+---+ -
| src port | dst port | |
+---+---+---+---+---+---+---+---+ 8(bytes)
| length | check sum | |
+---+---+---+---+---+---+---+---+ -
| |
+ data +
| |
+---+---+---+---+---+---+---+---+

udp的首部真的很简单,头2个字节表示的是原端口,后2个字节表示的是目的端口,端口是系统层区分进程的标识。接着是udp长度,最后就是校验和,这个其实很重要,现在的系统都是默认开启udp校验和的,所以我们才能确保udp消息传输的完整性。如果这个校验和关闭了,那会让我们绝对会很忧伤,因为udp不仅不能保证数据一定到达,还不能保证即使数据到了,这个数据是否是正确的。比如:我在发送端发送了“hello”,而接收端却接收到了“hell”。如果真的是这样,我们就必须自己去校验数据的正确性。还好udp默认开发了校验,我们可以保证udp的数据完整性。


udp数据的封装


                                    +---------+
| 应用数据 |
+---------+
| |
v v
+---------+---------+
| udp首部 | 应用数据 |
+---------+---------+
| |
v UDP数据报 v
+---------+---------+---------+
| ip首部 | udp首部 | 应用数据 |
+---------+---------+---------+
| |
v IP数据报 v
+---------+---------+---------+---------+---------+
|以太网首部 | ip首部 | udp首部 | 应用数据 |以太网尾部 |
+---------+---------+---------+---------+---------+
| 14 20 8 4 |
| -> 以太网帧 <- |

数据的封装和tcp是一样,应用层的数据加上udp首部,构成udp数据报,再加上ip首部构成ip数据报,最后加上以太网首部和尾部构成以太网帧,经过网卡发送出去。


Golang udp实践


实践出真知,编程就需要多实践,才能体会其中的奥妙。


echo客户端和服务端


echo服务,实现数据包的回显,这是很多人网络编程起点,因为这个服务足够简单,但又把网络的数据流都过了一遍,这里也用go udp实现一个echo服务。

实现客户端发送一个“hello”,服务端接收消息并原封不动的返回给客户度。


server.go


package main

import (
"flag"
"fmt"
"log"
"net"
)

var addr = flag.String("addr", ":10000", "udp server bing address")

func init() {
log.SetFlags(log.LstdFlags | log.Lshortfile)
flag.Parse()
}

func main() {
//Resolving address
udpAddr, err := net.ResolveUDPAddr("udp", *addr)
if err != nil {
log.Fatalln("Error: ", err)
}

// Build listining connections
conn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
log.Fatalln("Error: ", err)
}
defer conn.Close()

// Interacting with one client at a time
recvBuff := make([]byte, 1024)
for {
log.Println("Ready to receive packets!")
// Receiving a message
rn, rmAddr, err := conn.ReadFromUDP(recvBuff)
if err != nil {
log.Println("Error:", err)
return
}

fmt.Printf("<<< Packet received from: %s, data: %s\n", rmAddr.String(), string(recvBuff[:rn]))
// Sending the same message back to current client
_, err = conn.WriteToUDP(recvBuff[:rn], rmAddr)
if err != nil {
log.Println("Error:", err)
return
}
fmt.Println(">>> Sent packet to: ", rmAddr.String())
}
}

client1.go


package main

import (
"flag"
"fmt"
"log"
"net"
)

var raddr = flag.String("raddr", "127.0.0.1:10000", "remote server address")

func init() {
log.SetFlags(log.LstdFlags | log.Lshortfile)
flag.Parse()
}

func main() {
// Resolving Address
remoteAddr, err := net.ResolveUDPAddr("udp", *raddr)
if err != nil {
log.Fatalln("Error: ", err)
}

// Make a connection
tmpAddr := &net.UDPAddr{
IP: net.ParseIP("127.0.0.1"),
Port: 0,
}

conn, err := net.DialUDP("udp", tmpAddr, remoteAddr)
// Exit if some error occured
if err != nil {
log.Fatalln("Error: ", err)
}
defer conn.Close()

// write a message to server
_, err = conn.Write([]byte("hello"))
if err != nil {
log.Println(err)
} else {
fmt.Println(">>> Packet sent to: ", *raddr)
}

// Receive response from server
buf := make([]byte, 1024)
rn, rmAddr, err := conn.ReadFromUDP(buf)
if err != nil {
log.Println(err)
} else {
fmt.Printf("<<< %d bytes received from: %v, data: %s\n", rn, rmAddr, string(buf[:rn]))
}
}

client2.go


package main

import (
"flag"
"fmt"
"log"
"net"
)

var (
laddr = flag.String("laddr", "127.0.0.1:9000", "local server address")
raddr = flag.String("raddr", "127.0.0.1:10000", "remote server address")
)

func init() {
log.SetFlags(log.LstdFlags | log.Lshortfile)
flag.Parse()
}

func main() {
// Resolving Address
localAddr, err := net.ResolveUDPAddr("udp", *laddr)
if err != nil {
log.Fatalln("Error: ", err)
}

remoteAddr, err := net.ResolveUDPAddr("udp", *raddr)
if err != nil {
log.Fatalln("Error: ", err)
}

// Build listening connections
conn, err := net.ListenUDP("udp", localAddr)
// Exit if some error occured
if err != nil {
log.Fatalln("Error: ", err)
}
defer conn.Close()

// write a message to server
_, err = conn.WriteToUDP([]byte("hello"), remoteAddr)
if err != nil {
log.Println(err)
} else {
fmt.Println(">>> Packet sent to: ", *raddr)
}

// Receive response from server
buf := make([]byte, 1024)
rn, remAddr, err := conn.ReadFromUDP(buf)
if err != nil {
log.Println(err)
} else {
fmt.Printf("<<< %d bytes received from: %v, data: %s\n", rn, remAddr, string(buf[:rn]))
}
}

这里实现echo的服务端和客户端,和tcp的差不多,但是有一些小细节需要注意。

对于server端,先net.ListenUDP建立udp一个监听,返回一个udp连接,这里需要注意udp不像tcp,建立tcp监听后返回的是一个Listener,然后阻塞等待接收一个新的连接,这样区别是因为udp一个非面向连接的协议,它没有会话管理。同时也因为udp是非面向连接的协议,当接收到消息后,想把消息返回给当前的客户端时,是不能像tcp一样,直接往conn里写的,而是需要指定远端地址。

对于client端,类似tcp先Dial,返回一个连接,对于发送消息用Write,接收消息用Read,当然udp也可以用ReadFromUDP,这样可以知道从哪得到的消息。但其实client也可以用另一种方式写,如client2.go程序,先建立一个监听,返回一个连接,用这个连接发送消息给服务端和从服务器接收消息,这种方式和tcp倒是有很大的不同。


参考


golang pkg

给大家推荐一款新的编辑神器

winlin 回复了问题 • 10 人关注 • 8 个回复 • 1394 次浏览 • 2017-06-23 17:33 • 来自相关话题

golang实现基于redis和consul的可水平扩展的排行榜服务范例

changjixiong 发表了文章 • 1 个评论 • 352 次浏览 • 2017-06-14 22:15 • 来自相关话题

  本文的完整代码见https://github... 查看全部

  本文的完整代码见https://github.com/changjixion ... snotehttps://github.com/changjixiong/goNotes/tree/master/utilshttps://github.com/changjixion ... nvoke如果文中没有显示链接说明链接在被转发的时候被干掉了,请搜索找到原文阅读。


概述


  排行榜在各种互联网应用中广泛存在。本文将用一个范例说明如何利用redis和consul实现可水平扩展的等级排行榜服务。


redis的使用


  实现排行榜有2个地方需要用到redis:


  1.存储玩家的排行信息,这里使用的是Sorted Sets,代码如下


err := Rds.ZAdd(
PlayerLvRankKey,
redis.Z{
Score: lvScoreWithTime(playerInfo.Lv, time.Now().Unix()),
Member: playerInfo.PlayerID,
},
).Err()

  其中lvScoreWithTime根据玩家等级及到达的时间计算score用于排名,等级相同的情况下,先到达等级的计算分值大于后达到的。


  2.存储玩家自身的信息(名字,ID等),用于在排行榜中显示,毕竟仅仅只有排行的ID是不够的。这里采用hashset,代码如下


// ma的类型为map[string]string
err := Rds.HMSet(fmt.Sprintf("playerInfo:%d", playerID), ma).Err()

服务器端


  先初始化redis连接


rdsClient := redis.NewClient(&redis.Options{
Addr: fmt.Sprintf("%s:%d", "127.0.0.1", 6379),
Password: "123456",
DB: 0,
})
playercache.Rds = rdsClient
rankservice.Rds = rdsClient

  增加初始玩家信息(略)。


  注册服务器接口,此部分详细说明请参考《golang通过反射使用json字符串调用struct的指定方法及返回json结果》http://changjixiong.com/reflect-invoke-method-of-struct-and-get-json-format-result/


reflectinvoke.RegisterMethod(rankservice.DefaultRankService)

  将服务注册到consul,此部分详细说明请参考《golang使用服务发现系统consul》http://changjixiong.com/use-consul-in-golang/


go registerServer()

  在端口9528上开启服务用于结构client请求并返回结果


ln, err := net.Listen("tcp", "0.0.0.0:9528")

if nil != err {
panic("Error: " + err.Error())
}

for {
conn, err := ln.Accept()
// 对Accept()产生的临时错误的处理,可以参考net/http/server.go中的func (srv *Server) Serve(l net.Listener)
if err != nil {
panic("Error: " + err.Error())
}

go RankServer(conn)
}

  增加玩家经验及设置玩家的排行榜数据的接口如下


func (rankService *RankService) AddPlayerExp(playerID, exp int) bool {

player := playercache.GetPlayerInfo(playerID)
if nil == player {
return false
}

player.Exp += exp
// 固定经验升级,可以按需要修改
if player.Exp >= playercache.LvUpExp {
player.Lv += 1
player.Exp = player.Exp - playercache.LvUpExp
rankService.SetPlayerLvRank(player)
}

playercache.SetPlayerInfo(player)

return true
}

func (rankService *RankService) SetPlayerLvRank(playerInfo *playercache.PlayerInfo) bool {

if nil == playerInfo {
return false
}

err := Rds.ZAdd(
PlayerLvRankKey,
redis.Z{
Score: lvScoreWithTime(playerInfo.Lv, time.Now().Unix()),
Member: playerInfo.PlayerID,
},
).Err()

if nil != err {
log.Println("RankService: SetPlayerLvRank:", err)
return false
}

return true
}

  获取指定排行的玩家信息的接口


func (rankService *RankService) GetPlayerByLvRank(start, count int64) []*playercache.PlayerInfo {

playerInfos := []*playercache.PlayerInfo{}

ids, err := Rds.ZRevRange(PlayerLvRankKey, start, start+count-1).Result()

if nil != err {
log.Println("RankService: GetPlayerByLvRank:", err)
return playerInfos
}

for _, idstr := range ids {
id, err := strconv.Atoi(idstr)

if nil != err {
log.Println("RankService: GetPlayerByLvRank:", err)
} else {
playerInfo := playercache.LoadPlayerInfo(id)

if nil != playerInfos {
playerInfos = append(playerInfos, playerInfo)
}
}
}

return playerInfos

}

客户端


  连接到consul并查到到排行榜服务的地址,连接并发送请求


func main() {

client, err := consulapi.NewClient(consulapi.DefaultConfig())

if err != nil {
log.Fatal("consul client error : ", err)
}

for {

time.Sleep(time.Second * 3)
var services map[string]*consulapi.AgentService
var err error

services, err = client.Agent().Services()

log.Println("services", strings.Repeat("-", 80))
for _, service := range services {
log.Println(service)
}

if nil != err {
log.Println("in consual list Services:", err)
continue
}

if _, found := services["rankNode_1"]; !found {
log.Println("rankNode_1 not found")
continue
}
log.Println("choose", strings.Repeat("-", 80))
log.Println("rankNode_1", services["rankNode_1"])
sendData(services["rankNode_1"])

}
}

运行情况


  consul上注册了2个自定义的服务,一个是名为serverNode的echo服务(来源 《golang使用服务发现系统consul》),另一个是本文的排行榜服务rankNode。


  服务器接收到的请求片段


get: {"func_name":"AddPlayerExp","params":[4,41]}
get: {"func_name":"AddPlayerExp","params":[2,35]}
get: {"func_name":"AddPlayerExp","params":[5,27]}
get: {"func_name":"GetPlayerByLvRank","params":[0,3]}

  客户端在consul中查找到服务并连接rankNode_1


services ----------------------------------------------------------
&{consul consul [] 8300 false}
&{rankNode_1 rankNode [serverNode] 9528 127.0.0.1 false}
&{serverNode_1 serverNode [serverNode] 9527 127.0.0.1 false}
choose ------------------------------------------------------------
rankNode_1 &{rankNode_1 rankNode [serverNode] 9528 127.0.0.1 false}

  客户端收到的回应片段


get: {"func_name":"AddPlayerExp","data":[true],"errorcode":0}
get: {"func_name":"AddPlayerExp","data":[true],"errorcode":0}
get: {"func_name":"AddPlayerExp","data":[true],"errorcode":0}
get: {"func_name":"GetPlayerByLvRank","data":[[{"player_id":3,"player_name":"玩家3","exp":57,"lv":4,"online":true},{"player_id":2,"player_name":"玩家2","exp":31,"lv":4,"online":true},{"player_id":1,"player_name":"玩家1","exp":69,"lv":3,"online":true}]],"errorcode":0}

一点说明


  为什么说是可水平扩展的排行榜服务呢?文中已经看到,目前有2个自定的服务注册在consul上,client选择了rankNode_1,那么如果注册了多个rankNode,则可以在其中某些节点不可用时,client可以选择其他可用的节点获取服务,而当不可用的节点重新可用时,可以继续注册到consul以提供服务。

GoCN每日新闻(2017-06-14)

回复

astaxie 发起了问题 • 1 人关注 • 0 个回复 • 497 次浏览 • 2017-06-14 10:58 • 来自相关话题

GoCN每日新闻(2017-06-13)

stirlingx 回复了问题 • 2 人关注 • 1 个回复 • 462 次浏览 • 2017-06-13 11:18 • 来自相关话题

kcp-go源码解析

sheepbao 发表了文章 • 0 个评论 • 1521 次浏览 • 2017-06-12 15:24 • 来自相关话题

kcp-go源码解析

对kcp-go的源码解析,有错误之处,请一定告之。
sheepbao 2017.0612

概念

ARQ:自动重传请求(Automatic Repeat-reQuest,... 查看全部

kcp-go源码解析


对kcp-go的源码解析,有错误之处,请一定告之。

sheepbao 2017.0612


概念


ARQ:自动重传请求(Automatic Repeat-reQuest,ARQ)是OSI模型中数据链路层的错误纠正协议之一.

RTO:Retransmission TimeOut

FEC:Forward Error Correction


kcp简介


kcp是一个基于udp实现快速、可靠、向前纠错的的协议,能以比TCP浪费10%-20%的带宽的代价,换取平均延迟降低30%-40%,且最大延迟降低三倍的传输效果。纯算法实现,并不负责底层协议(如UDP)的收发。查看官方文档kcp


kcp-go是用go实现了kcp协议的一个库,其实kcp类似tcp,协议的实现也很多参考tcp协议的实现,滑动窗口,快速重传,选择性重传,慢启动等。

kcp和tcp一样,也分客户端和监听端。


    +-+-+-+-+-+            +-+-+-+-+-+
| Client | | Server |
+-+-+-+-+-+ +-+-+-+-+-+
|------ kcp data ------>|
|<----- kcp data -------|

kcp协议


layer model


+----------------------+
| Session |
+----------------------+
| KCP(ARQ) |
+----------------------+
| FEC(OPTIONAL) |
+----------------------+
| CRYPTO(OPTIONAL)|
+----------------------+
| UDP(Packet) |
+----------------------+

KCP header


KCP Header Format


      4           1   1     2 (Byte)
+---+---+---+---+---+---+---+---+
| conv |cmd|frg| wnd |
+---+---+---+---+---+---+---+---+
| ts | sn |
+---+---+---+---+---+---+---+---+
| una | len |
+---+---+---+---+---+---+---+---+
| |
+ DATA +
| |
+---+---+---+---+---+---+---+---+

代码结构


src/vendor/github.com/xtaci/kcp-go/
├── LICENSE
├── README.md
├── crypt.go 加解密实现
├── crypt_test.go
├── donate.png
├── fec.go 向前纠错实现
├── frame.png
├── kcp-go.png
├── kcp.go kcp协议实现
├── kcp_test.go
├── sess.go 会话管理实现
├── sess_test.go
├── snmp.go 数据统计实现
├── updater.go 任务调度实现
├── xor.go xor封装
└── xor_test.go

着重研究两个文件kcp.gosess.go


kcp浅析


kcp是基于udp实现的,所有udp的实现这里不做介绍,kcp做的事情就是怎么封装udp的数据和怎么解析udp的数据,再加各种处理机制,为了重传,拥塞控制,纠错等。下面介绍kcp客户端和服务端整体实现的流程,只是大概介绍一下函数流,不做详细解析,详细解析看后面数据流的解析。


kcp client整体函数流


和tcp一样,kcp要连接服务端需要先拨号,但是和tcp有个很大的不同是,即使服务端没有启动,客户端一样可以拨号成功,因为实际上这里的拨号没有发送任何信息,而tcp在这里需要三次握手。


DialWithOptions(raddr string, block BlockCrypt, dataShards, parityShards int)
V
net.DialUDP("udp", nil, udpaddr)
V
NewConn()
V
newUDPSession() {初始化UDPSession}
V
NewKCP() {初始化kcp}
V
updater.addSession(sess) {管理session会话,任务管理,根据用户设置的internal参数间隔来轮流唤醒任务}
V
go sess.readLoop()
V
go s.receiver(chPacket)
V
s.kcpInput(data)
V
s.fecDecoder.decodeBytes(data)
V
s.kcp.Input(data, true, s.ackNoDelay)
V
kcp.parse_data(seg) {将分段好的数据插入kcp.rcv_buf缓冲}
V
notifyReadEvent()

客户端大体的流程如上面所示,先Dial,建立udp连接,将这个连接封装成一个会话,然后启动一个go程,接收udp的消息。


kcp server整体函数流


ListenWithOptions() 
V
net.ListenUDP()
V
ServerConn()
V
newFECDecoder()
V
go l.monitor() {从chPacket接收udp数据,写入kcp}
V
go l.receiver(chPacket) {从upd接收数据,并入队列}
V
newUDPSession()
V
updater.addSession(sess) {管理session会话,任务管理,根据用户设置的internal参数间隔来轮流唤醒任务}
V
s.kcpInput(data)`
V
s.fecDecoder.decodeBytes(data)
V
s.kcp.Input(data, true, s.ackNoDelay)
V
kcp.parse_data(seg) {将分段好的数据插入kcp.rcv_buf缓冲}
V
notifyReadEvent()

服务端的大体流程如上图所示,先Listen,启动udp监听,接着用一个go程监控udp的数据包,负责将不同session的数据写入不同的udp连接,然后解析封装将数据交给上层。


kcp 数据流详细解析


不管是kcp的客户端还是服务端,他们都有io行为,就是读与写,我们只分析一个就好了,因为它们读写的实现是一样的,这里分析客户端的读与写。


kcp client 发送消息


s.Write(b []byte) 
V
s.kcp.WaitSnd() {}
V
s.kcp.Send(b) {将数据根据mss分段,并存在kcp.snd_queue}
V
s.kcp.flush(false) [flush data to output] {
if writeDelay==true {
flush
}else{
每隔`interval`时间flush一次
}
}
V
kcp.output(buffer, size)
V
s.output(buf)
V
s.conn.WriteTo(ext, s.remote)
V
s.conn..Conn.WriteTo(buf)

读写都是在sess.go文件中实现的,Write方法:


// Write implements net.Conn
func (s *UDPSession) Write(b []byte) (n int, err error) {
for {
...

// api flow control
if s.kcp.WaitSnd() < int(s.kcp.snd_wnd) {
n = len(b)
for {
if len(b) <= int(s.kcp.mss) {
s.kcp.Send(b)
break
} else {
s.kcp.Send(b[:s.kcp.mss])
b = b[s.kcp.mss:]
}
}

if !s.writeDelay {
s.kcp.flush(false)
}
s.mu.Unlock()
atomic.AddUint64(&DefaultSnmp.BytesSent, uint64(n))
return n, nil
}

...
// wait for write event or timeout
select {
case <-s.chWriteEvent:
case <-c:
case <-s.die:
}

if timeout != nil {
timeout.Stop()
}
}
}

假设发送一个hello消息,Write方法会先判断发送窗口是否已满,满的话该函数阻塞,不满则kcp.Send("hello"),而Send函数实现根据mss的值对数据分段,当然这里的发送的hello,长度太短,只分了一个段,并把它们插入发送的队列里。


func (kcp *KCP) Send(buffer []byte) int {
...
for i := 0; i < count; i++ {
var size int
if len(buffer) > int(kcp.mss) {
size = int(kcp.mss)
} else {
size = len(buffer)
}
seg := kcp.newSegment(size)
copy(seg.data, buffer[:size])
if kcp.stream == 0 { // message mode
seg.frg = uint8(count - i - 1)
} else { // stream mode
seg.frg = 0
}
kcp.snd_queue = append(kcp.snd_queue, seg)
buffer = buffer[size:]
}
return 0
}

接着判断参数writeDelay,如果参数设置为false,则立马发送消息,否则需要任务调度后才会触发发送,发送消息是由flush函数实现的。


// flush pending data
func (kcp *KCP) flush(ackOnly bool) {
var seg Segment
seg.conv = kcp.conv
seg.cmd = IKCP_CMD_ACK
seg.wnd = kcp.wnd_unused()
seg.una = kcp.rcv_nxt

buffer := kcp.buffer
// flush acknowledges
ptr := buffer
for i, ack := range kcp.acklist {
size := len(buffer) - len(ptr)
if size+IKCP_OVERHEAD > int(kcp.mtu) {
kcp.output(buffer, size)
ptr = buffer
}
// filter jitters caused by bufferbloat
if ack.sn >= kcp.rcv_nxt || len(kcp.acklist)-1 == i {
seg.sn, seg.ts = ack.sn, ack.ts
ptr = seg.encode(ptr)

}
}
kcp.acklist = kcp.acklist[0:0]

if ackOnly { // flash remain ack segments
size := len(buffer) - len(ptr)
if size > 0 {
kcp.output(buffer, size)
}
return
}

// probe window size (if remote window size equals zero)
if kcp.rmt_wnd == 0 {
current := currentMs()
if kcp.probe_wait == 0 {
kcp.probe_wait = IKCP_PROBE_INIT
kcp.ts_probe = current + kcp.probe_wait
} else {
if _itimediff(current, kcp.ts_probe) >= 0 {
if kcp.probe_wait < IKCP_PROBE_INIT {
kcp.probe_wait = IKCP_PROBE_INIT
}
kcp.probe_wait += kcp.probe_wait / 2
if kcp.probe_wait > IKCP_PROBE_LIMIT {
kcp.probe_wait = IKCP_PROBE_LIMIT
}
kcp.ts_probe = current + kcp.probe_wait
kcp.probe |= IKCP_ASK_SEND
}
}
} else {
kcp.ts_probe = 0
kcp.probe_wait = 0
}

// flush window probing commands
if (kcp.probe & IKCP_ASK_SEND) != 0 {
seg.cmd = IKCP_CMD_WASK
size := len(buffer) - len(ptr)
if size+IKCP_OVERHEAD > int(kcp.mtu) {
kcp.output(buffer, size)
ptr = buffer
}
ptr = seg.encode(ptr)
}

// flush window probing commands
if (kcp.probe & IKCP_ASK_TELL) != 0 {
seg.cmd = IKCP_CMD_WINS
size := len(buffer) - len(ptr)
if size+IKCP_OVERHEAD > int(kcp.mtu) {
kcp.output(buffer, size)
ptr = buffer
}
ptr = seg.encode(ptr)
}

kcp.probe = 0

// calculate window size
cwnd := _imin_(kcp.snd_wnd, kcp.rmt_wnd)
if kcp.nocwnd == 0 {
cwnd = _imin_(kcp.cwnd, cwnd)
}

// sliding window, controlled by snd_nxt && sna_una+cwnd
newSegsCount := 0
for k := range kcp.snd_queue {
if _itimediff(kcp.snd_nxt, kcp.snd_una+cwnd) >= 0 {
break
}
newseg := kcp.snd_queue[k]
newseg.conv = kcp.conv
newseg.cmd = IKCP_CMD_PUSH
newseg.sn = kcp.snd_nxt
kcp.snd_buf = append(kcp.snd_buf, newseg)
kcp.snd_nxt++
newSegsCount++
kcp.snd_queue[k].data = nil
}
if newSegsCount > 0 {
kcp.snd_queue = kcp.remove_front(kcp.snd_queue, newSegsCount)
}

// calculate resent
resent := uint32(kcp.fastresend)
if kcp.fastresend <= 0 {
resent = 0xffffffff
}

// check for retransmissions
current := currentMs()
var change, lost, lostSegs, fastRetransSegs, earlyRetransSegs uint64
for k := range kcp.snd_buf {
segment := &kcp.snd_buf[k]
needsend := false
if segment.xmit == 0 { // initial transmit
needsend = true
segment.rto = kcp.rx_rto
segment.resendts = current + segment.rto
} else if _itimediff(current, segment.resendts) >= 0 { // RTO
needsend = true
if kcp.nodelay == 0 {
segment.rto += kcp.rx_rto
} else {
segment.rto += kcp.rx_rto / 2
}
segment.resendts = current + segment.rto
lost++
lostSegs++
} else if segment.fastack >= resent { // fast retransmit
needsend = true
segment.fastack = 0
segment.rto = kcp.rx_rto
segment.resendts = current + segment.rto
change++
fastRetransSegs++
} else if segment.fastack > 0 && newSegsCount == 0 { // early retransmit
needsend = true
segment.fastack = 0
segment.rto = kcp.rx_rto
segment.resendts = current + segment.rto
change++
earlyRetransSegs++
}

if needsend {
segment.xmit++
segment.ts = current
segment.wnd = seg.wnd
segment.una = seg.una

size := len(buffer) - len(ptr)
need := IKCP_OVERHEAD + len(segment.data)

if size+need > int(kcp.mtu) {
kcp.output(buffer, size)
current = currentMs() // time update for a blocking call
ptr = buffer
}

ptr = segment.encode(ptr)
copy(ptr, segment.data)
ptr = ptr[len(segment.data):]

if segment.xmit >= kcp.dead_link {
kcp.state = 0xFFFFFFFF
}
}
}

// flash remain segments
size := len(buffer) - len(ptr)
if size > 0 {
kcp.output(buffer, size)
}

// counter updates
sum := lostSegs
if lostSegs > 0 {
atomic.AddUint64(&DefaultSnmp.LostSegs, lostSegs)
}
if fastRetransSegs > 0 {
atomic.AddUint64(&DefaultSnmp.FastRetransSegs, fastRetransSegs)
sum += fastRetransSegs
}
if earlyRetransSegs > 0 {
atomic.AddUint64(&DefaultSnmp.EarlyRetransSegs, earlyRetransSegs)
sum += earlyRetransSegs
}
if sum > 0 {
atomic.AddUint64(&DefaultSnmp.RetransSegs, sum)
}

// update ssthresh
// rate halving, https://tools.ietf.org/html/rfc6937
if change > 0 {
inflight := kcp.snd_nxt - kcp.snd_una
kcp.ssthresh = inflight / 2
if kcp.ssthresh < IKCP_THRESH_MIN {
kcp.ssthresh = IKCP_THRESH_MIN
}
kcp.cwnd = kcp.ssthresh + resent
kcp.incr = kcp.cwnd * kcp.mss
}

// congestion control, https://tools.ietf.org/html/rfc5681
if lost > 0 {
kcp.ssthresh = cwnd / 2
if kcp.ssthresh < IKCP_THRESH_MIN {
kcp.ssthresh = IKCP_THRESH_MIN
}
kcp.cwnd = 1
kcp.incr = kcp.mss
}

if kcp.cwnd < 1 {
kcp.cwnd = 1
kcp.incr = kcp.mss
}
}

flush函数非常的重要,kcp的重要参数都是在调节这个函数的行为,这个函数只有一个参数ackOnly,意思就是只发送ack,如果ackOnly为true的话,该函数只遍历ack列表,然后发送,就完事了。
如果不是,也会发送真实数据。
在发送数据前先进行windSize探测,如果开启了拥塞控制nc=0,则每次发送前检测服务端的winsize,如果服务端的winsize变小了,自身的winsize也要更着变小,来避免拥塞。如果没有开启拥塞控制,就按设置的winsize进行数据发送。

接着循环每个段数据,并判断每个段数据的是否该重发,还有什么时候重发:



  1. 如果这个段数据首次发送,则直接发送数据。

  2. 如果这个段数据的当前时间大于它自身重发的时间,也就是RTO,则重传消息。

  3. 如果这个段数据的ack丢失累计超过resent次数,则重传,也就是快速重传机制。这个resent参数由resend参数决定。

  4. 如果这个段数据的ack有丢失且没有新的数据段,则触发ER,ER相关信息ER


最后通过kcp.output发送消息hello,output是个回调函数,函数的实体是sess.go的:


func (s *UDPSession) output(buf []byte) {
var ecc [][]byte

// extend buf's header space
ext := buf
if s.headerSize > 0 {
ext = s.ext[:s.headerSize+len(buf)]
copy(ext[s.headerSize:], buf)
}

// FEC stage
if s.fecEncoder != nil {
ecc = s.fecEncoder.Encode(ext)
}

// encryption stage
if s.block != nil {
io.ReadFull(rand.Reader, ext[:nonceSize])
checksum := crc32.ChecksumIEEE(ext[cryptHeaderSize:])
binary.LittleEndian.PutUint32(ext[nonceSize:], checksum)
s.block.Encrypt(ext, ext)

if ecc != nil {
for k := range ecc {
io.ReadFull(rand.Reader, ecc[k][:nonceSize])
checksum := crc32.ChecksumIEEE(ecc[k][cryptHeaderSize:])
binary.LittleEndian.PutUint32(ecc[k][nonceSize:], checksum)
s.block.Encrypt(ecc[k], ecc[k])
}
}
}

// WriteTo kernel
nbytes := 0
npkts := 0
// if mrand.Intn(100) < 50 {
for i := 0; i < s.dup+1; i++ {
if n, err := s.conn.WriteTo(ext, s.remote); err == nil {
nbytes += n
npkts++
}
}
// }

if ecc != nil {
for k := range ecc {
if n, err := s.conn.WriteTo(ecc[k], s.remote); err == nil {
nbytes += n
npkts++
}
}
}
atomic.AddUint64(&DefaultSnmp.OutPkts, uint64(npkts))
atomic.AddUint64(&DefaultSnmp.OutBytes, uint64(nbytes))
}

output函数才是真正的将数据写入内核中,在写入之前先进行了fec编码,fec编码器的实现是用了一个开源库github.com/klauspost/reedsolomon,编码以后的hello就不是和原来的hello一样了,至少多了几个字节。
fec编码器有两个重要的参数reedsolomon.New(dataShards, parityShards, reedsolomon.WithMaxGoroutines(1)),dataShardsparityShards,这两个参数决定了fec的冗余度,冗余度越大抗丢包性就越强。


kcp的任务调度器


其实这里任务调度器是一个很简单的实现,用一个全局变量updater来管理session,代码文件为updater.go。其中最主要的函数


func (h *updateHeap) updateTask() {
var timer <-chan time.Time
for {
select {
case <-timer:
case <-h.chWakeUp:
}

h.mu.Lock()
hlen := h.Len()
now := time.Now()
if hlen > 0 && now.After(h.entries[0].ts) {
for i := 0; i < hlen; i++ {
entry := heap.Pop(h).(entry)
if now.After(entry.ts) {
entry.ts = now.Add(entry.s.update())
heap.Push(h, entry)
} else {
heap.Push(h, entry)
break
}
}
}
if hlen > 0 {
timer = time.After(h.entries[0].ts.Sub(now))
}
h.mu.Unlock()
}
}

任务调度器实现了一个堆结构,每当有新的连接,session都会插入到这个堆里,接着for循环每隔interval时间,遍历这个堆,得到entry然后执行entry.s.update()。而entry.s.update()会执行s.kcp.flush(false)来发送数据。


总结


这里简单介绍了kcp的整体流程,详细介绍了发送数据的流程,但未介绍kcp接收数据的流程,其实在客户端发送数据后,服务端是需要返回ack的,而客户端也需要根据返回的ack来判断数据段是否需要重传还是在队列里清除该数据段。处理返回来的ack是在函数kcp.Input()函数实现的。具体详细流程下次再介绍。