| // Copyright 2009 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| // This package implements Native Client's simple RPC (SRPC). | |
| package srpc | |
| import ( | |
| "bytes" | |
| "log" | |
| "os" | |
| "sync" | |
| ) | |
| // A Client represents the client side of an SRPC connection. | |
| type Client struct { | |
| fd int // fd to server | |
| r msgReceiver | |
| s msgSender | |
| service map[string]srv // services by name | |
| out chan *msg // send to out to write to connection | |
| mu sync.Mutex // protects pending, idGen | |
| pending map[uint64]*RPC | |
| idGen uint64 // generator for request IDs | |
| } | |
| // A srv is a single method that the server offers. | |
| type srv struct { | |
| num uint32 // method number | |
| fmt string // argument format | |
| } | |
| // An RPC represents a single RPC issued by a client. | |
| type RPC struct { | |
| Ret []interface{} // Return values | |
| Done chan *RPC // Channel where notification of done arrives | |
| Errno Errno // Status code | |
| c *Client | |
| id uint64 // request id | |
| } | |
| // NewClient allocates a new client using the file descriptor fd. | |
| func NewClient(fd int) (c *Client, err os.Error) { | |
| c = new(Client) | |
| c.fd = fd | |
| c.r.fd = fd | |
| c.s.fd = fd | |
| c.service = make(map[string]srv) | |
| c.pending = make(map[uint64]*RPC) | |
| // service discovery request | |
| m := &msg{ | |
| protocol: protocol, | |
| isReq: true, | |
| Ret: []interface{}{[]byte(nil)}, | |
| Size: []int{4000}, | |
| } | |
| m.packRequest() | |
| c.s.send(m) | |
| m, err = c.r.recv() | |
| if err != nil { | |
| return nil, err | |
| } | |
| m.unpackResponse() | |
| if m.status != OK { | |
| log.Stderrf("NewClient service_discovery: %s", m.status) | |
| return nil, m.status | |
| } | |
| for n, line := range bytes.Split(m.Ret[0].([]byte), []byte{'\n'}, 0) { | |
| i := bytes.Index(line, []byte{':'}) | |
| if i < 0 { | |
| continue | |
| } | |
| c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])} | |
| } | |
| c.out = make(chan *msg) | |
| go c.input() | |
| go c.output() | |
| return c, nil | |
| } | |
| func (c *Client) input() { | |
| for { | |
| m, err := c.r.recv() | |
| if err != nil { | |
| log.Exitf("client recv: %s", err) | |
| } | |
| if m.unpackResponse(); m.status != OK { | |
| log.Stderrf("invalid message: %s", m.status) | |
| continue | |
| } | |
| c.mu.Lock() | |
| rpc, ok := c.pending[m.requestId] | |
| if ok { | |
| c.pending[m.requestId] = nil, false | |
| } | |
| c.mu.Unlock() | |
| if !ok { | |
| log.Stderrf("unexpected response") | |
| continue | |
| } | |
| rpc.Ret = m.Ret | |
| rpc.Done <- rpc | |
| } | |
| } | |
| func (c *Client) output() { | |
| for m := range c.out { | |
| c.s.send(m) | |
| } | |
| } | |
| // NewRPC creates a new RPC on the client connection. | |
| func (c *Client) NewRPC(done chan *RPC) *RPC { | |
| if done == nil { | |
| done = make(chan *RPC) | |
| } | |
| c.mu.Lock() | |
| id := c.idGen | |
| c.idGen++ | |
| c.mu.Unlock() | |
| return &RPC{nil, done, OK, c, id} | |
| } | |
| // Start issues an RPC request for method name with the given arguments. | |
| // The RPC r must not be in use for another pending request. | |
| // To wait for the RPC to finish, receive from r.Done and then | |
| // inspect r.Ret and r.Errno. | |
| func (r *RPC) Start(name string, arg []interface{}) { | |
| var m msg | |
| r.Errno = OK | |
| r.c.mu.Lock() | |
| srv, ok := r.c.service[name] | |
| if !ok { | |
| r.c.mu.Unlock() | |
| r.Errno = ErrBadRPCNumber | |
| r.Done <- r | |
| return | |
| } | |
| r.c.pending[r.id] = r | |
| r.c.mu.Unlock() | |
| m.protocol = protocol | |
| m.requestId = r.id | |
| m.isReq = true | |
| m.rpcNumber = srv.num | |
| m.Arg = arg | |
| // Fill in the return values and sizes to generate | |
| // the right type chars. We'll take most any size. | |
| // Skip over input arguments. | |
| // We could check them against arg, but the server | |
| // will do that anyway. | |
| i := 0 | |
| for srv.fmt[i] != ':' { | |
| i++ | |
| } | |
| fmt := srv.fmt[i+1:] | |
| // Now the return prototypes. | |
| m.Ret = make([]interface{}, len(fmt)-i) | |
| m.Size = make([]int, len(fmt)-i) | |
| for i := 0; i < len(fmt); i++ { | |
| switch fmt[i] { | |
| default: | |
| log.Exitf("unexpected service type %c", fmt[i]) | |
| case 'b': | |
| m.Ret[i] = false | |
| case 'C': | |
| m.Ret[i] = []byte(nil) | |
| m.Size[i] = 1 << 30 | |
| case 'd': | |
| m.Ret[i] = float64(0) | |
| case 'D': | |
| m.Ret[i] = []float64(nil) | |
| m.Size[i] = 1 << 30 | |
| case 'h': | |
| m.Ret[i] = int(-1) | |
| case 'i': | |
| m.Ret[i] = int32(0) | |
| case 'I': | |
| m.Ret[i] = []int32(nil) | |
| m.Size[i] = 1 << 30 | |
| case 's': | |
| m.Ret[i] = "" | |
| m.Size[i] = 1 << 30 | |
| } | |
| } | |
| m.packRequest() | |
| r.c.out <- &m | |
| } | |
| // Call is a convenient wrapper that starts the RPC request, | |
| // waits for it to finish, and then returns the results. | |
| // Its implementation is: | |
| // | |
| // r.Start(name, arg); | |
| // <-r.Done; | |
| // return r.Ret, r.Errno; | |
| // | |
| func (r *RPC) Call(name string, arg []interface{}) (ret []interface{}, err Errno) { | |
| r.Start(name, arg) | |
| <-r.Done | |
| return r.Ret, r.Errno | |
| } |