22 |
28 |
23 | ![]()
24 |
25 |
26 |
27 |
29 |
34 |
30 |
33 | 确认加入群聊
31 |加入该群聊
32 | 确认加入群聊
31 |
22 | %s", string(node.AsLeaf().Literal)))) 33 | return ast.GoToNext, true 34 | } 35 | 36 | _, ok = node.(*ast.CodeBlock) 37 | if ok { 38 | syncHtml, _ := syntaxhighlight.AsHTML(node.AsLeaf().Literal, func(options *syntaxhighlight.HTMLConfig) { 39 | options.Type = "pl-en" 40 | options.Keyword = "pl-k" 41 | options.Plaintext = "pl-s1" 42 | options.String = "pl-s1" 43 | options.Comment = "pl-c" 44 | }) 45 | w.Write([]byte(fmt.Sprintf("
%s", string(syncHtml)))) 46 | return ast.GoToNext, true 47 | } 48 | // test := syntaxhighlight.HTMLConfig{ 49 | // String: "str", 50 | // Keyword: "kwd", 51 | // Comment: "com", 52 | // Type: "typ", 53 | // Literal: "lit", 54 | // Punctuation: "pun", 55 | // Plaintext: "pln", 56 | // Tag: "tag", 57 | // HTMLTag: "htm", 58 | // HTMLAttrName: "atn", 59 | // HTMLAttrValue: "atv", 60 | // Decimal: "dec", 61 | // Whitespace: "", 62 | // } 63 | return ast.GoToNext, false 64 | 65 | } 66 | -------------------------------------------------------------------------------- /pkg/markdown/markdown_test.go: -------------------------------------------------------------------------------- 1 | package markdown 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | func TestToHtml(t *testing.T) { 9 | 10 | htm := ToHtml("a\n```go\n /** test **/ func Test(v []byte) (error){ fmt.Println(\"zdsdsdsd\")}\n```\nb `测试`") 11 | 12 | fmt.Println("htm--->", htm) 13 | 14 | } 15 | -------------------------------------------------------------------------------- /pkg/pool/dispatcher.go: -------------------------------------------------------------------------------- 1 | package pool 2 | 3 | import ( 4 | "sync/atomic" 5 | ) 6 | 7 | var WorkerChannel = make(chan chan *Job) 8 | 9 | type JobStatistics struct { 10 | Executing int64 // Total number of jobs executed 11 | Total int64 12 | } 13 | 14 | type Collector struct { 15 | Work chan *Job // receives jobs to send to workers 16 | End chan bool // when receives bool stops workers 17 | jobS *JobStatistics 18 | queue *Queue 19 | } 20 | 21 | func StartDispatcher(workerCount int64) Collector { 22 | var i int64 23 | var workers []Worker 24 | input := make(chan *Job) // channel to recieve work 25 | end := make(chan bool) // channel to spin down workers 26 | jobFinished := make(chan bool) 27 | collector := Collector{ 28 | Work: input, 29 | End: end, 30 | jobS: &JobStatistics{}, 31 | queue: NewQueue(), 32 | } 33 | 34 | go collector.loopPop() 35 | 36 | for i < workerCount { 37 | i++ 38 | worker := Worker{ 39 | ID: i, 40 | Channel: make(chan *Job), 41 | WorkerChannel: WorkerChannel, 42 | End: make(chan struct{}), 43 | jobFinished: jobFinished, 44 | } 45 | worker.Start() 46 | workers = append(workers, worker) // stores worker 47 | } 48 | go func() { 49 | for { 50 | select { 51 | case <-jobFinished: // job finished 52 | atomic.AddInt64(&collector.jobS.Executing, -1) 53 | } 54 | } 55 | }() 56 | 57 | // start collector 58 | go func() { 59 | for { 60 | select { 61 | case <-end: 62 | for _, w := range workers { 63 | w.Stop() // stop worker 64 | } 65 | return 66 | case job := <-input: 67 | collector.queue.Push(job) 68 | } 69 | } 70 | }() 71 | 72 | return collector 73 | } 74 | 75 | func (c Collector) loopPop() { 76 | for { 77 | jobObj := c.queue.Pop() 78 | atomic.AddInt64(&c.jobS.Total, 1) 79 | worker := <-WorkerChannel // wait for available channel 80 | atomic.AddInt64(&c.jobS.Executing, 1) 81 | worker <- jobObj.(*Job) // dispatch work to worker 82 | } 83 | 84 | } 85 | 86 | func (c Collector) GetStatistics() *JobStatistics { 87 | return c.jobS 88 | } 89 | 90 | func (c Collector) Waiting() int { 91 | return c.queue.Len() 92 | } 93 | -------------------------------------------------------------------------------- /pkg/pool/queue.go: -------------------------------------------------------------------------------- 1 | package pool 2 | 3 | import ( 4 | "github.com/eapache/queue" 5 | "runtime" 6 | "sync" 7 | ) 8 | 9 | 10 | type Queue struct { 11 | sync.Mutex 12 | popable *sync.Cond 13 | buffer *queue.Queue 14 | closed bool 15 | } 16 | 17 | func NewQueue() *Queue { 18 | e := &Queue{ 19 | buffer: queue.New(), 20 | } 21 | e.popable = sync.NewCond(&e.Mutex) 22 | return e 23 | } 24 | 25 | func (e *Queue) Push(v interface{}) { 26 | e.Mutex.Lock() 27 | defer e.Mutex.Unlock() 28 | if !e.closed { 29 | e.buffer.Add(v) 30 | e.popable.Signal() 31 | } 32 | } 33 | func (e *Queue) Close() { 34 | e.Mutex.Lock() 35 | defer e.Mutex.Unlock() 36 | if !e.closed { 37 | e.closed = true 38 | e.popable.Broadcast() //广播 39 | } 40 | } 41 | 42 | //Pop 取出队列,（阻塞模式） 43 | func (e *Queue) Pop() (v interface{}) { 44 | c := e.popable 45 | buffer := e.buffer 46 | 47 | e.Mutex.Lock() 48 | defer e.Mutex.Unlock() 49 | 50 | for buffer.Length() == 0 && !e.closed { 51 | c.Wait() 52 | } 53 | 54 | if e.closed { //已关闭 55 | return 56 | } 57 | 58 | if buffer.Length() > 0 { 59 | v = buffer.Peek() 60 | buffer.Remove() 61 | } 62 | return 63 | } 64 | 65 | //试着取出队列（非阻塞模式）返回ok == false 表示空 66 | func (e *Queue) TryPop() (v interface{}, ok bool) { 67 | buffer := e.buffer 68 | 69 | e.Mutex.Lock() 70 | defer e.Mutex.Unlock() 71 | 72 | if buffer.Length() > 0 { 73 | v = buffer.Peek() 74 | buffer.Remove() 75 | ok = true 76 | } else if e.closed { 77 | ok = true 78 | } 79 | 80 | return 81 | } 82 | 83 | // 获取队列长度 84 | func (e *Queue) Len() int { 85 | return e.buffer.Length() 86 | } 87 | 88 | //Wait 等待队列消费完成 89 | func (e *Queue) Wait() { 90 | for { 91 | if e.closed || e.buffer.Length() == 0 { 92 | break 93 | } 94 | 95 | runtime.Gosched() //出让时间片 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /pkg/pool/worker.go: -------------------------------------------------------------------------------- 1 | package pool 2 | 3 | import ( 4 | "log" 5 | ) 6 | 7 | type JobFunc func(id int64, data interface{}) 8 | 9 | type Job struct { 10 | Data interface{} 11 | JobFunc JobFunc 12 | } 13 | 14 | type Worker struct { 15 | ID int64 16 | WorkerChannel chan chan *Job // used to communicate between dispatcher and workers 17 | Channel chan *Job 18 | End chan struct{} 19 | jobFinished chan bool 20 | } 21 | 22 | // start worker 23 | func (w *Worker) Start() { 24 | go func() { 25 | for { 26 | w.WorkerChannel <- w.Channel // when the worker is available place channel in queue 27 | select { 28 | case job := <-w.Channel: // worker has received job 29 | if job != nil { 30 | job.JobFunc(w.ID, job.Data) // do work 31 | w.jobFinished <- true 32 | } 33 | 34 | case <-w.End: 35 | return 36 | } 37 | } 38 | }() 39 | } 40 | 41 | // end worker 42 | func (w *Worker) Stop() { 43 | log.Printf("worker [%d] is stopping", w.ID) 44 | w.End <- struct{}{} 45 | } 46 | -------------------------------------------------------------------------------- /pkg/register/register.go: -------------------------------------------------------------------------------- 1 | package register 2 | 3 | import "github.com/TangSengDaoDao/TangSengDaoDaoServer/pkg/wkhttp" 4 | 5 | // APIRouter api路由者 6 | type APIRouter interface { 7 | Route(r *wkhttp.WKHttp) 8 | } 9 | 10 | var apiRoutes = make([]APIRouter, 0) 11 | 12 | // Add 添加api 13 | func Add(r APIRouter) { 14 | apiRoutes = append(apiRoutes, r) 15 | } 16 | 17 | var taskRoutes = make([]TaskRouter, 0) 18 | 19 | // GetRoutes 获取所有路由者 20 | func GetRoutes() []APIRouter { 21 | return apiRoutes 22 | } 23 | 24 | // TaskRouter task路由者 25 | type TaskRouter interface { 26 | RegisterTasks() 27 | } 28 | 29 | // AddTask 添加任务 30 | func AddTask(task TaskRouter) { 31 | taskRoutes = append(taskRoutes, task) 32 | } 33 | 34 | // GetTasks 获取所有任务 35 | func GetTasks() []TaskRouter { 36 | return taskRoutes 37 | } 38 | -------------------------------------------------------------------------------- /pkg/util/base62.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // Ten2Hex 十进制转换为62进制 8 | func Ten2Hex(ten int64) string { 9 | hex := "" 10 | var divValue, resValue int64 11 | for ten >= 62 { 12 | divValue = ten / int64(62) 13 | resValue = ten % 62 14 | hex = tenValue2Char(resValue) + hex 15 | ten = divValue 16 | } 17 | if ten != 0 { 18 | hex = tenValue2Char(ten) + hex 19 | } 20 | return hex 21 | } 22 | 23 | func tenValue2Char(ten int64) string { 24 | switch ten { 25 | case 0: 26 | case 1: 27 | case 2: 28 | case 3: 29 | case 4: 30 | case 5: 31 | case 6: 32 | case 7: 33 | case 8: 34 | case 9: 35 | return fmt.Sprintf("%d", ten) 36 | case 10: 37 | return "a" 38 | case 11: 39 | return "b" 40 | case 12: 41 | return "c" 42 | case 13: 43 | return "d" 44 | case 14: 45 | return "e" 46 | case 15: 47 | return "f" 48 | case 16: 49 | return "g" 50 | case 17: 51 | return "h" 52 | case 18: 53 | return "i" 54 | case 19: 55 | return "j" 56 | case 20: 57 | return "k" 58 | case 21: 59 | return "l" 60 | case 22: 61 | return "m" 62 | case 23: 63 | return "n" 64 | case 24: 65 | return "o" 66 | case 25: 67 | return "p" 68 | case 26: 69 | return "q" 70 | case 27: 71 | return "r" 72 | case 28: 73 | return "s" 74 | case 29: 75 | return "t" 76 | case 30: 77 | return "u" 78 | case 31: 79 | return "v" 80 | case 32: 81 | return "w" 82 | case 33: 83 | return "s" 84 | case 34: 85 | return "y" 86 | case 35: 87 | return "z" 88 | case 36: 89 | return "A" 90 | case 37: 91 | return "B" 92 | case 38: 93 | return "C" 94 | case 39: 95 | return "D" 96 | case 40: 97 | return "E" 98 | case 41: 99 | return "F" 100 | case 42: 101 | return "G" 102 | case 43: 103 | return "H" 104 | case 44: 105 | return "I" 106 | case 45: 107 | return "J" 108 | case 46: 109 | return "K" 110 | case 47: 111 | return "L" 112 | case 48: 113 | return "M" 114 | case 49: 115 | return "N" 116 | case 50: 117 | return "O" 118 | case 51: 119 | return "P" 120 | case 52: 121 | return "Q" 122 | case 53: 123 | return "R" 124 | case 54: 125 | return "S" 126 | case 55: 127 | return "T" 128 | case 56: 129 | return "U" 130 | case 57: 131 | return "V" 132 | case 58: 133 | return "W" 134 | case 59: 135 | return "S" 136 | case 60: 137 | return "Y" 138 | case 61: 139 | return "Z" 140 | default: 141 | return "" 142 | } 143 | return "" 144 | } 145 | -------------------------------------------------------------------------------- /pkg/util/common.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | ) 7 | 8 | // CheckErr CheckErr 9 | func CheckErr(err error) { 10 | if err != nil { 11 | panic(err) 12 | } 13 | } 14 | 15 | // Substr Substr 16 | func Substr(str string, start, length int) string { 17 | if length == 0 { 18 | return "" 19 | } 20 | runeStr := []rune(str) 21 | lenStr := len(runeStr) 22 | 23 | if start < 0 { 24 | start = lenStr + start 25 | } 26 | if start > lenStr { 27 | start = lenStr 28 | } 29 | end := start + length 30 | if end > lenStr { 31 | end = lenStr 32 | } 33 | if length < 0 { 34 | end = lenStr + length 35 | } 36 | if start > end { 37 | start, end = end, start 38 | } 39 | return string(runeStr[start:end]) 40 | } 41 | 42 | func objToStr(v interface{}) string { 43 | var strV string 44 | switch v.(type) { 45 | 46 | case int: 47 | strV = fmt.Sprintf("%d", v) 48 | break 49 | case uint: 50 | strV = fmt.Sprintf("%d", v) 51 | break 52 | case int64: 53 | strV = fmt.Sprintf("%d", v) 54 | break 55 | case uint64: 56 | strV = fmt.Sprintf("%d", v) 57 | break 58 | case int8: 59 | strV = fmt.Sprintf("%d", v) 60 | break 61 | case uint8: 62 | strV = fmt.Sprintf("%d", v) 63 | break 64 | case int16: 65 | strV = fmt.Sprintf("%d", v) 66 | break 67 | case uint16: 68 | strV = fmt.Sprintf("%d", v) 69 | break 70 | case int32: 71 | strV = fmt.Sprintf("%d", v) 72 | break 73 | case uint32: 74 | strV = fmt.Sprintf("%s", v) 75 | break 76 | case string: 77 | strV = fmt.Sprintf("%s", v) 78 | break 79 | case float32: 80 | strV = fmt.Sprintf("%s", v) 81 | break 82 | case float64: 83 | strV = fmt.Sprintf("%s", v) 84 | break 85 | default: 86 | strV = fmt.Sprintf("%s", v) 87 | 88 | } 89 | return strV 90 | } 91 | 92 | // Sign Sign 93 | func Sign(params map[string]interface{}, appKey string) string { 94 | signStr := MapToQueryParamSort(params) 95 | return MD5(fmt.Sprintf("%s&key=%s", signStr, appKey)) 96 | } 97 | 98 | // MapToQueryParamSort map 以 key1=value1 & key2=value2形式排序拼接 99 | func MapToQueryParamSort(params map[string]interface{}) string { 100 | if len(params) == 0 { 101 | return "" 102 | } 103 | strs := "" 104 | keys := make([]string, 0, len(params)) 105 | for k := range params { 106 | keys = append(keys, k) 107 | } 108 | sort.Strings(keys) 109 | 110 | for _, k := range keys { 111 | v := params[k] 112 | if v == "" { 113 | continue 114 | } 115 | //strs = strs+k+"&"+v 116 | strs = fmt.Sprintf("%s%s=%s%s", strs, k, objToStr(v), "&") 117 | } 118 | if len(strs) > 0 { 119 | strs = strs[0 : len(strs)-1] 120 | } 121 | return strs 122 | } 123 | -------------------------------------------------------------------------------- /pkg/util/dh.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "crypto/rand" 5 | "io" 6 | 7 | "golang.org/x/crypto/curve25519" 8 | ) 9 | 10 | // GetCurve25519KeypPair GetCurve25519KeypPair 11 | func GetCurve25519KeypPair() (Aprivate, Apublic [32]byte) { 12 | //产生随机数 13 | if _, err := io.ReadFull(rand.Reader, Aprivate[:]); err != nil { 14 | panic(err) 15 | } 16 | curve25519.ScalarBaseMult(&Apublic, &Aprivate) 17 | return 18 | } 19 | 20 | // GetCurve25519Key GetCurve25519Key 21 | func GetCurve25519Key(private, public [32]byte) (Key [32]byte) { 22 | //产生随机数 23 | curve25519.ScalarMult(&Key, &private, &public) 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /pkg/util/hash.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import "hash/crc32" 4 | 5 | // HashCrc32 通过字符串获取32位数字 6 | func HashCrc32(str string) uint32 { 7 | 8 | return crc32.ChecksumIEEE([]byte(str)) 9 | } 10 | -------------------------------------------------------------------------------- /pkg/util/json.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "bytes" 5 | "encoding/json" 6 | ) 7 | 8 | //将对象转换为JSON 9 | func ToJson(obj interface{}) string { 10 | jsonData, err := json.Marshal(obj) 11 | if err != nil { 12 | return "" 13 | } 14 | return string(jsonData) 15 | } 16 | 17 | func JsonToMap(json string) (map[string]interface{}, error) { 18 | var resultMap map[string]interface{} 19 | err := ReadJsonByByte([]byte(json), &resultMap) 20 | return resultMap, err 21 | } 22 | func ReadJsonByByte(body []byte, obj interface{}) error { 23 | mdz := json.NewDecoder(bytes.NewBuffer(body)) 24 | 25 | mdz.UseNumber() 26 | err := mdz.Decode(obj) 27 | 28 | if err != nil { 29 | return err 30 | } 31 | return nil 32 | } 33 | -------------------------------------------------------------------------------- /pkg/util/md5.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "crypto/hmac" 5 | "crypto/md5" 6 | "crypto/sha1" 7 | "encoding/base64" 8 | "encoding/hex" 9 | "fmt" 10 | ) 11 | 12 | //MD5 加密 13 | func MD5(str string) string { 14 | h := md5.New() 15 | h.Write([]byte(str)) // 需要加密的字符串 16 | passwordmdsBys := h.Sum(nil) 17 | return hex.EncodeToString(passwordmdsBys) 18 | } 19 | 20 | // SHA1加密 21 | func SHA1(str string) string { 22 | fmt.Println("str:", str) 23 | h := sha1.New() 24 | h.Write([]byte(str)) 25 | bs := h.Sum(nil) 26 | return hex.EncodeToString(bs) 27 | } 28 | 29 | func HMACSHA1(keyStr string, data string) string { 30 | //hmac ,use sha1 31 | key := []byte(keyStr) 32 | mac := hmac.New(sha1.New, key) 33 | mac.Write([]byte(data)) 34 | srcBytes := mac.Sum(nil) 35 | return base64.StdEncoding.EncodeToString(srcBytes) 36 | } 37 | -------------------------------------------------------------------------------- /pkg/util/page.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import "strconv" 4 | 5 | // Page Page 6 | type Page struct { 7 | PageSize uint64 `json:"page_size"` 8 | PageIndex uint64 `json:"page_index"` 9 | Total uint64 `json:"total"` 10 | Data interface{} `json:"data"` 11 | } 12 | 13 | // NewPage NewPage 14 | func NewPage(pageIndex uint64, pageSize uint64, total uint64, data interface{}) *Page { 15 | 16 | return &Page{PageIndex: pageIndex, PageSize: pageSize, Data: data, Total: total} 17 | } 18 | 19 | //ToPageNumOrDefault 将字符串转换为数字类型 如果字符串为空 则赋值分页默认参数 20 | func ToPageNumOrDefault(pageIndex string, pageSize string) (pIndex64 uint64, pSize64 uint64) { 21 | var pageIndex64 uint64 22 | var pageSize64 uint64 23 | if pageIndex == "" { 24 | pageIndex64 = 1 25 | } else { 26 | pageIndex64, _ = strconv.ParseUint(pageIndex, 10, 64) 27 | } 28 | 29 | if pageSize == "" { 30 | pageSize64 = 10 31 | } else { 32 | pageSize64, _ = strconv.ParseUint(pageSize, 10, 64) 33 | } 34 | 35 | return pageIndex64, pageSize64 36 | } 37 | -------------------------------------------------------------------------------- /pkg/util/qreflect.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "reflect" 5 | ) 6 | 7 | // AttrToUnderscore 获取struct的所有属性并转为下划线模式 8 | func AttrToUnderscore(st interface{}) []string { 9 | t := reflect.ValueOf(st) 10 | vType := t.Elem().Type() 11 | names := make([]string, 0) 12 | for i := 0; i < vType.NumField(); i++ { 13 | if vType.Field(i).Type.Kind() == reflect.Struct { 14 | continue 15 | } 16 | name := vType.Field(i).Name 17 | if name != "" { 18 | names = append(names, UnderscoreName(name)) 19 | } 20 | } 21 | return names 22 | } 23 | -------------------------------------------------------------------------------- /pkg/util/qreflect_test.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "gopkg.in/go-playground/assert.v1" 5 | "testing" 6 | ) 7 | 8 | func TestStructAttrToUnderscore(t *testing.T) { 9 | 10 | names := AttrToUnderscore(&struct { 11 | MessageID uint64 12 | Name string 13 | UserAge int 14 | }{}) 15 | assert.Equal(t, "message_id", names[0]) 16 | assert.Equal(t, "name", names[1]) 17 | assert.Equal(t, "user_age", names[2]) 18 | } 19 | -------------------------------------------------------------------------------- /pkg/util/sha.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "crypto/hmac" 5 | "crypto/sha256" 6 | "encoding/base64" 7 | "encoding/hex" 8 | ) 9 | 10 | func HmacSha256(message string, secret string) string { 11 | key := []byte(secret) 12 | h := hmac.New(sha256.New, key) 13 | h.Write([]byte(message)) 14 | sha := hex.EncodeToString(h.Sum(nil)) 15 | return base64.StdEncoding.EncodeToString([]byte(sha)) 16 | } 17 | -------------------------------------------------------------------------------- /pkg/util/sign.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | ) 7 | 8 | func GetSignStr(params map[string]interface{}) string { 9 | var signStr string 10 | keys := make([]string, 0, len(params)) 11 | for k := range params { 12 | keys = append(keys, k) 13 | } 14 | sort.Strings(keys) 15 | 16 | for i, k := range keys { 17 | v := params[k] 18 | if v == "" { 19 | continue 20 | } 21 | vs := ObjToStr(v) 22 | 23 | signStr = fmt.Sprintf("%s=%s", k, vs) 24 | 25 | if i != len(keys)-1 { 26 | signStr += "&" 27 | } 28 | } 29 | return signStr 30 | } 31 | 32 | func ObjToStr(v interface{}) string { 33 | var strV string 34 | switch v.(type) { 35 | 36 | case int: 37 | strV = fmt.Sprintf("%d", v) 38 | case uint: 39 | strV = fmt.Sprintf("%d", v) 40 | case int64: 41 | strV = fmt.Sprintf("%d", v) 42 | case uint64: 43 | strV = fmt.Sprintf("%d", v) 44 | case int8: 45 | strV = fmt.Sprintf("%d", v) 46 | case uint8: 47 | strV = fmt.Sprintf("%d", v) 48 | case int16: 49 | strV = fmt.Sprintf("%d", v) 50 | case uint16: 51 | strV = fmt.Sprintf("%d", v) 52 | case int32: 53 | strV = fmt.Sprintf("%d", v) 54 | case uint32: 55 | strV = fmt.Sprintf("%s", v) 56 | case string: 57 | strV = fmt.Sprintf("%s", v) 58 | case float32: 59 | strV = fmt.Sprintf("%s", v) 60 | case float64: 61 | strV = fmt.Sprintf("%s", v) 62 | default: 63 | strV = fmt.Sprintf("%s", v) 64 | } 65 | return strV 66 | } 67 | -------------------------------------------------------------------------------- /pkg/util/stringbuffer.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "bytes" 5 | "log" 6 | "strconv" 7 | ) 8 | 9 | // 内嵌bytes.Buffer，支持连写 10 | type Buffer struct { 11 | *bytes.Buffer 12 | } 13 | 14 | func NewBuffer() *Buffer { 15 | return &Buffer{Buffer: new(bytes.Buffer)} 16 | } 17 | 18 | func (b *Buffer) Append(i interface{}) *Buffer { 19 | switch val := i.(type) { 20 | case int: 21 | b.append(strconv.Itoa(val)) 22 | case int64: 23 | b.append(strconv.FormatInt(val, 10)) 24 | case uint: 25 | b.append(strconv.FormatUint(uint64(val), 10)) 26 | case uint64: 27 | b.append(strconv.FormatUint(val, 10)) 28 | case string: 29 | b.append(val) 30 | case []byte: 31 | b.Write(val) 32 | case rune: 33 | b.WriteRune(val) 34 | } 35 | 36 | return b 37 | } 38 | 39 | func (b *Buffer) append(s string) *Buffer { 40 | defer func() { 41 | if err := recover(); err != nil { 42 | log.Println("*****内存不够了！******") 43 | } 44 | }() 45 | 46 | b.WriteString(s) 47 | return b 48 | } -------------------------------------------------------------------------------- /pkg/util/time.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import "time" 4 | 5 | func ToyyyyMMddHHmm(tm time.Time) string { 6 | 7 | return tm.Format("2006-01-02 15:04") 8 | } 9 | 10 | func ToyyyyMMddHHmmss(tm time.Time) string { 11 | 12 | return tm.Format("2006-01-02 15:04:05") 13 | } 14 | 15 | func ToyyyyMM2(tm time.Time) string { 16 | 17 | return tm.Format("200601") 18 | } 19 | 20 | func ToyyyyMMdd(tm time.Time) string { 21 | 22 | return tm.Format("20060102") 23 | } 24 | 25 | func PareTimeStrForYYYYMMdd(timeStr string) (time.Time, error) { 26 | return time.Parse("20060102", timeStr) 27 | } 28 | 29 | //带-的日期 30 | func Toyyyy_MM_dd(tm time.Time) string { 31 | 32 | return tm.Format("2006-01-02") 33 | } 34 | 35 | func Toyyyy_MM(tm time.Time) string { 36 | 37 | return tm.Format("2006-01") 38 | } 39 | 40 | func PareTimeStrForYYYY_mm_dd(timeStr string) (time.Time, error) { 41 | return time.Parse("2006-01-02", timeStr) 42 | } 43 | -------------------------------------------------------------------------------- /pkg/util/yuan_cent.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import "fmt" 4 | 5 | // YuanToCent 元转分 6 | func YuanToCent(yuan float64) int64 { 7 | dec, err := NewFromString(fmt.Sprintf("%0.2f", yuan)) 8 | CheckErr(err) 9 | m, err := NewFromString("100") 10 | CheckErr(err) 11 | 12 | return dec.Mul(m).IntPart() 13 | } 14 | 15 | // CentToYuan 分转元 16 | func CentToYuan(cent int64) float64 { 17 | centDec, err := NewFromString(fmt.Sprintf("%d", cent)) 18 | CheckErr(err) 19 | mDec, err := NewFromString(fmt.Sprintf("%d", 100)) 20 | CheckErr(err) 21 | 22 | result, _ := centDec.Div(mDec).Round(2).Float64() 23 | CheckErr(err) 24 | return result 25 | } 26 | -------------------------------------------------------------------------------- /pkg/wait/wait.go: -------------------------------------------------------------------------------- 1 | package wait 2 | 3 | import ( 4 | "log" 5 | "sync" 6 | ) 7 | 8 | const ( 9 | // To avoid lock contention we use an array of list struct (rw mutex & map) 10 | // for the id argument, we apply mod operation and uses its remainder to 11 | // index into the array and find the corresponding element. 12 | defaultListElementLength = 64 13 | ) 14 | 15 | // Wait Wait 16 | type Wait interface { 17 | // Register waits returns a chan that waits on the given ID. 18 | // The chan will be triggered when Trigger is called with 19 | // the same ID. 20 | Register(id uint64) <-chan interface{} 21 | // Trigger triggers the waiting chans with the given ID. 22 | Trigger(id uint64, x interface{}) 23 | IsRegistered(id uint64) bool 24 | } 25 | 26 | type list struct { 27 | e []listElement 28 | } 29 | 30 | type listElement struct { 31 | l sync.RWMutex 32 | m map[uint64]chan interface{} 33 | } 34 | 35 | // New creates a Wait. 36 | func New() Wait { 37 | res := list{ 38 | e: make([]listElement, defaultListElementLength), 39 | } 40 | for i := 0; i < len(res.e); i++ { 41 | res.e[i].m = make(map[uint64]chan interface{}) 42 | } 43 | return &res 44 | } 45 | 46 | func (w *list) Register(id uint64) <-chan interface{} { 47 | idx := id % defaultListElementLength 48 | newCh := make(chan interface{}, 1) 49 | w.e[idx].l.Lock() 50 | defer w.e[idx].l.Unlock() 51 | if _, ok := w.e[idx].m[id]; !ok { 52 | w.e[idx].m[id] = newCh 53 | } else { 54 | log.Panicf("dup id %x", id) 55 | } 56 | return newCh 57 | } 58 | 59 | func (w *list) Trigger(id uint64, x interface{}) { 60 | idx := id % defaultListElementLength 61 | w.e[idx].l.Lock() 62 | ch := w.e[idx].m[id] 63 | delete(w.e[idx].m, id) 64 | w.e[idx].l.Unlock() 65 | if ch != nil { 66 | ch <- x 67 | close(ch) 68 | } 69 | } 70 | 71 | func (w *list) IsRegistered(id uint64) bool { 72 | idx := id % defaultListElementLength 73 | w.e[idx].l.RLock() 74 | defer w.e[idx].l.RUnlock() 75 | _, ok := w.e[idx].m[id] 76 | return ok 77 | } 78 | -------------------------------------------------------------------------------- /pkg/wkevent/event.go: -------------------------------------------------------------------------------- 1 | package wkevent 2 | 3 | import "github.com/gocraft/dbr/v2" 4 | 5 | type Type int 6 | 7 | const ( 8 | // None 无 9 | None Type = iota 10 | // Message 发送消息事件 11 | Message 12 | // CMD CMD 13 | CMD 14 | ) 15 | 16 | func (t Type) Int() int { 17 | return int(t) 18 | } 19 | 20 | type Status int 21 | 22 | const ( 23 | Wait Type = iota // 等待发布 24 | Success // 发布重构 25 | Fail 26 | ) 27 | 28 | func (s Status) Int() int { 29 | return int(s) 30 | } 31 | 32 | type Data struct { 33 | Event string // 事件标示 34 | Type Type // 事件类型 35 | Data interface{} // 事件数据 36 | } 37 | type Event interface { 38 | // 开启事件 39 | Begin(data *Data, tx *dbr.Tx) (int64, error) 40 | // 提交事件 41 | Commit(eventId int64) 42 | } 43 | -------------------------------------------------------------------------------- /pkg/wkhook/README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative ./pkg/wkhook/webhook.proto -------------------------------------------------------------------------------- /pkg/wkhook/webhook.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package wkhook; 4 | 5 | option go_package = "./;wkhook"; 6 | 7 | service WebhookService { 8 | // 发送webhook事件 9 | rpc SendWebhook (EventReq) returns (EventResp); 10 | } 11 | 12 | enum EventStatus { 13 | Error = 0; 14 | Success = 1; 15 | } 16 | 17 | message EventReq { 18 | string event = 1; 19 | bytes data = 2; 20 | } 21 | 22 | message EventResp { 23 | EventStatus status = 1; 24 | bytes data = 2; 25 | } -------------------------------------------------------------------------------- /pkg/wkrsa/rsa.go: -------------------------------------------------------------------------------- 1 | package wkrsa 2 | 3 | import ( 4 | "crypto" 5 | "crypto/md5" 6 | "crypto/rand" 7 | "crypto/rsa" 8 | "crypto/x509" 9 | "encoding/base64" 10 | "encoding/pem" 11 | "errors" 12 | ) 13 | 14 | // Sign rsa签名 15 | // pemPrivKey 私钥key 类似 -----BEGIN RSA PRIVATE KEY----- 16 | // xxxx 17 | // -----END RSA PRIVATE KEY----- 18 | func SignWithMD5(data []byte, pemPrivKey []byte) (string, error) { 19 | hashMd5 := md5.Sum(data) 20 | hashed := hashMd5[:] 21 | block, _ := pem.Decode(pemPrivKey) 22 | if block == nil { 23 | return "", errors.New("private key error") 24 | } 25 | privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes) 26 | if err != nil { 27 | return "", err 28 | } 29 | signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.MD5, hashed) 30 | return base64.StdEncoding.EncodeToString(signature), err 31 | } 32 | -------------------------------------------------------------------------------- /pkg/wkrsa/rsa_test.go: -------------------------------------------------------------------------------- 1 | package wkrsa 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | func TestSignWithMD5(t *testing.T) { 9 | 10 | dz := `-----BEGIN RSA PRIVATE KEY----- 11 | MIIEowIBAAKCAQEAxGbKnrOumh0r4FfRDL3NIGP7scxxvsVupktTdFqf8TgHLT67 12 | qfMXxM/JSAmNxJVz4zS8zVla4FlTJ4kyh3IJW+65vzXKX/errnI0gNk0p3IME+Wd 13 | LDetwy04Dk40B4GhMrfnomMff6W7UXG4fyLX9gzCIhkAeLNNl6eZS8IOgFULWZRO 14 | pYdlylncY4EQiv6ljXQtKmTIxvi7ivS/9sSFqgS+qnbd0QexrZlM1D2O4abFgrjs 15 | BaFHC4zGrg3TztiWynGUSOpjFv2v92doxDgSxP69xNry9Vq+6kERJpbqvJ3ujUEY 16 | T4bLk8avXNjyMg79/xNeiQ4gxvSHj3v3YOOlIQIDAQABAoIBADbY9fDIARSs3Nnz 17 | 7D+Aqc5H3bxTedhqznHGS3IM9OmqWea6xDG734Fo/a8Oa/bgPdLPoYI/V++bQmui 18 | FuhYYmC4FEtfvDp8sgcvgZYSEnBImzLbRr9YdUAyWps0H7eQ7fF6BkgFIoDFScB+ 19 | 36Uxl9nwyi43iTgr6plVhqvvb5lKqPQTZWWI50hs0EYcADngy2st6+sJxJXylCI4 20 | w3vjXhE9WdwBk54QD6FPPrzRHWpqHDjPcuyxbVijEoz0YMdO+tnHweUn+YnQnHxi 21 | rswF7b9/DL8mhIX67SKqF7wM+RCgrweVswNCcEsZyfCtMKgI7uwDjaDkvhI+XaYq 22 | vfNUe9kCgYEAzK+Zb3A4ZxPWhYrubqmGYa7KvmtetRO5LAyWXMFH5vzU+TKzDcJm 23 | qZTxhzH8yt43PgrjOL5C+X2cIkNfEXHl9oIuuAMbMDSqThvox+o8Lsz5gTKy9/rR 24 | sucBRc41N/axLalVpbevD3Q3+2WjH25ap7h0RsZsladshEoxXI8jpCMCgYEA9aOD 25 | SSoywbVrsMXhr2wgxNXUuQGxWH6x3ZbAG86xxerElVwT06SbowDO77xFmiQsUvlW 26 | BpYrVPBg48B/Sgvvb0mKHhXVe8Maegq6bCofVpAU9IhDZokwIGJgEm2MgziZJAe+ 27 | 3/2DCFV22olrkqDhllqBTenuSyiIfWcGHr+zM+sCgYB0EWNVgPJK6UHtajH4iKMO 28 | Q1rujd4fmnaXlu+w211Vi6uNQAWu2Lz0juRDQMJTm50BzpS4uZMq/OKLv15qewbn 29 | OT0a1ZAWTtcAAe2HZ7kG5O7bJ4+69PzykPH0zpD5Eie4d9x8Y2OexM11/lV43lAD 30 | 6aHt/FjYqB7uCVBiZzzTtwKBgQDGY+jN9+IEp4UxwbCUYQ1aTKXBQoe8xJ7dLDs+ 31 | ekMEaaeaRkLRJdp53VZFM9c3Nk4COdTr/u9Ca96lM7zazib0x/1gbRv+GEbTGMUW 32 | RTMIU9hI46EkOFsBXNLhL09UUCsHeaYE/JiO64/R0zlptLxeFfznM6+9TiBmwAWm 33 | YgfXPwKBgDn1n2aWpGpH/cz8AQapMxqo7YK2Lc/Vwqw7O4mmNQ0TOJOgECHrWJX2 34 | 2UfOnyh8mDNFq9Udt4XMkfH5aPmWF7ejl2ddz3A4kdz5DMaVgRPktJh6nFAllKz/ 35 | R0a+FMM2fsqqRjYN4Zf84pJvWnIy7dG/pXKq8AAWkV7iJNVpshGb 36 | -----END RSA PRIVATE KEY-----` 37 | fmt.Println("privateKeyBuff.Bytes()-->", dz) 38 | 39 | _, err := SignWithMD5([]byte("test"), []byte(dz)) 40 | if err != nil { 41 | panic(err) 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /testenv/docker-compose.yaml: -------------------------------------------------------------------------------- 1 | version: '3.1' 2 | services: 3 | redis: 4 | image: redis 5 | restart: always 6 | ports: 7 | - 6379:6379 8 | mysql: 9 | image: mysql:8.0.33 10 | command: --default-authentication-plugin=mysql_native_password 11 | restart: always 12 | environment: 13 | MYSQL_ROOT_PASSWORD: demo 14 | MYSQL_DATABASE: test 15 | ports: 16 | - 3306:3306 17 | wukongim: # wukongim底层通讯服务 18 | image: wukongim/wukongim:latest 19 | restart: always 20 | volumes: 21 | - ./wukongimdata:/root/wukongim 22 | environment: 23 | WK_MODE: "debug" 24 | WK_EXTERNAL_IP: "192.168.99.219" 25 | ports: 26 | - 5001:5001 # http api 端口 27 | - 5100:5100 # tcp端口 28 | - 5200:5200 # websocket端口 29 | - 5300:5300 # monitor端口 30 | minio: # minio文件管理服务 31 | image: minio/minio:latest # use a remote image 32 | restart: always 33 | command: "server /data --console-address ':9001'" 34 | ports: 35 | - "9000:9000" 36 | - "9001:9001" 37 | environment: 38 | - MINIO_ROOT_USER=admin 39 | - MINIO_ROOT_PASSWORD=12345678 40 | volumes: 41 | - ./miniodata:/data --------------------------------------------------------------------------------