path: root/pim/cmd/caldavfs/main.go

// caldav/fs serves a CalDAV calendar as a 9p file system.
//
// It is a backend behind pim/lib/cal, which owns the tree, so everything
// above it -- events/date, events/uuid, ctl, query, alarm, changed -- is
// the same as any other calendar. Only fetching differs, and unlike a
// published .ics this one is a conversation: discovery, then a report
// for the window we care about.
//
// A CalDAV server that advertises calendar-auto-schedule (RFC 6638)
// sends the iMIP for you: writing your PARTSTAT back both updates your
// copy and tells the organiser. That is the whole reason this backend
// can honestly offer rsvp where ical/fs cannot.
package main

import (
	"context"
	"flag"
	"fmt"
	"os"
	"strings"
	"sync"
	"time"

	"github.com/emersion/go-ical"
	"github.com/emersion/go-webdav/caldav"

	"pim/lib/cal"
)

func fatal(format string, a ...interface{}) {
	cal.Warnf(format, a...)
	os.Exit(1)
}

type backend struct {
	name    string
	client  *caldav.Client
	path    string // the calendar collection
	window  time.Duration
	refresh time.Duration
	sched   bool // server does the scheduling for us

	mu   sync.Mutex
	evs  []*cal.Event
	sig  string
	last time.Time
	err  string
}

func (b *backend) Name() string { return b.name }

// autoschedule is reported so a dry run shows it; it decides whether
// writing a PARTSTAT is enough or whether we must send the iMIP too.
func (b *backend) Sched() bool { return b.sched }

func (b *backend) Caps() string {
	// Writing is not implemented yet, so say so rather than promise it.
	// When it is: "read write rsvp" plus "schedule" when the server
	// advertises calendar-auto-schedule.
	return "read"
}

func (b *backend) Refresh() time.Duration { return b.refresh }

func (b *backend) Status() (time.Time, string) {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.last, b.err
}

func (b *backend) Describe() string {
	s := fmt.Sprintf("collection %s\n", b.path)
	s += fmt.Sprintf("autoschedule %v\n", b.sched)
	return s
}

// Sync asks for every event in the window and reports whether the set
// changed. ETags make that cheap to decide: if every object still has
// the etag we saw last time, nothing has moved.
func (b *backend) Sync() (bool, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()

	now := time.Now()
	q := &caldav.CalendarQuery{
		CompRequest: caldav.CalendarCompRequest{
			Name:  "VCALENDAR",
			Props: []string{"VERSION"},
			Comps: []caldav.CalendarCompRequest{{
				Name: "VEVENT",
				Props: []string{
					"SUMMARY", "UID", "DTSTART", "DTEND", "DURATION",
					"RRULE", "RDATE", "EXDATE", "RECURRENCE-ID",
					"LOCATION", "DESCRIPTION", "STATUS", "SEQUENCE",
					"ORGANIZER", "ATTENDEE",
				},
			}},
		},
		CompFilter: caldav.CompFilter{
			Name: "VCALENDAR",
			Comps: []caldav.CompFilter{{
				Name:  "VEVENT",
				Start: now.Add(-b.window),
				End:   now.Add(b.window),
			}},
		},
	}
	objs, err := b.client.QueryCalendar(ctx, b.path, q)
	b.note(time.Now(), err)
	if err != nil {
		return false, err
	}

	sig := etagsig(objs)
	b.mu.Lock()
	same := sig == b.sig && b.evs != nil
	b.mu.Unlock()
	if same {
		return false, nil
	}

	cals := make([]*ical.Calendar, 0, len(objs))
	for _, o := range objs {
		if o.Data != nil {
			cals = append(cals, o.Data)
		}
	}
	evs := cal.FromCalendars(cals)

	b.mu.Lock()
	b.evs, b.sig = evs, sig
	b.mu.Unlock()
	cal.Warnf("%s: %d objects", b.name, len(objs))
	return true, nil
}

func (b *backend) Events() ([]*cal.Event, error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.evs, nil
}

func (b *backend) note(t time.Time, err error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.last = t
	if err != nil {
		b.err = err.Error()
	} else {
		b.err = ""
	}
}

// etagsig summarises the collection: path and etag per object. If the
// server changes nothing, this does not change either.
func etagsig(objs []caldav.CalendarObject) string {
	s := make([]string, 0, len(objs))
	for _, o := range objs {
		s = append(s, o.Path+" "+o.ETag)
	}
	// QueryCalendar makes no promise about order
	sortStrings(s)
	return strings.Join(s, "\n")
}

func sortStrings(s []string) {
	for i := 1; i < len(s); i++ {
		for j := i; j > 0 && s[j] < s[j-1]; j-- {
			s[j], s[j-1] = s[j-1], s[j]
		}
	}
}

func main() {
	cal.Argv0 = "caldav/fs"
	var (
		endpoint = flag.String("e", "", "caldav endpoint, e.g. https://caldav.fastmail.com/dav/")
		user     = flag.String("u", "", "account name")
		pwfile   = flag.String("p", "", "file holding the password (keeps it out of ps)")
		which    = flag.String("C", "", "which calendar to serve, by display name")
		name     = flag.String("N", "", "name to report in ctl (default: the display name)")
		srv      = flag.String("s", "", "service name to post in /srv (default caldav.$user.$pid)")
		days     = flag.Int("w", 400, "expansion window in days")
		poll     = flag.Duration("r", 15*time.Minute, "how often to re-query")
		dry      = flag.Bool("n", false, "load and report, do not serve")
	)
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr,
			"usage: caldav/fs -e endpoint -u user -p pwfile [-C calendar] [-N name] [-s srv] [-w days] [-r poll] [-n]\n")
		os.Exit(2)
	}
	flag.Parse()

	if *endpoint == "" || *user == "" || *pwfile == "" {
		flag.Usage()
	}
	pass, err := readSecret(*pwfile)
	if err != nil {
		fatal("%v", err)
	}

	client, coll, sched, err := dial(*endpoint, *user, pass, *which)
	if err != nil {
		fatal("%v", err)
	}

	who := os.Getenv("user")
	if who == "" {
		who = "glenda"
	}
	if *srv == "" {
		// as rio(1) and plumb(1) name theirs, so several may run at once
		*srv = fmt.Sprintf("caldav.%s.%d", who, os.Getpid())
	}
	label := *name
	if label == "" {
		label = coll.Name
	}

	be := &backend{
		name: label, client: client, path: coll.Path, sched: sched,
		window:  time.Duration(*days) * 24 * time.Hour,
		refresh: *poll,
	}

	s := cal.New(be, cal.Config{
		User: who, Srv: *srv, Conf: *pwfile,
		Window: time.Duration(*days) * 24 * time.Hour,
	})
	if *dry {
		if err := s.Report(); err != nil {
			fatal("%v", err)
		}
		return
	}
	if err := s.Serve(); err != nil {
		fatal("%v", err)
	}
}