From e590c52e8b0ed88b12d05202da4f6b43d4993fdd Mon Sep 17 00:00:00 2001
From: Jordan Orelli <jordanorelli@gmail.com>
Date: Sat, 30 Jul 2016 12:22:52 -0400
Subject: [PATCH] there's an envelope missing

manta looks like it's parsing an envelope type manually instead of
defining a proto definition for it. next step is to try to synthesize
that definition based on the manta code. it appears to be as follows:

message Envelope {
    required EDemoCommands command = 1;
    required varint tick = 2;
    required varint size = 3;
    required bytes body = 4;
}

or something to that effect. Reading protobuf primitives off the wire
manually is looney-bins.
---
 main.go   |  2 +-
 parser.go | 26 ++++++++++++++++++++++++--
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/main.go b/main.go
index fb533fb..fa18eb8 100644
--- a/main.go
+++ b/main.go
@@ -69,7 +69,7 @@ func main() {
 	}
 
 	p := newParser(r)
-	if _, err := p.checkHeader(); err != nil {
+	if err := p.start(); err != nil {
 		bail(1, "parse error: %v", err)
 	}
 }
diff --git a/parser.go b/parser.go
index 7788b4e..dfa01c9 100644
--- a/parser.go
+++ b/parser.go
@@ -8,17 +8,39 @@ import (
 type parser struct {
 	// the source of replay bytes. Must NOT be compressed.
 	source io.Reader
+
+	// re-useable scratch buffer. Contents never guaranteed to be clean.
+	scratch []byte
 }
 
 func newParser(r io.Reader) *parser {
-	return &parser{source: r}
+	return &parser{source: r, scratch: make([]byte, 1<<10)}
+}
+
+func (p *parser) start() error {
+	ok, err := p.checkHeader()
+	if err != nil {
+		return fmt.Errorf("parser start error: %v", err)
+	}
+	if !ok {
+		return fmt.Errorf("parser start error: invalid header")
+	}
+	return nil
 }
 
 // checks whether we have an acceptable header at the current reader position.
 func (p *parser) checkHeader() (bool, error) {
-	buf := make([]byte, 8)
+	buf := p.scratch[:8]
 	if _, err := p.source.Read(buf); err != nil {
 		return false, fmt.Errorf("unable to read header bytes: %v", err)
 	}
 	return string(buf) == replay_header, nil
 }
+
+// skips n bytes in the underlying source
+func (p *parser) skip(n int) error {
+	if _, err := p.source.Read(p.scratch[:n]); err != nil {
+		return fmt.Errorf("unable to skip %d bytes: %v", n, err)
+	}
+	return nil
+}