[logdog/common/types] custom JSON encoding to allow streamaddr to be zero.

logdog/common/types/streamaddr.go

 // Copyright 2017 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package types
 
 import (
+        "bytes"
+        "encoding/json"
         "flag"
         "net/url"
         "strings"
 
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
 )
 
 const logDogURLScheme = "logdog"
 
 // StreamAddr is a fully-qualified LogDog stream address.
 type StreamAddr struct {
         // Host is the LogDog host.
-        Host string
+        Host string `json:"host"`
 
         // Project is the LUCI project name that this log belongs to.
-        Project cfgtypes.ProjectName
+        Project cfgtypes.ProjectName `json:"project"`
 
         // Path is the LogDog stream path.
-        Path StreamPath
+        Path StreamPath `json:"path"`
 }
 
 var _ flag.Value = (*StreamAddr)(nil)
 
 // Set implements flag.Value
 func (s *StreamAddr) Set(v string) error {
         a, err := ParseURL(v)
         if err != nil {
                 return err
         }
@@ skipping 25 matching lines @@
 
 // URL returns a LogDog URL that represents this Stream.
 func (s *StreamAddr) URL() *url.URL {
         return &url.URL{
                 Scheme: logDogURLScheme,
                 Host:   s.Host,
                 Path:   strings.Join([]string{"", string(s.Project), string(s.Path)}, "/"),
         }
 }
 
+// jsonStreamAddr is used to allow type checking during deserialization, but
+// special casing IsZero == 'null'.
+type jsonStreamAddr struct {

[dnj, 2017/05/23 15:28:19]

This is unfortunate. Are you opposed to using "omitempty" in all of the fields
and settling for an empty object instead of null?

addr: null
addr: {}

The latter isn't any less descriptive to me, and null will still unmarshal just
fine.

+        Host    string               `json:"host"`
+        Project cfgtypes.ProjectName `json:"project"`
+        Path    StreamPath           `json:"path"`
+}
+
+// MarshalJSON implements json.Marshaler
+func (s StreamAddr) MarshalJSON() ([]byte, error) {
+        if s.IsZero() {
+                return []byte(`null`), nil
+        }
+        // TODO(iannucci): when we support go 1.8 on appengine, this can be written as
+        //   json.Marshal((*jsonStreamAddr)(s)).
+        jsa := jsonStreamAddr{s.Host, s.Project, s.Path}
+        return json.Marshal(jsa)
+}
+
+// UnmarshalJSON implements json.Marshaler
+func (s *StreamAddr) UnmarshalJSON(d []byte) error {
+        if bytes.Equal(d, []byte(`null`)) {
+                s.Host = ""
+                s.Project = ""
+                s.Path = ""
+                return nil
+        }
+        // TODO(iannucci): when we support go 1.8 on appengine, this can be written as
+        //   return json.Unmarshal(d, (*jsonStreamAddr)(s))
+        jsa := jsonStreamAddr{}
+        if err := json.Unmarshal(d, &jsa); err != nil {
+                return err
+        }
+        s.Host = jsa.Host
+        s.Project = jsa.Project
+        s.Path = jsa.Path
+        return nil
+}
+
 // ParseURL parses a LogDog URL into a Stream. If the URL is malformed, or
 // if the host, project, or path is invalid, an error will be returned.
 //
 // A LogDog URL has the form:
 // logdog://<host>/<project>/<prefix>/+/<name>
 func ParseURL(v string) (*StreamAddr, error) {
         u, err := url.Parse(v)
         if err != nil {
                 return nil, errors.Annotate(err).Reason("failed to parse URL").Err()
         }
@@ skipping 23 matching lines @@
         }
 
         if err := addr.Path.Validate(); err != nil {
                 return nil, errors.Annotate(err).Reason("invalid stream path: %(path)q").
                         D("path", addr.Path).
                         Err()
         }
 
         return &addr, nil
 }