Idle client v2 stops receiving new emails in some time.

[serhiynovos]

I need a service to listening for incoming emails and send them to internal server. It's working but I noticed that in some time like 1 2 days it stops receiving a new emails. In console I don't see any errors. Is there are any way I can check idle client status and if it's failed I can restart client or even just fail client so container with it will be restarted automatically ?

package client

import (
	"bytes"
	"context"
	"fmt"
	"log"
	"sync"
	"text/template"

	"github.com/emersion/go-imap/v2"
	"github.com/emersion/go-imap/v2/imapclient"
	"github.com/mnako/letters"
	"mycom.imap.client/pkg/config"
	"mycom.imap.client/pkg/models"
	"mycom.imap.client/pkg/parsers"
	mycomserver "mycom.imap.client/pkg/mycom-server"
)

type IMAPClient struct {
	idleClient *imapclient.Client
	ctx        context.Context
	wg         *sync.WaitGroup
	idleCmd    *imapclient.IdleCommand
	config     config.Listener
}

func (client *IMAPClient) Start() {
	fmt.Printf("Start %s listener\n", client.config.Name)
	client.wg.Add(1)

	idleC, err := imapclient.DialTLS(client.config.Imap.Host, &imapclient.Options{
		UnilateralDataHandler: &imapclient.UnilateralDataHandler{
			Expunge: func(seqNum uint32) {
				log.Printf("message %v has been expunged", seqNum)
			},
			Mailbox: func(data *imapclient.UnilateralDataMailbox) {
				if data.NumMessages != nil {
					client.fetch(*data.NumMessages)
				}
			},
		},
	})

	if err != nil {
		log.Fatalf("failed to dial IMAP server: %v", err)
	}

	client.idleClient = idleC

	if err := idleC.Login(client.config.Imap.Username, client.config.Imap.Password).Wait(); err != nil {
		log.Fatalf("failed to login: %v", err)
	}

	if _, err := idleC.Select("INBOX", nil).Wait(); err != nil {
		log.Fatalf("failed to select INBOX: %v", err)
	}

	// Start idling
	idleCmd, err := idleC.Idle()
	if err != nil {
		log.Fatalf("IDLE command failed: %v", err)
	}
	client.idleCmd = idleCmd

	<-client.ctx.Done()
	client.Close()
}

func (client *IMAPClient) fetch(number uint32) {
	fmt.Println("Fetch", number)
	seqSet := imap.SeqSetNum(number)
	fetchOptions := &imap.FetchOptions{
		UID:         true,
		BodySection: []*imap.FetchItemBodySection{{}},
	}

	// Create a new fetch client for each fetch operation
	fetchC, err := imapclient.DialTLS(client.config.Imap.Host, nil)
	if err != nil {
		log.Fatalf("failed to dial IMAP server: %v", err)
	}
	defer fetchC.Close() // Ensure the client is closed after the operation

	if err := fetchC.Login(client.config.Imap.Username, client.config.Imap.Password).Wait(); err != nil {
		log.Fatalf("failed to login: %v", err)
	}

	if _, err := fetchC.Select("INBOX", nil).Wait(); err != nil {
		log.Fatalf("failed to select INBOX: %v", err)
	}

	fetchCmd := fetchC.Fetch(seqSet, fetchOptions)
	defer fetchCmd.Close()

	for {
		msg := fetchCmd.Next()
		if msg == nil {
			break
		}

		for {
			item := msg.Next()
			if item == nil {
				break
			}

			switch item := item.(type) {
			case imapclient.FetchItemDataUID:
				log.Printf("UID: %v", item.UID)
			case imapclient.FetchItemDataBodySection:
				email, err := letters.ParseEmail(item.Literal)
				if err != nil {
					log.Fatal(err)
				}

				from := email.Headers.From[0].Address
				subject := email.Headers.Subject
				message := email.Text

				fmt.Println("=========================================================================")

				fmt.Println("Sender ::", from)
				fmt.Println("Subject :: ", subject)
				fmt.Println("Email Text ::", message)

				canAccept := false

				if len(client.config.AcceptFrom) == 0 {
					canAccept = true
				} else {
					for _, acceptFrom := range client.config.AcceptFrom {
						if from == acceptFrom {
							canAccept = true
							break
						}
					}
				}

				if !canAccept {
					fmt.Println("Email is not in whitelist. Ignore this email ::", from)
					return
				}

				// Load the template
				tmpl, err := template.ParseFiles("mmmessage_template.txt")
				if err != nil {
					log.Fatalf("Error loading template: %v", err)
				}

				text, recipients := parsers.ParseIncomingEmailBody(message)

				if len(recipients) == 0 {
					fmt.Println("No recipients found. Ignore")
					return
				}

				sessionId, err := mycomserver.GetSessionID(client.config.Actions[0])

				if err != nil {
					fmt.Println("Failed to get session id", err.Error())
					return
				}

				// Define the data for the template
				data := models.MMMessageData{
					SessionID:    sessionId,
					EmailSubject: subject,
					Application:  "EmailListener",
					Priority:     "10",
					EmailText:    text,
					Recipients:   recipients,
				}

				// Execute the template with the data and save to a string variable
				var buf bytes.Buffer
				if err := tmpl.Execute(&buf, data); err != nil {
					log.Fatalf("Error executing template: %v", err)
				}
				renderedTemplate := buf.String()

				fmt.Println("Received template", renderedTemplate)

				if err := mycomserver.SendMMMessage(client.config.Actions[0], renderedTemplate); err != nil {
					fmt.Println("Failed sending MMMessage", err.Error())
				} else {
					fmt.Println("MMMessage sucessfully sent")
				}
			}
		}
	}
}

func (client *IMAPClient) Close() {
	log.Println("Close Client")
	client.idleClient.Close()
	client.idleCmd.Close()
	client.wg.Done()
}

func NewIMAPClient(ctx context.Context, wg *sync.WaitGroup, config config.Listener) *IMAPClient {
	return &IMAPClient{
		ctx:    ctx,
		wg:     wg,
		config: config,
	}
}

[emersion]

Since ca0ddb7, IdleCommand.Wait can be called before Close. It should now be possible to use it to figure out when the connection is broken.

[birudeghi]

@emersion Should we also include timeout adjustability regardless, as they won't be able to act on that new information without it?

[emersion]

A connection can be closed by the server for many reasons, e.g. the server is restarted, or connectivity is lost for a moment.

[serhiynovos]

@emersion is there any way to handle it ?

[emersion]

In your code snippet, you can add something like

if err := idleCmd.Wait(); err != nil {
    log.Fatalf("IDLE command failed: %v", err)
}

maybe in a goroutine since you're already blocking with <-client.ctx.Done().