ban users that ban bots

try better responding

Author: graynk

app/handler_helpers.go

@@ -17,10 +17,17 @@ const (
 	NotSupported    = "Not supported yet, sorry"
 )
 
+type MethodOfResponding = int
+
+const (
+	Reply MethodOfResponding = iota
+	Send
+)
+
 func (d DistorterBot) HandleAnimationCommon(c tb.Context) (*tb.Message, string, string, error) {
 	m := c.Message()
 	b := c.Bot()
-	progressMessage, err := d.GetProgressMessage(c, "Downloading...")
+	progressMessage, err := d.SendMessage(c, "Downloading...", Reply)
 	if err != nil {
 		d.logger.Error(err)
 		return nil, "", "", err
@@ -113,14 +120,27 @@ func (d DistorterBot) DoneMessageWithRepeater(b *tb.Bot, m *tb.Message, failed b
 	}
 }
 
-func (d DistorterBot) GetProgressMessage(c tb.Context, toSend interface{}) (*tb.Message, error) {
+func (d DistorterBot) SendMessage(c tb.Context, toSend interface{}, method MethodOfResponding) (*tb.Message, error) {
 	b := c.Bot()
 	message := c.Message()
-	m, err := b.Reply(message, toSend)
+
+	var m *tb.Message
+	var err error
+	if method == Reply {
+		m, err = b.Reply(message, toSend)
+	} else {
+		m, err = b.Send(message.Chat, toSend)
+	}
 	for err != nil {
-		if strings.Contains(err.Error(), "not enough rights to send") {
+		switch {
+		case strings.Contains(err.Error(), "not enough rights to send"):
 			b.Reply(message, NotEnoughRights)
+		case strings.Contains(err.Error(), "bot was blocked by the user (403)"):
+			d.videoWorker.BanUser(message.Chat.ID)
+		case strings.Contains(err.Error(), "telegram: Bad Request: message to be replied not found (400)"):
+			return d.SendMessage(c, toSend, Send)
 		}
+
 		var timeout int
 		timeout, err = tools.ExtractPossibleTimeout(err)
 		if err != nil {
@@ -138,7 +158,7 @@ func (d DistorterBot) GetProgressMessage(c tb.Context, toSend interface{}) (*tb.
 }
 
 func (d DistorterBot) SendMessageWithRepeater(c tb.Context, toSend interface{}) error {
-	_, err := d.GetProgressMessage(c, toSend)
+	_, err := d.SendMessage(c, toSend, Reply)
 	return err
 }
 

app/queue/honest_priority_queue.go

@@ -10,19 +10,31 @@ import (
 // Wraps PriorityQueue to make it thread-safe. Manages priorities.
 // Extremely inefficient, but works for my use-case (very slow jobs and small queue sizes)
 type HonestJobQueue struct {
-	mu    *sync.RWMutex
-	queue PriorityQueue
-	users map[int64]int // Tracks the amount of job per-user currently in the queue. Used to calculate priority
+	mu     *sync.RWMutex
+	queue  PriorityQueue
+	users  map[int64]int // Tracks the amount of job per-user currently in the queue. Used to calculate priority
+	banned map[int64]any // Drop jobs from these users
 }
 
 func NewHonestJobQueue(initialCapacity int) *HonestJobQueue {
 	return &HonestJobQueue{
-		mu:    &sync.RWMutex{},
-		queue: make(PriorityQueue, 0, initialCapacity),
-		users: make(map[int64]int),
+		mu:     &sync.RWMutex{},
+		queue:  make(PriorityQueue, 0, initialCapacity),
+		users:  make(map[int64]int),
+		banned: make(map[int64]any),
 	}
 }
 
+// BanUser This will "ban" the user (if they were impatient and banned the bot first)
+// causing their jobs to be dropped when they pop up. Once all the jobs have been popped
+// the ban will be lifted
+func (hjq *HonestJobQueue) BanUser(userID int64) {
+	hjq.mu.Lock()
+	defer hjq.mu.Unlock()
+
+	hjq.banned[userID] = nil
+}
+
 func (hjq *HonestJobQueue) updatePriorities(userID int64) {
 	for i, job := range hjq.queue {
 		if job.userID != userID {
@@ -55,6 +67,23 @@ func (hjq *HonestJobQueue) Pop() *Job {
 	defer hjq.mu.Unlock()
 
 	job := heap.Pop(&hjq.queue).(*Job)
+
+	if _, ok := hjq.banned[job.userID]; ok {
+		allBannedJobsExhausted := true
+		for _, queued := range hjq.queue {
+			if queued.userID == job.userID {
+				allBannedJobsExhausted = false
+				break
+			}
+		}
+
+		if allBannedJobsExhausted {
+			delete(hjq.banned, job.userID)
+		}
+
+		return hjq.Pop()
+	}
+
 	hjq.users[job.userID]--
 
 	if hjq.users[job.userID] == 0 {

app/tools/video_worker.go

@@ -23,6 +23,10 @@ func NewVideoWorker(workerCount int) *VideoWorker {
 	return &worker
 }
 
+func (vw *VideoWorker) BanUser(userID int64) {
+	vw.queue.BanUser(userID)
+}
+
 func (vw *VideoWorker) run() {
 	for range vw.messenger {
 		vw.queue.Pop().Run()