codebydante's picture
Upload 114 files
bd894b3 verified
Raw History Blame
9 kB
package bot
import (
"EverythingSuckz/fsb/config"
"context"
"fmt"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"time"
firebase "firebase.google.com/go/v4"
"google.golang.org/api/option"
"github.com/celestix/gotgproto"
"github.com/celestix/gotgproto/sessionMaker"
"github.com/glebarez/sqlite"
"github.com/gotd/td/tg"
"go.uber.org/zap"
)
type Worker struct {
ID int
Client *gotgproto.Client
Self *tg.User
Token string
log *zap.Logger
}
func (w *Worker) String() string {
return fmt.Sprintf("{Worker (%d|@%s)}", w.ID, w.Self.Username)
}
type BotWorkers struct {
Bots []*Worker
starting int
index int
mut sync.Mutex
log *zap.Logger
}
var Workers *BotWorkers = &BotWorkers{
log: nil,
Bots: make([]*Worker, 0),
}
func (w *BotWorkers) Init(log *zap.Logger) {
w.log = log.Named("Workers")
}
func (w *BotWorkers) AddDefaultClient(client *gotgproto.Client, self *tg.User) {
if w.Bots == nil {
w.Bots = make([]*Worker, 0)
}
w.incStarting()
w.Bots = append(w.Bots, &Worker{
Client: client,
ID: w.starting,
Self: self,
Token: config.ValueOf.BotToken,
log: w.log,
})
w.log.Sugar().Info("Default bot loaded")
}
func (w *BotWorkers) incStarting() {
w.mut.Lock()
defer w.mut.Unlock()
w.starting++
}
func (w *BotWorkers) Add(token string) (string, error) {
w.mut.Lock()
for _, b := range w.Bots {
if b.Token == token {
w.mut.Unlock()
return "", fmt.Errorf("el token ya existe en la lista de workers")
}
}
w.mut.Unlock()
w.incStarting()
var botID int = w.starting
client, err := startWorker(w.log, token, botID)
if err != nil {
return "", err
}
w.log.Sugar().Infof("Bot @%s loaded with ID %d", client.Self.Username, botID)
w.mut.Lock()
w.Bots = append(w.Bots, &Worker{
Client: client,
ID: botID,
Self: client.Self,
Token: token,
log: w.log,
})
w.mut.Unlock()
return client.Self.Username, nil
}
func GetNextWorker() *Worker {
Workers.mut.Lock()
defer Workers.mut.Unlock()
index := (Workers.index + 1) % len(Workers.Bots)
Workers.index = index
worker := Workers.Bots[index]
Workers.log.Sugar().Debugf("Using worker %d", worker.ID)
return worker
}
func StartWorkers(log *zap.Logger) (*BotWorkers, error) {
Workers.Init(log)
// Fetch dynamic tokens from Firebase
var dynamicTokens []string
if config.ValueOf.FirebaseJSON != "" {
dynamicTokens, _ = Workers.LoadTokensFromFirebase()
}
allTokens := append(config.ValueOf.MultiTokens, dynamicTokens...)
if len(allTokens) == 0 {
Workers.log.Sugar().Info("No worker bot tokens provided, skipping worker initialization")
return Workers, nil
}
Workers.log.Sugar().Info("Starting workers")
if config.ValueOf.UseSessionFile {
Workers.log.Sugar().Info("Using session file for workers")
newpath := filepath.Join(".", "sessions")
if err := os.MkdirAll(newpath, os.ModePerm); err != nil {
Workers.log.Error("Failed to create sessions directory", zap.Error(err))
return nil, err
}
}
var wg sync.WaitGroup
var successfulStarts int32
totalBots := len(allTokens)
for i := 0; i < totalBots; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
done := make(chan error, 1)
go func() {
_, err := Workers.Add(allTokens[i])
done <- err
}()
select {
case err := <-done:
if err != nil {
Workers.log.Error("Failed to start worker", zap.Int("index", i), zap.Error(err))
} else {
atomic.AddInt32(&successfulStarts, 1)
}
case <-ctx.Done():
Workers.log.Error("Timed out starting worker", zap.Int("index", i))
}
}(i)
}
wg.Wait() // Wait for all goroutines to finish
Workers.log.Sugar().Infof("Successfully started %d/%d bots", successfulStarts, totalBots)
if len(dynamicTokens) > 0 {
fmt.Println("\n🔥 [Firebase] Conectado exitosamente a Firestore.")
fmt.Println(Workers.GetWorkerListText(true))
}
return Workers, nil
}
func (w *BotWorkers) GetWorkerListText(onlyDynamic bool) string {
w.mut.Lock()
defer w.mut.Unlock()
var envBots []*Worker
var dynamicBots []*Worker
envTokensMap := make(map[string]bool)
for _, t := range config.ValueOf.MultiTokens {
envTokensMap[t] = true
}
for _, b := range w.Bots {
if b.Token == config.ValueOf.BotToken {
continue
}
if envTokensMap[b.Token] {
envBots = append(envBots, b)
} else {
dynamicBots = append(dynamicBots, b)
}
}
var sb strings.Builder
if len(envBots) > 0 {
sb.WriteString(fmt.Sprintf("⚙️ **Lista de %d Tokens Estáticos (.env):**\n\n", len(envBots)))
for i, b := range envBots {
sb.WriteString(fmt.Sprintf("%d️⃣ @%s\n`%s`\n\n", i+1, b.Self.Username, b.Token))
}
}
if len(dynamicBots) > 0 {
sb.WriteString(fmt.Sprintf("📋 **Lista de %d Tokens Dinámicos (Firebase):**\n\n", len(dynamicBots)))
for i, b := range dynamicBots {
sb.WriteString(fmt.Sprintf("%d️⃣ @%s\n`%s`\n\n", i+1, b.Self.Username, b.Token))
}
} else if len(envBots) == 0 {
return "ℹ️ No hay tokens adicionales configurados (ni dinámicos ni estáticos)."
}
return strings.TrimSpace(sb.String())
}
func startWorker(l *zap.Logger, botToken string, index int) (*gotgproto.Client, error) {
log := l.Named("Worker").Sugar()
log.Infof("Starting worker with index - %d", index)
var sessionType sessionMaker.SessionConstructor
if config.ValueOf.UseSessionFile {
// Use the Bot ID (first part of token) as the session filename
// This prevents sessions from shuffling if order changes, which causes wrong usernames.
sessionID := fmt.Sprintf("%d", index)
if parts := strings.Split(botToken, ":"); len(parts) == 2 {
sessionID = parts[0]
}
sessionType = sessionMaker.SqlSession(sqlite.Open(fmt.Sprintf("sessions/worker-%s.session", sessionID)))
} else {
sessionType = sessionMaker.SimpleSession()
}
client, err := gotgproto.NewClient(
int(config.ValueOf.ApiID),
config.ValueOf.ApiHash,
gotgproto.ClientTypeBot(botToken),
&gotgproto.ClientOpts{
Session: sessionType,
DisableCopyright: true,
Middlewares: GetFloodMiddleware(log.Desugar()),
},
)
if err != nil {
return nil, err
}
return client, nil
}
// SaveTokenToFirebase connects to Firestore and saves a bot token.
func (w *BotWorkers) SaveTokenToFirebase(token string) error {
if config.ValueOf.FirebaseJSON == "" {
return fmt.Errorf("FIREBASE_JSON env var is empty, cannot save token dynamically")
}
ctx := context.Background()
opt := option.WithCredentialsJSON([]byte(config.ValueOf.FirebaseJSON))
app, err := firebase.NewApp(ctx, nil, opt)
if err != nil {
return fmt.Errorf("error initializing firebase: %v", err)
}
client, err := app.Firestore(ctx)
if err != nil {
return fmt.Errorf("error connecting to firestore: %v", err)
}
defer client.Close()
// Check if token already exists to avoid duplication
iter := client.Collection("brody_tokens").Where("token", "==", token).Documents(ctx)
docs, err := iter.GetAll()
if err == nil && len(docs) > 0 {
return fmt.Errorf("el token ya existe en la base de datos de Firebase")
}
// Use a new document ID
docRef := client.Collection("brody_tokens").NewDoc()
_, err = docRef.Set(ctx, map[string]interface{}{
"token": token,
"created_at": time.Now(),
})
return err
}
// LoadTokensFromFirebase connects to Firestore and reads all saved bot tokens.
func (w *BotWorkers) LoadTokensFromFirebase() ([]string, error) {
if config.ValueOf.FirebaseJSON == "" {
return nil, nil
}
w.log.Sugar().Info("Loading tokens from Firebase Firestore...")
ctx := context.Background()
opt := option.WithCredentialsJSON([]byte(config.ValueOf.FirebaseJSON))
app, err := firebase.NewApp(ctx, nil, opt)
if err != nil {
w.log.Sugar().Warnf("error initializing firebase to load tokens: %v", err)
return nil, err
}
client, err := app.Firestore(ctx)
if err != nil {
w.log.Sugar().Warnf("error connecting to firestore to load tokens: %v", err)
return nil, err
}
defer client.Close()
iter := client.Collection("brody_tokens").Documents(ctx)
docs, err := iter.GetAll()
if err != nil {
w.log.Sugar().Warnf("error fetching tokens from firestore: %v", err)
return nil, err
}
var tokens []string
seen := make(map[string]bool)
for _, doc := range docs {
if t, ok := doc.Data()["token"].(string); ok && t != "" {
if !seen[t] {
tokens = append(tokens, t)
seen[t] = true
} else {
// Remove duplicated keys from firestore automatically
doc.Ref.Delete(ctx)
}
}
}
w.log.Sugar().Infof("Successfully loaded %d dynamic tokens from Firebase", len(tokens))
return tokens, nil
}