unistack-org/micro
4
0
Fork 2
Code Issues 18 Pull Requests Actions Packages Projects Releases 331 Wiki Activity

Updated codec interface and code. Painful stuff

Browse Source
This commit is contained in:
Asim
2015-11-28 11:22:29 +00:00
parent f49922f6b3
commit 654728027b
18 changed files with 380 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
client/buffer.go
View File

@@ -1,13 +1,14 @@
package client
import (
"io"
"bytes"
)
type buffer struct {
io.ReadWriter
*bytes.Buffer
}
func (b *buffer) Close() error {
b.Buffer.Reset()
return nil
}

101
client/codec.go
View File

@@ -1,101 +0,0 @@
package client
import (
"io"
"net/rpc"
"sync"
"github.com/micro/go-micro/codec"
"github.com/youtube/vitess/go/rpcplus"
"github.com/youtube/vitess/go/rpcplus/jsonrpc"
"github.com/youtube/vitess/go/rpcplus/pbrpc"
)
var (
defaultContentType = "application/octet-stream"
defaultCodecs = map[string]codecFunc{
"application/json": jsonrpc.NewClientCodec,
"application/json-rpc": jsonrpc.NewClientCodec,
"application/protobuf": pbrpc.NewClientCodec,
"application/proto-rpc": pbrpc.NewClientCodec,
"application/octet-stream": pbrpc.NewClientCodec,
}
)
// only for internal use
type codecFunc func(io.ReadWriteCloser) rpcplus.ClientCodec
// wraps an net/rpc ClientCodec to provide an rpcplus.ClientCodec
// temporary until we strip out use of rpcplus
type rpcCodecWrap struct {
sync.Mutex
c codec.Codec
rwc io.ReadWriteCloser
}
func (cw *rpcCodecWrap) WriteRequest(r *rpcplus.Request, b interface{}) error {
cw.Lock()
defer cw.Unlock()
req := &rpc.Request{ServiceMethod: r.ServiceMethod, Seq: r.Seq}
data, err := cw.c.Marshal(req)
if err != nil {
return err
}
_, err = pbrpc.WriteNetString(cw.rwc, data)
if err != nil {
return err
}
data, err = cw.c.Marshal(b)
if err != nil {
return err
}
_, err = pbrpc.WriteNetString(cw.rwc, data)
if err != nil {
return err
}
return nil
}
func (cw *rpcCodecWrap) ReadResponseHeader(r *rpcplus.Response) error {
data, err := pbrpc.ReadNetString(cw.rwc)
if err != nil {
return err
}
rtmp := new(rpc.Response)
err = cw.c.Unmarshal(data, rtmp)
if err != nil {
return err
}
r.ServiceMethod = rtmp.ServiceMethod
r.Seq = rtmp.Seq
r.Error = rtmp.Error
return nil
}
func (cw *rpcCodecWrap) ReadResponseBody(b interface{}) error {
data, err := pbrpc.ReadNetString(cw.rwc)
if err != nil {
return err
}
if b != nil {
return cw.c.Unmarshal(data, b)
}
return nil
}
func (cw *rpcCodecWrap) Close() error {
return cw.rwc.Close()
}
// wraps a CodecFunc to provide an internal codecFunc
// temporary until we strip rpcplus out
func codecWrap(c codec.Codec) codecFunc {
return func(rwc io.ReadWriteCloser) rpcplus.ClientCodec {
return &rpcCodecWrap{
rwc: rwc,
c: c,
}
}
}

4
client/options.go
View File

@@ -10,7 +10,7 @@ import (
type options struct {
contentType string
broker broker.Broker
codecs map[string]codec.Codec
codecs map[string]codec.NewCodec
registry registry.Registry
transport transport.Transport
wrappers []Wrapper
@@ -24,7 +24,7 @@ func Broker(b broker.Broker) Option {
}
// Codec to be used to encode/decode requests for a given content type
func Codec(contentType string, c codec.Codec) Option {
func Codec(contentType string, c codec.NewCodec) Option {
return func(o *options) {
o.codecs[contentType] = c
}

40
client/rpc_client.go
View File

@@ -1,7 +1,7 @@
package client
import (
"encoding/json"
"bytes"
"fmt"
"sync"
@@ -13,8 +13,6 @@ import (
"github.com/micro/go-micro/transport"
rpc "github.com/youtube/vitess/go/rpcplus"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
)
@@ -27,7 +25,7 @@ func newRpcClient(opt ...Option) Client {
var once sync.Once
opts := options{
codecs: make(map[string]codec.Codec),
codecs: make(map[string]codec.NewCodec),
}
for _, o := range opt {
@@ -37,7 +35,6 @@ func newRpcClient(opt ...Option) Client {
if len(opts.contentType) == 0 {
opts.contentType = defaultContentType
}
fmt.Println("content type", opts.contentType)
if opts.transport == nil {
opts.transport = transport.DefaultTransport
@@ -62,9 +59,9 @@ func newRpcClient(opt ...Option) Client {
return c
}
func (r *rpcClient) codecFunc(contentType string) (codecFunc, error) {
func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
if c, ok := r.opts.codecs[contentType]; ok {
return codecWrap(c), nil
return c, nil
}
if cf, ok := defaultCodecs[contentType]; ok {
return cf, nil
@@ -86,7 +83,7 @@ func (r *rpcClient) call(ctx context.Context, address string, request Request, r
msg.Header["Content-Type"] = request.ContentType()
cf, err := r.codecFunc(request.ContentType())
cf, err := r.newCodec(request.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
@@ -119,7 +116,7 @@ func (r *rpcClient) stream(ctx context.Context, address string, request Request,
msg.Header["Content-Type"] = request.ContentType()
cf, err := r.codecFunc(request.ContentType())
cf, err := r.newCodec(request.ContentType())
if err != nil {
return nil, errors.InternalServerError("go.micro.client", err.Error())
}
@@ -194,30 +191,21 @@ func (r *rpcClient) Publish(ctx context.Context, p Publication) error {
md["Content-Type"] = p.ContentType()
// encode message body
var body []byte
switch p.ContentType() {
case "application/octet-stream":
b, err := proto.Marshal(p.Message().(proto.Message))
if err != nil {
return err
}
body = b
case "application/json":
b, err := json.Marshal(p.Message())
if err != nil {
return err
}
body = b
cf, err := r.newCodec(p.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
b := &buffer{bytes.NewBuffer(nil)}
if err := cf(b).Write(&codec.Message{Type: codec.Publication}, p.Message()); err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
r.once.Do(func() {
r.opts.broker.Connect()
})
return r.opts.broker.Publish(p.Topic(), &broker.Message{
Header: md,
Body: body,
Body: b.Bytes(),
})
}

39
client/rpc_codec.go
View File

@@ -3,13 +3,15 @@ package client
import (
"bytes"
"github.com/micro/go-micro/codec"
"github.com/micro/go-micro/codec/proto"
"github.com/micro/go-micro/transport"
rpc "github.com/youtube/vitess/go/rpcplus"
)
type rpcPlusCodec struct {
client transport.Client
codec rpc.ClientCodec
codec codec.Codec
req *transport.Message
buf *readWriteCloser
@@ -20,6 +22,18 @@ type readWriteCloser struct {
rbuf *bytes.Buffer
}
var (
defaultContentType = "application/octet-stream"
defaultCodecs = map[string]codec.NewCodec{
// "application/json": jsonrpc.NewClientCodec,
// "application/json-rpc": jsonrpc.NewClientCodec,
"application/protobuf": proto.NewCodec,
"application/proto-rpc": proto.NewCodec,
"application/octet-stream": proto.NewCodec,
}
)
func (rwc *readWriteCloser) Read(p []byte) (n int, err error) {
return rwc.rbuf.Read(p)
}
@@ -34,7 +48,7 @@ func (rwc *readWriteCloser) Close() error {
return nil
}
func newRpcPlusCodec(req *transport.Message, client transport.Client, cf codecFunc) *rpcPlusCodec {
func newRpcPlusCodec(req *transport.Message, client transport.Client, c codec.NewCodec) *rpcPlusCodec {
rwc := &readWriteCloser{
wbuf: bytes.NewBuffer(nil),
rbuf: bytes.NewBuffer(nil),
@@ -42,14 +56,19 @@ func newRpcPlusCodec(req *transport.Message, client transport.Client, cf codecFu
r := &rpcPlusCodec{
buf: rwc,
client: client,
codec: cf(rwc),
codec: c(rwc),
req: req,
}
return r
}
func (c *rpcPlusCodec) WriteRequest(req *rpc.Request, body interface{}) error {
if err := c.codec.WriteRequest(req, body); err != nil {
m := &codec.Message{
Id: req.Seq,
Method: req.ServiceMethod,
Type: codec.Request,
}
if err := c.codec.Write(m, body); err != nil {
return err
}
c.req.Body = c.buf.wbuf.Bytes()
@@ -63,14 +82,20 @@ func (c *rpcPlusCodec) ReadResponseHeader(r *rpc.Response) error {
}
c.buf.rbuf.Reset()
c.buf.rbuf.Write(m.Body)
return c.codec.ReadResponseHeader(r)
var me codec.Message
err := c.codec.ReadHeader(&me, codec.Response)
r.ServiceMethod = me.Method
r.Seq = me.Id
r.Error = me.Error
return err
}
func (c *rpcPlusCodec) ReadResponseBody(r interface{}) error {
return c.codec.ReadResponseBody(r)
func (c *rpcPlusCodec) ReadResponseBody(b interface{}) error {
return c.codec.ReadBody(b)
}
func (c *rpcPlusCodec) Close() error {
c.buf.Close()
c.codec.Close()
return c.client.Close()
}