175 lines
3.1 KiB
Go
175 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"sync"
|
|
"syscall"
|
|
|
|
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
|
|
"github.com/jessevdk/go-flags"
|
|
)
|
|
|
|
type Options struct {
|
|
ConfigFile string `short:"c" long:"config" description:"Config file name" required:"true"`
|
|
}
|
|
|
|
func main() {
|
|
var (
|
|
opt Options
|
|
cfg Config
|
|
wg sync.WaitGroup
|
|
)
|
|
|
|
_, err := flags.ParseArgs(&opt, os.Args)
|
|
if err != nil {
|
|
os.Exit(1)
|
|
}
|
|
|
|
err = readConfig(opt.ConfigFile, &cfg)
|
|
if err != nil {
|
|
_, _ = fmt.Fprintf(os.Stderr, "Failed to run: [%s]\n", err.Error())
|
|
os.Exit(2)
|
|
}
|
|
|
|
bot, err := tgbotapi.NewBotAPI(cfg.BotToken)
|
|
if err != nil {
|
|
log.Panic(err)
|
|
}
|
|
|
|
db, err := connectToDataBase(
|
|
cfg.Postgres.Host,
|
|
cfg.Postgres.Port,
|
|
cfg.Postgres.User,
|
|
cfg.Postgres.Password,
|
|
cfg.Postgres.DBName,
|
|
)
|
|
|
|
if err != nil {
|
|
_, _ = fmt.Fprintf(os.Stderr, "Failed to connect db: [%s]\n", err.Error())
|
|
os.Exit(5)
|
|
}
|
|
|
|
ch := newCommandHandler()
|
|
pb := newPlayersBoard()
|
|
ms := NewMessageStorage()
|
|
|
|
ctx, cancelFunc := createContext(&cfg, bot, ch, db, pb, ms)
|
|
|
|
getLogger(ctx).Infof("Run...")
|
|
|
|
err = pb.load(ctx)
|
|
if err != nil {
|
|
_, _ = fmt.Fprintf(os.Stderr, "Failed to show players board: [%s]\n", err.Error())
|
|
os.Exit(5)
|
|
}
|
|
|
|
runCommandHandler(ctx, ch, &wg)
|
|
runMessageStorage(ctx, ms, &wg)
|
|
runHttpServer(ctx, cfg.Http, &wg)
|
|
runSignalHandler(ctx, cancelFunc)
|
|
|
|
getLogger(ctx).Infof("Running")
|
|
|
|
wg.Wait()
|
|
}
|
|
|
|
func runCommandHandler(ctx context.Context, ch *commandHandler, wg *sync.WaitGroup) {
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
defer wg.Done()
|
|
|
|
ch.run(ctx)
|
|
}()
|
|
}
|
|
|
|
func runMessageStorage(ctx context.Context, ms *messageStorage, wg *sync.WaitGroup) {
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
defer wg.Done()
|
|
|
|
ms.run(ctx)
|
|
}()
|
|
}
|
|
|
|
func runHttpServer(ctx context.Context, addr string, wg *sync.WaitGroup) {
|
|
server := http.Server{
|
|
Addr: addr,
|
|
Handler: newHttpHandler(ctx),
|
|
}
|
|
|
|
getLogger(ctx).Infof("Run http server on: [%s]", addr)
|
|
|
|
ls, err := (&net.ListenConfig{}).Listen(ctx, "tcp", addr)
|
|
if err != nil {
|
|
_, _ = fmt.Fprintf(os.Stderr, "Failed open port: [%s]\n", err.Error())
|
|
os.Exit(3)
|
|
}
|
|
|
|
go func() {
|
|
<-ctx.Done()
|
|
_ = server.Close()
|
|
}()
|
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
defer wg.Done()
|
|
|
|
err = server.Serve(ls)
|
|
if err != nil && err != http.ErrServerClosed {
|
|
_, _ = fmt.Fprintf(os.Stderr, "Failed to run http server: [%s]\n", err.Error())
|
|
os.Exit(4)
|
|
}
|
|
}()
|
|
}
|
|
|
|
func runSignalHandler(ctx context.Context, cancelFunc func()) {
|
|
sigs := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
|
|
|
|
go func() {
|
|
for {
|
|
switch <-sigs {
|
|
case syscall.SIGINT, syscall.SIGTERM:
|
|
getLogger(ctx).Infof("Interrapt, exit.")
|
|
cancelFunc()
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
// =====
|
|
//mess := tgbotapi.NewMessage(-1001155171053, "")
|
|
//m, err := bot.Send(mess)
|
|
|
|
//var updateID int
|
|
//
|
|
//for {
|
|
// updates, _ := bot.GetUpdates(tgbotapi.UpdateConfig{
|
|
// Offset: updateID + 1,
|
|
// Timeout: 30,
|
|
// })
|
|
//
|
|
// for _, u := range updates {
|
|
// updateID = u.UpdateID
|
|
//
|
|
// fmt.Println(u.Message.Chat.ID, u.Message.Text)
|
|
//
|
|
// mess := tgbotapi.NewMessage(51716267, u.Message.Text)
|
|
// bot.Send(mess)
|
|
// }
|
|
//
|
|
// fmt.Println("qq")
|
|
//}
|
|
|
|
// =====
|