Support running dbtest in Docker container

bson/bson.go

@@ -34,6 +34,7 @@ package bson
 
 import (
 	"bytes"
+	"context"
 	"crypto/md5"
 	"crypto/rand"
 	"encoding/binary"
@@ -64,6 +65,10 @@ type Getter interface {
 	GetBSON() (interface{}, error)
 }
 
+type GetterCtx interface {
+	GetBSONWithContext(context.Context) (interface{}, error)
+}
+
 // A value implementing the bson.Setter interface will receive the BSON
 // value via the SetBSON method during unmarshaling, and the object
 // itself will not be changed as usual.
@@ -95,6 +100,10 @@ type Setter interface {
 	SetBSON(raw Raw) error
 }
 
+type SetterCtx interface {
+	SetBSONWithContext(ctx context.Context, raw Raw) error
+}
+
 // SetZero may be returned from a SetBSON method to have the value set to
 // its respective zero value. When used in pointer values, this will set the
 // field to nil rather than to the pre-allocated value.
@@ -279,7 +288,7 @@ var nullBytes = []byte("null")
 func (id *ObjectId) UnmarshalJSON(data []byte) error {
 	if len(data) > 0 && (data[0] == '{' || data[0] == 'O') {
 		var v struct {
-			Id json.RawMessage `json:"$oid"`
+			Id   json.RawMessage `json:"$oid"`
 			Func struct {
 				Id json.RawMessage
 			} `json:"$oidFunc"`
@@ -505,13 +514,17 @@ func handleErr(err *error) {
 //         F int64  "myf,omitempty,minsize"
 //     }
 //
-func Marshal(in interface{}) (out []byte, err error) {
+func MarshalWithContext(ctx context.Context, in interface{}) (out []byte, err error) {
 	defer handleErr(&err)
 	e := &encoder{make([]byte, 0, initialBufferSize)}
-	e.addDoc(reflect.ValueOf(in))
+	e.addDoc(ctx, reflect.ValueOf(in))
 	return e.out, nil
 }
 
+func Marshal(in interface{}) (out []byte, err error) {
+	return MarshalWithContext(context.TODO(), in)
+}
+
 // Unmarshal deserializes data from in into the out value.  The out value
 // must be a map, a pointer to a struct, or a pointer to a bson.D value.
 // In the case of struct values, only exported fields will be deserialized.
@@ -547,7 +560,7 @@ func Marshal(in interface{}) (out []byte, err error) {
 // silently skipped.
 //
 // Pointer values are initialized when necessary.
-func Unmarshal(in []byte, out interface{}) (err error) {
+func UnmarshalWithContext(ctx context.Context, in []byte, out interface{}) (err error) {
 	if raw, ok := out.(*Raw); ok {
 		raw.Kind = 3
 		raw.Data = in
@@ -560,7 +573,7 @@ func Unmarshal(in []byte, out interface{}) (err error) {
 		fallthrough
 	case reflect.Map:
 		d := newDecoder(in)
-		d.readDocTo(v)
+		d.readDocTo(ctx, v)
 	case reflect.Struct:
 		return errors.New("Unmarshal can't deal with struct values. Use a pointer.")
 	default:
@@ -569,12 +582,16 @@ func Unmarshal(in []byte, out interface{}) (err error) {
 	return nil
 }
 
+func Unmarshal(in []byte, out interface{}) (err error) {
+	return UnmarshalWithContext(context.TODO(), in, out)
+}
+
 // Unmarshal deserializes raw into the out value.  If the out value type
 // is not compatible with raw, a *bson.TypeError is returned.
 //
 // See the Unmarshal function documentation for more details on the
 // unmarshalling process.
-func (raw Raw) Unmarshal(out interface{}) (err error) {
+func (raw Raw) UnmarshalWithContext(ctx context.Context, out interface{}) (err error) {
 	defer handleErr(&err)
 	v := reflect.ValueOf(out)
 	switch v.Kind() {
@@ -583,7 +600,7 @@ func (raw Raw) Unmarshal(out interface{}) (err error) {
 		fallthrough
 	case reflect.Map:
 		d := newDecoder(raw.Data)
-		good := d.readElemTo(v, raw.Kind)
+		good := d.readElemTo(ctx, v, raw.Kind)
 		if !good {
 			return &TypeError{v.Type(), raw.Kind}
 		}
@@ -595,6 +612,10 @@ func (raw Raw) Unmarshal(out interface{}) (err error) {
 	return nil
 }
 
+func (raw Raw) Unmarshal(out interface{}) (err error) {
+	return raw.UnmarshalWithContext(context.TODO(), out)
+}
+
 type TypeError struct {
 	Type reflect.Type
 	Kind byte

bson/context.go

@@ -0,0 +1,89 @@
+// BSON library for Go
+//
+// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// gobson - BSON library for Go.
+//
+
+package bson
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type bsonOptions struct {
+	// skipCustom is used by
+	//   - decode.go to skip looking for a custom SetBSON() or SetBSONWithContext()
+	//   - encode.go to skip looking for a custom GetBSON() or GetBSONWithContext()
+	// for any type with the base type name specified by 'skipCustom'.
+	// This is useful to avoid infinite loop caused by:
+	//    - calling Unmarshal from custom SetBSON function (decode.go)
+	//    - encode.go calling custom GetBSON after just calling custom GetBSON for a given type
+	skipCustom string
+}
+
+type key int
+
+var bsonKey key = 0
+
+// Returns the topmost bsonOptions value stored in ctx, if any.
+func fromContext(ctx context.Context) (*bsonOptions, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	opts, ok := ctx.Value(bsonKey).(*bsonOptions)
+	return opts, ok
+}
+
+// Returns the base type name (type name without a prefix that contains any combination of * or []).
+func baseTypeName(typ reflect.Type) string {
+	return strings.Trim(fmt.Sprintf("%v", typ), "*[]")
+}
+
+// Creates a new context with a value for skipCustom based on base type name of valu.
+func NewContextWithSkipCustom(ctx context.Context, valu interface{}) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, bsonKey, &bsonOptions{skipCustom: baseTypeName(reflect.TypeOf(valu))})
+}
+
+// IsSkipCustom is useful to avoid infinite loop caused by:
+//    - calling Unmarshal from custom SetBSON function (decode.go)
+//    - encode.go calling custom GetBSON after just calling custom GetBSON for a given type
+//
+// Returns true if base type name of typ is the same as skipCustom.
+//
+// This method is used to skip all custom SetBSON/GetBSON functions of all types with the same base type.
+// Note: if goal is to skip the custom functions of certain variations of a base type,
+// skipCustom will not work (it will skip all variants).
+func IsSkipCustom(ctx context.Context, typ reflect.Type) bool {
+	if opts, _ := fromContext(ctx); opts != nil {
+		return opts.skipCustom == baseTypeName(typ)
+	}
+	return false
+}