Golang msgp.NewReader函数代码示例

// call KVAutobus key_range API
func (db *KVAutobus) getKeyRange(kStart, kEnd storage.Key) (Ks, error) {
	b64key1 := encodeKey(kStart)
	b64key2 := encodeKey(kEnd)
	url := fmt.Sprintf("%s/kvautobus/api/key_range/%s/%s/%s/", db.host, db.collection, b64key1, b64key2)

	timedLog := dvid.NewTimeLog()
	resp, err := db.client.Get(url)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode == http.StatusNotFound {
		return nil, nil // Handle no keys found.
	}

	r := msgp.NewReader(bufio.NewReader(resp.Body))
	var mks Ks
	if err := mks.DecodeMsg(r); err != nil {
		return nil, err
	}
	for _, mk := range mks {
		storage.StoreKeyBytesRead <- len(mk)
	}
	timedLog.Infof("PROXY key_range to %s returned %d (%d keys)\n", db.host, resp.StatusCode, len(mks))
	return mks, nil
}

func (h *StoreHandler) parseReq(sr *StoreReq) error {
	/* unpack */
	msgr := msgp.NewReader(sr.reqBuffer)
	reqi, err := msgr.ReadIntf()
	if err != nil {
		return errors.New(fmt.Sprintf("fail to decode data from storeReq: %s", err.Error()))
	}
	req, ok := reqi.(map[string]interface{})
	if !ok {
		return errors.New(fmt.Sprintf("invalid data from storeReq: data need be map"))
	}
	datai, ok := req["data"]
	if !ok {
		return errors.New(fmt.Sprintf("invalid data from storeReq: data not exist"))
	}
	sr.data = datai.([]byte)
	idi, ok := req["id"]
	if !ok {
		return errors.New(fmt.Sprintf("invalid data from storeReq: id not exist"))
	}
	sr.id, ok = idi.(uint64)
	if !ok {
		idt, ok := idi.(int64)
		if !ok || idt < 0 {
			return errors.New(fmt.Sprintf("invalid data from storeReq: id is not int64 or uint64, or < 0"))
		}
		sr.id = uint64(idt)
	}
	return nil
}

// check if any metadata has been written into this store.
func (db *KVAutobus) metadataExists() (bool, error) {
	var ctx storage.MetadataContext
	kStart, kEnd := ctx.KeyRange()
	b64key1 := encodeKey(kStart)
	b64key2 := encodeKey(kEnd)
	url := fmt.Sprintf("%s/kvautobus/api/key_range/%s/%s/%s/", db.host, db.collection, b64key1, b64key2)
	dvid.Infof("metdataExists: doing GET on %s\n", url)

	timedLog := dvid.NewTimeLog()
	resp, err := db.client.Get(url)
	if err != nil {
		return false, err
	}
	defer resp.Body.Close()
	if resp.StatusCode == http.StatusNotFound {
		return true, nil // Handle no keys found.
	}

	r := msgp.NewReader(bufio.NewReader(resp.Body))
	var mks Ks
	if err := mks.DecodeMsg(r); err != nil {
		return false, err
	}
	timedLog.Infof("PROXY key_range metadata to %s returned %d (%d keys)\n", db.host, resp.StatusCode, len(mks))
	if len(mks) == 0 {
		return false, nil
	}
	return true, nil
}

// call KVAutobus keyvalue_range API
func (db *KVAutobus) getKVRange(kStart, kEnd storage.Key) (KVs, error) {
	b64key1 := encodeKey(kStart)
	b64key2 := encodeKey(kEnd)
	url := fmt.Sprintf("%s/kvautobus/api/keyvalue_range/%s/%s/", db.host, b64key1, b64key2)

	timedLog := dvid.NewTimeLog()
	resp, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode == http.StatusNotFound {
		return nil, nil // Handle no keys found.
	}

	r := msgp.NewReader(bufio.NewReader(resp.Body))
	var mkvs KVs
	if err := mkvs.DecodeMsg(r); err != nil {
		dvid.Errorf("Couldn't decode getKVRange return\n")
		return nil, err
	}

	timedLog.Infof("PROXY keyvalue_range to %s returned %d (%d kv pairs)\n", db.host, resp.StatusCode, len(mkvs))
	return mkvs, nil
}

func NewCodec(conn io.ReadWriteCloser) *codec {
	c := &codec{
		conn: conn,
		r:    msgp.NewReader(conn),
		w:    msgp.NewWriter(conn),
	}
	return c
}

func NewCodec(ws *websocket.Conn) *codec {
	c := &codec{
		ws: ws,
		r:  msgp.NewReader(nil),
		w:  msgp.NewWriter(nil),
	}
	return c
}

func (s *initialDispatchSuite) TestSpoolCancel(c *C) {
	var (
		args = Profile{
			"type": "testSleep",
		}
		appName      = "application"
		spoolMsg, _  = msgp.AppendIntf(nil, []interface{}{map[string]interface{}(args), appName})
		cancelMsg, _ = msgp.AppendIntf(nil, []interface{}{})
	)

	spoolDisp, err := s.d.Handle(spool, msgp.NewReader(bytes.NewReader(spoolMsg)))
	c.Assert(err, IsNil)
	c.Assert(spoolDisp, FitsTypeOf, &spoolCancelationDispatch{})
	spoolDisp.Handle(spoolCancel, msgp.NewReader(bytes.NewReader(cancelMsg)))
	msg := <-s.dw.ch
	c.Assert(msg.code, DeepEquals, int64(replySpoolOk))
}

func NewCodec(db *redis.Database, channel string) *codec {
	c := &codec{
		db: db,
		ch: channel,
		r:  msgp.NewReader(nil),
		w:  msgp.NewWriter(nil),
	}
	return c
}

func (s *initialDispatchSuite) TestSpawnAndKill(c *C) {
	var (
		opts = Profile{
			"type": "testSleep",
		}
		appName    = "application"
		executable = "test_app.exe"
		args       = make(map[string]string, 0)
		env        = make(map[string]string, 0)
		// spawnMsg   = message{s.session, spawn, []interface{}{opts, appName, executable, args, env}}
		spawnMsg, _ = msgp.AppendIntf(nil, []interface{}{map[string]interface{}(opts), appName, executable, args, env})
		killMsg, _  = msgp.AppendIntf(nil, []interface{}{})
	)
	spawnDisp, err := s.d.Handle(spawn, msgp.NewReader(bytes.NewReader(spawnMsg)))
	c.Assert(err, IsNil)
	c.Assert(spawnDisp, FitsTypeOf, &spawnDispatch{})

	// First chunk must be empty to notify about start
	msg := <-s.dw.ch
	c.Assert(msg.code, DeepEquals, int64(replySpawnWrite))
	c.Assert(msg.args, HasLen, 1)
	data, ok := msg.args[0].([]byte)
	c.Assert(ok, Equals, true)
	c.Assert(data, HasLen, 0)

	// Let's read some output
	msg = <-s.dw.ch
	c.Assert(msg.code, Equals, int64(replySpawnWrite))
	c.Assert(msg.args, HasLen, 1)

	data, ok = msg.args[0].([]byte)
	c.Assert(ok, Equals, true)
	c.Assert(data, Not(HasLen), 0)

	noneDisp, err := spawnDisp.Handle(spawnKill, msgp.NewReader(bytes.NewReader(killMsg)))
	c.Assert(err, IsNil)
	c.Assert(noneDisp, IsNil)
}

func BenchmarkIncidentDecode(b *testing.B) {
	v := Incident{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

// benchmark decoding a small, "fast" type.
// the point here is to see how much garbage
// is generated intrinsically by the encoding/
// decoding process as opposed to the nature
// of the struct.
func BenchmarkFastDecode(b *testing.B) {
	v := &TestFast{
		Lat:  40.12398,
		Long: -41.9082,
		Alt:  201.08290,
		Data: []byte("whaaaaargharbl"),
	}

	var buf bytes.Buffer
	msgp.Encode(&buf, v)
	dc := msgp.NewReader(msgp.NewEndlessReader(buf.Bytes(), b))
	b.SetBytes(int64(buf.Len()))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.DecodeMsg(dc)
	}
}

func BenchmarkNotificationDecode(b *testing.B) {
	r := Notification{
		Method: "Call",
		Body:   nil,
	}

	var buf bytes.Buffer
	msgp.Encode(&buf, &r)
	byts := buf.Bytes()

	mr := msgp.NewReader(&buf)

	for i := 0; i < b.N; i++ {
		buf.Reset()
		buf.Write(byts)
		r.DecodeMsg(mr)
	}
}

func BenchmarkResponseDecode(b *testing.B) {
	r := Response{
		ID:    100,
		Error: "error",
		Body:  nil,
	}

	var buf bytes.Buffer
	msgp.Encode(&buf, &r)
	byts := buf.Bytes()

	mr := msgp.NewReader(&buf)

	for i := 0; i < b.N; i++ {
		buf.Reset()
		buf.Write(byts)
		r.DecodeMsg(mr)
	}
}

func (b *Broker) getData(partition int32, offset int64) ([]byte, error) {
	// TODO: using pool ?
	bb, err := b.bc.Leader(gBrokerTopic, partition)
	if err != nil {
		return nil, err
	}
	bbb := sarama.NewBroker(bb.Addr())
	defer bbb.Close()
	err = bbb.Open(b.brokerConfig)
	if err != nil {
		return nil, err
	}
	freq := &sarama.FetchRequest{}
	freq.AddBlock(gBrokerTopic, partition, offset, int32(b.config.brokerMaxMessageSize))
	fres, err := bbb.Fetch(freq)
	if err != nil {
		return nil, err
	}
	fresb := fres.GetBlock(gBrokerTopic, partition)
	msgs := fresb.MsgSet.Messages
	if len(msgs) == 0 {
		return nil, errors.New("no msg found in broker")
	}
	/* unpack */
	buf := bytes.NewReader(msgs[0].Msg.Value)
	buf.Seek(0, 0)
	msgr := msgp.NewReader(buf)
	resi, err := msgr.ReadIntf()
	if err != nil {
		return nil, errors.New(fmt.Sprintf("fail to decode data from broker: %s", err.Error()))
	}
	res, ok := resi.(map[string]interface{})
	if !ok {
		return nil, errors.New(fmt.Sprintf("invalid data from broker: data need be map"))
	}
	datai, ok := res["data"]
	if !ok {
		return nil, errors.New(fmt.Sprintf("invalid data from broker: data not exist"))
	}
	return datai.([]byte), nil
}

// call KVAutobus keyvalue_range API
func (db *KVAutobus) getKVRange(ctx storage.Context, kStart, kEnd storage.Key) (KVs, error) {
	// Get any request context and pass to kvautobus for tracking.
	reqctx, ok := ctx.(storage.RequestCtx)
	var reqID string
	if ok {
		parts := strings.Split(reqctx.GetRequestID(), "/")
		if len(parts) > 0 {
			reqID = parts[len(parts)-1]
		}
	}

	// Construct the KVAutobus URL
	b64key1 := encodeKey(kStart)
	b64key2 := encodeKey(kEnd)
	url := fmt.Sprintf("%s/kvautobus/api/keyvalue_range/%s/%s/%s/?=%s", db.host, db.collection, b64key1, b64key2, reqID)

	timedLog := dvid.NewTimeLog()
	resp, err := db.client.Get(url)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode == http.StatusNotFound {
		return nil, nil // Handle no keys found.
	}

	r := msgp.NewReader(bufio.NewReader(resp.Body))
	var mkvs KVs
	if err := mkvs.DecodeMsg(r); err != nil {
		dvid.Errorf("Couldn't decode getKVRange return\n")
		return nil, err
	}
	for _, mkv := range mkvs {
		storage.StoreKeyBytesRead <- len(mkv[0])
		storage.StoreValueBytesRead <- len(mkv[1])
	}

	timedLog.Infof("[%s] PROXY keyvalue_range to %s returned %d (%d kv pairs)\n", reqID, db.host, resp.StatusCode, len(mkvs))
	return mkvs, nil
}