chirpnest/workers.go
2019-08-30 10:48:38 +08:00

660 lines
22 KiB
Go

package main
import (
"encoding/json"
"fmt"
"log"
"math/rand"
"strconv"
"strings"
"time"
"github.com/streadway/amqp"
tb "gopkg.in/tucnak/telebot.v2"
)
func MQGetMsgWorker(id int, msgs chan<- ChatWarsMessage) {
//log.Printf("MQGetMsgWorker[" + strconv.Itoa(id) + "] : Starting.")
var err error
c := MQClient{
User: cfg.Rabbit.User,
Password: cfg.Rabbit.Password,
Host: cfg.Rabbit.Host,
Path: cfg.Rabbit.Path,
SSL: false,
}
for true {
c.Connection, err = amqp.Dial("amqp://" + c.User + ":" + c.Password + "@" + c.Host + "/" + c.Path)
logOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Cannot open MQ connection")
if err != nil {
//c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
c.Channel, err = c.Connection.Channel()
logOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Cannot open MQ channel")
if err != nil {
c.Channel.Close()
c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
c.Queue, err = c.Channel.QueueDeclare(
"msg", // name
false, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
logOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Failed to declare a queue")
if err != nil {
c.Channel.Close()
c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
m, err := c.Channel.Consume(
c.Queue.Name, // queue
"", // consumer
true, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
logOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Failed to register a consumer")
if err != nil {
c.Channel.Close()
c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
for d := range m {
var x ChatWarsMessage
//log.Printf("MQGetMsgWorker["+strconv.Itoa(id)+"] : Received a message: %s", string(d.Body))
err = json.Unmarshal(d.Body, &x)
logOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Can't unmarshal.\n"+string(d.Body))
if err == nil {
msgs <- x
}
}
c.Channel.Close()
c.Connection.Close()
}
log.Printf("MQGetMsgWorker[" + strconv.Itoa(id) + "] : Closing.")
}
func MQKeepAliveWorker() {
//log.Printf("MQKeepAliveWorker : Starting.")
var err error
c := MQClient{
User: cfg.Rabbit.User,
Password: cfg.Rabbit.Password,
Host: cfg.Rabbit.Host,
Path: cfg.Rabbit.Path,
SSL: false,
}
for true {
c.Connection, err = amqp.Dial("amqp://" + c.User + ":" + c.Password + "@" + c.Host + "/" + c.Path)
logOnError(err, "MQKeepAliveWorker : Cannot open MQ connection")
if err != nil {
time.Sleep(15 * time.Second)
continue
}
c.Channel, err = c.Connection.Channel()
logOnError(err, "MQKeepAliveWorker : Cannot open MQ channel")
if err != nil {
c.Channel.Close()
c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
c.Queue, err = c.Channel.QueueDeclare(
"keepalive", // name
false, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
logOnError(err, "MQKeepAliveWorker : Failed to declare a queue")
if err != nil {
c.Channel.Close()
c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
m, err := c.Channel.Consume(
c.Queue.Name, // queue
"", // consumer
true, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
logOnError(err, "MQKeepAliveWorker] : Failed to register a consumer")
if err != nil {
c.Channel.Close()
c.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
for d := range m {
x := MQKeepAlive{}
err = json.Unmarshal(d.Body, &x)
logOnError(err, "MQKeepAliveWorker : Can't unmarshal.\n"+string(d.Body))
if err == nil {
//log.Printf("MQKeepAliveWorker : Received message from %s (%d).\n", x.Nickname, x.TGUserID64)
if x.Date.Add(10 * time.Second).Before(time.Now()) {
// outdated keep-alive coming from client
} else if clt, ok := getLockedClient(x.TGUserID64, true); ok {
clt.HeartBeat = x.Date
if clt.Active {
//log.Printf("MQKeepAliveWorker : Client %s (%d) already active.\n", clt.Login, clt.TGUserID64)
clt.Mux.Unlock()
} else {
clt.Login = x.Nickname
//log.Printf("MQKeepAliveWorker : Connecting to %s (%d).\n", clt.Login, clt.TGUserID64)
clt.MQ.User = cfg.Rabbit.User
clt.MQ.Password = cfg.Rabbit.Password
clt.MQ.Host = cfg.Rabbit.Host
clt.MQ.Path = x.Queue
clt.MQ.SSL = false
clt.MQ.Connection, err = amqp.Dial("amqp://" + clt.MQ.User + ":" + clt.MQ.Password + "@" + clt.MQ.Host + "/" + clt.MQ.Path)
logOnError(err, "MQKeepAliveWorker : Failed to connect to RabbitMQ")
if err != nil {
clt.MQ.Connection.Close()
} else {
clt.MQ.Channel, err = clt.MQ.Connection.Channel()
logOnError(err, "MQKeepAliveWorker : Failed to open a channel")
if err != nil {
clt.MQ.Channel.Close()
clt.MQ.Connection.Close()
} else {
clt.MQ.Queue, err = clt.MQ.Channel.QueueDeclare(
"msg", // name
false, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
logOnError(err, "MQKeepAliveWorker : Failed to declare a queue")
if err != nil {
clt.MQ.Channel.Close()
clt.MQ.Connection.Close()
} else {
clt.Active = true
//log.Printf("MQKeepAliveWorker : Connected to %s.\n", x.Nickname)
}
}
}
clt.Mux.Unlock()
if clt.Active {
c := TGCommand{
Type: commandSendMsg,
ToUserID64: x.TGUserID64,
Text: "Your client is connected.",
}
TGCmdQueue <- c
c = TGCommand{
Type: commandSendMsg,
ToUserID64: cfg.Bot.Admin,
Text: fmt.Sprintf("Client `%s` is connected.", x.Nickname),
}
TGCmdQueue <- c
clientSendCWMsg(x.TGUserID64, `🏅Me`)
} else {
c := TGCommand{
Type: commandSendMsg,
ToUserID64: cfg.Bot.Admin,
Text: fmt.Sprintf("Cannot connect to client `%s`.", x.Nickname),
}
TGCmdQueue <- c
}
}
}
}
}
c.Channel.Close()
c.Connection.Close()
}
log.Printf("MQKeepAliveWorker : Closing.")
}
func MQTGCmdWorker(id int, cmds <-chan TGCommand) {
//log.Printf("MQTGCmdWorker[" + strconv.Itoa(id) + "] : Starting.")
for c := range cmds {
if clt, ok := getLockedClient(c.FromUserID64, false); ok {
j, err := json.Marshal(c)
logOnError(err, "MQTGCmdWorker["+strconv.Itoa(id)+"] : Marshal(c)")
//log.Printf("MQTGCmdWorker["+strconv.Itoa(id)+"] : new command.\n%s\n", string(j))
for clt.MQ.Connection.IsClosed() {
clt.Active = false
log.Printf("MQTGCmdWorker : Resetting MQ connection for #%d.\n", c.FromUserID64)
clt.MQ.Connection, err = amqp.Dial("amqp://" + clt.MQ.User + ":" + clt.MQ.Password + "@" + clt.MQ.Host + "/" + clt.MQ.Path)
logOnError(err, "MQTGCmdWorker : Cannot open MQ connection")
if err != nil {
clt.MQ.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
clt.MQ.Channel, err = clt.MQ.Connection.Channel()
logOnError(err, "MQTGCmdWorker : Cannot open MQ channel")
if err != nil {
clt.MQ.Channel.Close()
clt.MQ.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
clt.MQ.Queue, err = clt.MQ.Channel.QueueDeclare(
"msg", // name
false, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
logOnError(err, "MQTGCmdWorker : Failed to declare a queue")
if err != nil {
clt.MQ.Channel.Close()
clt.MQ.Connection.Close()
time.Sleep(15 * time.Second)
continue
}
}
err = clt.MQ.Channel.Publish(
"", // exchange
clt.MQ.Queue.Name, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "application/json",
Body: []byte(j),
})
logOnError(err, "MQTGCmdWorker["+strconv.Itoa(id)+"] : Publishing message.")
//log.Printf("MQTGCmdWorker[" + strconv.Itoa(id) + "] : Message published.")
clt.Mux.Unlock()
} else {
log.Printf("MQTGCmdWorker["+strconv.Itoa(id)+"] : client %d offline.\n", c.FromUserID64)
}
}
log.Printf("MQTGCmdWorker[" + strconv.Itoa(id) + "] : Closing.")
}
func SQLCWMsgWorker(id int, msgs <-chan ChatWarsMessage, objIds chan<- int64) {
//log.Printf("SQLCWMsgWorker[" + strconv.Itoa(id) + "] : Starting.")
for m := range msgs {
objId, err := addObjMsg(m.ID64, m.ChatID64, m.TGUserID64, m.TGSenderUserID64, m.Date, m.Text)
logOnError(err, "SQLCWMsgWorker["+strconv.Itoa(id)+"] : Inserting message.")
if err == nil && objId != 0 {
// log.Printf("SQLCWMsgWorker["+strconv.Itoa(id)+"] : Message inserted (%d).\n", objId)
objIds <- objId
} else {
log.Printf("SQLCWMsgWorker["+strconv.Itoa(id)+"] : Message in error\n%s\n", m.Text)
}
}
log.Printf("SQLCWMsgWorker[" + strconv.Itoa(id) + "] : Closing.")
}
func SQLIdentifyMsgWorker(id int, objIds <-chan int64) {
//log.Printf("SQLIdentifyMsgWorker[" + strconv.Itoa(id) + "] : Starting.")
for objId := range objIds {
m, err := getObjMsg(objId)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Retrieving message.")
if err == nil {
//log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Message retrieved (%d)\n%s\n", objId, m.Text)
rule, err := getMsgParsingRule(m)
if err != nil {
//logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : msgRegex.")
log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Message unidentified (%d)\n%s\n", objId, m.Text)
} else {
err = setObjSubTypeId(objId, rule.MsgTypeID)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId")
switch rule.MsgTypeID {
case objSubTypeMessageGRolesReq:
case objSubTypeMessageGo:
case objSubTypeMessageReportReq:
case objSubTypeMessageGReportReq:
case objSubTypeMessageHeroReq:
case objSubTypeMessageMeReq:
case objSubTypeMessageInventoryReq:
case objSubTypeMessageTimeReq:
case objSubTypeMessagePledge:
case objSubTypeMessagePillageGo:
case objSubTypeMessagePillageTimeout:
case objSubTypeMessagePillageWin:
case objSubTypeMessagePillageLoss:
case objSubTypeMessageGoQuest:
case objSubTypeMessageGoFastFight:
case objSubTypeMessageGoArena:
case objSubTypeMessageTop:
case objSubTypeMessageMenu:
case objSubTypeMessageBuyReq:
case objSubTypeMessageSellReq:
case objSubTypeMessageOrderbookReq:
case objSubTypeMessageWithdrawReq:
case objSubTypeMessageWithdrawCode:
case objSubTypeMessageWithdrawRcv:
case objSubTypeMessageStockReq:
case objSubTypeMessageMiscReq:
case objSubTypeMessageGStockResReq:
case objSubTypeMessageGStockAlchReq:
case objSubTypeMessageGStockMiscReq:
case objSubTypeMessageGStockRecReq:
case objSubTypeMessageGStockPartReq:
case objSubTypeMessageGStockOthReq:
case objSubTypeMessageGStockAnyAck:
_, err := parseSubTypeMessageGStockAnyAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGStockAnyAck.")
case objSubTypeMessageReportAck:
cwm, err := parseSubTypeMessageReportAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageReportAck.")
cwm.ObjID64 = objId
case objSubTypeMessageMiniWar:
cwm, err := parseSubTypeMessageMiniWar(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageMiniWar.")
cwm.ObjID64 = objId
err = insertMsgMiniWar(cwm)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgMiniWar")
case objSubTypeMessagePillageInc:
cwm, err := parseSubTypeMessagePillageInc(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessagePillageInc.")
cwm.ObjID64 = objId
err = insertMsgPillageInc(cwm)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgPillageInc")
// only catch live pillages
if m.Date.Add(3 * time.Minute).After(time.Now()) {
s := TGCommand{
Type: commandSendMsg,
Text: fmt.Sprintf("Catching pillage (%s)", m.Date.Format(time.RFC3339)),
ToUserID64: m.TGUserID64,
}
TGCmdQueue <- s
p := JobPayloadPillage{
ObjID64: objId,
Date: m.Date,
}
b, _ := json.Marshal(&p)
_, err = createJob(objSubTypeJobPillage, objJobPriority, m.TGUserID64, m.ObjID64, m.Date.Add(time.Duration(25+rand.Intn(35))*time.Second), b)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : createJob(JobPillage)")
}
case objSubTypeMessageMeAck:
cwm, err := parseSubTypeMessageMeAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageMeAck.")
clientMsgMeAck(cwm)
_, err = addObjXP(cwm.CWUserID64, cwm.ExpNow, cwm.ExpLvl, cwm.Level, m.Date)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : addObjXP(MeAck)")
case objSubTypeMessageGoQuestAck:
cwm, err := parseSubTypeMessageGoQuestAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGoQuestAck.")
uid, err := clientGetCWUserID64(m.TGUserID64)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Retrieving UserID64.")
if err != nil {
err = setObjSubTypeId(objId, objSubTypeMessageUnknown)
} else {
clientMsgGoQuestAck(cwm)
_, err = addObjQuest(uid, cwm.QuestTypeID, cwm.Duration, m.Date.UTC())
}
case objSubTypeMessageDuelFight:
cwm, err := parseSubTypeMessageDuelFight(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageDuelFight.")
cwm.ObjID64 = objId
err = insertMsgDuelFight(cwm)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgDuelFight")
case objSubTypeMessageUnionWar:
_, err := parseSubTypeMessageUnionWar(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageUnionWar.")
case objSubTypeMessageGRolesAck:
cwm, err := parseSubTypeMessageGRolesAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGRolesAck.")
clientMsgGRolesAck(cwm)
case objSubTypeMessageAuctionAnnounce:
cwm, err := parseSubTypeMessageAuctionAnnounce(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageAuctionAnnounce.")
cwm.ObjID64 = objId
err = insertMsgAuctionAnnounce(cwm)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgAuctionAnnounce")
if cwm.End.After(time.Now().UTC()) || strings.Compare(cwm.Status, `#active`) == 0 {
p := JobPayloadMsgRefresh{
ObjID64: m.ObjID64,
}
b, _ := json.Marshal(&p)
_, err = createJob(objSubTypeJobMsgRefresh, objJobPriority, m.TGUserID64, m.ObjID64, cwm.End.Add(5*time.Minute).UTC(), b)
/* hack for autobid - FIXME */
if cwm.Price == 0 && cwm.ItemID64 == getObjItemID(`k05`, `Hunter blade`) {
clientSendCWMsg(cfg.Bot.Admin, fmt.Sprintf("/bet_%d_1", cwm.LotID))
}
}
case objSubTypeMessageTimeAck:
_, err := fromChatWarsDate(rule.re.ReplaceAllString(m.Text, "${Day}") + " " + rule.re.ReplaceAllString(m.Text, "${Month}") + " " + rule.re.ReplaceAllString(m.Text, "${Year}") + " " + rule.re.ReplaceAllString(m.Text, "${Hour}") + ":" + rule.re.ReplaceAllString(m.Text, "${Minute}"))
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : fromChatWarsDate")
case objSubTypeMessageOrderbookAck:
_, err := parseSubTypeMessageOrderbookAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageOrderbookAck.")
case objSubTypeMessageStockAck:
_, err := parseSubTypeMessageStockAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageStockAck.")
case objSubTypeMessageGDepositReq:
_, err := parseSubTypeMessageGDepositReq(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGDepositReq.")
case objSubTypeMessageGDepositAck:
_, err := parseSubTypeMessageGDepositAck(m, rule.re)
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGDepositAck.")
default:
//log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Unknwon message type in rule %d : %d (%d)\n%s\n", msgParsingRules[i].ID, msgParsingRules[i].MsgTypeID, objId, m.Text)
}
muxCallbacks.Lock()
if mc1, mok1 := callbacks[m.TGUserID64]; mok1 {
if mc2, mok2 := mc1[rule.MsgTypeID]; mok2 {
for j := range mc2 {
err := rescheduleJob(mc2[j], m.ObjID64, time.Now().UTC())
logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : callbacks triggering")
}
mc1[rule.MsgTypeID] = nil
}
}
muxCallbacks.Unlock()
}
}
}
log.Printf("SQLIdentifyMsgWorker[" + strconv.Itoa(id) + "] : Closing.")
}
func SQLJobWorker() {
//log.Printf("SQLJobWorker : Starting.")
for true {
jobs, err := loadCurrentJobs()
logOnError(err, "SQLJobWorker : loadCurrentJobs")
/*
if len(jobs) > 0 {
log.Printf("SQLJobWorker : %d jobs.\n", len(jobs))
}
*/
if err == nil {
for _, j := range jobs {
JobQueue <- j
}
if len(jobs) < SQLJobSliceSize {
time.Sleep(100 * time.Millisecond)
}
} else {
time.Sleep(1 * time.Second)
}
}
log.Printf("SQLJobWorker : Closing.")
}
func JobWorker(id int, jobs <-chan Job) {
//log.Printf("jobWorker[" + strconv.Itoa(id) + "] : Starting.")
// FIXME : discard timed out jobs
for j := range jobs {
//log.Printf("JobWorker[%d] : Starting job %d (timeout : %s).\n", id, j.ID64, j.Timeout.Format(time.RFC3339))
if time.Now().UTC().Before(j.Timeout) {
switch j.JobTypeID {
case objSubTypeJobRescanMsg:
jobRescan(j)
case objSubTypeJobSetJobDone:
jobSetDone(j)
case objSubTypeJobPillage:
jobPillage(j)
case objSubTypeJobMsgClient:
jobMsgClient(j)
case objSubTypeJobMsgRefresh:
jobMsgRefresh(j)
case objSubTypeJobBackupExport:
jobBackupExport(j)
case objSubTypeJobBackupImport:
jobBackupImport(j)
case objSubTypeJobGStock:
jobGStock(j)
case objSubTypeJobGDeposit:
jobGDeposit(j)
case objSubTypeJobGDepositForward:
jobGDepositForward(j)
default:
log.Printf("jobWorker["+strconv.Itoa(id)+"] : No handler for job type #%d.\n", j.JobTypeID)
}
} else {
log.Printf("JobWorker[%d] : Job %d timed out.\n", id, j.ID64)
setJobDone(j.ID64)
}
}
log.Printf("jobWorker[" + strconv.Itoa(id) + "] : Closing.")
}
func TGCmdWorker(id int, b *tb.Bot, cmds <-chan TGCommand) {
//log.Printf("TGCmdWorker[" + strconv.Itoa(id) + "] : Starting.")
for c := range cmds {
//j, err := json.Marshal(c)
//logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : Marshal(c)")
//log.Printf("TGCmdWorker["+strconv.Itoa(id)+"] : new command.\n%s\n", string(j))
opt := tb.SendOptions{}
switch c.ParseMode {
case cmdParseModePlain:
opt.ParseMode = tb.ModeDefault
case cmdParseModeMarkDown:
opt.ParseMode = tb.ModeMarkdown
case cmdParseModeHTML:
opt.ParseMode = tb.ModeHTML
default:
opt.ParseMode = tb.ModeDefault
}
switch c.Type {
case commandSendMsg:
if c.ToChatID64 != 0 {
ch := tb.Chat{
ID: c.ToChatID64,
}
_, err := b.Send(&ch, c.Text, &opt)
logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : SendMsg Chat")
} else if c.ToUserID64 != 0 {
u := tb.User{
ID: int(c.ToUserID64),
}
_, err := b.Send(&u, c.Text, &opt)
logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : SendMsg User")
}
case commandReplyMsg:
ch := tb.Chat{
ID: c.FromChatID64,
}
m := tb.Message{
ID: int(c.FromMsgID64),
Chat: &ch,
}
_, err := b.Reply(&m, c.Text, &opt)
logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : ReplyMsg")
case commandSendDocument:
if c.ToChatID64 != 0 {
ch := tb.Chat{
ID: c.ToChatID64,
}
d := c.Document
_, err := b.Send(&ch, &d)
//_, err := c.Document.Send(b, ch, nil)
logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : SendDocument Chat")
} else if c.ToUserID64 != 0 {
u := tb.User{
ID: int(c.ToUserID64),
}
d := c.Document
_, err := b.Send(&u, &d)
//_, err := c.Document.Send(b, &ch, nil)
logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : SendDocument Chat")
}
default:
log.Printf("TGCmdWorker[" + strconv.Itoa(id) + "] : Unknown command.\n")
}
}
log.Printf("TGCmdWorker[" + strconv.Itoa(id) + "] : Closing.")
}
func MQTidyKeepAliveWorker() {
//log.Printf("MQTidyKeepAliveWorker : Starting.")
for true {
t := time.Now()
muxClients.Lock()
for id, clt := range clients {
clt.Mux.Lock()
if clt.Active && clt.HeartBeat.Add(3*KeepAliveHeartBeatSeconds*time.Second).Before(time.Now()) {
msgs, err := clt.MQ.Channel.QueuePurge(clt.MQ.Queue.Name, false)
logOnError(err, "MQTidyKeepAliveWorker : Channel.QueuePurge()")
err = clt.MQ.Channel.Close()
logOnError(err, "MQTidyKeepAliveWorker : Channel.Close()")
err = clt.MQ.Connection.Close()
logOnError(err, "MQTidyKeepAliveWorker : Connection.Close()")
cmd := TGCommand{
Type: commandSendMsg,
ToUserID64: id,
Text: "Timeout, purging and closing command queue.",
}
TGCmdQueue <- cmd
cmd = TGCommand{
Type: commandSendMsg,
ToUserID64: cfg.Bot.Admin,
Text: fmt.Sprintf("Client %s timed out (%d messages purged).", clt.Login, msgs),
}
TGCmdQueue <- cmd
clt.Active = false
} else if clt.Active {
//log.Printf("MQTidyKeepAliveWorker : Client %s is active.\n", clt.Login)
} else {
//log.Printf("MQTidyKeepAliveWorker : Client %s is inactive.\n", clt.Login)
}
clt.Mux.Unlock()
}
muxClients.Unlock()
time.Sleep(time.Until(t.Add(time.Second)))
}
log.Printf("MQTidyKeepAliveWorker : Closing.")
}