path: root/memex/main.go

package main

import (
	"archive/tar"
	"errors"
	"flag"
	"fmt"
	"os"
	"path"
	"sort"
	"strings"
	"sync/atomic"
	"time"
	"xxhash"
)

type EntryKind int

/* entry kinds */
const (
	Ereg EntryKind = iota
	Elnk
	Edir
	Elast
)

/* a memex entry */
type Entry struct {
	Kind EntryKind
	Name string
	Mode int
	Size int64
	Msec int64
	Dest string /* for symbolic links */
	Addr Addr
	Xxh  uint64 /* checksum for regular files */
}

type Commit struct {
	Tree Addr
	Msg  string
	Time int64
	Prev Addr /* the parent commit */
}

var config Conf

func (k EntryKind) String() string {
	switch k {
	case Ereg:
		return "reg"
	case Elnk:
		return "lnk"
	case Edir:
		return "dir"
	default:
		return "<invalid>"
	}
}

func errf(msg string, objs ...interface{}) {
	fmt.Fprintf(os.Stderr, msg+"\n", objs...)
}

func fail(msg string, objs ...interface{}) {
	errf(msg, objs...)
	os.Exit(2)
}
func faile(e error) { fail("%v", e) }

/* Modifies a revision, scanned using the Walker argument, to add
 * the file system data selected in paths (the paths are relative
 * to the walker's current path)
 */
func addPaths(a *SdarAdder, root Walker, paths []string) (Addr, error) {
	type FsItem struct{ cur, rest string }

	items := make([]FsItem, len(paths))
	for i, p := range paths {
		it := &items[i]
		it.cur, it.rest = PopDir(p)
	}
	sort.Slice(items, func(i, j int) bool {
		return items[i].cur < items[j].cur
	})

	walkers, err := root.Dive()
	if err != nil {
		return nil, err
	}

	/* build a slice of entries for the current directory
	 * amended with the paths */
	ents := make([]Entry, 0, len(items)+len(walkers))
	for len(items) > 0 || len(walkers) > 0 {
		var walker Walker
		var arname, fsname string

		if len(walkers) > 0 {
			walker = walkers[0]
			arname = walker.Here().Name
		}
		if len(items) > 0 {
			fsname = items[0].cur
		}

		/* insert the entry from the archive */
		if fsname == "" || (arname != "" && arname < fsname) {
			walkers = walkers[1:]
			ents = append(ents, *walker.Here())
			continue
		}

		var sub []string /* all the sub-paths to add from fsname */
		full := false    /* whether fsname has to be added in full */
		var nsub int
		for _, it := range items {
			if it.cur != fsname {
				break
			}
			if it.rest == "" {
				full = true
				sub = nil
			} else if !full {
				sub = append(sub, it.rest)
			}
			nsub++
		}
		items = items[nsub:]
		if fsname == arname {
			walkers = walkers[1:]
		}

		if full {
			fsrel := path.Join(root.Path(), fsname)
			fswalk, err := MakeFsWalker(fsrel)
			if err != nil {
				return nil, err
			}
			dent, err := a.AddFsAt(fswalk)
			if err != nil {
				return nil, err
			}
			ents = append(ents, dent)
		} else if fsname == arname && walker.Here().Kind == Edir {
			addr, err := addPaths(a, walker, sub)
			if err != nil {
				return nil, err
			}
			dent := *walker.Here()
			dent.Addr = addr
			ents = append(ents, dent)
		} else {
			/* in this case either:
			 *   - fsname < arname (or walker == nil) and
			 *     the directory is not in the last archive
			 *     and needs to be created
			 *   - or, fsname == arname and walker.Here() is not
			 *     a directory: something became a directory, so
			 *     we create a new one
			 */
			fsrel := path.Join(root.Path(), fsname)
			fswalk := DummyWalker(fsrel)
			addr, err := addPaths(a, fswalk, sub)
			if err != nil {
				return nil, err
			}
			dent := Entry{
				Kind: Edir,
				Name: fsname,
				Mode: 0755,
				Addr: addr,
			}
			ents = append(ents, dent)
		}
	}

	return a.AddDirEnts(ents)
}

type commitArgs struct {
	cur   string
	msg   string
	now   time.Time
	force bool
	paths []string
}

/* Adds a complete commit to the sdar stash,
 * the address of the new commit is returned */
func addCommit(args commitArgs, head Addr) (new Addr, err error) {
	full := len(args.paths) == 0
	for i := 0; i < len(args.paths); i++ {
		p := path.Join(args.cur, args.paths[i])
		full = full || p == "." || p == ""

		out := len(p) > 1 && p[:2] == ".."
		out = out || len(p) > 0 && p[0] == '/'
		if out {
			err = fmt.Errorf("%s may not be in checkout", p)
			return
		}

		args.paths[i] = p
	}

	var a *SdarAdder
	a, err = MakeAdder(config.Arch)
	if err != nil {
		return
	}
	defer func() {
		adderr := a.Done()
		if err == nil {
			err = adderr
		} else if adderr != nil {
			errf("sdar add error: %v", adderr)
		}
	}()

	var tree Addr
	var walker Walker

	progress := func() {
		n := atomic.LoadInt64(&a.nbytes)
		fmt.Printf("writing: %s ", BytesString(n))
	}

	if full {
		walker = MakeFsDirWalker("", false)
		done := InfoLoop(progress)
		tree, err = a.AddFsDir(walker)
		done()
	} else {
		var rd SdarReader
		rd, err = MakeReader(config.Arch)
		if err != nil {
			return
		}
		defer rd.Done()
		walker, err = MakeSdarWalker(head, rd)
		if err != nil {
			return
		}
		done := InfoLoop(progress)
		tree, err = addPaths(a, walker, args.paths)
		done()
	}
	if err != nil {
		return
	}

	return a.AddCommit(Commit{
		Tree: tree,
		Msg:  args.msg,
		Time: args.now.Unix(),
		Prev: head,
	})
}

func commitCmd(args commitArgs) {
	if args.msg == "" && !args.force {
		fail("missing commit message")
	}

	/* grab a lock to avoid racy accesses to the stash,
	 * it is released when the commit subcommand exits */
	if _, err := GetRepoLock(config.Arch); err != nil {
		faile(err)
	}

	_, err := os.Stat(path.Join(config.Arch, "stash/log"))
	if err == nil {
		fail("flush %s/stash/ before continuing", config.Arch)
	} else if !os.IsNotExist(err) {
		faile(err)
	}

	/* read the ref after grabbing the lock since
	 * we will use it to build the new commit */
	head, err := ReadRef(config.Arch, config.Ref)
	if err != nil {
		faile(err)
	}

	newhead, err := addCommit(args, head)
	if err != nil {
		faile(err)
	}
	if err := SdarCommit(config.Arch); err != nil {
		faile(err)
	}

	if WriteRef(config.Arch, config.Ref, newhead) != nil {
		fail("could not set ref/%s to %v", config.Ref, newhead)
	}
	if SetSync(config.Ref, &config) != nil {
		fail("could not update config to sync=%s", config.Ref)
	}
}

func walkEnt(w Walker, ent *Entry, verbose bool) {
	if ent == nil {
		return
	}
	name := w.Path()
	if ent.Kind == Edir {
		name += "/"
	}
	fmt.Println(name)
	if verbose {
		if ent.Kind == Elnk {
			fmt.Printf("  %s %s\n", ent.Kind, ent.Dest)
		} else {
			fmt.Printf("  %s %#o", ent.Kind, ent.Mode)
			fmt.Printf(" '%s'", time.Unix(ent.Msec, 0))
			if ent.Kind == Ereg {
				fmt.Printf(" %d", ent.Size)
				fmt.Printf(" %016X\n", ent.Xxh)
			} else {
				fmt.Printf("\n")
			}
		}
		if ent.Addr.Ok() {
			fmt.Printf("  %v\n", ent.Addr)
		}
	}
}

func walkDir(w Walker, rec, verbose bool) {
	ws, err := w.Dive()
	if err != nil {
		faile(err)
	}
	for _, w := range ws {
		walkEnt(w, w.Here(), verbose)
		if rec {
			walkDir(w, true, verbose)
		}
	}
}

func parseRevspec(rev string, rd SdarReader) Addr {
	ci := Revspec(rev, rd)
	if ci == nil {
		fail("could not parse revspec '%s'", rev)
	}
	return ci
}

func walkRevAt(rd SdarReader, rev, rel string) Walker {
	addr := parseRevspec(rev, rd)
	w, err := MakeSdarWalker(addr, rd)
	if err == nil {
		w, err = WalkTo(w, rel)
	}
	if err != nil {
		faile(err)
	}
	return w
}

func makeArchiveReader() SdarReader {
	rd, err := MakeReader(config.Arch)
	if err != nil {
		faile(err)
	}
	return rd

}

type walkArgs struct {
	cur   string
	rev   string
	paths []string
	norec bool
	verb  bool
}

func walkCmd(args walkArgs) {
	if len(args.paths) == 0 {
		args.paths = []string{"/"}
	}

	rd := makeArchiveReader()
	defer rd.Done()

	w := walkRevAt(rd, args.rev, "")
	for _, p := range args.paths {
		rel := path.Join(args.cur, p)
		wp, err := WalkTo(w, rel)
		if err != nil {
			faile(err)
		}
		if len(p) > 0 && p[len(p)-1] == '/' {
			walkDir(wp, !args.norec, args.verb)
		} else {
			walkEnt(wp, wp.Here(), args.verb)
		}
	}
}

func walkCommit(a Addr, c Commit) {
	/* TODO print known refs */
	d := time.Unix(c.Time, 0)
	fmt.Printf("Addr: %v\nDate: %s\n", a, d)

	msg := strings.Replace(c.Msg, "\n", "\n    ", -1)
	msg = strings.TrimSpace(msg)
	if msg != "" {
		fmt.Printf("\n    %s\n", msg)
	}

	fmt.Println("")
}

type logArgs struct {
	cur   string
	rev   string
	paths []string
}

func logCmd(args logArgs) {
	rd := makeArchiveReader()
	defer rd.Done()

	var acur, apre Addr
	acur = parseRevspec(args.rev, rd)

	ents := make(map[string]*Entry)
	for i := 0; i < len(args.paths); i++ {
		p := path.Join(args.cur, args.paths[i])
		ents[p] = nil
	}

	var cur, pre Commit
	for {
		var wrev Walker = DummyWalker("")
		if !acur.IsZero() {
			var err error
			cur, err = rd.ReadCommit(acur)
			if err != nil {
				faile(err)
			}
			wrev = MakeCommitWalker(&cur, rd)
		}

		/* find out if we need to show
		 * the previous commit (pre) */
		changed := len(ents) == 0
		for p, old := range ents {
			w, err := WalkTo(wrev, p)
			if err != nil {
				faile(err)
			}
			new := w.Here()
			if old != nil && new != nil {
				diff, _ := simpleDiff(old, new)
				if diff != 0 {
					changed = true
				}
			} else {
				if old != nil || new != nil {
					changed = true
				}
			}
			ents[p] = new
		}
		if apre.Ok() && (changed || acur.IsZero()) {
			walkCommit(apre, pre)
		}

		if acur.IsZero() {
			break
		}

		pre = cur
		apre = acur
		acur = cur.Prev
	}
}

type diffArgs struct {
	cur   string
	arev  string
	brev  string
	paths []string
	fast  bool
	norec bool
	shush bool
}

func diffCmd(args diffArgs) int {
	if args.brev == "" {
		if args.arev == "" {
			args.arev = "."
		}
	} else {
		args.cur = ""
		if args.arev == "" {
			args.arev = args.brev + "^"
		}
	}

	rd := makeArchiveReader()
	defer rd.Done()

	var wa, wb Walker
	wa = walkRevAt(rd, args.arev, args.cur)
	if args.brev == "" {
		wb = MakeFsDirWalker(args.cur, !args.fast)
	} else {
		wb = walkRevAt(rd, args.brev, args.cur)
	}

	chgs, err := Diff(wa, wb, simpleDiff, !args.norec)
	if err != nil {
		faile(err)
	}

	if args.shush {
		if len(chgs) > 0 {
			return 1
		} else {
			return 0
		}
	}

	/* find moves */
	type adddel struct{ add, del *Change }
	ads := make(map[uint64]*adddel)
	for i, chg := range chgs {
		var ad *adddel
		if chg.kind == Cadd && chg.e2.Xxh != 0 {
			addr := chg.e2.Xxh
			if _, ok := ads[addr]; !ok {
				ads[addr] = &adddel{}
			}
			ad = ads[addr]
			ad.add = &chgs[i]
		}
		if chg.kind == Cdel && chg.e1.Xxh != 0 {
			addr := chg.e1.Xxh
			if _, ok := ads[addr]; !ok {
				ads[addr] = &adddel{}
			}
			ad = ads[addr]
			ad.del = &chgs[i]
		}
		if ad != nil && ad.add != nil && ad.del != nil {
			ad.del.kind = Cskip
			ad.add.kind = Cmove
			ad.add.from = ad.del.path
		}
	}

	suff := map[EntryKind]string{Edir: "/", Elnk: "@", Ereg: ""}
	for _, chg := range chgs {
		e1, e2 := chg.e1, chg.e2
		if chg.kind == Cmod &&
			e1.Kind == Edir &&
			chg.fields == Ftime {
			continue
		}
		switch chg.kind {
		case Cadd:
			fmt.Println("+", chg.path+suff[e2.Kind])
		case Cdel:
			fmt.Println("-", chg.path+suff[e1.Kind])
		case Cmod:
			fmt.Println("!", chg.path+suff[e1.Kind])
		case Cmove:
			fmt.Printf("= %s (<- %s)\n",
				chg.path+suff[e2.Kind], chg.from)
		}
	}
	return 0
}

func syncFile(abs string, addr Addr, rd SdarReader) error {
	f, err := os.OpenFile(abs, os.O_WRONLY|os.O_CREATE, 0777)
	if err != nil {
		return err
	}
	defer f.Close()
	f.Truncate(0)
	return rd.WriteTo(addr, f)
}

func syncFs(cs []Change, rd SdarReader) error {
	/* 1. deletions, in reverse order */
	fmt.Println("deleting data")
	for i := len(cs) - 1; i >= 0; i-- {
		if c := &cs[i]; c.kind == Cdel {
			abs := path.Join(config.Root, c.path)
			/* FIXME, abs' directory may not be
			 * writeable, let's ignore this now */
			err := os.Remove(abs)
			if err != nil {
				return err
			}
		}
	}

	/* 2. additions & modifications */
	fmt.Println("adding data")
	for i := 0; i < len(cs); i++ {
		if c := &cs[i]; c.kind == Cadd || c.kind == Cmod {
			var err error

			abs := path.Join(config.Root, c.path)

			/* if an entry changed kind we need to
			 * remove the old one; we also remove
			 * changed links & files to make sure
			 * os.Symlink's destination do not exist
			 * and the file permissions are fine for
			 * writing */
			remove := c.kind == Cmod &&
				(c.fields&Fkind != 0 || c.e1.Kind != Edir)
			if remove {
				err = os.Remove(abs)
				if err != nil {
					return err
				}
			}

			switch c.e2.Kind {
			default:
				panic("unreachable")
			case Edir:
				if c.kind == Cadd || remove {
					err = os.Mkdir(abs, 0777)
				}
			case Elnk:
				err = os.Symlink(c.e2.Dest, abs)
			case Ereg:
				err = syncFile(abs, c.e2.Addr, rd)
			}

			if err != nil {
				return err
			}
		}
	}

	/* 3. set modes & mtimes */
	fmt.Println("setting modes & times")
	for i := len(cs) - 1; i >= 0; i-- {
		if c := &cs[i]; (c.kind == Cadd || c.kind == Cmod) &&
			(c.e2.Kind == Ereg || c.e2.Kind == Edir) {
			abs := path.Join(config.Root, c.path)
			mode := os.FileMode(uint32(c.e2.Mode))
			err := os.Chmod(abs, mode)
			if err == nil && c.e2.Kind == Ereg {
				time := time.Unix(c.e2.Msec, 0)
				err = os.Chtimes(abs, time, time)
			}
			if err != nil {
				return err
			}
		}
	}

	return nil
}

type syncArgs struct {
	cur   string
	rev   string
	force bool
	paths []string
}

func syncCmd(args syncArgs) {
	if len(args.paths) == 0 && args.rev == "" {
		fmt.Println(config.Sync)
		return
	}

	rd := makeArchiveReader()
	defer rd.Done()

	/* use this walker to check if we are overriding
	 * data that was not committed */
	var wsyn Walker
	if !args.force {
		wsyn = walkRevAt(rd, ".", args.cur)
	}

	sync := false
	if len(args.paths) == 0 {
		args.paths = []string{"/"}
		args.cur = ""
		sync = true
	}

	for _, dir := range args.paths {
		/* if the sync is not forced, check if the current
		 * file system state matches the local ref */
		rel := path.Join(args.cur, dir)
		wfs := MakeFsDirWalker(rel, false)
		if wsyn != nil {
			war, err := WalkTo(wsyn, dir)
			if err != nil {
				faile(err)
			}
			cs, err := Diff(wfs, war, simpleDiff, false)
			if err != nil {
				faile(err)
			}
			if len(cs) > 0 {
				errf("skipping dirty path %s", dir)
				sync = false
				continue
			}
		}

		wrev := walkRevAt(rd, args.rev, rel)
		cs, err := Diff(wfs, wrev, simpleDiff, true)
		if err != nil {
			faile(err)
		}

		/* execute the changes given by the diff */
		err = syncFs(cs, rd)
		if err != nil {
			fail("fs sync failed: %v", err)
		}
	}

	if sync {
		syncRev := args.rev
		if !RevAbsolute(syncRev) {
			addr := Revspec(args.rev, rd)
			syncRev = addr.String()
		}
		if SetSync(syncRev, &config) != nil {
			fail("could not update config to sync=%s", syncRev)
		}
	}
}

func initCmd(paths []string) {
	for _, p := range paths {
		if err := InitArchive(p); err != nil {
			faile(err)
		} else {
			fmt.Println("initialized new archive in", p)
		}
	}
}

/* Visit kinds */
const (
	Vbad = 1 << iota
	Vblob
	Vdir
	Vcommit
)

type Check struct {
	reader SdarReader
	item   map[string]int
	seen   int64
	bad    []string
	loc    []string
}

func visited(a Addr, k int, chk *Check) bool {
	s := a.String()
	visit, _ := chk.item[s]
	chk.item[s] = visit | k
	return (visit & k) != 0
}

func markBad(a Addr, chk *Check) {
	if !visited(a, Vbad, chk) {
		chk.bad = append(chk.bad, path.Join(chk.loc...))
	}
}

func checkData(ent *Entry, chk *Check) (err error) {
	if visited(ent.Addr, Vblob, chk) {
		return
	}
	seen := chk.seen
	digest := xxhash.New()
	writer := &Counted{&chk.seen, digest}
	err = chk.reader.WriteTo(ent.Addr, writer)
	cksum := digest.Sum64()
	bad := (chk.seen-seen) != ent.Size || cksum != ent.Xxh
	if errors.Is(err, readError) {
		bad = true
		/* the reader is still in a consistent
		 * state so we can swallow the error */
		err = nil
	}
	if bad {
		markBad(ent.Addr, chk)
	}
	return
}

func checkWalk(w Walker, chk *Check) (bool, error) {
	ent := w.Here()

	chk.loc = append(chk.loc, ent.Name)
	defer func() {
		chk.loc = chk.loc[:len(chk.loc)-1]
	}()

	switch ent.Kind {
	default:
		panic("unreachable")
	case Ereg:
		if !ent.Addr.Ok() {
			return true, nil
		}
		err := checkData(ent, chk)
		return false, err
	case Elnk:
		return false, nil
	case Edir:
		if !ent.Addr.Ok() {
			return true, nil
		}
		if visited(ent.Addr, Vdir, chk) {
			return false, nil
		}
		ws, err := w.Dive() /* ws is nil if err != nil */
		var bad bool
		if errors.Is(err, readError) {
			bad = true
			err = nil
		}
		for _, w := range ws {
			wbad, err := checkWalk(w, chk)
			bad = wbad || bad
			if err != nil {
				/* stop asap, rd may be broken */
				return false, err
			}
		}
		if bad {
			markBad(ent.Addr, chk)
		}
		return false, err
	}
}

func checkCmd(revs []string) int {
	rd := makeArchiveReader()
	defer rd.Done()

	if len(revs) == 0 {
		revs = AllRefs(config.Arch)
	}

	chk := &Check{reader: rd, item: make(map[string]int)}
	done := InfoLoop(func() {
		n := atomic.LoadInt64(&chk.seen)
		fmt.Printf("checking: %s ", BytesString(n))
	})

	for _, rev := range revs {
		addr := Revspec(rev, rd)
		if addr == nil {
			done()
			fail("could not parse revspec '%s'", rev)
		}
		for !addr.IsZero() && !visited(addr, Vcommit, chk) {
			chk.loc = append(chk.loc[:0], addr.String())
			commit, err := rd.ReadCommit(addr)
			if errors.Is(err, readError) {
				markBad(addr, chk)
				break
			}
			if err == nil {
				var wbad bool
				walk := MakeCommitWalker(&commit, rd)
				wbad, err = checkWalk(walk, chk)
				if wbad {
					/* wbad can only be true if
					 * the tree address is bad;
					 * but then the commit should
					 * not have deserialized
					 * properly */
					panic("invariant violation")
				}
			}
			if err != nil {
				done()
				faile(err)
			}
			addr = commit.Prev
		}
	}

	done()

	for _, bad := range chk.bad {
		errf("bad %s", bad)
	}

	if len(chk.bad) != 0 {
		return 1
	} else {
		return 0
	}
}

func tarAt(w Walker, rd SdarReader, tw *tar.Writer) (err error) {
	ent := w.Here()
	if ent == nil {
		return
	}

	switch ent.Kind {
	default:
		panic("unreachable")
	case Elnk:
		hdr := &tar.Header{
			Typeflag: tar.TypeSymlink,
			Name:     w.Path(),
			Linkname: ent.Dest,
			ModTime:  time.Unix(ent.Msec, 0),
		}
		err = tw.WriteHeader(hdr)
	case Ereg:
		hdr := &tar.Header{
			Typeflag: tar.TypeReg,
			Name:     w.Path(),
			Mode:     int64(ent.Mode),
			Size:     ent.Size,
			ModTime:  time.Unix(ent.Msec, 0),
		}
		err = tw.WriteHeader(hdr)
		if err == nil {
			err = rd.WriteTo(ent.Addr, tw)
		}
	case Edir:
		hdr := &tar.Header{
			Typeflag: tar.TypeDir,
			Name:     w.Path(),
			Mode:     int64(ent.Mode),
			ModTime:  time.Unix(ent.Msec, 0),
		}
		if hdr.Name != "" {
			err = tw.WriteHeader(hdr)
			if err != nil {
				return
			}
		}
		var ws []Walker
		ws, err = w.Dive()
		for i := 0; i < len(ws) && err == nil; i++ {
			err = tarAt(ws[i], rd, tw)
		}
	}
	return
}

type getArgs struct {
	rev   string
	tar   bool
	cur   string
	paths []string
}

func getCmd(args getArgs) {
	rd := makeArchiveReader()
	defer rd.Done()

	curw := walkRevAt(rd, args.rev, args.cur)

	if !args.tar && len(args.paths) == 1 {
		/* if a single file is asked for we
		 * send it to stdout straight */
		w, err := WalkTo(curw, args.paths[0])
		if err != nil {
			faile(err)
		}
		ent := w.Here()
		if ent != nil && ent.Kind == Ereg {
			err := rd.WriteTo(ent.Addr, os.Stdout)
			if err != nil {
				faile(err)
			}
			return
		}
	}

	/* otherwise, create a tar archive */
	tw := tar.NewWriter(os.Stdout)
	for _, rel := range args.paths {
		w, err := WalkTo(curw, rel)
		if err != nil {
			faile(err)
		}
		if err = tarAt(w, rd, tw); err != nil {
			faile(err)
		}
	}
	tw.Close()
}

type resetArgs struct {
	rev, ref string
	sync     bool
	creat    bool
}

func resetCmd(args resetArgs) {
	rd := makeArchiveReader()
	defer rd.Done()

	addr := parseRevspec(args.rev, rd)

	if args.sync {
		sync := addr.String()
		if RevAbsolute(args.rev) {
			sync = args.rev
		}
		if SetSync(sync, &config) != nil {
			fail("could not update config to sync=%s", sync)
		}
		return
	}

	if args.ref == "" {
		fmt.Println(addr)
		return
	}

	if args.creat {
		if err := NewRef(config.Arch, args.ref); err != nil {
			faile(err)
		}
	}

	if WriteRef(config.Arch, args.ref, addr) != nil {
		fail("could not set ref/%s to %v", args.ref, addr)
	}
}

type UsageAlt struct{ args, desc string }

var docs = map[string][]UsageAlt{
	"init": {{
		"[PATH ...]",
		`Sets up new bare archives at the specified paths`,
	}},
	"commit": {{
		"[-f] [-m MESSAGE] [PATH ...]",
		`Commits the filesystem objects listed; if the list
		is empty, all files from the current working
		directory are committed

			-f    allow an empty commit message`,
	}},
	"log": {{
		"[-r REV] [PATH ...]",
		`Lists commits starting from the revision specified
		using '-r'; if paths are specified, only commits
		where those paths changed are listed

			-r    starting revision, default is .`,
	}},
	"walk": {{
		"[-S] [-v] [-r REV] [PATH ...]",
		`Dumps the archive contents at the given revision
		and paths; if the path list is empty, it is taken
		to be /

			-r    revision to walk, default is .
			-S    shallow walk (stop on directories)
			-v    verbose output`,
	}},
	"diff": {{
		"[-S] [-s] [-a REVA] [-b REVB]",
		`Diffs revision '-a' against revision '-b';
		if '-b' is missing, the file system is
		compared; if '-a' is missing REVB^ is used;
		if both are missing '-a' is taken to be .

			-f    fast mode, do not checksum file
			      contents 
			-S    shallow diff (stop on directories)
			-s    silent mode, exit with code 1
			      if revisions differ, 0 if they
			      do not, and 2 if errors`,
	}},
	"get": {{
		"[-t] [-r REV] [PATH ...]",
		`Extracts the specified paths from a revision;
		if a single path to a regular file is given
		the file is extracted and output on the standard
		output as is; in other cases, or if '-t' is set,
		a tar archive is output on the standard output

			-r    revision, default is .
			-t    output a tar archive`,
	}},
	"sync": {{
		"[-f] REV [PATH ...]",
		`Updates the paths to match a given revision;
		if the path list is empty it defaults to /

			-f    force modifications to paths that
			      differ from the sync revision`,
	}, {
		"",
		`Displays the current sync revision`,
	}},
	"reset": {{
		"REV",
		`Displays the address of REV`,
	}, {
		"-s REV",
		`Resets the sync revision to REV`,
	}, {
		"[-c] REF REV",
		`Resets the ref REF to the address of REV;
		if '-c' is set and the ref does not exist,
		it is created`,
	}},
	"check": {{
		"",
		`Verifies the integrity of the archive,
		starting from all the refs available;
		returns non-zero in case of problem`,
	}},
}

func usage(arg0, subcmd string) {
	o := flag.CommandLine.Output()
	multi := len(docs[subcmd]) > 1
	for i, u := range docs[subcmd] {
		if multi {
			if i == 0 {
				fmt.Fprintf(o, "usage %d: ", i+1)
			} else {
				fmt.Fprintf(o, "   or %d: ", i+1)
			}
		} else {
			fmt.Fprintf(o, "usage: ")
		}
		fmt.Fprintf(o, "%s %s %s\n", arg0, subcmd, u.args)
	}
	for i, u := range docs[subcmd] {
		var desc string
		if multi {
			fmt.Fprintf(o, "\n%d: ", i+1)
		} else {
			fmt.Fprintf(o, "\n   ")
		}
		desc = strings.ReplaceAll(u.desc, "\t\t", "   ")
		fmt.Fprintf(o, "%s\n", desc)
	}
	fmt.Fprintf(o, "\n")
}

func parseArgs(subcmd string, fs *flag.FlagSet) {
	fs.Usage = func() {}
	if err := fs.Parse(os.Args[2:]); err != nil {
		if err != flag.ErrHelp {
			os.Exit(2)
		}
		usage(os.Args[0], subcmd)
		os.Exit(1)
	}
}

func main() {
	if !FindSdarBin() {
		fail("could not find sdar")
	}

	if len(os.Args) < 2 {
		fail("subcommand expected")
	}

	if os.Args[1] == "init" {
		cmd := flag.NewFlagSet("init", flag.ContinueOnError)
		parseArgs("init", cmd)
		initCmd(cmd.Args())
		os.Exit(0)
	}

	/* all commands but init have to be run
	 * from within a memex checkout */
	dir, _ := os.Getwd()
	cur, err := ParseConfig(dir, &config)
	if err != nil {
		if err == notFoundError {
			fail("not in a memex checkout")
		} else {
			fail("could not parse config: %v", err)
		}
	}

	switch os.Args[1] {

	case "commit":
		var args commitArgs
		cmd := flag.NewFlagSet("commit", flag.ContinueOnError)
		cmd.StringVar(&args.msg, "m", "", "")
		cmd.BoolVar(&args.force, "f", false, "")
		parseArgs("commit", cmd)

		args.cur = cur
		args.now = time.Now()
		args.paths = cmd.Args()
		commitCmd(args)

	case "log":
		var args logArgs
		cmd := flag.NewFlagSet("log", flag.ContinueOnError)
		cmd.StringVar(&args.rev, "r", ".", "")
		parseArgs("log", cmd)

		args.cur = cur
		args.paths = cmd.Args()
		logCmd(args)

	case "walk":
		var args walkArgs
		cmd := flag.NewFlagSet("walk", flag.ContinueOnError)
		cmd.StringVar(&args.rev, "r", ".", "")
		cmd.BoolVar(&args.norec, "S", false, "")
		cmd.BoolVar(&args.verb, "v", false, "")
		parseArgs("walk", cmd)

		args.cur = cur
		args.paths = cmd.Args()
		walkCmd(args)

	case "diff":
		var args diffArgs
		cmd := flag.NewFlagSet("diff", flag.ContinueOnError)
		cmd.StringVar(&args.arev, "a", "", "")
		cmd.StringVar(&args.brev, "b", "", "")
		cmd.BoolVar(&args.fast, "f", false, "")
		cmd.BoolVar(&args.norec, "S", false, "")
		cmd.BoolVar(&args.shush, "s", false, "")
		parseArgs("diff", cmd)

		args.cur = cur
		args.paths = cmd.Args()
		os.Exit(diffCmd(args))

	case "get":
		var args getArgs
		cmd := flag.NewFlagSet("get", flag.ContinueOnError)
		cmd.StringVar(&args.rev, "r", ".", "")
		cmd.BoolVar(&args.tar, "t", false, "")
		parseArgs("get", cmd)

		args.cur = cur
		args.paths = cmd.Args()
		getCmd(args)

	case "sync":
		var args syncArgs
		cmd := flag.NewFlagSet("sync", flag.ContinueOnError)
		cmd.BoolVar(&args.force, "f", false, "")
		parseArgs("sync", cmd)

		if rest := cmd.Args(); len(rest) > 0 {
			args.rev = rest[0]
			args.paths = rest[1:]
		}
		args.cur = cur
		syncCmd(args)

	case "reset":
		var args resetArgs
		cmd := flag.NewFlagSet("reset", flag.ContinueOnError)
		cmd.BoolVar(&args.sync, "s", false, "")
		cmd.BoolVar(&args.creat, "c", false, "")
		parseArgs("reset", cmd)

		rest := cmd.Args()
		if args.sync {
			if len(rest) != 1 {
				fail("one argument expected: REV")
			}
			args.rev = rest[0]
		} else {
			switch len(rest) {
			case 1:
				args.rev = rest[0]
			case 2:
				args.ref = rest[0]
				args.rev = rest[1]
			default:
				fail("expected arguments: [REF] REV")
			}
		}
		resetCmd(args)

	case "check":
		cmd := flag.NewFlagSet("check", flag.ContinueOnError)
		parseArgs("check", cmd)
		os.Exit(checkCmd(cmd.Args()))

	default:
		errf("unknown subcommand '%s'", os.Args[1])
		fmt.Fprintf(os.Stderr, "subcommands:")
		for c := range docs {
			fmt.Fprintf(os.Stderr, " %s", c)
		}
		fail("")

	}
	os.Exit(0)
}