LG-27EP950效果还不错，赞

手掌那么大

主机效果图

高达联名款，一个字“型”

package main
import (
    "github.com/gin-gonic/gin"
)
func main() {
    d := gin.Default()
    d.GET("/index", func(c *gin.Context) {
        c.JSON(200, gin.H{"message":"hello world","data":""})
    })
    d.Run("127.0.0.1:8080")
}

2013年买的第一本go语言的书，至今还是比较好的入门书籍

距离现在好几年了，这两年go生态相对比较好，从而线上服务转去golang。
实际就是现代C语言，没有class面向对象，只有使用函数来做面向对象。

go常用命令

go get

go get http://github.com/123/abc
$GOPATH
获取组件

go build

bin/

go run

go mod

dep

module
如果Go的版本太低不能使用，建议将Go的版本升级到最新。
环境变量中可以增加GOPROXY=https://goproxy.io 这样没有梯子的情况下可以正确的加载相应的包文件。
环境变量GO111MODULE不要设置，如果已经增加了这个变量请务必设置为GO111MODULE=auto。
在项目的根目录下使用命令go mod init projectName。

go tool

go tool nm ./example

基本类型

类型 长度(字节) 默认值 说明
bool 1 false

byte 1 0 uint8
rune 4 0 Unicode Code Point, int32
int, uint 4或8 0 32 或 64 位
int8, uint8 1 0 -128 ~ 127, 0 ~ 255，byte是uint8 的别名
int16, uint16 2 0 -32768 ~ 32767, 0 ~ 65535
int32, uint32 4 0 -21亿~ 21亿, 0 ~ 42亿，rune是int32 的别名
int64, uint64 8 0

float32 4 0.0
float64 8 0.0
complex64 8

complex128 16

uintptr 4或8 以存储指针的 uint32 或 uint64 整数
array 值类型
struct 值类型
string "" UTF-8 字符串
slice nil 引用类型
map nil 引用类型
channel nil 引用类型
interface nil 接口
function nil 函数

数组与切片

数组

Don’t communicate by sharing memory; share memory by communicating.

var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}

深拷贝是指将值类型的数据进行拷贝的时候，拷贝的是数值本身，所以值类型的数据默认都是深拷贝。浅拷贝指的是拷贝的引用地址，修改拷贝过后的数据,原有的数据也被修改。 那么如何做到引用类型的深拷贝？也就是需要将引用类型的值进行拷贝。修改拷贝的值不会对原有的值造成影响。

// copy(目标切片,数据源)  深拷贝数据函数
s2 := []int{1, 2, 3, 4}
s3 := []int{7, 8, 9}

copy(s2, s3)        //将s3拷贝到s2中    
fmt.Println(s2)     //结果 [7 8 9 4]
fmt.Println(s3)     //结果 [7 8 9]

copy(s3, s2[2:])    //将s2中下标为2的位置 到结束的值 拷贝到s3中 
fmt.Println(s2)     //结果 [1 2 3 4]
fmt.Println(s3)     //结果 [3 4 9]

copy(s3, s2)        //将s2拷贝到s3中
fmt.Println(s2)     //结果 [1 2 3 4]
fmt.Println(s3)     //结果 [1 2 3]

二维数据

数组长度是固定的，如果要扩展数组，得使用切片

切片

make()是Go语言中的内置函数，主要用于创建并初始化slice切片类型，或者map字典类型，或者channel通道类型数据。他与new方法的区别是。new用于各种数据类型的内存分配，在Go语言中认为他返回的是一个指针。指向的是一个某种类型的零值。make 返回的是一个有着初始值的非零值。

使用make函数

var s3 []int = make([]int, 0)

or

var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var slice0 []int = arr[start:end] 
1:3
var slice1 []int = arr[:end]        
var slice2 []int = arr[start:]        
var slice3 []int = arr[:] 
var slice4 = arr[:len(arr)-1]

切片是可索引的，并且可以由 len() 方法获取长度。
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。
切片是面向地址的，修改数值会影响相关变量。

map

定义语法

map[KeyType]ValueType
    
//1, 声明map 默认值是nil
var m1 map[key_data_type]value_data_type
声明  变量名称 map[key的数据类型]value的数据类型
//2，使用make声明
m2:=make(map[key_data_type]value_data_type)
//3,直接声明并初始化赋值map方法
m3:=map[string]int{"语文":89,"数学":23,"英语":90}

demo:

func main() {
    scoreMap := make(map[string]int, 8)
    scoreMap["张三"] = 90
    scoreMap["小明"] = 100
    fmt.Println(scoreMap)
    fmt.Println(scoreMap["小明"])
    fmt.Printf("type of a:%T\n", scoreMap)
}

结构体

基本上和C的struct一样
在Go语言中，使用type关键字可以定义出新的自定义类型，有了自定义类型之后我们就可以为自定义类型添加各种方法了。

type person1 struct {
        name, city string
        age        int8
}

package main

import (
    "fmt"
)

//定义结构体
type Person struct {
    name    string
    age     int
    sex     string
    address string
}

实例：

func main() {
    //实例化后并使用结构体
    p := Person{} //使用简短声明方式，后面加上{}代表这是结构体
    
    p.age = 2     //给结构体内成员变量赋值
    p.address = "陕西"
    p.name = "好家伙"
    p.sex = "女"
    
    fmt.Println(p.age, p.address, p.name, p.sex)//使用点.来访问结构体内成员的变量的值。

}

指针

基本上和C一致
指针是存储另一个变量的内存地址的变量。 例如： 变量B的值为100， 地址为0x1122。变量A的值为变量B的地址0x1122，那么A就拥有了变量B的地址，则A就成为指针。Go语言中通过&获取变量的地址。通过* 获取指针所对应的变量存储的数值。

package main

import (
    "fmt"
)

func main() {

    //定义一个变量
    a := 2
    fmt.Printf("变量A的地址为%p", &a) //通过%p占位符, &符号获取变量的内存地址。
    //变量A的地址为0xc000072090
    

    //创建一个指针
    // 指针的声明 通过 *T 表示T类型的指针
    var i *int     //int类型的指针
    var f *float64 //float64类型的指针
    fmt.Println(i) // < nil >空指针
    fmt.Println(f)

    //因为指针存储的变量的地址 所以指针存储值
    i = &a
    fmt.Println(i)  //i存储a的内存地址0xc000072090
    fmt.Println(*i) //i存储这个指针存储的变量的数值2
    *i = 100
    fmt.Println(*i) //100
    fmt.Println(a)  //100通过指针操作 直接操作的是指针所对应的数值

}

指针的指针，也就是存储的不是具体的数值了，而是另一个指针的地址。

func main(){
    a := 2
    var i *int         //声明一个int类型的指针
    fmt.Println(&a)    //0xc00000c1c8
    i = &a             //将a的地址取出来放到i里面
    fmt.Println(&i)    //0xc000006028
    var a2 **int       //声明一个指针类型的指针
    a2 = &i            //再把i的地址放进a2里面
    fmt.Println(a2)    //获取的是a2所对应的数值0xc000006028也就是i的地址
}

指针属于引用类型的数据， 所以在传递过程中是将参数的地址传给函数，将指针作为参数传递时，只有值类型的数据，需要传递指针，而引用类型的数据本身就是传递的地址，所以数组传递可以使用指针，切片是引用类型数据，则不需要传递指针传递。

package main

import (
    "fmt"
)

func main() {
    s := 10
    fmt.Println(s) //调用函数之前数值是10
    fun1(&s)
    fmt.Println(s) //调用函数之后再访问则被修改成2
}

//接收一个int类型的指针作为参数
func fun1(a *int) {
    *a = 2
}

使用结构体调用指针

//1 使用结构体指针
var p *Person
p = &p2 //将p2 的地址赋给p
import "encoding/json"
package main

import (
    "encoding/json"
    "fmt"
)
//结构体
type Prescription struct {
    Name     string        
    Unit     string        
    Additive *Prescription 
}

func main() {
    p := Prescription{}
    p.Name = "鹤顶红"
    p.Unit = "1.2kg"
    p.Additive = &Prescription{
        Name: "砒霜",
        Unit: "0.5kg",
    }

    buf, err := json.Marshal(p) //转换为json返回两个结果
    if err != nil {
        fmt.Println("err = ", err)
        return
    }

    fmt.Println("json = ", string(buf))
}

package main

import (
    "encoding/json"
    "fmt"
)

//结构体
type Prescription struct {
    Name     string        `json:"name"` //重新指定json字段为小写输出
    Unit     string        `json:"unit"`
    Additive *Prescription `json:"additive,omitempty"`
}

func main() {
    jsonstr := `{"name":"鹤顶红","unit":"1.2kg","additive":{"name":"砒霜","unit":"0.5kg"}}`
    var p Prescription
    if err := json.Unmarshal([]byte(jsonstr), &p); err != nil {
        fmt.Println(err)
    }
    fmt.Println(p)
}

流程控件

日常语言的if、for range、switch不作具体描述，比较特殊的用法是select
while(true)
{

}
select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

select 是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。 select 随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

函数与方法

如果你想让一个方法可以被别的包访问的话，你需要把这个方法的第一个字母大写。这是一种约定。

面向对象

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

反射工具类

reflect

通道

通道（channel）是用来传递数据的一个数据结构。

//通道的声明
var channel chan int
//如果通道时nil 则要通过make创建通道
channel= make(chan int)

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

在函数或者方法前面加上关键字go，就会同时运行一个新的goroutine。

与函数不同的是goroutine调用之后会立即返回，不会等待goroutine的执行结果，所以goroutine不会接收返回值。 把封装main函数的goroutine叫做主goroutine，main函数作为主goroutine执行，如果main函数中goroutine终止了，程序也将终止，其他的goroutine都不会再执行。

虽然说Go编译器将Go的代码编译成本地可执行代码。不需要像java或者.net那样的语言需要一个虚拟机来运行，但其实go是运行在runtime调度器上的，它主要负责内存管理、垃圾回收、栈处理等等。也包含了Go运行时系统交互的操作，控制goroutine的操作，Go程序的调度器可以很合理的分配CPU资源给每一个任务。

Go1.5版本之前默认是单核执行的。从1.5之后使用可以通过runtime.GOMAXPROCS()来设置让程序并发执行，提高CPU的利用率。

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    //获取当前GOROOT目录
    fmt.Println("GOROOT:", runtime.GOROOT())
    //获取当前操作系统
    fmt.Println("操作系统:", runtime.GOOS)
    //获取当前逻辑CPU数量
    fmt.Println("逻辑CPU数量：", runtime.NumCPU())

    //设置最大的可同时使用的CPU核数  取逻辑cpu数量
    n := runtime.GOMAXPROCS(runtime.NumCPU())
    fmt.Println(n) //一般在使用之前就将cpu数量设置好 所以最好放在init函数内执行

    //goexit 终止当前goroutine
    //创建一个goroutine
    go func() {
        fmt.Println("start...")
        runtime.Goexit() //终止当前goroutine
        fmt.Println("end...")
    }()
    time.Sleep(3 * time.Second) //主goroutine 休眠3秒 让子goroutine执行完
    fmt.Println("main_end...")
}

延迟函数

package main

import (
    "fmt"
)

func main() {
    defer test(1) //第一个被defer的，函数后执行
    defer test(2) //第二个被defer的，函数先执行
    test(3)       //没有defer的函数，第一次执行
    
    //执行结果
    //3
    //2
    //1
}

func test(s int) {
    fmt.Println(s)
}

错误处理

实际每个函数都可以定义二个参数的返回，error类型
例如
txt, err = test("test.txt");

错误类型

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := errors.New("错误信息...")
    fmt.Println(err)

    num, err2 := Calculation(0)
    fmt.Println(num, err2)
}

//通过内置errors包创建错误对象来返回
func Calculation(divisor int) (int, error) {
    if divisor == 0 {
        return 0, errors.New("错误:除数不能为零.")
    }
    return 100 / divisor, nil
}

panic和recover
中断信息，recover接收信息

package main

import (
    "fmt"
)

func main() {
    Test1()
}

func Test1() {
    defer func() {
        ms := recover()//这里执行恢复操作
        fmt.Println(ms, "恢复执行了..") //恢复程序执行,且必须在defer函数中执行
    }()
    defer fmt.Println("第1个被defer执行")
    defer fmt.Println("第2个被defer执行")
    for i := 0; i <= 6; i++ {
        fmt.Println(i);
        if i == 4 {
            panic("中断操作") //让程序进入恐慌 终端程序操作
        }
    }
    
    defer fmt.Println("第3个被defer执行") //恐慌之后的代码是不会被执行的
}

常用工具包

官方常用工具包有如下
fmt、strings、strconv、os、io、errors

导入包

引入每个工具包，都先要先导入
使用import 导入包。go自己会默认从GO的安装目录和GOPATH环境变量中的目录，检索src下的目录进行检索包是否存在。所以导入包的时候路径要从src目录下开始写。GOPATH 就是我们自己定义的包的目录。

// 每行一个写法
import fmt
// 导入多个，还可以重命名
import (
    "fmt"
    "sync"
    "os" "test"
    _ "test.com/test"  // 只调用里面的init，不调用里面的方法
)

闭包

闭包：
package main
import (
    "fmt"
)
func main() {
    res := closure()
    fmt.Println(res) //0x49a880  返回内层函数函数体地址
    r1 := res()      //执行closure函数返回的匿名函数
    fmt.Println(r1)  //1
    r2 := res()
    fmt.Println(r2) //2 
    //普通的函数应该返回1，而这里存在闭包结构所以返回2 。
    //一个外层函数当中有内层函数，这个内层函数会操作外层函数的局部变量,并且外层函数把内层函数作为返回值,则这里内层函数和外层函数的局部变量,统称为闭包结构。这个外层函数的局部变量的生命周期会发生改变，不会随着外层函数的结束而销毁。
    //所以上面打印的r2 是累计到2 。

    res2 := closure() //再次调用则产生新的闭包结构 局部变量则新定义的
    fmt.Println(res2)
    r3 := res2()
    fmt.Println(r3)
}

//定义一个闭包结构的函数 返回一个匿名函数
func closure() func() int { //外层函数
    //定义局部变量a
    a := 0 //外层函数的局部变量
    //定义内层匿名函数 并直接返回
    return func() int { //内层函数
        a++ //在匿名函数中将变量自增。内层函数用到了外层函数的局部变量，此变量不会随着外层函数的结束销毁
        return a
    }
}

sync工具

package main

import (
    "fmt"
    "sync"
)

//创建一个同步等待组的对象
var wg sync.WaitGroup

func main() {
    wg.Add(3) //设置同步等待组的数量
    go Relief1()
    go Relief2()
    go Relief3()
    wg.Wait() //主goroutine进入阻塞状态
    fmt.Println("main end...")
}

func Relief1() {
    fmt.Println("func1...")
    wg.Done() //执行完成 同步等待数量减1
}
func Relief2() {
    defer wg.Done()
    fmt.Println("func2...")
}
func Relief3() {
    defer wg.Done() //推荐使用延时执行的方法来减去执行组的数量
    fmt.Println("func3...")
}

互斥锁

互斥锁，当一个goroutine获得锁之后其他的就只能等待当前goroutine执行完成之后解锁后才能访问资源。对应的方法有上锁Lock()和解锁Unlock()。

读写锁

互斥锁是用来控制多个协程在访问同一个资源的时候进行加锁控制,保证了数据安全，但同时也降低了性能，如果说多个goroutine同时访问一个数据，只是读取一下数据，并没有对数据进行任何修改操作，那么不管多少个goroutine来读取都应该是可以的。主要问题在于修改。修改的数据就需要加锁操作，来保证数据在多个goroutine读取的时候统一。 读取和读取之间是不需要互斥操作的，所以我们用读写锁专门针对读操作和写操作的互斥锁。

rsync的使用

因为不使用rsync://协议，不走配置文件。配置文件太麻烦了，我们直接使用ssh的22端口进行传输。
首先要同步的机上都安装上rsync.

yum install -y rsync

同步命令

rsync -av --progress --exclude="vendor/*"  源目录/  目标目录/


rsync -av --progress --exclude="vendor/*" --exclude="Runtime/log/*" root@163.163.163.163:/webwww/www/slplat /webwww/www/

参数解释

--exclude 排除要同步的目录
-a 参数表示存档模式，保存所有的元数据，比如修改时间（modification time）、权限、所有者等，并且软链接也会同步过去。
-v 输出细节
--progress 输出同步信息

每次运行即可同步信息

同步好文件之后，一般要停掉源服务器的写入，因为要同步数据库迁移。

这里可以使用腾讯云的数据库迁移工具。

或使用navicat mysql的迁移工具。
这里要注意同步的话要同版本迁移，例如mysql5.7，目标数据库最好是5.7，如使用8.0.22可能有问题，因为mysql8.0.22去掉int类型的位长。

dns与cdn的更新

因为dns可能存在缓存的问题，并不能及时更新到用户层，所以源来的服务器最好开启，把数据库等连接填写新外网的数据库。

测试

最后一步测试流程，例如有些接口做了ip白名单的，要主动加上。

ab命令详解

-n 即requests，用于指定压力测试总共的执行次数。
-c 即concurrency，用于指定的并发数。
-t 即timelimit，等待响应的最大时间(单位：秒)。
-b 即windowsize，TCP发送/接收的缓冲大小(单位：字节)。
-p 即postfile，发送POST请求时需要上传的文件，此外还必须设置-T参数。
-u 即putfile，发送PUT请求时需要上传的文件，此外还必须设置-T参数。
-T 即content-type，用于设置Content-Type请求头信息，例如：application/x-www-form-urlencoded，默认值为text/plain。
-v 即verbosity，指定打印帮助信息的冗余级别。
-w 以HTML表格形式打印结果。
-i 使用HEAD请求代替GET请求。
-x 插入字符串作为table标签的属性。
-y 插入字符串作为tr标签的属性。
-z 插入字符串作为td标签的属性。
-C 添加cookie信息，例如："Apache=1234"(可以重复该参数选项以添加多个)。
-H 添加任意的请求头，例如："Accept-Encoding: gzip"，请求头将会添加在现有的多个请求头之后(可以重复该参数选项以添加多个)。
-A 添加一个基本的网络认证信息，用户名和密码之间用英文冒号隔开。
-P 添加一个基本的代理认证信息，用户名和密码之间用英文冒号隔开。
-X 指定使用的和端口号，例如:"126.10.10.3:88"。
-V 打印版本号并退出。
-k 使用HTTP的KeepAlive特性。
-d 不显示百分比。
-S 不显示预估和警告信息。
-g 输出结果信息到gnuplot格式的文件中。
-e 输出结果信息到CSV格式的文件中。
-r 指定接收到错误信息时不退出程序。
-h 显示用法信息，其实就是ab -help。

模拟并发请求100次，总共请求10000次
命令模板：
ab -c 100 -n 10000 待测试网站（建议完整路径）
内容解释：

Server Software: nginx/1.10.2 (服务器软件名称及版本信息)
Server Hostname: 192.168.1.106(服务器主机名)
Server Port: 80 (服务器端口)
Document Path: /index1.html. (供测试的URL路径)
Document Length: 3721 bytes (供测试的URL返回的文档大小)
Concurrency Level: 1000 (并发数)
Time taken for tests: 2.327 seconds (压力测试消耗的总时间)
Complete requests: 5000 (的总次数)
Failed requests: 688 (失败的请求数)
Write errors: 0 (网络连接写入错误数)
Total transferred: 17402975 bytes (传输的总数据量)
HTML transferred: 16275725 bytes (HTML文档的总数据量)
Requests per second: 2148.98 [#/sec] (mean) (平均每秒的请求数) 这个是非常重要的参数数值，服务器的吞吐量
Time per request: 465.338 [ms] (mean) (所有并发用户(这里是1000)都请求一次的平均时间)
Time request: 0.247 [ms] (mean, across all concurrent requests) (单个用户请求一次的平均时间)
Transfer rate: 7304.41 [Kbytes/sec] received 每秒获取的数据长度 (传输速率，单位：KB/s)

模式的测试

php-fpm、workerman http、swoole http、swoole协程http, 主要围绕这几种来展开

swoole模式

workerman模式

php-fpm模式

总结

这里可以查看得知php-fpm进程每次要ast一下代码过程会减慢速度，简单业务的情况下，workerman会更快一些。

安装

首先我们在主要的服务器上使用yum来安装一下

yum -y install ansible

安装完之后，更新一下主机配置
vim /etc/ansible/hosts

例如我们配置一组ip

[mg]
1.55.239.140
1.71.34.97
1.75.220.150
1.75.207.240

生成密钥（这个可以详看我写的openssh通讯）

ssh-keygen -t rsa

将pub加到其它机器上，实现ssh通讯

具体命令

Ansible的命令格式为， ansible 主机群组名 -m 命令模块名 -a "批量执行的操作"
其中-m不是必须的，默认为command模块，-a也不是必须的，表示命令模块的参数，比如前面的ping模块就没有参数。
可以使用 ansible-doc -l 列出所有可用的命令模块， ansible-doc -s 模块名 查看指定模块的参数信息

ping # 主机连通性测试
command # 在远程主机上执行命令,不支持管道
shell # 在远程主机上调用shell解析器,支持管道命令个
copy # 用于将文件复制到远程主机,支持设定内容和修改权限.
file # 创建文件,创建连接文件,删除文件等
fetch # 从远程复制文件到本地
cron # 管理cron计划任务
yum # 用于模块的安装
service # 管理服务
user # 管理用户账号
group # 用户组管理
script # 将本地的脚本在远端服务器运行
setup # 该模块主要用于收集信息，是通过调用facts组件来实现的,以变量形式存储主机上的信息

-------------------------------------------------------------------

ansible mg -m command -a "free -g"
ansible mg -m shell -a "free -g|grep Mem"
ansible mg -m script -a "/root/echo.sh"
ansible mg -m copy -a "src=/root/echo.sh dest=/tmp/ owner=root group=root mode=0755"
ansible mg -m yum -a "name=wget state=latest"
ansible mg -m service -a "name=nginx state=stoped"
ansible mg -m get_url -a "url=http://www.baidu.com dest=/tmp/index.html mode=0440 force=yes"
ansible mg -m setup
ansible mg -m file -a "dest=/opt/test state=touch"
directory：创建目录
file：如果文件不存在，则创建
link：创建symbolic link
absent：删除文件或目录
touch： 创建一个不存在的空文件
ansible mg -m cron -a "name='backup servcie' minute=*/5 job='/usr/sbin/ntpdate  time.nist.gov >/dev/null 2>&1'"

暂时使用得最多的是command和shell

检测指定ip


ansible 127.0.0.1 -m ping


特定组


ansible mg -m ping


所有配置


ansible all -m ping


批量操作示例

ansible mg -m shell -a "yum install -y yum-utils device-mapper-persistent-data lvm2"

ansible mg -m shell -a "yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo"

ansible mg -m shell -a "yum -y install docker-ce docker-ce-cli containerd.io"

ansible mg -m shell -a "systemctl start docker"

总结

ansible更高级的功能暂时没用上，但批量处理命令的方式实在是方便！

register在worker进程和gateway进程中间

运行

我们下载运行一下

主要由3个worker组成，对应文件里的3个

我们主要将逻辑写在Events.php事件逻辑里即可，其它交给布署的人员。
跟websocket三核心方法一样
onConnect // 客户连接
onMessage // 处理客户消息
onClose // 客户关闭

核心文件

因为GatewayWorker依赖workerman的原因，源码文件并不多，主要我们要掌握思路
.
├── BusinessWorker.php 用户事件处理
├── Gateway.php gateway
├── Lib
│   ├── Context.php 上下文管理
│   ├── Db.php db类
│   ├── DbConnection.php db连接，作池使用
│   └── Gateway.php gateway方法，主要学习这个类
├── Protocols
│   └── GatewayProtocol.php 通讯协议
└── Register.php Register类

Protocols和Lib暂且可以不分析，除了Lib/Gateway.php文件

Register

主要是管理gateway连接和worker连接, 然后广播一下地址broadcastAddresses

BusinessWorker

BusinessWorker主要是调用用户Events.php的逻辑, 并向GateWay保持通讯

GatewayWorker

主要是入口，例如每个浏览器先访问GatewayWorker, GatewayWorker再到找Register进程，连接到用户逻辑模块。

Lib\Gateway

很多核心逻辑处理，主要看这个类

方法比较多
sendToAll 广播信息
sendToClient 发送给指定客户
isUidOnline 判断某个客户端是否在线
isOnline 是否在线
getClientInfoByGroup 获取某个组信息
getAllClientIdCount 获取所有在线client_id数
getUidListByGroup 获取某个群组在线uid
getAllUidList 获取全局在线uid
等等
方法比较多，需每个认真查看逻辑，分析作者设计思想

总结

总的来说GatewayWorker的设计思想还是比较好的，可以横向扩展分布式的思路。如果不关心是怎么运作，倒是写好Events.php就够用，学习好Lib\Gateways的方法。

附录

GatewayWorker手册

配置个web的http worker

在代码里再请求curl 8089端口，即http://127.0.0.1:8089
为了调试，我们开启curl的debug功能

curl_setopt($ch, CURLOPT_VERBOSE, true); // curl debug
curl_setopt($ch, CURLOPT_STDERR, fopen(CRONPATH.'/Application/Log/curl.log', 'w+'));
$response = curl_getinfo( $ch );

测试正常连接百度是正常的，但连接127.0.0.1:8089一直在等待中
Warning: file_get_contents(http://127.0.0.1:8089/?op=cl_list&secret=b61e757422497ccaef7dab5d59b180dd): Failed to open stream: HTTP request failed! in /webwww/y/cronshow/Application/Library/Web.php on line 174

curl_start
exec
* Expire in 0 ms for 6 (transfer 0x558eac35eb10)
* Expire in 2000 ms for 8 (transfer 0x558eac35eb10)
* Expire in 2000 ms for 2 (transfer 0x558eac35eb10)
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Expire in 200 ms for 4 (transfer 0x558eac35eb10)
* Connected to 127.0.0.1 (127.0.0.1) port 8089 (#0)
> GET /?op=cl_list&secret=b61e757422497ccaef7dab5d59b180dd HTTP/1.1
Host: 127.0.0.1:8089
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.5
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded; charset=utf-8
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:28.0) Gecko/20100101 Firefox/28.0
X-MicrosoftAjax: Delta=true

* Operation timed out after 2000 milliseconds with 0 bytes received
* Closing connection 0

显示2秒之后断开

docker里开启strace调试

docker run --cap-add=SYS_PTRACE -it -v ~/code:/webwww --name php-fpm-8033 show/php-fpm:8.0.3

进入docker里查看

strace -tt -p 对应进程端口
可使用php job.php status查看workerman的worker端口

可以监测到连接8089的时候是-1

socket(AF_INET, SOCK_STREAM, IPPROTO_IP) = 8

connect(8, {sa_family=AF_INET, sin_port=htons(8089), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EINPROGRESS (Operation now in progress)

getpeername(8, {sa_family=AF_INET, sin_port=htons(8089), sin_addr=inet_addr("127.0.0.1")}, [128->16]) = 0
getsockname(8, {sa_family=AF_INET, sin_port=htons(53752), sin_addr=inet_addr("127.0.0.1")}, [128->16]) = 0

正常的情况下是0

connect(9, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr("192.168.65.1")}, 16) = 0

这时候思考到workerman的count参数只开启了一个阻塞进程，故而改成3个进程即可。

通过这个事故，下定决定分析workerman源码

分析

我们先查看一下workerman的目录

.
├── _webwww_y_cronshow_job.php.pid
├── workerman
│   ├── Autoloader.php
│   ├── Connection
│   │   ├── AsyncTcpConnection.php
│   │   ├── AsyncUdpConnection.php
│   │   ├── ConnectionInterface.php
│   │   ├── TcpConnection.php
│   │   └── UdpConnection.php
│   ├── Events
│   │   ├── Ev.php
│   │   ├── Event.php
│   │   ├── EventInterface.php
│   │   ├── Libevent.php
│   │   ├── React
│   │   │   ├── Base.php
│   │   │   ├── ExtEventLoop.php
│   │   │   ├── ExtLibEventLoop.php
│   │   │   └── StreamSelectLoop.php
│   │   ├── Select.php
│   │   └── Swoole.php
│   ├── Lib
│   │   ├── Constants.php
│   │   └── Timer.php
│   ├── MIT-LICENSE.txt
│   ├── Protocols
│   │   ├── Frame.php
│   │   ├── Http
│   │   │   ├── Chunk.php
│   │   │   ├── Request.php
│   │   │   ├── Response.php
│   │   │   ├── ServerSentEvents.php
│   │   │   ├── Session
│   │   │   │   ├── FileSessionHandler.php
│   │   │   │   └── RedisSessionHandler.php
│   │   │   ├── Session.php
│   │   │   └── mime.types
│   │   ├── Http.php
│   │   ├── ProtocolInterface.php
│   │   ├── Text.php
│   │   ├── Websocket.php
│   │   └── Ws.php
│   ├── README.md
│   ├── Timer.php
│   ├── Worker.php
│   └── composer.json
└── workerman.log

上来来说
Connection 连接类
Events 网络事件类
Protocols 请求协议类
主要这三部分组成
核心文件主要是Worker.php，不得不佩服workerman作者，简单即精华。
所以我们从Worker.php文件开始说起

其实我们所有服务都是从runAll开始

一层层来分析一下runAll所做的事

checkSapiEnv

主要是检查环境符不符合要求

init

初始化主要生成master的pid文件和对应的log文件
Timer::init(); 初始化事件

注册并signal事件
这里要了解一下php的pcntl库

parseCommand

主要解析命令行的输入
登录php job.php start
即对'start','stop','restart','reload','status','connections'等做接收处理

daemonize

判断是否需要守护进程，如约需要pcntl_fork当前一下

initWorkers

初始化worker
如果你定义了三组worker就三次
例如

$jobworker = new JobWorker();
$cronworker = new CronWorker();
$webworker = new WebWorker();

最近监听各worker的端口

设置监听端口并设置接收监听resumeAccept

这里主要使用到了php的stream和socket库

resumeAccept会增加Event事件，监听每个用户请求的connection

installSignal

注册Signal库，即触发各种网络进程事件
例如ctrl-c关闭进程，kill -9关闭进程等
这里要了解每个sig的含义
SIGINT,SIGTERM,SIGHUP,SIGUSR1,SIGQUIT,SIGUSR2,SIGIO,SIGPIPE

saveMasterPid

保存Master进程的pid

displayUI

设置要显示的UI
运行成功之后会有个界面

forkWorkers

这里主要是查看定义worker里的个数，例如我们的webworker定义count=3，会生成webworker相关的3个子进程。

resetStd

设置定义的输入输出

monitorWorkers

使用pcntl_signal_dispatch事件，监控每个子进程的情况。
Worker类就大概这样的情况了

网络相关

因为在stream和socket里，并没有协议做解释，所以协议的处理我们会在Protocols文件夹里做相对就的处理

例如我们定义的是text://127.0.0.1:123, 就会找到Text做弄对应的处理
http://0.0.0.0:456,即指定Http.php做相关处理
协议的定义在workerman手册能找到

结尾

workerman为我们带来了异步，提升并发，这是比php-fpm带来更多的好处。但我们也要了解一下进程内是怎么一回事，因为mysql长链接断开等问题。
workerman主要的难度是多进程和网络事件，这部分需要我们学习select、poll、epoll等。了解网络解释的一些过程，此篇比较精简说明一下workerman，后续更新每个模块的详解。

fpm模式

server {
        index index.html index.htm index.php;
        root /webwww/www/landpage/Public/dist;
        server_name landpage.xx.com;
  listen 443;
  listen 80;
  ssl on;
  ssl_certificate /webwww/ssl/1_.cn_bundle.crt;
  ssl_certificate_key /webwww/ssl/2_.cn.key;
  ssl_session_timeout 5m;
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #按照这个协议配置
  ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;#按照这个套件配置
  ssl_prefer_server_ciphers on;
        location  / {
                #alias /webwww/www/landpage/Public/dist;             #项目路径
                index index.html;
                try_files $uri $uri/ /index.html;
        }
        location /api {
          root /webwww/www/landpage/Public;
          if (!-e $request_filename){
             rewrite ^/(.*)$ /index.php?s=$1 last;
             break;
          }
          try_files $uri $uri/ /index.php;
        }
        location ~ [^/]\.php(/|$) {
                root  /webwww/www/landpage/Public;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass 172.17.0.7:9000;
                fastcgi_index index.php;
                include fastcgi_params;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                #fastcgi_param   SCRIPT_FILENAME         $request_filename;
                fastcgi_param PATH_INFO       $fastcgi_path_info;
        }
}

nginx查看php-fpm状态

php-fpm需要配置一下

[www]
user = www-data
group = www-data
listen = 127.0.0.1:9000
pm = dynamic
pm.max_children = 20
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 10
;pm.process_idle_timeout = 300
pm.max_requests = 10000
pm.status_path = /status_show
slowlog = /webwww/log/php-fpm-slow.log

nginx增加location

location ~^/status_show$ {
        fastcgi_param SCRIPT_FILENAME $fastcgi_script_name;
        include fastcgi_params;
        fastcgi_pass 172.17.0.2:9000;
}

查看本域名/status_show?full即所有连接
/status_show还可以指定json、html和xml的方式显示

proxy模式

server {
        listen 443;
        listen 80;
        ssl on;
        ssl_certificate /webwww/ssl/1_.cn_bundle.crt;
        ssl_certificate_key /webwww/ssl/2_.cn.key;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #按照这个协议配置
        server_name jumpuser.xxx.cn;
        root /webwww/www/jumpuser/Public/dist;
        location  / {
                index index.html;
                try_files $uri $uri/ /index.html;
        }
       location /api {
                proxy_pass http://172.19.0.2:8080;
                proxy_http_version 1.1;
                proxy_set_header X-Real-IP $remote_addr;
        }
        index index.html index;
}

以上配置都是访问/api开头走后台，默认其它路径走前端， 后端项目必须使用强路由的形式。

为了解决知道用户时长，我们采用了websocket作为通讯,php采用了swoole的websocket功能。

主要有三个事件
Open 建立链接的处理
Message 收到客户端的处理
Close 关闭与客户端的处理

前端配置基本和后端一样, http页面能访问ws和wss,但https只能访问wss。

var ws = new WebSocket("wss://xxx/websocket")
ws.onopen = function () { 
    ws.send("hello"); 
}; 
ws.onmessage = function (resp) { 
    document.getElementById('total').innerHTML = resp.data; 
};
ws.onclose = function () {}; 

nginx配置：

upstream websocket {
    server 172.17.0.2:9507; # 如果只有一条可以直接放在proxy_pass里
}
location /websocket {
          proxy_pass http://websocket;
          proxy_read_timeout 60s;
          proxy_send_timeout 60s;
          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_http_version 1.1;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection "upgrade";
}

链接的时候可以可以参数放在后面，服务器能从get里获取token参数进行鉴权
wss://test.com/websocket?token=abcdefg

需要注意，如果是启用swoole里面的ssl功能，需将proxy_pass的 http://websocket 改成https://websocket

因为我们默认wss走443端口，而我们443端口已经有配置证书，故直接走http://websocket即可。

心跳

因为我们默认服务器配置是60秒时候，所以前端或后端定时发送数据来维护链接即可。

 proxy_read_timeout 60s;
 proxy_send_timeout 60s;

前端

setInterval(wx.send('1'),100000); 

腾讯云的坑

如果是从CDN走websocket,默认也是支持的，默认根据源站的配置，走80端口。
链接是能链接，但是wss的时候会出现ws.send不了数据。 如果要使用websocket建议使用ECDN(全站加速）

官方说明

cdn是提供网站静态内容的加速分发处理能力，ECDN 为纯动态网站与动静态混合型网站提供高可靠、低延时一站式加速服务。具体您可以了解下对应产品的功能介绍
CDN的应用场景：https://cloud.tencent.com/document/product/228/37846
ECDN的功能介绍：https://cloud.tencent.com/document/product/570/10359

其它

附：
cdn的协议跟随引发的问题
WARNING ssl_accept: bad SSL client[127.0.0.1:35418], reason=156, error_string=http request #4068
这个错误说明有明文 HTTP 请求发送到了 SSL 的 HTTPS 端口。
https://github.com/swoole/swoole-src/issues/4068#event-4585154187

// 使用Manager管理数据库
use Illuminate\Database\Capsule\Manager as Db;
self::$db = new Db;
            foreach($dbconfig as $connection_name => $config)
            {
                $db_arr = [
                    'driver'    => $config['dbtype'] ?? 'mysql', 
                    'host'      => $config['host'],
                    'port'      => $config['port'],
                    'database'  => $config['dbname'],
                    'username'  => $config['username'],
                    'password'  => $config['password'],
                    'charset'   => $config['charset'] ?? 'utf8',
                    'collation' => $config['collation'] ?? 'utf8_general_ci',
                    'prefix'    => '',
                ];
                self::$db->addConnection($db_arr,$connection_name);
            }
            // self::$db->setEventDispatcher(new Dispatcher(new Container));
            // 设置fetch的方式
            self::$db->setFetchMode(\PDO::FETCH_ASSOC);
            self::$db->setAsGlobal();
            self::$db->bootEloquent();

setAsGlobal更新instance对象
bootEloquent开始启用。

常用原生用法，使用connection类
query()
select()
cursor()
prepared()
getPdoForSelect()
unprepared()
run()
runQueryCallback()
logQuery()
getQueryLog()

Manger作为facade Db的使用
调用conneciton()

Manager::connection('default')->select("select * from test");

查看databae\PDO\Connection.php和databse\Conneciton查看实现的方法。

其实比较好用的游标，使用原生协程来跟进多数据fetch

另一个值得学习的databse\Eloquent\Model类，orm神器

可以查看出优美地调用__call和__callStatic

在databse\Eloquent\Builder可以发现更多orm的使用方法
例如
updateOrCreate
firstOrFail

查看源码，值得学习大神处理的逻辑。
基本上都是静态的方式调用

相对应有些失败之后还有重连的机制。

大概源码查看到此，基本上学习此源码，orm足够使用的了。

cloudbase jenkins应用:

gitee:

但发觉没报警机制，例如发送短信和钉钉报警(钉钉主要拉机器人，这里不做详细介绍)。


"elasticsearch/elasticsearch": "^7.0"

首先在composer里加载elasticsearch的开源组件

核心代码如下：

 public static function getSearch($type = '', $hostname = 'k8s-slave02')
    {
        $searchtype = '';
        switch($type)
        {
            case 'diskio':
                $searchtype = 'system.diskio';
                break;
            case 'network':
                $searchtype = 'system.network';
                break;
            case 'cpu':
                $searchtype = 'system.cpu';
                break;
            case 'memory':
                $searchtype = 'system.memory';
                break;
            case 'filesystem':
                $searchtype = 'system.filesystem';
                break;
            default:
                $searchtype = '';
                break;
        }
        if(empty($client))
        {
            $hosts = \SilangPHP\Config::get("Db.elasticsearch");
            self::$client = ClientBuilder::create()->setHosts($hosts)->build();
        }
        $params = [
            'index' => 'metricbeat-7.5.1',
            'type' => '_doc',
            'sort' => '@timestamp:desc',
            'size' => 1,
            'body' => [
                'query' => [
                    'bool' => [
                        'must' => [
                            [ 'match' => [ 'host.hostname' => $hostname ] ],
                            // system.diskio | docker.cpu system.network load  system.cpu system.process.summary system.process.summary
                            [ 'match' => [ 'event.dataset' => $searchtype ] ],
                        ]
                    ]
                ]
            ]
        ];
        $results = self::$client->search($params);
        $milliseconds = $results['took'];
        $maxScore     = $results['hits']['max_score'];
        $score = $results['hits']['hits'][0]['_score'];
        $doc   = $results['hits']['hits'][0]['_source'];
        return $doc;
    }

主要通过匹配搜索host.hostname主机名称和event.dataset事件来获取相关信息，为了获取最新的来报警，排序使用@timestamp:desc时间倒序来获取。

汇总发送效果

规则报警得大家自己去定义，例如内存高于80%的时候触发报警。
使用过某些开源的监控工具，其实也没精力去学习更多，也相对复杂，简单有简单的好处。
相比第一版报警系统，现在的其实可观很多^{_^}

马克斯的神助攻，动物币都有所上升。^{_^}