summaryrefslogtreecommitdiff
path: root/src/pkg/exp/nacl/srpc/client.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/exp/nacl/srpc/client.go')
-rw-r--r--src/pkg/exp/nacl/srpc/client.go172
1 files changed, 86 insertions, 86 deletions
diff --git a/src/pkg/exp/nacl/srpc/client.go b/src/pkg/exp/nacl/srpc/client.go
index d19b48888..9e47376f8 100644
--- a/src/pkg/exp/nacl/srpc/client.go
+++ b/src/pkg/exp/nacl/srpc/client.go
@@ -6,48 +6,48 @@
package srpc
import (
- "bytes";
- "log";
- "os";
- "sync";
+ "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
+ 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
+ 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
+ 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);
+ 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{
@@ -55,54 +55,54 @@ func NewClient(fd int) (c *Client, err os.Error) {
isReq: true,
Ret: []interface{}{[]byte(nil)},
Size: []int{4000},
- };
- m.packRequest();
- c.s.send(m);
- m, err = c.r.recv();
+ }
+ m.packRequest()
+ c.s.send(m)
+ m, err = c.r.recv()
if err != nil {
return nil, err
}
- m.unpackResponse();
+ m.unpackResponse()
if m.status != OK {
- log.Stderrf("NewClient service_discovery: %s", m.status);
- return nil, m.status;
+ 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{':'});
+ i := bytes.Index(line, []byte{':'})
if i < 0 {
continue
}
- c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])};
+ 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;
+ c.out = make(chan *msg)
+ go c.input()
+ go c.output()
+ return c, nil
}
func (c *Client) input() {
for {
- m, err := c.r.recv();
+ 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;
+ log.Stderrf("invalid message: %s", m.status)
+ continue
}
- c.mu.Lock();
- rpc, ok := c.pending[m.requestId];
+ c.mu.Lock()
+ rpc, ok := c.pending[m.requestId]
if ok {
c.pending[m.requestId] = nil, false
}
- c.mu.Unlock();
+ c.mu.Unlock()
if !ok {
- log.Stderrf("unexpected response");
- continue;
+ log.Stderrf("unexpected response")
+ continue
}
- rpc.Ret = m.Ret;
- rpc.Done <- rpc;
+ rpc.Ret = m.Ret
+ rpc.Done <- rpc
}
}
@@ -117,11 +117,11 @@ 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};
+ 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.
@@ -129,25 +129,25 @@ func (c *Client) NewRPC(done chan *RPC) *RPC {
// 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;
+ var m msg
- r.Errno = OK;
- r.c.mu.Lock();
- srv, ok := r.c.service[name];
+ 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.mu.Unlock()
+ r.Errno = ErrBadRPCNumber
+ r.Done <- r
+ return
}
- r.c.pending[r.id] = r;
- r.c.mu.Unlock();
+ 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;
+ 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.
@@ -155,15 +155,15 @@ func (r *RPC) Start(name string, arg []interface{}) {
// Skip over input arguments.
// We could check them against arg, but the server
// will do that anyway.
- i := 0;
+ i := 0
for srv.fmt[i] != ':' {
i++
}
- fmt := srv.fmt[i+1:];
+ fmt := srv.fmt[i+1:]
// Now the return prototypes.
- m.Ret = make([]interface{}, len(fmt)-i);
- m.Size = make([]int, len(fmt)-i);
+ 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:
@@ -171,28 +171,28 @@ func (r *RPC) Start(name string, arg []interface{}) {
case 'b':
m.Ret[i] = false
case 'C':
- m.Ret[i] = []byte(nil);
- m.Size[i] = 1 << 30;
+ 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;
+ 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;
+ m.Ret[i] = []int32(nil)
+ m.Size[i] = 1 << 30
case 's':
- m.Ret[i] = "";
- m.Size[i] = 1 << 30;
+ m.Ret[i] = ""
+ m.Size[i] = 1 << 30
}
}
- m.packRequest();
- r.c.out <- &m;
+ m.packRequest()
+ r.c.out <- &m
}
// Call is a convenient wrapper that starts the RPC request,
@@ -204,7 +204,7 @@ func (r *RPC) Start(name string, arg []interface{}) {
// 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;
+ r.Start(name, arg)
+ <-r.Done
+ return r.Ret, r.Errno
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-15 03:29:52 +0000