LogDog: Add collector service implementation.

common/logdog/butlerproto/proto.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package butlerproto
 
 import (
         "bytes"
         "compress/zlib"
         "errors"
@@ skipping 108 matching lines @@
                 return err
         }
 
         switch r.Metadata.Type {
         case protocol.ButlerMetadata_ButlerLogBundle:
                 data, err := r.readData(fr)
                 if err != nil {
                         return fmt.Errorf("butlerproto: failed to read Bundle data: %s", err)
                 }
 
-                if r.Metadata.ProtoVersion != protocol.Version {
-                        return fmt.Errorf("butlerproto: unknown protobuf version (%q != %q)",
-                                r.Metadata.ProtoVersion, protocol.Version)
+                if r.Metadata.ProtoVersion == protocol.Version {

[dnj (Google), 2016/01/21 04:36:24]

Instead of rejecting messages without a known version, it will just not try and
parse them.

The Collector will reject the messages that have unknown versions.

+                        bundle := protocol.ButlerLogBundle{}
+                        if err := proto.Unmarshal(data, &bundle); err != nil {
+                                return fmt.Errorf("butlerproto: failed to unmarshal Bundle frame: %s", err)
+                        }
+                        r.Bundle = &bundle
                 }
-
-                bundle := protocol.ButlerLogBundle{}
-                if err := proto.Unmarshal(data, &bundle); err != nil {
-                        return fmt.Errorf("butlerproto: failed to unmarshal Bundle frame: %s", err)
-                }
-                r.Bundle = &bundle
                 return nil
 
         default:
                 return fmt.Errorf("butlerproto: unknown data type: %s", r.Metadata.Type)
         }
 }
 
 // limitErrorReader is similar to io.LimitReader, except that it returns
 // a custom error instead of io.EOF.
 //
@@ skipping 13 matching lines @@
         }
         n, err := r.Reader.Read(p)
         r.limit -= int64(n)
         return n, err
 }
 
 // Writer writes Butler messages that the Reader can read.
 type Writer struct {
         protoBase
 
+        // ProtoVersion is the protocol version string to use. If empty, the current

[dnj (Google), 2016/01/21 04:36:24]

Useful for testing: "hey, pretend that you wrote this version".

+        // ProtoVersion will be used.
+        ProtoVersion string
+
         // Compress, if true, allows the Writer to choose to compress data when
         // applicable.
         Compress bool
 
         // CompressThreshold is the minimum size that data must be in order to
         CompressThreshold int
 
         compressBuf    bytes.Buffer
         compressWriter *zlib.Writer
 }
 
 func (w *Writer) writeData(fw recordio.Writer, t protocol.ButlerMetadata_ContentType, data []byte) error {
         if int64(len(data)) > w.getMaxSize() {
                 return fmt.Errorf("butlerproto: serialized size exceeds soft cap (%d > %d)", len(data), w.getMaxSize())
         }
 
+        pv := w.ProtoVersion
+        if pv == "" {
+                pv = protocol.Version
+        }
         md := protocol.ButlerMetadata{
                 Type:         t,
-                ProtoVersion: protocol.Version,
+                ProtoVersion: pv,
         }
 
         // If we're configured to compress and the data is below our threshold,
         // compress.
         if w.Compress && len(data) >= w.CompressThreshold {
                 w.compressBuf.Reset()
                 if w.compressWriter == nil {
                         w.compressWriter = zlib.NewWriter(&w.compressBuf)
                 } else {
                         w.compressWriter.Reset(&w.compressBuf)
@@ skipping 43 matching lines @@
 
 // WriteWith writes a ButlerLogBundle to the supplied recordio.Writer.
 func (w *Writer) WriteWith(fw recordio.Writer, b *protocol.ButlerLogBundle) error {
         data, err := proto.Marshal(b)
         if err != nil {
                 return fmt.Errorf("butlerproto: failed to marshal Bundle: %s", b)
         }
 
         return w.writeData(fw, protocol.ButlerMetadata_ButlerLogBundle, data)
 }