feat(logbook): add logbook inspection structs & methods

working in flatbuffers brings the burden of needing diagnostic struct methods. Might as well lay the foundations for a logbook subcommand while we're at it

also, fixes a number of bugs, adds a bunch of tests.

actions/dataset_test.go

@@ -96,11 +96,11 @@ func TestAddDataset(t *testing.T) {
 func TestDataset(t *testing.T) {
 	rmf := func(t *testing.T) repo.Repo {
 		store := cafs.NewMapstore()
+		testPeerProfile.PrivKey = privKey
 		mr, err := repo.NewMemRepo(testPeerProfile, store, qfs.NewMemFS(), profile.NewMemStore())
 		if err != nil {
 			panic(err)
 		}
-		// mr.SetPrivateKey(privKey)
 		return mr
 	}
 	DatasetTests(t, rmf)

logbook/log/log.go

@@ -33,16 +33,17 @@ import (
 // authors, forming a conflict-free replicated data type (CRDT), and a basis
 // for collaboration through knowledge of each other's operations
 type Book struct {
-	authorname string
-	id         string
 	pk         crypto.PrivKey
+	id         string
+	authorname string
 	logs       map[uint32][]*Log
 }
 
 // NewBook initializes a Book
 func NewBook(pk crypto.PrivKey, authorname, authorID string) (*Book, error) {
 	return &Book{
 		pk:         pk,
+		id:         authorID,
 		authorname: authorname,
 		logs:       map[uint32][]*Log{},
 	}, nil
@@ -63,6 +64,11 @@ func (book *Book) AppendLog(l *Log) {
 	book.logs[l.Model()] = append(book.logs[l.Model()], l)
 }
 
+// Logs returns the full map of logs keyed by model type
+func (book *Book) Logs() map[uint32][]*Log {
+	return book.logs
+}
+
 // ModelLogs gives all sets whoe model type matches model
 func (book *Book) ModelLogs(model uint32) []*Log {
 	return book.logs[model]
@@ -164,8 +170,8 @@ func (book Book) marshalFlatbuffer(builder *flatbuffers.Builder) flatbuffers.UOf
 func (book *Book) unmarshalFlatbuffer(b *logfb.Book) error {
 	newBook := Book{
 		pk:         book.pk,
-		authorname: string(b.Name()),
 		id:         string(b.Identifier()),
+		authorname: string(b.Name()),
 		logs:       map[uint32][]*Log{},
 	}
 
@@ -195,15 +201,15 @@ func (book Book) logsSlice() (logs []*Log) {
 // Log is a causally-ordered set of operations performed by a single author.
 // log attribution is verified by an author's signature
 type Log struct {
-	signature []byte
-	ops       []Op
-	logs      []*Log
+	Signature []byte
+	Ops       []Op
+	Logs      []*Log
 }
 
 // InitLog creates a Log from an initialization operation
 func InitLog(initop Op) *Log {
 	return &Log{
-		ops: []Op{initop},
+		Ops: []Op{initop},
 	}
 }
 
@@ -216,38 +222,33 @@ func FromFlatbufferBytes(data []byte) (*Log, error) {
 
 // Append adds an operation to the log
 func (lg *Log) Append(op Op) {
-	lg.ops = append(lg.ops, op)
-}
-
-// Len returns the number of of the latest entry in the log
-func (lg Log) Len() int {
-	return len(lg.ops)
+	lg.Ops = append(lg.Ops, op)
 }
 
 // Model gives the operation type for a log, based on the first operation
 // written to the log. Logs can contain multiple models of operations, but the
 // first operation written to a log determines the kind of log for
 // catagorization purposes
 func (lg Log) Model() uint32 {
-	return lg.ops[0].Model
+	return lg.Ops[0].Model
 }
 
 // Author returns the name and identifier this log is attributed to
 func (lg Log) Author() (name, identifier string) {
-	return lg.ops[0].Name, lg.ops[0].AuthorID
+	return lg.Ops[0].Name, lg.Ops[0].AuthorID
 }
 
 // Name returns the human-readable name for this log, determined by the
 // initialization event
 // TODO (b5) - name must be made mutable by playing forward any name-changing
 // operations and applying them to the log
 func (lg Log) Name() string {
-	return lg.ops[0].Name
+	return lg.Ops[0].Name
 }
 
 // Child returns a child log for a given name, and nil if it doesn't exist
 func (lg Log) Child(name string) *Log {
-	for _, l := range lg.logs {
+	for _, l := range lg.Logs {
 		if l.Name() == name {
 			return l
 		}
@@ -257,12 +258,12 @@ func (lg Log) Child(name string) *Log {
 
 // AddChild appends a log as a direct descendant of this log
 func (lg *Log) AddChild(l *Log) {
-	lg.logs = append(lg.logs, l)
+	lg.Logs = append(lg.Logs, l)
 }
 
 // Verify confirms that the signature for a log matches
 func (lg Log) Verify(pub crypto.PubKey) error {
-	ok, err := pub.Verify(lg.SigningBytes(), lg.signature)
+	ok, err := pub.Verify(lg.SigningBytes(), lg.Signature)
 	if err != nil {
 		return err
 	}
@@ -272,17 +273,12 @@ func (lg Log) Verify(pub crypto.PubKey) error {
 	return nil
 }
 
-// Ops gives the set of operations in a log
-func (lg Log) Ops() []Op {
-	return lg.ops
-}
-
 // Sign assigns the log signature by signing the logging checksum with a given
 // private key
 // TODO (b5) - this is assuming the log is authored by this private key. as soon
 // as we add collaborators, this won't be true
 func (lg *Log) Sign(pk crypto.PrivKey) (err error) {
-	lg.signature, err = pk.Sign(lg.SigningBytes())
+	lg.Signature, err = pk.Sign(lg.SigningBytes())
 	if err != nil {
 		return err
 	}
@@ -293,7 +289,7 @@ func (lg *Log) Sign(pk crypto.PrivKey) (err error) {
 // SigningBytes perpares a byte slice for signing from a log's operations
 func (lg Log) SigningBytes() []byte {
 	hasher := md5.New()
-	for _, op := range lg.ops {
+	for _, op := range lg.Ops {
 		hasher.Write([]byte(op.Ref))
 	}
 	return hasher.Sum(nil)
@@ -315,9 +311,9 @@ func (lg Log) SignedFlatbufferBytes(pk crypto.PrivKey) ([]byte, error) {
 // offset
 func (lg Log) MarshalFlatbuffer(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	// build logs bottom up, collecting offsets
-	logcount := len(lg.logs)
+	logcount := len(lg.Logs)
 	logoffsets := make([]flatbuffers.UOffsetT, logcount)
-	for i, o := range lg.logs {
+	for i, o := range lg.Logs {
 		logoffsets[i] = o.MarshalFlatbuffer(builder)
 	}
 
@@ -330,11 +326,11 @@ func (lg Log) MarshalFlatbuffer(builder *flatbuffers.Builder) flatbuffers.UOffse
 	namestr, idstr := lg.Author()
 	name := builder.CreateString(namestr)
 	id := builder.CreateString(idstr)
-	signature := builder.CreateByteString(lg.signature)
+	signature := builder.CreateByteString(lg.Signature)
 
-	count := len(lg.ops)
+	count := len(lg.Ops)
 	offsets := make([]flatbuffers.UOffsetT, count)
-	for i, o := range lg.ops {
+	for i, o := range lg.Ops {
 		offsets[i] = o.MarshalFlatbuffer(builder)
 	}
 
@@ -353,29 +349,35 @@ func (lg Log) MarshalFlatbuffer(builder *flatbuffers.Builder) flatbuffers.UOffse
 	return logfb.LogEnd(builder)
 }
 
-// UnmarshalFlatbuffer reads a Log from
+// UnmarshalFlatbufferBytes is a convenince wrapper to deserialze a flatbuffer
+// slice into a log
+func (lg *Log) UnmarshalFlatbufferBytes(data []byte) error {
+	return lg.UnmarshalFlatbuffer(logfb.GetRootAsLog(data, 0))
+}
+
+// UnmarshalFlatbuffer populates a logfb.Log from a Log pointer
 func (lg *Log) UnmarshalFlatbuffer(lfb *logfb.Log) (err error) {
 	newLg := Log{}
 
 	if len(lfb.Signature()) != 0 {
-		newLg.signature = lfb.Signature()
+		newLg.Signature = lfb.Signature()
 	}
 
-	newLg.ops = make([]Op, lfb.OpsetLength())
+	newLg.Ops = make([]Op, lfb.OpsetLength())
 	opfb := &logfb.Operation{}
 	for i := 0; i < lfb.OpsetLength(); i++ {
 		if lfb.Opset(opfb, i) {
-			newLg.ops[i] = UnmarshalOpFlatbuffer(opfb)
+			newLg.Ops[i] = UnmarshalOpFlatbuffer(opfb)
 		}
 	}
 
 	if lfb.LogsLength() > 0 {
-		newLg.logs = make([]*Log, lfb.LogsLength())
+		newLg.Logs = make([]*Log, lfb.LogsLength())
 		childfb := &logfb.Log{}
 		for i := 0; i < lfb.LogsLength(); i++ {
 			if lfb.Logs(childfb, i) {
-				newLg.logs[i] = &Log{}
-				newLg.logs[i].UnmarshalFlatbuffer(childfb)
+				newLg.Logs[i] = &Log{}
+				newLg.Logs[i].UnmarshalFlatbuffer(childfb)
 			}
 		}
 	}

logbook/log/log_test.go

@@ -31,7 +31,7 @@ func TestBookFlatbuffer(t *testing.T) {
 		Size:      2,
 		Note:      "note!",
 	})
-	log.signature = []byte{1, 2, 3}
+	log.Signature = []byte{1, 2, 3}
 
 	log.AddChild(InitLog(Op{
 		Type:      OpTypeInit,