-
Notifications
You must be signed in to change notification settings - Fork 0
/
letsgo.go
252 lines (216 loc) · 6.26 KB
/
letsgo.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
package letsgo
import (
"database/sql"
"log"
"os"
"time"
"github.com/gomodule/redigo/redis"
"github.com/time2k/letsgo-ng/config"
"github.com/afex/hystrix-go/hystrix"
_ "github.com/go-sql-driver/mysql" //mysql
"github.com/labstack/echo"
)
//CommonParams Letsgo handler,model 通用参数
type CommonParams struct {
//Letsgo *Letsgo
HTTPContext echo.Context
Params map[string]string
Debug *DebugInfo
}
//Init 初始化
func (commp *CommonParams) Init() {
commp.Params = make(map[string]string)
commp.Debug = NewDebugInfo()
}
//SetParam 插入参数
func (commp *CommonParams) SetParam(name string, value string) bool {
commp.Params[name] = value
return true
}
//GetParam 读出参数
func (commp *CommonParams) GetParam(name string) string {
v, ok := commp.Params[name]
if ok != true {
return ""
}
return v
}
//Letsgo 框架依赖功能结构体
type Letsgo struct {
DBC
Cache *Cache
CacheLock *CacheLock
DBQuery *DBQuery
HTTPQuery *HTTPQuery
JSONRPCClient *JSONRPCClient
Schedules *Schedule
Logger *log.Logger
LoggerFile *os.File
ContextSet contextSet
MicroserviceClient MicroserviceClienter
}
//NewLetsgo 返回一个Letsgo类型的结构体指针
func NewLetsgo() {
Default = &Letsgo{}
}
//Init 初始化框架
func (L *Letsgo) Init() {
//init ModulePool
/*L.ModulePool = sync.Pool{
New: func() interface{} { return new(Module) },
}*/
//hystrix setting
hystrix.ConfigureCommand(config.HYSTRIX_DEFAULT_TAG, config.HYSTRIX_DEFAULT_CONFIG)
}
//InitDBQuery 初始化DBQuery
func (L *Letsgo) InitDBQuery(cfg config.DBconfigStruct) {
//db init
L.DBC = make(map[string]DBSet)
L.DBQuery = newDBQuery()
for k, v := range cfg {
var err error
DBset := DBSet{Master: nil, Slave: nil}
//init Master
DBset.Master, err = sql.Open("mysql", v["master"].DBusername+":"+v["master"].DBpassword+"@tcp("+v["master"].DBhostsip+")/"+v["master"].DBname+"?charset="+v["master"].DBcharset)
if err != nil {
log.Panicf("[error]Databases: connect error: %s", err.Error())
}
DBset.Master.SetMaxOpenConns(v["master"].DBconnMaxConns)
DBset.Master.SetMaxIdleConns(v["master"].DBconnMaxIdles)
DBset.Master.SetConnMaxLifetime(v["master"].DBconnMaxLifeTime)
err = DBset.Master.Ping()
if err != nil {
log.Panicf("[error]Databases: connect error: %s", err.Error())
}
//init slave
//判断是否是主从集群
if v["slave"] != (config.DBconfig{}) {
DBset.Slave, err = sql.Open("mysql", v["slave"].DBusername+":"+v["slave"].DBpassword+"@tcp("+v["slave"].DBhostsip+")/"+v["slave"].DBname+"?charset="+v["slave"].DBcharset)
if err != nil {
log.Panicf("[error]Databases: connect error: %s", err.Error())
}
DBset.Slave.SetMaxOpenConns(v["slave"].DBconnMaxConns)
DBset.Slave.SetMaxIdleConns(v["slave"].DBconnMaxIdles)
DBset.Master.SetConnMaxLifetime(v["slave"].DBconnMaxLifeTime)
err = DBset.Slave.Ping()
if err != nil {
log.Panicf("[error]Databases: connect error: %s", err.Error())
}
} else {
DBset.Slave = nil
}
//finally assign
L.DBC[k] = DBset
}
L.DBQuery.SetDBset(L.DBC)
L.DBQuery.SetCache(L.Cache)
}
//InitMemcached 初始化memcached
func (L *Letsgo) InitMemcached(MemcachedHost []string, MemcachedMaxIdleConns int, MemcachedMaxTimeout time.Duration) {
//init cache
L.Cache = newCache()
//memcached
L.Cache.Memcached = newLmemcache()
L.Cache.Memcached.Conn(MemcachedHost...)
L.Cache.Memcached.MaxIdleConns(MemcachedMaxIdleConns)
L.Cache.Memcached.MaxTimeout(MemcachedMaxTimeout)
L.Cache.Init()
}
//InitRedis 初始化redis, RedisType 1-standalone 2-redis cluster
func (L *Letsgo) InitRedis(RedisType int, RedisServers []string, RedisDialOption []redis.DialOption) {
//init cache
L.Cache = newCache()
if RedisType == 1 {
L.Cache.Redis = newLredis()
} else {
L.Cache.Redis = newLredisc()
}
err := L.Cache.Redis.Init(RedisServers, RedisDialOption)
if err != nil {
log.Panicf("[error]RedisCluster: %s", err.Error())
}
L.Cache.Init()
}
//InitHTTPQuery 初始化http
func (L *Letsgo) InitHTTPQuery(HTTPLog string) {
//init HTTPQuery
L.HTTPQuery = newHTTPQuery()
if L.Cache.UseRedisOrMemcached == 0 {
log.Panicf("[error]HTTP use cache but cache doesn't init")
}
L.HTTPQuery.SetCache(L.Cache)
L.HTTPQuery.Init(HTTPLog)
}
//InitLog 初始化日志
func (L *Letsgo) InitLog(LogFileName string) {
logfile, err := os.OpenFile(LogFileName, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Panicf("Can't open the log file %s", LogFileName)
}
L.LoggerFile = logfile
L.Logger = log.New(logfile, "[LetsGo Log]", log.Ldate|log.Ltime|log.Llongfile)
}
//InitSchedule 初始化并发器
func (L *Letsgo) InitSchedule() {
L.Schedules = newSchedule()
L.Schedules.Init()
}
//InitJSONRPC 初始化JSON RPC
func (L *Letsgo) InitJSONRPC(RPCConfig map[string]config.RPCconfig) {
//init jsonrpc
L.JSONRPCClient = NewJSONRPCClient()
L.JSONRPCClient.Init()
for service, rpcconfig := range RPCConfig {
L.JSONRPCClient.Set(service, rpcconfig.Network, rpcconfig.Address, rpcconfig.MicroserviceName)
}
}
//InitMemConfig 初始化内存式配置
func (L *Letsgo) InitMemConfig() {
//init config
InitConfig()
}
//InitCacheLock 初始化缓存锁
func (L *Letsgo) InitCacheLock() {
//init CacheLock
L.CacheLock = newCacheLock()
if L.Cache.UseRedisOrMemcached == 0 {
log.Panicf("[error]CacheLock use cache but cache doesn't init")
}
L.CacheLock.Cache = L.Cache
}
//InitContextSet 初始化上下文集合
func (L *Letsgo) InitContextSet() {
//init ContextSet
L.ContextSet = newContextSet()
}
//InitMicroServiceClient 初始化微服务框架客户端
func (L *Letsgo) InitMicroserviceClient(client MicroserviceClienter) {
L.MicroserviceClient = client
L.MicroserviceClient.Init()
}
//Close 关闭Letsgo框架
func (L *Letsgo) Close() {
if L.DBC != nil {
for _, v := range L.DBC {
v.Master.Close()
//判断是否是主从集群
if v.Slave != nil {
v.Slave.Close()
}
}
}
if L.Logger != nil {
L.LoggerFile.Close()
}
if L.Cache != nil && L.Cache.Redis != nil {
L.Cache.Redis.Close()
}
if L.ContextSet != nil {
L.ContextSet.CancelAll()
}
if L.MicroserviceClient != nil && L.MicroserviceClient.IsDeregisterBeforeExit() {
L.MicroserviceClient.DeregisterAllService()
}
}
//Default 框架自持变量
var Default *Letsgo