Golang rpc.Request类代码示例

func (c *serverCodec) ReadRequestHeader(request *rpc.Request) error {
	name, messageType, seq, err := c.protocol.ReadMessageBegin(c.transport)
	if err != nil {
		return err
	}
	if messageType != MessageTypeCall { // Currently don't support one way
		return errors.New("thrift: expected Call message type")
	}

	// TODO: should use a limited size cache for the nameCache to avoid a possible
	//       memory overflow from nefarious or broken clients
	newName := c.nameCache[name]
	if newName == "" {
		newName = CamelCase(name)
		if !strings.ContainsRune(newName, '.') {
			newName = "Thrift." + newName
		}
		c.nameCache[name] = newName
	}

	c.mu.Lock()
	c.methodName[uint64(seq)] = name
	c.mu.Unlock()

	request.ServiceMethod = newName
	request.Seq = uint64(seq)

	return nil
}

func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
	var sz uint16
	err := binary.Read(c.c, binary.BigEndian, &sz)
	if err != nil {
		return err
	}
	log.Print("sz: ", sz)
	raw_message := make([]byte, sz)
	n, err := io.ReadFull(c.c, raw_message)
	if err != nil || n != int(sz) {
		return err
	}
	c.req.reset()
	log.Print("raw_message: ", string(raw_message))
	err = json.Unmarshal(raw_message, &(c.req))
	log.Print("after unmarshal: ", c.req)
	if err != nil {
		log.Print("err: ", err)
		return err
	}
	r.ServiceMethod = c.req.Method
	c.mutex.Lock()
	c.seq++
	c.pending[c.seq] = c.req.Id
	c.req.Id = nil
	r.Seq = c.seq
	c.mutex.Unlock()
	return nil
}

func (c *RedisServerCodec) innerReadRequestHeader(r *rpc.Request) (err error) {
	defer func() {
		if ret := recover(); ret != nil {
			err = errors.Errorf("Read Header:%s", ret)
		}
	}()

	m, err := bufioReadMessage(c.r)
	if err != nil {
		return
	}

	arr, err := m.Array()
	if err != nil {
		err = errors.Errorf("must by array type:%v", m.Type)
		return
	}

	op, _ := arr[0].Str()
	op = strings.ToLower(op)
	method, ok := methodMap[op]
	if !ok {
		err = errors.Errorf("method not supported:%s", op)
		return
	}
	r.ServiceMethod = method
	c.seq++
	r.Seq = c.seq
	c.msg = m
	return nil
}

func (this *Client) Call(method string, arg interface{}, reply interface{}) (e error) {

	clientConn := new(clientConn)
	clientConn.rest()
	this.codec = NewClientCodec(clientConn)
	req := rpc.Request{}
	req.Seq = defaultIdCreator.NewId()
	req.ServiceMethod = method
	e = this.codec.WriteRequest(&req, arg)
	buffer := bytes.NewBuffer(clientConn.Data)
	resp, e := http.Post(this.addr, "application/json", buffer)
	if e != nil {
		return
	}
	clientConn.SetResponse(resp)
	tmp := &rpc.Response{}
	e = this.codec.ReadResponseHeader(tmp)
	if e != nil {
		return
	}
	e = this.codec.ReadResponseBody(reply)
	if e != nil {
		return
	}
	fmt.Println(string(clientConn.Data))
	return
}

func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
	var req protorpcpb.Request
	if err := readFrame(c.rwc, &req); err != nil {
		return err
	}
	r.ServiceMethod = req.GetMethod()
	r.Seq = req.GetSeq()
	return nil
}

func writeRequest(c *clientCodec) error {
	head := rpc.Request{}
	head.ServiceMethod = "TestFunc"
	head.Seq = 1

	body := testpb.Request{}
	body.Query = proto.String("ping www.tencent.com")
	return c.WriteRequest(&head, &body)
}

func (c *codec) ReadRequestHeader(r *rpc.Request) error {
	c.header = internal.Header{} // reset
	if err := c.decode(&c.header); err != nil {
		return err
	}

	r.ServiceMethod = c.header.Method
	r.Seq = c.header.SeqID
	return nil
}

// ReadRequestHeader receives and decodes a net/rpc request header r.
func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
	// This is almost identical to ReadResponseHeader(), above.
	var err error
	var hdr ProtoRPCRequestHeader
	if err = c.m.ReadMessage(&hdr); err != nil {
		// Don't log an error here, since this is where normal EOF
		// happens over net/rpc channels, e.g., if a client finishes and
		// disconnects.
		return err
	}
	r.Seq = *hdr.Seq
	r.ServiceMethod = *hdr.Op
	return nil
}

// ReadRequestHeader reads the header protobuf (which is prefixed by a uvarint
// indicating its size) from the connection, decodes it, and stores the fields
// in the given request.
func (s *ServerCodec) ReadRequestHeader(req *rpc.Request) error {
	var header wire.Header
	if err := ReadProto(s.r, &header); err != nil {
		return err
	}
	if header.Method == nil {
		return fmt.Errorf("header missing method: %s", header)
	}
	if header.Seq == nil {
		return fmt.Errorf("header missing seq: %s", header)
	}
	req.ServiceMethod = *header.Method
	req.Seq = *header.Seq
	return nil
}

func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
	msg := <-c.msgs
	c.req.reset()
	if err := json.Unmarshal(msg.Body, &c.req); err != nil {
		return err
	}
	r.ServiceMethod = c.req.Method
	c.Lock()
	c.seq++
	c.pending[c.seq] = prop{msg.CorrelationId, msg.ReplyTo}
	r.Seq = c.seq
	c.Unlock()

	return nil
}

func (c *serverCodec) ReadRequestHeader(req *rpc.Request) error {
	line, err := c.r.ReadSlice('\n')
	if err != nil {
		return err
	}
	if len(line) <= 2 {
		return fmt.Errorf("incomplete request header")
	}
	llen, err := strconv.Atoi(string(line[:len(line)-2])) // ignore trailing CRLF
	if err != nil {
		return err
	}
	if llen < 0 {
		return fmt.Errorf("negative request header length")
	}
	b := make([]byte, llen+2) // 2 bytes for trailing CRLF
	_, err = io.ReadFull(c.r, b)
	if err != nil {
		return err
	}

	var header struct {
		Method string `json:"interface_name"`
		//Seq    uint64 `json:"seq"`
	}
	err = json.Unmarshal(b, &header)
	if err != nil {
		return err
	}
	req.ServiceMethod = header.Method
	// req.Seq = header.Seq
	return nil
}

func (this *ServerCodec) ReadRequestHeader(r *rpc.Request) (e error) {
	data, e := ioutil.ReadAll(this.conn)
	if e != nil {
		log.Println(e.Error())
		return
	}
	e = json.Unmarshal(data, &this.req)
	if e != nil {
		this.resp.Error = e.Error()
		return
	}
	r.Seq = this.req.Id
	r.ServiceMethod = this.req.Method
	log.Println("req:", string(*this.req.Params))
	return
}

func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
	header := wire.RequestHeader{}
	err := readRequestHeader(c.r, &header)
	if err != nil {
		return err
	}

	c.mutex.Lock()
	c.seq++
	c.pending[c.seq] = header.GetId()
	r.ServiceMethod = header.GetMethod()
	r.Seq = c.seq
	c.mutex.Unlock()

	c.reqHeader = header
	return nil
}

func (server *serverCodec) ReadRequestHeader(r *rpc.Request) error {
	server.curDelivery = <-server.message

	if server.curDelivery.CorrelationId == "" {
		return errors.New("no routing key in delivery")
	}

	r.Seq = atomic.AddUint64(&server.seq, 1)

	server.lock.Lock()
	server.calls[r.Seq] = route{server.curDelivery.MessageId, server.curDelivery.CorrelationId}
	server.lock.Unlock()

	r.ServiceMethod = server.curDelivery.ReplyTo

	return nil
}

func TestRW(t *testing.T) {
	var buf bufc

	var c codec
	c.w = &buf
	var req rpc.Request
	req.Seq = 1
	req.ServiceMethod = "foo"

	c.WriteRequest(&req, nil)
	c.r = bufio.NewReader(&buf)
	c.ReadRequestHeader(&req)

	if req.Seq != 1 || req.ServiceMethod != "foo" {
		t.Errorf("Request decode/encode mismatch")
	}

}