-
Notifications
You must be signed in to change notification settings - Fork 347
/
model.go
155 lines (129 loc) · 2.92 KB
/
model.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
package db
import (
"time"
"github.com/lonng/nanoserver/db/model"
_ "github.com/go-sql-driver/mysql"
"github.com/go-xorm/xorm"
log "github.com/sirupsen/logrus"
)
const asyncTaskBacklog = 128
var (
database *xorm.Engine
logger *log.Entry
chWrite chan interface{} // async write channel
chUpdate chan interface{} // async update channel
)
type options struct {
showSQL bool
maxOpenConns int
maxIdleConns int
}
// ModelOption specifies an option for dialing a xordefaultModel.
type ModelOption func(*options)
// MaxIdleConns specifies the max idle connect numbers.
func MaxIdleConns(i int) ModelOption {
return func(opts *options) {
opts.maxIdleConns = i
}
}
// MaxOpenConns specifies the max open connect numbers.
func MaxOpenConns(i int) ModelOption {
return func(opts *options) {
opts.maxOpenConns = i
}
}
// ShowSQL specifies the buffer size.
func ShowSQL(show bool) ModelOption {
return func(opts *options) {
opts.showSQL = show
}
}
func envInit() {
// async task
go func() {
for {
select {
case t, ok := <-chWrite:
if !ok {
return
}
if _, err := database.Insert(t); err != nil {
logger.Error(err)
}
case t, ok := <-chUpdate:
if !ok {
return
}
if _, err := database.Update(t); err != nil {
logger.Error(err)
}
}
}
}()
// 定时ping数据库, 保持连接池连接
go func() {
ticker := time.NewTicker(time.Minute * 5)
for {
select {
case <-ticker.C:
database.Ping()
}
}
}()
}
//New create the database's connection
func MustStartup(dsn string, opts ...ModelOption) func() {
logger = log.WithField("component", "model")
settings := &options{
maxIdleConns: defaultMaxConns,
maxOpenConns: defaultMaxConns,
showSQL: true,
}
// options handle
for _, opt := range opts {
opt(settings)
}
logger.Infof("DSN=%s ShowSQL=%t MaxIdleConn=%v MaxOpenConn=%v", dsn, settings.showSQL, settings.maxIdleConns, settings.maxOpenConns)
// create database instance
if db, err := xorm.NewEngine("mysql", dsn); err != nil {
panic(err)
} else {
database = db
}
// 设置日志相关
database.SetLogger(&Logger{Entry: logger.WithField("orm", "xorm")})
chWrite = make(chan interface{}, asyncTaskBacklog)
chUpdate = make(chan interface{}, asyncTaskBacklog)
// options
database.SetMaxIdleConns(settings.maxIdleConns)
database.SetMaxOpenConns(settings.maxOpenConns)
database.ShowSQL(settings.showSQL)
syncSchema()
envInit()
closer := func() {
close(chWrite)
close(chUpdate)
database.Close()
logger.Info("stopped")
}
return closer
}
func syncSchema() {
database.StoreEngine("InnoDB").Sync2(
new(model.Agent),
new(model.CardConsume),
new(model.Desk),
new(model.History),
new(model.Login),
new(model.Online),
new(model.Order),
new(model.Recharge),
new(model.Register),
new(model.ThirdAccount),
new(model.Trade),
new(model.User),
new(model.Uuid),
new(model.Club),
new(model.UserClub),
)
}