Пример #1
0
func (s *Submission) Put() error {
	s.Modified = time.Now()

	if s.Id == 0 {
		s.Created = s.Modified

		b, err := bson.Marshal(s)
		if err != nil {
			return err
		}

		res, err := db.Exec("INSERT INTO submissions(author_id, struct, created, modified) VALUES(?, ?, ?, ?)", s.AuthorId, b, s.Created, s.Modified)
		if err != nil {
			return err
		}
		chZerk <- s.AuthorId

		s.Id, err = res.LastInsertId()
		return err

	} else {
		b, err := bson.Marshal(s)
		if err != nil {
			return err
		}

		_, err = db.Exec("UPDATE submissions SET author_id=?, struct=?, modified=? WHERE id=?", s.AuthorId, b, s.Modified, s.Id)
		chZerk <- s.AuthorId
		return err
	}
}
Пример #2
0
func (s *Standing) Put() error {
	s.Modified = time.Now()

	if s.Id == 0 {
		s.Created = s.Modified

		b, err := bson.Marshal(s)
		if err != nil {
			return err
		}

		res, err := db.Exec("INSERT INTO standings(author_id, score, penalty, struct, created, modified) VALUES(?, ?, ?, ?, ?, ?)", s.AuthorId, s.Score, s.Penalty, b, s.Created, s.Modified)
		if err != nil {
			return err
		}

		s.Id, err = res.LastInsertId()
		return err

	} else {
		b, err := bson.Marshal(s)
		if err != nil {
			return err
		}

		_, err = db.Exec("UPDATE standings SET author_id=?, score=?, penalty=?, struct=?, modified=? WHERE id=?", s.AuthorId, s.Score, s.Penalty, b, s.Modified, s.Id)
		return err
	}
}
Пример #3
0
func (c *Clarification) Put() error {
	c.Modified = time.Now()

	if c.Id == 0 {
		c.Created = c.Modified

		b, err := bson.Marshal(c)
		if err != nil {
			return err
		}

		res, err := db.Exec("INSERT INTO clarifications(asker_id, response, struct, created, modified) VALUES(?, ?, ?, ?, ?)", c.AskerId, c.Response, b, c.Created, c.Modified)
		if err != nil {
			return err
		}

		c.Id, err = res.LastInsertId()
		return err

	} else {
		b, err := bson.Marshal(c)
		if err != nil {
			return err
		}

		_, err = db.Exec("UPDATE clarifications SET asker_id=?, response=?, struct=?, modified=? WHERE id=?", c.AskerId, c.Response, b, c.Modified, c.Id)
		return err
	}
}
Пример #4
0
func (a *Account) Put() error {
	a.Modified = time.Now()

	if a.Id == 0 {
		a.Created = a.Modified

		b, err := bson.Marshal(a)
		if err != nil {
			return err
		}

		res, err := db.Exec("INSERT INTO accounts(handle_lower, name_lower, level, struct, created, modified) VALUES(?, ?, ?, ?, ?, ?)", strings.ToLower(a.Handle), strings.ToLower(a.Name), a.Level, b, a.Created, a.Modified)
		if err != nil {
			return err
		}

		a.Id, err = res.LastInsertId()
		if err != nil {
			return err
		}
		chZerk <- a.Id
		return nil

	} else {
		b, err := bson.Marshal(a)
		if err != nil {
			return err
		}

		_, err = db.Exec("UPDATE accounts SET handle_lower=?, name_lower=?, level=?, struct=?, modified=? WHERE id=?", strings.ToLower(a.Handle), strings.ToLower(a.Name), a.Level, b, a.Modified, a.Id)
		chZerk <- a.Id
		return err
	}
}
Пример #5
0
func (e *Execution) Put() error {
	e.Modified = time.Now()

	if e.Id == 0 {
		e.Created = e.Modified

		b, err := bson.Marshal(e)
		if err != nil {
			return err
		}

		res, err := db.Exec("INSERT INTO executions(struct, created, modified) VALUES(?, ?, ?)", b, e.Created, e.Modified)
		if err != nil {
			return err
		}

		e.Id, err = res.LastInsertId()
		return err

	} else {
		b, err := bson.Marshal(e)
		if err != nil {
			return err
		}

		_, err = db.Exec("UPDATE executions SET struct=?, modified=? WHERE id=?", b, e.Modified, e.Id)
		return err
	}
}
Пример #6
0
func (p *Problem) Put() error {
	p.Modified = time.Now()

	if p.Id == 0 {
		p.Created = p.Modified

		b, err := bson.Marshal(p)
		if err != nil {
			return err
		}

		res, err := db.Exec("INSERT INTO problems(slug, char, struct, created, modified) VALUES(?, ?, ?, ?, ?)", p.Slug, p.Char, b, p.Created, p.Modified)
		if err != nil {
			return err
		}

		p.Id, err = res.LastInsertId()
		return err

	} else {
		b, err := bson.Marshal(p)
		if err != nil {
			return err
		}

		_, err = db.Exec("UPDATE problems SET slug=?, char=?, struct=?, modified=? WHERE id=?", p.Slug, p.Char, b, p.Modified, p.Id)
		return err
	}
}
Пример #7
0
func TestDecodeReadsOnlyOne(t *testing.T) {
	req := rpc.Request{
		ServiceMethod: "Foo.Bar",
		Seq:           3,
	}

	type T struct {
		Value string
	}

	tv := T{"test"}

	b, err := bson.Marshal(req)

	if err != nil {
		t.Fatal(err)
	}

	buf := bytes.NewBuffer(b)

	b, err = bson.Marshal(tv)

	if err != nil {
		t.Fatal(err)
	}

	buf.Write(b)
	dec := NewDecoder(buf)

	r := new(rpc.Request)
	err = dec.Decode(r)

	if *r != req {
		t.Fatal("Values don't match")
	}

	if err != nil {
		t.Fatal(err)
	}

	// We should be able to read a second message off this io.Reader
	tmp := new(T)
	err = dec.Decode(tmp)

	if err != nil {
		t.Fatal(err)
	}

	if *tmp != tv {
		t.Fatal("Values don't match")
	}

}
Пример #8
0
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)
}
Пример #9
0
func fnBsonEncodeFn(buf *bytes.Buffer, ts *TestStruc) error {
	bs, err := bson.Marshal(ts)
	if err == nil {
		buf.Write(bs)
	}
	return err
}
Пример #10
0
func (node *Node) Save() (err error) {
	db, err := DBConnect()
	if err != nil {
		return
	}
	defer db.Close()
	node.UpdateVersion()
	if len(node.Revisions) == 0 || node.Revisions[len(node.Revisions)-1].Version != node.Version {
		n := Node{node.Id, node.Version, node.File, node.Attributes, node.Indexes, node.Acl, node.VersionParts, node.Type, nil, node.Relatives}
		node.Revisions = append(node.Revisions, n)
	}
	bsonPath := fmt.Sprintf("%s/%s.bson", node.Path(), node.Id)
	os.Remove(bsonPath)
	nbson, err := bson.Marshal(node)
	if err != nil {
		return
	}
	err = ioutil.WriteFile(bsonPath, nbson, 0644)
	if err != nil {
		return
	}
	err = db.Upsert(node)
	if err != nil {
		return
	}
	return
}
Пример #11
0
// 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)

	sin := skynet.ServiceRPCIn{
		RequestInfo: requestInfo,
		Method:      funcName,
		ClientID:    sr.clientID,
	}

	sin.In, err = bson.Marshal(in)
	if err != nil {
		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)
		c.Log.Item(err)
	}

	if sout.ErrString != "" {
		serviceErr = serviceError{sout.ErrString}
	}

	result = sout.Out

	return
}
Пример #12
0
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)
	}
}
Пример #13
0
func (node *Node) Save() (err error) {
	node.UpdateVersion()
	if len(node.Revisions) == 0 || node.Revisions[len(node.Revisions)-1].Version != node.Version {
		n := Node{node.Id, node.Version, node.File, node.Attributes, node.Public, node.Indexes, node.Acl, node.VersionParts, node.Tags, nil, node.Linkages, node.CreatedOn, node.LastModified}
		node.Revisions = append(node.Revisions, n)
	}
	if node.CreatedOn == "" {
		node.CreatedOn = time.Now().Format(time.UnixDate)
	} else {
		node.LastModified = time.Now().Format(time.UnixDate)
	}

	bsonPath := fmt.Sprintf("%s/%s.bson", node.Path(), node.Id)
	os.Remove(bsonPath)
	nbson, err := bson.Marshal(node)
	if err != nil {
		return
	}
	err = ioutil.WriteFile(bsonPath, nbson, 0644)
	if err != nil {
		return
	}
	err = dbUpsert(node)
	if err != nil {
		return
	}
	return
}
Пример #14
0
func BenchmarkBsonUnmarshal(b *testing.B) {
	popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
	total := 0

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		b.StopTimer()

		p := NewPopulatedPreAccept(popr)

		data, err := bson.Marshal(p)
		if err != nil {
			panic(err)
		}

		total += len(data)

		msg := &PreAccept{}

		b.StartTimer()
		if err := bson.Unmarshal(data, msg); err != nil {
			panic(err)
		}

	}
	b.SetBytes(int64(total / b.N))
}
Пример #15
0
// Marshal and pack data into array of bytes for sending.
func (_ *BSONProtocol) MarshalAndPack(name string, structPtr interface{}) ([]byte, error) {
	outMsg := &OutgoingBSONMessage{
		Event: name,
		Data:  structPtr,
	}
	return bson.Marshal(outMsg)
}
Пример #16
0
// Bson to Json,InterfaceP{} by BsonBytes
// failed
func _Bson2Json(m *bson.M, i interface{}) error {
	b, err := bson.Marshal(m)
	if isError(err) {
		return err
	}
	return bson.Unmarshal(b, &i)
}
Пример #17
0
// 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, err error) {
	if requestInfo == nil {
		requestInfo = &skynet.RequestInfo{
			RequestID: skynet.UUID(),
		}
	}

	sin := service.ServiceRPCIn{
		RequestInfo: requestInfo,
		Method:      funcName,
	}

	sin.In, err = bson.Marshal(in)
	if err != nil {
		return
	}

	sout := service.ServiceRPCOut{}

	err = sr.rpcClient.Call(sr.service.Config.Name+".Forward", sin, &sout)
	if err != nil {
		sr.Close()
		c.Log.Item(err)
	}

	if sout.ErrString != "" {
		err = serviceError{sout.ErrString}
	}

	result = sout.Out

	return
}
Пример #18
0
// 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) {

	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.Name+".Forward", sin, &sout)
	if err != nil {
		sr.Close()

		// Log failure
		log.Printf(log.ERROR, "Error calling sr.rpcClient.Call: "+err.Error())
	}

	if sout.ErrString != "" {
		serviceErr = serviceError{sout.ErrString}
	}

	result = sout.Out

	return
}
Пример #19
0
func (s *URLSuite) TestBSON(c *C) {
	type doc struct {
		URL *charm.URL
	}
	url := charm.MustParseURL("cs:series/name")
	data, err := bson.Marshal(doc{url})
	c.Assert(err, IsNil)
	var v doc
	err = bson.Unmarshal(data, &v)
	c.Assert(v.URL, DeepEquals, url)

	data, err = bson.Marshal(doc{})
	c.Assert(err, IsNil)
	err = bson.Unmarshal(data, &v)
	c.Assert(v.URL, IsNil)
}
Пример #20
0
func Encode(obj interface{}) (p *WirePkt, err error) {
	p = new(WirePkt)
	switch obj.(type) {
	case *IdentifyClient:
		p.Type = TypeIdentifyClient
	case *TaskRequest:
		p.Type = TypeTaskRequest
	case *TaskResponse:
		p.Type = TypeTaskResponse
	case *Acknowledgement:
		p.Type = TypeAcknowledgement
	default:
		Warn("Encoding unknown type!")
		return nil, ErrUnknownType
	}
	p.Payload, err = bson.Marshal(obj)
	if err != nil {
		return nil, err
	}
	if len(p.Payload) >= MaximumPayloadSize {
		return nil, ErrObjectTooLarge
	}
	p.Length = uint16(len(p.Payload))

	return p, nil
}
Пример #21
0
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))
	}
}
Пример #22
0
func init() {
	log.SetFlags(log.Ltime | log.Lshortfile)

	thtw = *th.NewThriftTweet()
	// create structs, maps by using json data to do initial population
	json.Unmarshal([]byte(jsons), &tw)
	json.Unmarshal([]byte(jsons), &pbtw)
	json.Unmarshal([]byte(jsons), &twl)
	json.Unmarshal([]byte(jsons), &thtw)
	//log.Println("pbtw\n", pbtw)
	// create by values per serialization type
	bsonTweet, _ = bson.Marshal(&tw)
	jsonTweet = []byte(jsons)
	protoTw, _ = proto.Marshal(&pbtw)
	//ptw2, err := proto.Marshal(&pbtw)
	//log.Println(err)
	//log.Println(ptw2)
	msgpackTw, _ = msgpack.Marshal(tw)
	enc := gob.NewEncoder(&gobTw)
	err := enc.Encode(tw)
	if err != nil {
		panic("error")
	}
	//log.Println(string(gobTw.Bytes()))

	buf := thrift.NewTMemoryBuffer()
	thbp := thrift.NewTBinaryProtocol(buf, false, true)
	thtw.Write(thbp)
	thriftTw = buf.Bytes()
	tw2 := th.NewThriftTweet()
	tw2.Read(thbp)

}
Пример #23
0
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))
	}
}
Пример #24
0
func TestIntegrationList_Pagination(t *testing.T) {
	storage, err := goejdb.Open("TestIntegrationList", goejdb.JBOWRITER|goejdb.JBOCREAT)
	if err != nil {
		t.Error(err)
	}
	defer storage.Del()
	defer os.Remove("TestIntegrationList")

	chatColl, err := storage.CreateColl("12345", nil)
	if err != nil {
		t.Error(err)
	}
	defer os.Remove("TestIntegrationList_12345")

	for i := 25; i > 0; i-- {
		bsonBytes, _ := bson.Marshal(quotes.Quote{When: i})
		chatColl.SaveBson(bsonBytes)
	}

	manager := manageStorage{storage}

	res, err2 := manager.List("12345", 10)
	if err2 != nil {
		t.Error(err2)
	}

	assert.Equal(t, 10, len(*res))
}
Пример #25
0
func TestSend(t *testing.T) {
	client, server := net.Pipe()
	go doServiceHandshake(server, true, t)

	cn, err := NewConnectionFromNetConn("TestRPCService", client)
	c := cn.(*Conn)

	s := rpc.NewServer()
	var ts TestRPCService
	s.Register(&ts)
	go s.ServeCodec(bsonrpc.NewServerCodec(server))

	var tp TestParam
	tp.Val1 = "Hello World"
	tp.Val2 = 10

	ri := &skynet.RequestInfo{}

	ts.TestMethod = func(in skynet.ServiceRPCIn, out *skynet.ServiceRPCOut) (err error) {
		out.Out, err = bson.Marshal(&tp)

		var t TestParam

		if err != nil {
			return
		}

		if in.ClientID != c.clientID {
			return errors.New("Failed to set ClientID on request")
		}

		if in.Method != "Foo" {
			return errors.New("Failed to set Method on request")
		}

		if *in.RequestInfo != *ri {
			return errors.New("Failed to set RequestInfo on request")
		}

		err = bson.Unmarshal(in.In, &t)
		if err != nil {
			return
		}

		if t.Val1 != tp.Val1 || tp.Val2 != tp.Val2 {
			return errors.New("Request failed to send proper data")
		}

		return
	}

	err = c.Send(ri, "Foo", tp, &tp)
	if err != nil {
		t.Error(err)
		return
	}

	c.Close()
	server.Close()
}
Пример #26
0
func TestDecode(t *testing.T) {
	req := rpc.Request{
		ServiceMethod: "Foo.Bar",
		Seq:           3,
	}

	b, err := bson.Marshal(req)

	if err != nil {
		t.Fatal(err)
	}

	buf := bytes.NewBuffer(b)
	dec := NewDecoder(buf)

	r := new(rpc.Request)
	err = dec.Decode(r)

	if err != nil {
		t.Fatal(err)
	}

	if *r != req {
		t.Fatal("Values don't match")
	}
}
Пример #27
0
func WriteFile(path string, obj interface{}) (err error) {
	out, err := bson.Marshal(obj)
	if err != nil {
		return err
	}
	return ioutil.WriteFile(path, out, os.FileMode(0777))
}
Пример #28
0
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))
	}
}
Пример #29
0
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)
}
Пример #30
0
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})
}