misc renamings & refactoring

7 files changed, 103 insertions, 111 deletions

diff --git a/memex/diff.go b/memex/diff.go
index d6cd760..7608cc6 100644
--- a/memex/diff.go
+++ b/memex/diff.go
@@ -157,7 +157,7 @@ func simpleDiff(e1, e2 *Entry) (flds int, skip bool) {
 			}
 		}
 	case Elnk:
-		if e1.Link != e2.Link {
+		if e1.Dest != e2.Dest {
 			flds |= Flink
 		}
 	case Edir:
diff --git a/memex/fsys.go b/memex/fsys.go
index 1addcff..520049e 100644
--- a/memex/fsys.go
+++ b/memex/fsys.go
@@ -33,7 +33,7 @@ func makeFsEntry(abs string, finfo os.FileInfo) (Entry, error) {
 		if err != nil {
 			return ent, err
 		}
-		ent.Link = res
+		ent.Dest = res
 	case syscall.S_IFDIR:
 		ent.Kind = Edir
 		ent.Size = 0
diff --git a/memex/main.go b/memex/main.go
index 6c5c8cd..d4903fe 100644
--- a/memex/main.go
+++ b/memex/main.go
@@ -29,7 +29,7 @@ type Entry struct {
 	Mode int
 	Size int64
 	Msec int64
-	Link string /* in case of links */
+	Dest string /* for symbolic links */
 	Addr Addr
 	Xxh  uint64 /* checksum for regular files */
 }
@@ -57,10 +57,10 @@ func (k EntryKind) String() string {
 }
 
 func errf(msg string, objs ...interface{}) {
-	fmt.Fprintf(os.Stderr, "error!  "+msg+"\n", objs...)
+	fmt.Fprintf(os.Stderr, "error: "+msg+"\n", objs...)
 }
 
-/* modify a revision, scanned using the Walker argument, to add
+/* 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)
  */
@@ -215,7 +215,7 @@ func addCommit(args commitArgs, head Addr) (new Addr, err error) {
 
 	startInfo := func() func() {
 		return InfoLoop(func() {
-			fmt.Printf("writing: %s ", BytesString(a.nin))
+			fmt.Printf("writing: %s ", BytesString(a.nbytes))
 		})
 	}
 
@@ -323,7 +323,7 @@ func walkEnt(w Walker, ent *Entry, verbose bool) {
 	fmt.Println(name)
 	if verbose {
 		if ent.Kind == Elnk {
-			fmt.Printf("  %s %s\n", ent.Kind, ent.Link)
+			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))
@@ -679,7 +679,7 @@ func syncFs(cs []Change, rd SdarReader) error {
 					err = os.Mkdir(abs, 0777)
 				}
 			case Elnk:
-				err = os.Symlink(c.e2.Link, abs)
+				err = os.Symlink(c.e2.Dest, abs)
 			case Ereg:
 				err = syncFile(abs, c.e2.Addr, rd)
 			}
@@ -988,7 +988,7 @@ func tarAt(w Walker, rd SdarReader, tw *tar.Writer) (err error) {
 		hdr := &tar.Header{
 			Typeflag: tar.TypeSymlink,
 			Name:     w.Path(),
-			Linkname: ent.Link,
+			Linkname: ent.Dest,
 			ModTime:  time.Unix(ent.Msec, 0),
 		}
 		err = tw.WriteHeader(hdr)
@@ -1134,7 +1134,7 @@ func resetCmd(args resetArgs) int {
 }
 
 func main() {
-	findSdar()
+	FindSdarBin()
 
 	if len(os.Args) < 2 {
 		errf("subcommand expected")
diff --git a/memex/misc.go b/memex/misc.go
index 78adb5c..ad89498 100644
--- a/memex/misc.go
+++ b/memex/misc.go
@@ -10,8 +10,8 @@ import (
 func InfoLoop(line func()) func() {
 	delay := 100 * time.Millisecond
 
-	fi, _ := os.Stdout.Stat()
-	if (fi.Mode() & os.ModeCharDevice) == 0 {
+	finfo, _ := os.Stdout.Stat()
+	if (finfo.Mode() & os.ModeCharDevice) == 0 {
 		return func() {}
 	}
 
@@ -77,3 +77,9 @@ func (c *Counted) Write(buf []byte) (int, error) {
 	*c.p += int64(n)
 	return n, err
 }
+
+/* Only safe when the underlying Writer is itself
+ * a Closer */
+func (c *Counted) Close() error {
+	return c.w.(io.Closer).Close()
+}
diff --git a/memex/pack.go b/memex/pack.go
index 8f2511f..b7316fb 100644
--- a/memex/pack.go
+++ b/memex/pack.go
@@ -174,7 +174,7 @@ var entryPackets = map[EntryKind][]Field{
 	},
 	Elnk: []Field{
 		Field{"Name", Fstring},
-		Field{"Link", Fstring},
+		Field{"Dest", Fstring},
 	},
 	Edir: []Field{
 		Field{"Addr", Faddr},
diff --git a/memex/revs.go b/memex/revs.go
index 065f09f..0ac1dc0 100644
--- a/memex/revs.go
+++ b/memex/revs.go
@@ -46,7 +46,7 @@ var commits []string
 
 /* Build a commit cache by walking all the refs */
 func makeCache(r SdarReader) {
-	commits = ReadCommitCache(r.ArchPath())
+	commits = ReadCommitCache(r.archive_path)
 
 	newcs := make(map[string]struct{})
 	add := func(a string) bool {
@@ -59,8 +59,8 @@ func makeCache(r SdarReader) {
 		return ok
 	}
 
-	for _, ref := range AllRefs(r.ArchPath()) {
-		a, err := ReadRef(r.ArchPath(), ref)
+	for _, ref := range AllRefs(r.archive_path) {
+		a, err := ReadRef(r.archive_path, ref)
 		for err == nil && !add(a.String()) {
 			var c Commit
 			c, err = r.ReadCommit(a)
@@ -73,7 +73,7 @@ func makeCache(r SdarReader) {
 	}
 	sort.Strings(commits)
 	if len(newcs) > 0 {
-		WriteCommitCache(r.ArchPath(), commits)
+		WriteCommitCache(r.archive_path, commits)
 	}
 }
 
@@ -83,7 +83,7 @@ func baseAddr(ref string, r SdarReader) (Addr, error) {
 	if ref == "." {
 		ref = config.Sync
 	}
-	addr, err := ReadRef(r.ArchPath(), ref)
+	addr, err := ReadRef(r.archive_path, ref)
 	if err == nil {
 		return addr, nil
 	}
diff --git a/memex/sdar.go b/memex/sdar.go
index e2961ba..87be3ae 100644
--- a/memex/sdar.go
+++ b/memex/sdar.go
@@ -15,8 +15,6 @@ import (
 	"xxhash"
 )
 
-var SdarPath string
-
 const logIo = false
 
 /* Tags used in serialized memex packets;
@@ -30,19 +28,27 @@ const (
 /* The first byte is the level in {0,1,2} */
 type Addr []byte
 
-type Sdar struct {
+type SdarProcess struct {
 	*exec.Cmd
-	in   io.Writer
-	out  io.Reader
-	clo  io.Closer
-	nin  int64 /* how many bytes went through in */
-	sub  string
-	arch string
+	input        io.WriteCloser
+	output       io.Reader
+	command      string /* sub command name */
+	archive_path string
+}
+type SdarAdder struct {
+	*SdarProcess
+	nbytes int64 /* how many bytes went in */
+}
+type SdarReader struct{ *SdarProcess }
+
+type SdarProcessFailure struct {
+	command string
+	code    int
 }
-type SdarAdder struct{ *Sdar }
-type SdarReader struct{ *Sdar }
 
 var (
+	SdarPath string
+
 	readError  = errors.New("sdar read failed")
 	checkError = errors.New("sdar check failed")
 	addError   = errors.New("sdar add failed")
@@ -63,6 +69,10 @@ func (a Addr) String() string {
 
 var ZeroAddr Addr = make([]byte, 33)
 
+func (e SdarProcessFailure) Error() string {
+	return fmt.Sprintf("sdar %s exited with code %d", e.command, e.code)
+}
+
 func (a Addr) IsZero() bool {
 	return bytes.Equal(a, ZeroAddr)
 }
@@ -74,7 +84,7 @@ func AddrEqual(a1, a2 Addr) bool {
 	return bytes.Equal(a1, a2)
 }
 
-func findSdar() {
+func FindSdarBin() {
 	if SdarPath != "" {
 		return
 	}
@@ -101,18 +111,8 @@ func findSdar() {
 	panic("cannot find sdar")
 }
 
-func readReady(out io.Reader) bool {
-	var buf [8]byte
-	_, err := io.ReadFull(out, buf[:])
-	if err != nil || string(buf[:]) != "06ready\n" {
-		return false
-	}
-	return true
-}
-
-func startSdar(args ...string) (*Sdar, error) {
-	args = append(args, "-b")
-	cmd := exec.Command(SdarPath, args...)
+func startSdar(command, archive_path string) (*SdarProcess, error) {
+	cmd := exec.Command(SdarPath, command, "-b", "-a", archive_path)
 	cmd.Stderr = os.Stderr
 	op, err := cmd.StdoutPipe()
 	if err != nil {
@@ -126,16 +126,17 @@ func startSdar(args ...string) (*Sdar, error) {
 	if err := cmd.Start(); err != nil {
 		return nil, err
 	}
-	sdar := &Sdar{
-		Cmd:  cmd,
-		sub:  args[0],
-		in:   ip,
-		out:  op,
-		clo:  ip,
-		arch: "",
+	sdar := &SdarProcess{
+		Cmd:          cmd,
+		command:      command,
+		input:        ip,
+		output:       op,
+		archive_path: archive_path,
 	}
 
-	if !readReady(sdar.out) {
+	var buf [8]byte
+	_, err = io.ReadFull(sdar.output, buf[:])
+	if err != nil || string(buf[:]) != "06ready\n" {
 		err = sdar.Done()
 		if err == nil {
 			err = protoError
@@ -146,22 +147,17 @@ func startSdar(args ...string) (*Sdar, error) {
 	return sdar, nil
 }
 
-func (sdar *Sdar) Done() error {
-	sdar.clo.Close()
+func (sdar *SdarProcess) Done() error {
+	sdar.input.Close()
 	err := sdar.Wait()
 	if err == nil {
 		return nil
 	}
-	var exiterr *exec.ExitError
-	if !errors.As(err, &exiterr) {
+	var eerr *exec.ExitError
+	if !errors.As(err, &eerr) {
 		return err
 	}
-	code := exiterr.ExitCode()
-	return fmt.Errorf("sdar %s exited with code %d", sdar.sub, code)
-}
-
-func (sdar *Sdar) ArchPath() string {
-	return sdar.arch
+	return SdarProcessFailure{sdar.command, eerr.ExitCode()}
 }
 
 /* Use this counter to prevent multiple concurrent write
@@ -175,39 +171,32 @@ func startWriteOp() {
 	writeOps++
 }
 
-func SdarCommit(apath, msg string) error {
+func SdarCommit(archive_path, msg string) error {
 	startWriteOp()
 	defer func() { writeOps-- }()
-	c := exec.Command(SdarPath, "commit", "-a", apath, "-m", msg)
+	c := exec.Command(SdarPath, "commit", "-a", archive_path, "-m", msg)
 	c.Stdin = nil
 	c.Stdout = os.Stdout
 	c.Stderr = os.Stderr
 	return c.Run()
 }
 
-func MakeAdder(apath string) (SdarAdder, error) {
+func MakeAdder(archive_path string) (SdarAdder, error) {
 	startWriteOp()
-	sdar, err := startSdar("add", "-a", apath)
-	if err != nil {
-		return SdarAdder{}, err
-	}
-	sdar.in = &Counted{&sdar.nin, sdar.in}
-	sdar.arch = apath
-	return SdarAdder{sdar}, nil
+	sdar, err := startSdar("add", archive_path)
+	adder := SdarAdder{sdar, 0}
+	adder.input = &Counted{&adder.nbytes, adder.input}
+	return adder, err
 }
 
 func (a *SdarAdder) Done() error {
 	defer func() { writeOps = 0 }()
-	return a.Sdar.Done()
+	return a.SdarProcess.Done()
 }
 
-func MakeReader(apath string) (SdarReader, error) {
-	sdar, err := startSdar("read", "-a", apath)
-	if err != nil {
-		return SdarReader{}, err
-	}
-	sdar.arch = apath
-	return SdarReader{sdar}, nil
+func MakeReader(archive_path string) (SdarReader, error) {
+	sdar, err := startSdar("read", archive_path)
+	return SdarReader{sdar}, err
 }
 
 const AddrDisplayLen = 65
@@ -250,7 +239,7 @@ func readPkt(r io.Reader) []byte {
 }
 
 func (a SdarAdder) getAddr() (Addr, error) {
-	ans := readPkt(a.out)
+	ans := readPkt(a.output)
 	if len(ans) < 3 {
 		return nil, protoError
 	}
@@ -268,7 +257,7 @@ func (a SdarAdder) getAddr() (Addr, error) {
 	}
 }
 
-func makePkt(msg string, args ...interface{}) string {
+func (sp *SdarProcess) sendPkt(msg string, args ...interface{}) error {
 	pkt := fmt.Sprintf(msg+"\n", args...)
 	if len(pkt) > 255 {
 		panic("pkt too long")
@@ -277,15 +266,15 @@ func makePkt(msg string, args ...interface{}) string {
 	if logIo {
 		log.Println("=>", pkt)
 	}
-	return pkt
+	_, err := io.WriteString(sp.input, pkt)
+	return err
 }
 
 func (a SdarAdder) AddBuffer(b *bytes.Buffer) (Addr, error) {
-	msg := makePkt("raw %d", b.Len())
-	if _, err := io.WriteString(a.in, msg); err != nil {
+	if err := a.sendPkt("raw %d", b.Len()); err != nil {
 		return nil, err
 	}
-	if _, err := b.WriteTo(a.in); err != nil {
+	if _, err := b.WriteTo(a.input); err != nil {
 		return nil, err
 	}
 	return a.getAddr()
@@ -293,7 +282,7 @@ func (a SdarAdder) AddBuffer(b *bytes.Buffer) (Addr, error) {
 
 func (r SdarReader) writeStreamTo(limit int, w io.Writer) error {
 	for {
-		ans := readPkt(r.out)
+		ans := readPkt(r.output)
 		if len(ans) < 3 {
 			return protoError
 		}
@@ -312,18 +301,19 @@ func (r SdarReader) writeStreamTo(limit int, w io.Writer) error {
 			if err != nil || (limit >= 0 && nb > limit) {
 				return protoError
 			}
-			n, err := io.CopyN(w, r.out, int64(nb))
+			n, err := io.CopyN(w, r.output, int64(nb))
 			if int(n) != nb || err != nil {
 				return protoError
 			}
-			limit -= int(n)
+			if limit >= 0 {
+				limit -= int(n)
+			}
 		}
 	}
 }
 
 func (r SdarReader) WriteTo(addr Addr, w io.Writer) error {
-	msg := makePkt("%v", addr)
-	if _, err := io.WriteString(r.in, msg); err != nil {
+	if err := r.sendPkt("%v", addr); err != nil {
 		return err
 	}
 	return r.writeStreamTo(-1, w)
@@ -333,8 +323,7 @@ func (r SdarReader) ReadObject(b []byte, addr Addr, off int64) (int, error) {
 	if !addr.Ok() {
 		panic("invalid address")
 	}
-	msg := makePkt("%v %d %d", addr, off, len(b))
-	if _, err := io.WriteString(r.in, msg); err != nil {
+	if err := r.sendPkt("%v %d %d", addr, off, len(b)); err != nil {
 		return 0, err
 	}
 	buf := bytes.NewBuffer(b[:0])
@@ -346,8 +335,7 @@ func (r SdarReader) ReadAll(addr Addr) (*bytes.Buffer, error) {
 	if !addr.Ok() {
 		panic("invalid address")
 	}
-	msg := makePkt("%v", addr)
-	if _, err := io.WriteString(r.in, msg); err != nil {
+	if err := r.sendPkt("%v", addr); err != nil {
 		return nil, err
 	}
 	var buf bytes.Buffer
@@ -393,24 +381,24 @@ func SizedWriteTo(w io.Writer, r io.Reader, size int64) (int64, error) {
 }
 
 type SdarWalker struct {
-	rd  SdarReader
-	rel string
-	ent Entry
+	reader SdarReader
+	path   string
+	entry  Entry
 }
 
 func (walk *SdarWalker) Path() string {
-	return walk.rel
+	return walk.path
 }
 
 func (walk *SdarWalker) Here() *Entry {
-	return &walk.ent
+	return &walk.entry
 }
 
 func (walk *SdarWalker) Dive() ([]Walker, error) {
-	if walk.ent.Kind != Edir {
+	if walk.entry.Kind != Edir {
 		return nil, nil
 	}
-	b, err := walk.rd.ReadAll(walk.ent.Addr)
+	b, err := walk.reader.ReadAll(walk.entry.Addr)
 	if err != nil {
 		return nil, err
 	}
@@ -427,12 +415,12 @@ func (walk *SdarWalker) Dive() ([]Walker, error) {
 	}
 	ents := make([]Walker, nent)
 	for i := int64(0); i < nent; i++ {
-		w := SdarWalker{rd: walk.rd}
-		err := readEntry(b, &w.ent)
+		w := SdarWalker{reader: walk.reader}
+		err := readEntry(b, &w.entry)
 		if err != nil {
 			return ents[:i], err
 		}
-		w.rel = path.Join(walk.rel, w.ent.Name)
+		w.path = path.Join(walk.path, w.entry.Name)
 		ents[i] = &w
 	}
 	return ents, nil
@@ -453,18 +441,17 @@ func MakeSdarWalker(commit Addr, r SdarReader) (Walker, error) {
 	return MakeCommitWalker(&c, r), nil
 }
 
-func (a SdarAdder) addReg(abs string, sz int64) (Addr, uint64, error) {
-	f, err := os.Open(abs)
+func (a SdarAdder) addReg(fpath string, sz int64) (Addr, uint64, error) {
+	f, err := os.Open(fpath)
 	if err != nil {
 		return nil, 0, err
 	}
 	defer f.Close()
-	msg := makePkt("raw %d", sz)
-	if _, err = io.WriteString(a.in, msg); err != nil {
+	if err = a.sendPkt("raw %d", sz); err != nil {
 		return nil, 0, err
 	}
 	digest := xxhash.New()
-	w := io.MultiWriter(a.in, digest)
+	w := io.MultiWriter(a.input, digest)
 	if _, err = SizedWriteTo(w, f, sz); err != nil {
 		return nil, 0, err
 	}
@@ -479,9 +466,8 @@ func (a SdarAdder) addFsData(w Walker) (Addr, uint64, error) {
 	default:
 		panic("unreachable")
 	case Ereg:
-		root := config.Root
-		eabs := path.Join(root, w.Path())
-		return a.addReg(eabs, e.Size)
+		fpath := path.Join(config.Root, w.Path())
+		return a.addReg(fpath, e.Size)
 	case Elnk:
 		return nil, 0, nil
 	case Edir: