~sircmpwn/aerc

d603bbe2ce4adebfc9ec0bb708d814fd9152676c — Drew DeVault 3 years ago cc03f6f
Refactoring; consume listing response
4 files changed, 55 insertions(+), 51 deletions(-)

M ui/account.go
M worker/imap/list.go
M worker/imap/worker.go
M worker/types/messages.go
M ui/account.go => ui/account.go +22 -15
@@ 31,12 31,20 @@ func NewAccountTab(conf *config.AccountConfig,
		Worker: work,
		logger: logger,
	}
	acc.Worker.PostAction(types.Configure{Config: conf}, nil)
	acc.Worker.PostAction(types.Connect{}, func(msg types.WorkerMessage) {
		if _, ok := msg.(types.Ack); ok {
	acc.Worker.PostAction(&types.Configure{Config: conf}, nil)
	acc.Worker.PostAction(&types.Connect{}, func(msg types.WorkerMessage) {
		switch msg := msg.(type) {
		case *types.Done:
			acc.logger.Println("Connected.")
			acc.Worker.PostAction(types.ListDirectories{}, nil)
		} else {
			acc.Worker.PostAction(&types.ListDirectories{}, nil)
		case *types.CertificateApprovalRequest:
			// TODO: Ask the user
			acc.logger.Println("Approving certificate")
			acc.Worker.PostAction(&types.ApproveCertificate{
				Message:  types.RespondTo(msg),
				Approved: true,
			}, nil)
		default:
			acc.logger.Println("Connection failed.")
		}
	})


@@ 72,18 80,17 @@ func (acc *AccountTab) GetChannel() chan types.WorkerMessage {

func (acc *AccountTab) HandleMessage(msg types.WorkerMessage) {
	msg = acc.Worker.ProcessMessage(msg)
	switch msg.(type) {
	case types.Ack:
	case types.Unsupported:
	switch msg := msg.(type) {
	case *types.Done:
	case *types.CertificateApprovalRequest:
	case *types.Unsupported:
		// no-op
	case types.ApproveCertificate:
		// TODO: Ask the user
		acc.logger.Println("Approving certificate")
		acc.Worker.PostAction(types.Ack{
			Message: types.RespondTo(msg),
		}, nil)
	case *types.Error:
		acc.logger.Printf("Error: %v\n", msg.Error)
	case *types.Directory:
		acc.logger.Printf("Directory: %s\n", msg.Name)
	default:
		acc.Worker.PostAction(types.Unsupported{
		acc.Worker.PostAction(&types.Unsupported{
			Message: types.RespondTo(msg),
		}, nil)
	}

M worker/imap/list.go => worker/imap/list.go +8 -4
@@ 6,7 6,7 @@ import (
	"git.sr.ht/~sircmpwn/aerc2/worker/types"
)

func (imapw *IMAPWorker) handleListDirectories(msg types.ListDirectories) {
func (imapw *IMAPWorker) handleListDirectories(msg *types.ListDirectories) {
	mailboxes := make(chan *imap.MailboxInfo)
	done := make(chan error, 1)
	imapw.worker.Logger.Println("Listing mailboxes")


@@ 18,18 18,22 @@ func (imapw *IMAPWorker) handleListDirectories(msg types.ListDirectories) {
			select {
			case err := <-done:
				if err != nil {
					imapw.worker.PostMessage(types.Error{
					imapw.worker.PostMessage(&types.Error{
						Message: types.RespondTo(msg),
						Error:   err,
					}, nil)
				} else {
					imapw.worker.PostMessage(
						types.Done{types.RespondTo(msg)}, nil)
						&types.Done{types.RespondTo(msg)}, nil)
				}
				return
			case mbox := <-mailboxes:
				if mbox != nil {
					imapw.worker.Logger.Printf("%v\n", mbox.Name)
					imapw.worker.PostMessage(&types.Directory{
						Message:    types.RespondTo(msg),
						Name:       mbox.Name,
						Attributes: mbox.Attributes,
					}, nil)
				}
			}
		}

M worker/imap/worker.go => worker/imap/worker.go +18 -21
@@ 54,7 54,7 @@ func (w *IMAPWorker) verifyPeerCert(msg types.WorkerMessage) func(
			pool.AddCert(cert)
		}

		request := types.ApproveCertificate{
		request := &types.CertificateApprovalRequest{
			Message:  types.RespondTo(msg),
			CertPool: pool,
		}


@@ 62,25 62,25 @@ func (w *IMAPWorker) verifyPeerCert(msg types.WorkerMessage) func(

		response := <-w.worker.Actions
		if response.InResponseTo() != request {
			return fmt.Errorf("Expected UI to answer cert request")
			return fmt.Errorf("Expected UI to respond to cert request")
		}
		switch response.(type) {
		case types.Ack:
			return nil
		case types.Disconnect:
			return fmt.Errorf("UI rejected certificate")
		default:
			return fmt.Errorf("Expected UI to answer cert request")
		if approval, ok := response.(*types.ApproveCertificate); !ok {
			return fmt.Errorf("Expected UI to send certificate approval")
		} else {
			if approval.Approved {
				return nil
			} else {
				return fmt.Errorf("UI rejected certificate")
			}
		}
	}
}

func (w *IMAPWorker) handleMessage(msg types.WorkerMessage) error {
	switch msg := msg.(type) {
	case types.Ping:
	case types.Unsupported:
	case *types.Unsupported:
		// No-op
	case types.Configure:
	case *types.Configure:
		u, err := url.Parse(msg.Config.Source)
		if err != nil {
			return err


@@ 99,14 99,14 @@ func (w *IMAPWorker) handleMessage(msg types.WorkerMessage) error {

		w.config.scheme = u.Scheme
		w.config.user = u.User
	case types.Connect:
	case *types.Connect:
		var (
			c   *client.Client
			err error
		)
		tlsConfig := &tls.Config{
			InsecureSkipVerify:    true,
			VerifyPeerCertificate: w.verifyPeerCert(&msg),
			VerifyPeerCertificate: w.verifyPeerCert(msg),
		}
		switch w.config.scheme {
		case "imap":


@@ 146,7 146,8 @@ func (w *IMAPWorker) handleMessage(msg types.WorkerMessage) error {

		c.Updates = w.updates
		w.client = &imapClient{c, idle.NewClient(c)}
	case types.ListDirectories:
		w.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
	case *types.ListDirectories:
		w.handleListDirectories(msg)
	default:
		return errUnsupported


@@ 160,18 161,14 @@ func (w *IMAPWorker) Run() {
		case msg := <-w.worker.Actions:
			msg = w.worker.ProcessAction(msg)
			if err := w.handleMessage(msg); err == errUnsupported {
				w.worker.PostMessage(types.Unsupported{
				w.worker.PostMessage(&types.Unsupported{
					Message: types.RespondTo(msg),
				}, nil)
			} else if err != nil {
				w.worker.PostMessage(types.Error{
				w.worker.PostMessage(&types.Error{
					Message: types.RespondTo(msg),
					Error:   err,
				}, nil)
			} else {
				w.worker.PostMessage(types.Ack{
					Message: types.RespondTo(msg),
				}, nil)
			}
		case update := <-w.updates:
			w.worker.Logger.Printf("(= %T", update)

M worker/types/messages.go => worker/types/messages.go +7 -11
@@ 26,11 26,6 @@ func (m Message) InResponseTo() WorkerMessage {

// Meta-messages

// TODO: Figure out a nice way of merging Ack and Done
type Ack struct {
	Message
}

type Done struct {
	Message
}


@@ 46,8 41,9 @@ type Unsupported struct {

// Actions

type Ping struct {
type ApproveCertificate struct {
	Message
	Approved bool
}

type Configure struct {


@@ 69,13 65,13 @@ type ListDirectories struct {

// Messages

type Directory struct {
type CertificateApprovalRequest struct {
	Message
	Name *string
	CertPool *x509.CertPool
}

// Respond with an Ack to approve or Disconnect to reject
type ApproveCertificate struct {
type Directory struct {
	Message
	CertPool *x509.CertPool
	Attributes []string
	Name       string
}