Handle unexpected entity fields gracefully.

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
         "reflect"
         "strconv"
         "strings"
         "sync"
         "unicode"
 
         "github.com/luci/luci-go/common/errors"
 )
 
 // Entities with more than this many indexed properties will not be saved.
 const maxIndexedProperties = 20000
 
 type structTag struct {
         name           string
         idxSetting     IndexSetting
         isSlice        bool
         substructCodec *structCodec
         convert        bool
         metaVal        interface{}
+        isExtra        bool
         canSet         bool
 }
 
 type structCodec struct {
-        byMeta   map[string]int
-        byName   map[string]int
+        byMeta    map[string]int
+        byName    map[string]int
+        bySpecial map[string]int
+
         byIndex  []structTag
         hasSlice bool
         problem  error
 }
 
 type structPLS struct {
         o reflect.Value
         c *structCodec
 }
 
 var _ PropertyLoadSaver = (*structPLS)(nil)
 
 // typeMismatchReason returns a string explaining why the property p could not
 // be stored in an entity field of type v.Type().
 func typeMismatchReason(val interface{}, v reflect.Value) string {
         entityType := reflect.TypeOf(val)
         return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
 }
 
 func (p *structPLS) Load(propMap PropertyMap) error {
         convFailures := errors.MultiError(nil)
 
+        useExtra := false
+        extra := (*PropertyMap)(nil)
+        if i, ok := p.c.bySpecial["extra"]; ok {
+                useExtra = true
+                f := p.c.byIndex[i]
+                if f.canSet {
+                        extra = p.o.Field(i).Addr().Interface().(*PropertyMap)
+                }
+        }
         t := reflect.Type(nil)
         for name, props := range propMap {
                 multiple := len(props) > 1
                 for i, prop := range props {
                         if reason := loadInner(p.c, p.o, i, name, prop, multiple); reason != "" {
-                                if t == nil {
-                                        t = p.o.Type()
+                                if useExtra {
+                                        if extra != nil {
+                                                if *extra == nil {
+                                                        *extra = make(PropertyMap, 1)
+                                                }
+                                                (*extra)[name] = props
+                                        }
+                                        break // go to the next property in propMap
+                                } else {
+                                        if t == nil {
+                                                t = p.o.Type()
+                                        }
+                                        convFailures = append(convFailures, &ErrFieldMismatch{
+                                                StructType: t,
+                                                FieldName:  name,
+                                                Reason:     reason,
+                                        })
                                 }
-                                convFailures = append(convFailures, &ErrFieldMismatch{
-                                        StructType: t,
-                                        FieldName:  name,
-                                        Reason:     reason,
-                                })
                         }
                 }
         }
 
         if len(convFailures) > 0 {
                 return convFailures
         }
 
         return nil
 }
@@ skipping 165 matching lines @@
                 if prop.IndexSetting() == ShouldIndex {
                         idxCount++
                         if idxCount > maxIndexedProperties {
                                 return errors.New("gae: too many indexed properties")
                         }
                 }
                 return nil
         }
 
         for i, st := range p.c.byIndex {
-                if st.name == "-" {
+                if st.name == "-" || st.isExtra {
                         continue
                 }
                 name := st.name
                 if prefix != "" {
                         name = prefix + name
                 }
                 v := p.o.Field(i)
                 is1 := is
                 if st.idxSetting == NoIndex {
                         is1 = NoIndex
                 }
                 if st.isSlice {
                         for j := 0; j < v.Len(); j++ {
                                 if err = saveProp(name, is1, v.Index(j), &st); err != nil {
                                         return
                                 }
                         }
                 } else {
                         if err = saveProp(name, is1, v, &st); err != nil {
                                 return
                         }
                 }
         }
+
+        if i, ok := p.c.bySpecial["extra"]; ok {
+                if p.c.byIndex[i].name != "-" {
+                        for fullName, vals := range p.o.Field(i).Interface().(PropertyMap) {
+                                if _, ok := propMap[fullName]; !ok {
+                                        propMap[fullName] = vals
+                                }
+                        }
+                }
+        }
+
         return
 }
 
 func (p *structPLS) GetMeta(key string) (interface{}, bool) {
         if idx, ok := p.c.byMeta[key]; ok {
                 if val, ok := p.getMetaFor(idx); ok {
                         return val, true
                 }
         } else if key == "kind" {
                 return p.getDefaultKind(), true
@@ skipping 122 matching lines @@
 func getStructCodecLocked(t reflect.Type) (c *structCodec) {
         if c, ok := structCodecs[t]; ok {
                 return c
         }
 
         me := func(fmtStr string, args ...interface{}) error {
                 return fmt.Errorf(fmtStr, args...)
         }
 
         c = &structCodec{
-                byIndex: make([]structTag, t.NumField()),
-                byName:  make(map[string]int, t.NumField()),
-                byMeta:  make(map[string]int, t.NumField()),
+                byIndex:   make([]structTag, t.NumField()),
+                byName:    make(map[string]int, t.NumField()),
+                byMeta:    make(map[string]int, t.NumField()),
+                bySpecial: make(map[string]int, 1),
 
                 problem: errRecursiveStruct, // we'll clear this later if it's not recursive
         }
         defer func() {
                 // If the codec has a problem, free up the indexes
                 if c.problem != nil {
                         c.byIndex = nil
                         c.byName = nil
                         c.byMeta = nil
                 }
         }()
         structCodecs[t] = c
 
         for i := range c.byIndex {
                 st := &c.byIndex[i]
                 f := t.Field(i)
                 ft := f.Type
 
                 name := f.Tag.Get("gae")
                 opts := ""
                 if i := strings.Index(name, ","); i != -1 {
                         name, opts = name[:i], name[i+1:]
                 }
                 st.canSet = f.PkgPath == "" // blank == exported
+                if opts == "extra" {
+                        if _, ok := c.bySpecial["extra"]; ok {
+                                c.problem = me("struct has multiple fields tagged as 'extra'")
+                                return
+                        }
+                        if name != "" && name != "-" {
+                                c.problem = me("struct 'extra' field has invalid name %s, expecing `` or `-`", name)
+                                return
+                        }
+                        if ft != typeOfPropertyMap {
+                                c.problem = me("struct 'extra' field has invalid type %s, expecing PropertyMap", ft)
+                                return
+                        }
+                        st.isExtra = true
+                        st.name = name
+                        c.bySpecial["extra"] = i
+                        continue
+                }
                 st.convert = reflect.PtrTo(ft).Implements(typeOfPropertyConverter)
                 switch {
                 case name == "":
                         if !f.Anonymous {
                                 name = f.Name
                         }
                 case name[0] == '$':
                         name = name[1:]
                         if _, ok := c.byMeta[name]; ok {
                                 c.problem = me("meta field %q set multiple times", "$"+name)
@@ skipping 124 matching lines @@
                 switch val {
                 case "on", "On", "true":
                         return true, nil
                 case "off", "Off", "false":
                         return false, nil
                 }
                 return nil, fmt.Errorf("Toggle field has bad/missing default, got %q", val)
         }
         return nil, fmt.Errorf("helper: meta field with bad type/value %s/%q", t, val)
 }