// Idle setup the processes to wait for notifications from the IMAP source connection.
// If an EXISTS or EXPUNGE command comes across the pipe, the appropriate actions will be
// taken to update the destinations. If the process decides the inboxes are out of sync,
// it will pass a bool to the requestPurge channel. It is expected that the requestPurge
// channel is setup to initiate a purge process when it receives the notificaiton.
func Idle(src *imap.Client, appendRequests []chan WorkRequest, requestPurge chan bool) (err error) {
var nextUID uint32
if nextUID, err = getNextUID(src); err != nil {
log.Printf("Unable to get UIDNext: %s", err.Error())
return err
}
// hold the size so we can determine how to react to commands
startSize := src.Mailbox.Messages
// setup interrupt signal channel to terminate the idle
interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, os.Interrupt, os.Kill)
// setup ticker to reset the idle every 20 minutes (RFC-2177 recommends 29 mins max)
timeout := time.NewTicker(idleTimeoutMinutes * time.Minute)
// setup poller signal for checking for data on the idle command
poll := make(chan bool, 1)
poll <- true
log.Print("beginning idle...")
_, idleErr := src.Idle()
if (idleErr != nil) && (idleErr != imap.ErrTimeout) {
log.Printf("Idle error: %s", idleErr.Error())
return
}
for {
select {
// if we receive a 'poll' we should check the pipe for new messages
case <-poll:
err = src.Recv(0)
if (idleErr != nil) && (idleErr != imap.ErrTimeout) {
log.Printf("Idle error: %s", idleErr.Error())
go sleep(poll)
continue
}
// cache the data so we dont mess it up while start/stopping idle
var tempData []*imap.Response
tempData = append(tempData, src.Data...)
src.Data = nil
for _, data := range tempData {
switch data.Type {
case imap.Data:
// len of 2 likely means its an EXPUNGE or EXISTS command...
if len(data.Fields) == 2 {
msgNum := imap.AsNumber(data.Fields[0])
switch data.Fields[1] {
case "EXPUNGE":
log.Printf("Received an EXPUNGE notification requesting purge - %d", msgNum)
startSize = msgNum
requestPurge <- true
case "EXISTS":
log.Printf("Received an EXISTS notification - %d", msgNum)
if startSize > msgNum {
log.Printf("Mailbox decreased in size %d --> %d. Requesting a purge. MAILBOX MAY NEED TO SYNC", startSize, msgNum)
requestPurge <- true
startSize = msgNum
continue
}
// temporarily term the idle so we can fetch the message
if _, err = src.IdleTerm(); err != nil {
log.Printf("error while temporarily terminating idle: %s", err.Error())
return
}
log.Printf("terminated idle. appending message.")
newMessages := msgNum - startSize
log.Printf("attempting to find/append %d new messages", newMessages)
for i := uint32(0); i < newMessages; i++ {
var request WorkRequest
if request, err = getMessageInfo(src, nextUID); err == nil {
log.Printf("creating %d append requests for %d", len(appendRequests), nextUID)
for _, requests := range appendRequests {
requests <- request
}
log.Printf("done creating append requests for %d", nextUID)
nextUID++
startSize++
} else {
log.Printf("Unable to find message for UID (%d): %s", nextUID, err.Error())
}
}
log.Printf("continuing idle...")
// turn idle back on
if _, err = src.Idle(); err != nil {
log.Printf("Unable to restart idle: %s", err.Error())
return
}
}
}
}
}
go sleep(poll)
case <-interrupt:
log.Printf("Received interrupt. Terminating idle...")
_, err = src.IdleTerm()
if err != nil {
log.Printf("error while terminating idle: %s", err.Error())
}
return
case <-timeout.C:
log.Printf("resetting idle...")
_, err = src.IdleTerm()
if err != nil {
log.Printf("error while temporarily terminating idle: %s", err.Error())
return
}
log.Printf("terminated idle.")
// turn idle back on
_, err = src.Idle()
if err != nil {
log.Printf("Unable to restart idle: %s", err.Error())
return
}
log.Printf("idle restarted.")
}
}
return
}
func ExampleClient() {
//
// Note: most of error handling code is omitted for brevity
//
var (
c *imap.Client
cmd *imap.Command
rsp *imap.Response
)
// Connect to the server
c, _ = imap.Dial("imap.example.com")
// Remember to log out and close the connection when finished
defer c.Logout(30 * time.Second)
// Print server greeting (first response in the unilateral server data queue)
fmt.Println("Server says hello:", c.Data[0].Info)
c.Data = nil
// Enable encryption, if supported by the server
if c.Caps["STARTTLS"] {
c.StartTLS(nil)
}
// Authenticate
if c.State() == imap.Login {
c.Login("*****@*****.**", "mysupersecretpassword")
}
// List all top-level mailboxes, wait for the command to finish
cmd, _ = imap.Wait(c.List("", "%"))
// Print mailbox information
fmt.Println("\nTop-level mailboxes:")
for _, rsp = range cmd.Data {
fmt.Println("|--", rsp.MailboxInfo())
}
// Check for new unilateral server data responses
for _, rsp = range c.Data {
fmt.Println("Server data:", rsp)
}
c.Data = nil
// Open a mailbox (synchronous command - no need for imap.Wait)
c.Select("INBOX", true)
fmt.Print("\nMailbox status:\n", c.Mailbox)
// Fetch the headers of the 10 most recent messages
set, _ := imap.NewSeqSet("")
if c.Mailbox.Messages >= 10 {
set.AddRange(c.Mailbox.Messages-9, c.Mailbox.Messages)
} else {
set.Add("1:*")
}
cmd, _ = c.Fetch(set, "RFC822.HEADER")
// Process responses while the command is running
fmt.Println("\nMost recent messages:")
for cmd.InProgress() {
// Wait for the next response (no timeout)
c.Recv(-1)
// Process command data
for _, rsp = range cmd.Data {
header := imap.AsBytes(rsp.MessageInfo().Attrs["RFC822.HEADER"])
if msg, _ := mail.ReadMessage(bytes.NewReader(header)); msg != nil {
fmt.Println("|--", msg.Header.Get("Subject"))
}
}
cmd.Data = nil
// Process unilateral server data
for _, rsp = range c.Data {
fmt.Println("Server data:", rsp)
}
c.Data = nil
}
// Check command completion status
if rsp, err := cmd.Result(imap.OK); err != nil {
if err == imap.ErrAborted {
fmt.Println("Fetch command aborted")
} else {
fmt.Println("Fetch error:", rsp.Info)
}
}
}
