func InitWorker() {
workerConfig := g.Config().Worker
SmsWorkerChan = make(chan int, workerConfig.Sms)
MailWorkerChan = make(chan int, workerConfig.Mail)
QQWorkerChan = make(chan int, workerConfig.QQ)
ServerchanWorkerChan = make(chan int, workerConfig.Serverchan)
}
func Start() {
if !g.Config().Http.Enabled {
return
}
addr := g.Config().Http.Listen
if addr == "" {
return
}
s := &http.Server{
Addr: addr,
MaxHeaderBytes: 1 << 30,
}
log.Println("http listening", addr)
log.Fatalln(s.ListenAndServe())
}
func SendQQ(qq *model.QQ) {
defer func() {
<-QQWorkerChan
}()
url := g.Config().Api.QQ
cmd := exec.Command("/bin/bash", "./qq_sms.sh", url, qq.Subject, qq.Content)
err := cmd.Run()
if err != nil {
log.Println(err)
}
proc.IncreQQCount()
if g.Config().Debug {
log.Println("==qq==>>>>", qq.Subject)
}
}
func ConsumeSms() {
queue := g.Config().Queue.Sms
for {
L := redis.PopAllSms(queue)
if len(L) == 0 {
time.Sleep(time.Millisecond * 200)
continue
}
SendSmsList(L)
}
}
func ConsumeQQ() {
queue := g.Config().Queue.QQ
for {
L := redis.PopAllQQ(queue)
if len(L) == 0 {
time.Sleep(time.Millisecond * 200)
continue
}
SendQQList(L)
}
}
func ConsumeMail() {
queue := g.Config().Queue.Mail
for {
L := redis.PopAllMail(queue)
if len(L) == 0 {
time.Sleep(time.Millisecond * 200)
continue
}
SendMailList(L)
}
}
func ConsumeServerchan() {
queue := g.Config().Queue.Serverchan
for {
L := redis.PopAllServerchan(queue)
if len(L) == 0 {
time.Sleep(time.Millisecond * 200)
continue
}
SendServerchanList(L)
}
}
func SendSms(sms *model.Sms) {
defer func() {
<-SmsWorkerChan
}()
url := g.Config().Api.Sms
r := httplib.Post(url).SetTimeout(5*time.Second, 2*time.Minute)
r.Param("tos", sms.Tos)
r.Param("content", sms.Content)
resp, err := r.String()
if err != nil {
log.Println(err)
}
proc.IncreSmsCount()
if g.Config().Debug {
log.Println("==sms==>>>>", sms)
log.Println("<<<<==sms==", resp)
}
}
func SendMail(mail *model.Mail) {
defer func() {
<-MailWorkerChan
}()
url := g.Config().Api.Mail
r := httplib.Post(url).SetTimeout(5*time.Second, 2*time.Minute)
r.Param("tos", mail.Tos)
r.Param("subject", mail.Subject)
r.Param("content", mail.Content)
resp, err := r.String()
if err != nil {
log.Println(err)
}
proc.IncreMailCount()
if g.Config().Debug {
log.Println("==mail==>>>>", mail)
log.Println("<<<<==mail==", resp)
}
}
func SendServerchan(serverchan *model.Serverchan) {
defer func() {
<-ServerchanWorkerChan
}()
sckey := serverchan.Tos
if len(sckey) > 5 {
url := g.Config().Api.Serverchan
url += "/" + sckey + ".send"
r := httplib.Post(url).SetTimeout(5*time.Second, 2*time.Minute)
r.Param("text", serverchan.Subject)
r.Param("desp", serverchan.Content)
resp, err := r.String()
if err != nil {
log.Println(err)
}
if g.Config().Debug {
log.Println("==serverchan==>>>>", serverchan)
log.Println("<<<<==serverchan==", resp)
}
}
proc.IncreServerchanCount()
}
func InitConnPool() {
redisConfig := g.Config().Redis
ConnPool = &redis.Pool{
MaxIdle: redisConfig.MaxIdle,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", redisConfig.Addr)
if err != nil {
return nil, err
}
return c, err
},
TestOnBorrow: PingRedis,
}
}
func configCommonRoutes() {
http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("ok"))
})
http.HandleFunc("/version", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(g.VERSION))
})
http.HandleFunc("/workdir", func(w http.ResponseWriter, r *http.Request) {
RenderDataJson(w, file.SelfDir())
})
http.HandleFunc("/config/reload", func(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.RemoteAddr, "127.0.0.1") {
g.ParseConfig(g.ConfigFile)
RenderDataJson(w, g.Config())
} else {
w.Write([]byte("no privilege"))
}
})
}
