func (s *S) TestGetterErrors(c *C) {
e := errors.New("oops")
obj1 := &docWithGetterField{}
obj1.Field = &typeWithGetter{sampleItems[0].obj, e}
data, err := bson.Marshal(obj1)
c.Assert(err, ErrorMatches, "oops")
c.Assert(data, IsNil)
obj2 := &typeWithGetter{sampleItems[0].obj, e}
data, err = bson.Marshal(obj2)
c.Assert(err, ErrorMatches, "oops")
c.Assert(data, IsNil)
}
func (s *S) TestMarshalAllItems(c *C) {
for i, item := range allItems {
data, err := bson.Marshal(item.obj)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, wrapInDoc(item.data), Commentf("Failed on item %d: %#v", i, item))
}
}
func (s *S) TestMarshalOneWayItems(c *C) {
for _, item := range marshalItems {
data, err := bson.Marshal(item.obj)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, wrapInDoc(item.data))
}
}
func (s *S) TestMarshalErrorItems(c *C) {
for _, item := range marshalErrorItems {
data, err := bson.Marshal(item.obj)
c.Assert(err, ErrorMatches, item.data)
c.Assert(data, IsNil)
}
}
func (s *S) TestMarshalSampleItems(c *C) {
for i, item := range sampleItems {
data, err := bson.Marshal(item.obj)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, item.data, Commentf("Failed on item %d", i))
}
}
func (s *S) TestUnmarshalZeroesMap(c *C) {
data, err := bson.Marshal(bson.M{"b": 2})
c.Assert(err, IsNil)
m := bson.M{"a": 1}
err = bson.Unmarshal(data, &m)
c.Assert(err, IsNil)
c.Assert(m, DeepEquals, bson.M{"b": 2})
}
func (s *S) TestMarshalShortWithGetter(c *C) {
obj := typeWithIntGetter{42}
data, err := bson.Marshal(obj)
c.Assert(err, IsNil)
m := bson.M{}
err = bson.Unmarshal(data, m)
c.Assert(m["v"], Equals, 42)
}
func (e *Encoder) Encode(v interface{}) (err error) {
buf, err := bson.Marshal(v)
if err != nil {
return
}
_, err = e.w.Write(buf)
return
}
func (s *S) TestUnmarshalZeroesStruct(c *C) {
data, err := bson.Marshal(bson.M{"b": 2})
c.Assert(err, IsNil)
type T struct{ A, B int }
v := T{A: 1}
err = bson.Unmarshal(data, &v)
c.Assert(err, IsNil)
c.Assert(v.A, Equals, 0)
c.Assert(v.B, Equals, 2)
}
func addBSON(b []byte, doc interface{}) ([]byte, error) {
if doc == nil {
return append(b, 5, 0, 0, 0, 0), nil
}
data, err := bson.Marshal(doc)
if err != nil {
return b, err
}
return append(b, data...), nil
}
// SetMeta changes the optional "metadata" field associated with the
// file. The meaning of keys under that field is user-defined.
// For example:
//
// file.SetMeta(bson.M{"inode": inode})
//
// It is a runtime error to call this function when the file is not open
// for writing.
func (file *GridFile) SetMeta(metadata interface{}) {
file.assertMode(gfsWriting)
data, err := bson.Marshal(metadata)
file.m.Lock()
if err != nil && file.err == nil {
file.err = err
} else {
file.doc.Metadata = &bson.Raw{Data: data}
}
file.m.Unlock()
}
func (s *S) TestUnmarshalNonNilInterface(c *C) {
data, err := bson.Marshal(bson.M{"b": 2})
c.Assert(err, IsNil)
m := bson.M{"a": 1}
var i interface{}
i = m
err = bson.Unmarshal(data, &i)
c.Assert(err, IsNil)
c.Assert(i, DeepEquals, bson.M{"b": 2})
c.Assert(m, DeepEquals, bson.M{"a": 1})
}
func objToDoc(obj interface{}) (d bson.D, err error) {
data, err := bson.Marshal(obj)
if err != nil {
return nil, err
}
err = bson.Unmarshal(data, &d)
if err != nil {
return nil, err
}
return d, err
}
func testCrossPair(c *C, dump interface{}, load interface{}) {
c.Logf("Dump: %#v", dump)
c.Logf("Load: %#v", load)
zero := makeZeroDoc(load)
data, err := bson.Marshal(dump)
c.Assert(err, IsNil)
c.Logf("Dumped: %#v", string(data))
err = bson.Unmarshal(data, zero)
c.Assert(err, IsNil)
c.Logf("Loaded: %#v", zero)
c.Assert(zero, DeepEquals, load)
}
func (s *S) TestMarshalAllItemsWithGetter(c *C) {
for i, item := range allItems {
if item.data == "" {
continue
}
obj := &docWithGetterField{}
obj.Field = &typeWithGetter{result: item.obj.(bson.M)["_"]}
data, err := bson.Marshal(obj)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, wrapInDoc(item.data),
Commentf("Failed on item #%d", i))
}
}
func BenchmarkUnmarhsalStruct(b *testing.B) {
v := BenchT{A: "A", D: "D", E: "E"}
data, err := bson.Marshal(&v)
if err != nil {
panic(err)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
err = bson.Unmarshal(data, &v)
}
if err != nil {
panic(err)
}
}
func BenchmarkUnmarhsalMap(b *testing.B) {
m := bson.M{"a": "a", "d": "d", "e": "e"}
data, err := bson.Marshal(&m)
if err != nil {
panic(err)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
err = bson.Unmarshal(data, &m)
}
if err != nil {
panic(err)
}
}
func (s *S) TestUnmarshalSetterSetZero(c *C) {
setterResult["foo"] = bson.SetZero
defer delete(setterResult, "field")
data, err := bson.Marshal(bson.M{"field": "foo"})
c.Assert(err, IsNil)
m := map[string]*setterType{}
err = bson.Unmarshal([]byte(data), m)
c.Assert(err, IsNil)
value, ok := m["field"]
c.Assert(ok, Equals, true)
c.Assert(value, IsNil)
}
func TestServiceRPCBasic(t *testing.T) {
var addr net.Addr
config := &skynet.ServiceConfig{}
service := CreateService(EchoRPC{}, config)
service.ClientInfo = make(map[string]ClientInfo, 1)
addr = &net.TCPAddr{
IP: net.ParseIP("127.0.0.1"),
Port: 123,
}
service.ClientInfo["123"] = ClientInfo{
Address: addr,
}
srpc := NewServiceRPC(service)
in := M{"Hi": "there"}
out := &M{}
sin := skynet.ServiceRPCIn{
RequestInfo: &skynet.RequestInfo{
RequestID: "id",
OriginAddress: addr.String(),
ConnectionAddress: addr.String(),
},
Method: "Foo",
ClientID: "123",
}
sin.In, _ = bson.Marshal(in)
sout := skynet.ServiceRPCOut{}
err := srpc.Forward(sin, &sout)
if err != nil {
t.Error(err)
}
bson.Unmarshal(sout.Out, out)
if v, ok := (*out)["Hi"].(string); !ok || v != "there" {
t.Error(fmt.Sprintf("Expected %v, got %v", in, *out))
}
}
// ServiceClient.sendToInstance() tries to make an RPC request on a particular connection to an instance
func (c *ServiceClient) sendToInstance(sr ServiceResource,
requestInfo *skynet.RequestInfo, funcName string, in interface{}) (
result []byte, serviceErr, err error) {
ts("sendToInstance", requestInfo)
defer te("sendToInstance", requestInfo)
sr.service.FetchStats(c.client.doozer())
dbgf("stats: %+v\n", sr.service.Stats)
sin := skynet.ServiceRPCIn{
RequestInfo: requestInfo,
Method: funcName,
ClientID: sr.clientID,
}
sin.In, err = bson.Marshal(in)
if err != nil {
err = fmt.Errorf("Error calling bson.Marshal: %v", err)
return
}
sout := skynet.ServiceRPCOut{}
err = sr.rpcClient.Call(sr.service.Config.Name+".Forward", sin, &sout)
if err != nil {
sr.Close()
dbg("(sr.rpcClient.Call)", err)
// Log failure
c.Log.Error("Error calling sr.rpcClient.Call: " + err.Error())
}
if sout.ErrString != "" {
serviceErr = serviceError{sout.ErrString}
}
result = sout.Out
return
}
func (file *GridFile) insertChunk(data []byte) {
n := file.chunk
file.chunk++
debugf("GridFile %p: adding to checksum: %q", file, string(data))
file.wsum.Write(data)
for file.doc.ChunkSize*file.wpending >= 1024*1024 {
// Hold on.. we got a MB pending.
file.c.Wait()
if file.err != nil {
return
}
}
file.wpending++
debugf("GridFile %p: inserting chunk %d with %d bytes", file, n, len(data))
// We may not own the memory of data, so rather than
// simply copying it, we'll marshal the document ahead of time.
data, err := bson.Marshal(gfsChunk{bson.NewObjectId(), file.doc.Id, n, data})
if err != nil {
file.err = err
return
}
go func() {
err := file.gfs.Chunks.Insert(bson.Raw{Data: data})
file.m.Lock()
file.wpending--
if err != nil && file.err == nil {
file.err = err
}
file.c.Broadcast()
file.m.Unlock()
}()
}
// ServiceRPC.Forward is the entry point for RPC calls. It wraps actual RPC calls
// and provides a slot for the RequestInfo. The parameters to the actual RPC
// calls are transmitted in a []byte, and are then marshalled/unmarshalled on
// either end.
func (srpc *ServiceRPC) Forward(in skynet.ServiceRPCIn, out *skynet.ServiceRPCOut) (err error) {
srpc.service.activeRequests.Add(1)
defer srpc.service.activeRequests.Done()
srpc.service.Delegate.MethodCalled(in.Method)
clientInfo, ok := srpc.service.getClientInfo(in.ClientID)
if !ok {
err = errors.New("did not provide the ClientID")
return
}
in.RequestInfo.ConnectionAddress = clientInfo.Address.String()
if in.RequestInfo.OriginAddress == "" || !srpc.service.IsTrusted(clientInfo.Address) {
in.RequestInfo.OriginAddress = in.RequestInfo.ConnectionAddress
}
mc := MethodCall{
MethodName: in.Method,
RequestInfo: in.RequestInfo,
}
if srpc.service.Log != nil {
srpc.service.Log.Trace(fmt.Sprintf("%+v", mc))
}
m, ok := srpc.methods[in.Method]
if !ok {
err = errors.New(fmt.Sprintf("No such method %q", in.Method))
return
}
inValuePtr := reflect.New(m.Type().In(2))
err = bson.Unmarshal(in.In, inValuePtr.Interface())
if err != nil {
return
}
// Allocate the out parameter of the RPC call.
outType := m.Type().In(3)
var outValue reflect.Value
switch outType.Kind() {
case reflect.Ptr:
outValue = reflect.New(m.Type().In(3).Elem())
case reflect.Map:
outValue = reflect.MakeMap(outType)
default:
panic("illegal out param type")
}
srpc.service.Stats.LastRequest = time.Now().Format("2006-01-02T15:04:05Z-0700")
startTime := time.Now().UnixNano()
params := []reflect.Value{
reflect.ValueOf(srpc.service.Delegate),
reflect.ValueOf(in.RequestInfo),
inValuePtr.Elem(),
outValue,
}
returns := m.Call(params)
duration := time.Now().UnixNano() - startTime
// Update stats
atomic.AddInt64(&srpc.service.Stats.RequestsServed, 1)
atomic.AddInt64((*int64)(&srpc.service.Stats.TotalDuration), int64(duration)) // ns
srpc.service.Stats.AverageResponseTime = srpc.service.Stats.TotalDuration / time.Duration(srpc.service.Stats.RequestsServed)
mcp := MethodCompletion{
MethodName: in.Method,
RequestInfo: in.RequestInfo,
Duration: duration,
}
if srpc.service.Log != nil {
srpc.service.Log.Trace(fmt.Sprintf("%+v", mcp))
}
out.Out, err = bson.Marshal(outValue.Interface())
if err != nil {
return
}
erri := returns[0].Interface()
var rerr error
if erri != nil {
rerr, _ := erri.(error)
out.ErrString = rerr.Error()
}
srpc.service.Delegate.MethodCompleted(in.Method, duration, rerr)
return
}
func (s *S) TestMarshalWholeDocumentWithGetter(c *C) {
obj := &typeWithGetter{result: sampleItems[0].obj}
data, err := bson.Marshal(obj)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, sampleItems[0].data)
}