@agoric/cosmos 0.34.2-dev-5fcf452.0 → 0.34.2-dev-d355030.0

package/vm/client.go

@@ -0,0 +1,113 @@
+package vm
+
+import (
+	"context"
+	"fmt"
+	"net/rpc"
+)
+
+// ReceiveMessageMethod is the name of the method we call in order to have the
+// VM receive a Message.
+const ReceiveMessageMethod = "agvm.ReceiveMessage"
+
+// Message is what we send to the VM.
+type Message struct {
+	Port int
+	Data string
+	NeedsReply bool
+}
+
+// ClientCodec implements rpc.ClientCodec.
+var _ rpc.ClientCodec = (*ClientCodec)(nil)
+
+// ClientCodec implements a net/rpc ClientCodec for the "bridge" between the Go
+// runtime and the VM in the single-process dual-runtime configuration.
+//
+// We expect to call it via the legacy API with signature:
+//    sendToController func(needsReply bool, msg string) (string, error)
+// where msg and the returned string are JSON-encoded values.
+//
+// Note that the net/rpc framework cannot express a call that does not expect a
+// response, so we'll note such calls by sending with a reply port of 0 and
+// having the WriteRequest() method fabricate a Receive() call to clear the rpc
+// state.
+type ClientCodec struct {
+	ctx context.Context
+	send func(port, rPort int, msg string)
+	outbound map[int]rpc.Request
+	inbound chan *rpc.Response
+	replies map[uint64]string
+	replyToRead uint64
+}
+
+// NewClientCodec creates a new ClientCodec.
+func NewClientCodec(ctx context.Context, send func(int, int, string)) *ClientCodec {
+	return &ClientCodec{
+		ctx: ctx,
+		send: send,
+		outbound: make(map[int]rpc.Request),
+		inbound: make(chan *rpc.Response),
+		replies: make(map[uint64]string),
+	}
+}
+
+// WriteRequest sends a request to the VM.
+func (cc *ClientCodec) WriteRequest(r *rpc.Request, body interface{}) error {
+	if r.ServiceMethod != ReceiveMessageMethod {
+		return fmt.Errorf("unknown method %s", r.ServiceMethod)
+	}
+
+	msg, ok := body.(Message)
+	if !ok {
+		return fmt.Errorf("body %T is not a Message", body)
+	}
+	rPort := int(r.Seq + 1) // rPort is 1-indexed to indicate it's required
+	cc.outbound[rPort] = *r
+	var senderReplyPort int
+	if msg.NeedsReply {
+		senderReplyPort = rPort
+	}
+	cc.send(msg.Port, senderReplyPort, msg.Data)
+	if !msg.NeedsReply {
+		return cc.Receive(rPort, false, "<no-reply-requested>")
+	}
+	return nil
+}
+
+// ReadResponseHeader decodes a response header from the VM.
+func (cc *ClientCodec) ReadResponseHeader(r *rpc.Response) error {
+	resp := <-cc.inbound
+	*r = *resp
+	cc.replyToRead = r.Seq
+	return nil
+}
+
+// ReadResponseBody decodes a response body (currently just string) from the VM.
+func (cc *ClientCodec) ReadResponseBody(body interface{}) error {
+	if body != nil {
+		*body.(*string) = cc.replies[cc.replyToRead]
+	}
+	delete(cc.replies, cc.replyToRead)
+	return nil
+}
+
+// Receive is called by the VM to send a response to the client.
+func (cc *ClientCodec) Receive(rPort int, isError bool, data string) error {
+	outb := cc.outbound[rPort]
+	delete(cc.outbound, rPort)
+	resp := &rpc.Response{
+		ServiceMethod: outb.ServiceMethod,
+		Seq: outb.Seq,
+	}
+	if isError {
+		resp.Error = data
+	} else {
+		cc.replies[resp.Seq] = data
+	}
+	cc.inbound <- resp
+	return nil
+}
+
+func (cc *ClientCodec) Close() error {
+	return nil
+}

package/vm/client_test.go

@@ -0,0 +1,184 @@
+package vm_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/rpc"
+	"testing"
+	"time"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+)
+
+type Sender func(ctx context.Context, needReply bool, str string) (string, error)
+
+type errorWrapper struct {
+	Error string `json:"error"`
+}
+
+// ConnectVMClientCodec creates an RPC client codec and a sender to the
+// in-process implementation of the VM.
+func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int, int, string)) (*vm.ClientCodec, Sender) {
+	vmClientCodec := vm.NewClientCodec(context.Background(), sendFunc)
+	vmClient := rpc.NewClientWithCodec(vmClientCodec)
+
+	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
+		if str == "shutdown" {
+			return "", vmClientCodec.Close()
+		}
+
+		msg := vm.Message{
+			Port: nodePort,
+			NeedsReply: needReply,
+			Data: str,
+		}
+		var reply string
+		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		return reply, err
+	}
+
+	return vmClientCodec, sendToNode
+}
+
+type Fixture struct {
+	SendToNode Sender
+	SendToGo func (port int, msgStr string) string
+	ReplyToGo func (replyPort int, isError bool, respStr string) int
+}
+
+func NewFixture(t *testing.T) (*Fixture) {
+	nodePort := 42
+
+	f := &Fixture{}
+
+	sendFunc := func(port int, reply int, str string) {
+		switch str {
+			case "ping":
+				time.AfterFunc(100*time.Millisecond, func() {
+					fmt.Printf("sendFunc: port=%d, reply=%d, str=%s\n", port, reply, str)
+					if reply != 0 {
+						f.ReplyToGo(reply, false, "pong")
+					}
+				})
+			case "wait":
+				time.AfterFunc(300*time.Millisecond, func() {
+					fmt.Printf("sendFunc: port=%d, reply=%d, str=%s\n", port, reply, str)
+					if reply != 0 {
+						f.ReplyToGo(reply, false, "done-waiting")
+					}
+				})
+			default:
+				t.Errorf("Unexpected message %s", str)
+		}
+	}
+
+	vmClientCodec, sendToNode := ConnectVMClientCodec(
+		context.Background(),
+		int(nodePort),
+		sendFunc,
+	)
+	agdServer := vm.NewAgdServer()
+
+	f.SendToNode = sendToNode
+	f.SendToGo = func (port int, msgStr string) string {
+		fmt.Println("Send to Go", msgStr)
+		var respStr string
+		message := &vm.Message{
+			Port: int(port),
+			NeedsReply: true,
+			Data: msgStr,
+		}
+		
+		err := agdServer.ReceiveMessage(message, &respStr)
+		if err == nil {
+			return respStr
+		}
+	
+		// fmt.Fprintln(os.Stderr, "Cannot receive from controller", err)
+		errResp := errorWrapper{
+			Error: err.Error(),
+		}
+		respBytes, err := json.Marshal(&errResp)
+		if err != nil {
+			panic(err)
+		}
+		return string(respBytes)
+	}
+
+	f.ReplyToGo = func (replyPort int, isError bool, respStr string) int {
+		if err := vmClientCodec.Receive(replyPort, isError, respStr); err != nil {
+			return 1
+		}
+		return 0
+	}
+
+	return f
+}
+
+func TestClient_oneOutbound(t *testing.T) {
+	f := NewFixture(t)
+
+	// Try one blocking call.
+	ret, err := f.SendToNode(context.Background(), true, "ping")
+	if err != nil {
+		t.Error(err)
+	}
+	if ret != "pong" {
+		t.Errorf("ping want pong, got %s", ret)
+	}
+}
+
+func TestClient_ShortBg(t *testing.T) {
+
+	f := NewFixture(t)
+
+	// Try a short background call with a long overlapping call.
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		ret, err := f.SendToNode(context.Background(), true, "ping")
+		if err != nil {
+			t.Error(err)
+		}
+		if ret != "pong" {
+			t.Errorf("ping want pong, got %s", ret)
+		}
+	}()
+
+	ret, err := f.SendToNode(context.Background(), true, "wait")
+	if err != nil {
+		t.Error(err)
+	}
+	if ret != "done-waiting" {
+		t.Errorf("wait want done-waiting, got %s", ret)
+	}
+	<-done
+}
+
+func TestClient_LongBg(t *testing.T) {
+
+	f := NewFixture(t)
+
+	// Try a long background call with a short overlapping call.
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		ret, err := f.SendToNode(context.Background(), true, "wait")
+		if err != nil {
+			t.Error(err)
+		}
+		if ret != "done-waiting" {
+			t.Errorf("ping want done-waiting, got %s", ret)
+		}
+	}()
+
+	ret, err := f.SendToNode(context.Background(), true, "ping")
+	if err != nil {
+		t.Error(err)
+	}
+	if ret != "pong" {
+		t.Errorf("wait want pong, got %s", ret)
+	}
+	<-done
+}

package/vm/controller.go

@@ -1,16 +1,11 @@
 package vm
 
 import (
-	"fmt"
+	"context"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-type ControllerContext struct {
-	Context               sdk.Context
-	IBCChannelHandlerPort int
-}
-
 type ControllerAdmissionMsg interface {
 	sdk.Msg
 	CheckAdmissibility(sdk.Context, interface{}) error
@@ -31,10 +26,13 @@ type Jsonable interface{}
 // ActionPusher enqueues data for later consumption by the controller.
 type ActionPusher func(ctx sdk.Context, action Jsonable) error
 
-var controllerContext ControllerContext
+var wrappedEmptySDKContext = sdk.WrapSDKContext(
+	sdk.Context{}.WithContext(context.Background()),
+)
+var controllerContext context.Context = wrappedEmptySDKContext
 
 type PortHandler interface {
-	Receive(*ControllerContext, string) (string, error)
+	Receive(context.Context, string) (string, error)
 }
 
 var portToHandler = make(map[int]PortHandler)
@@ -45,9 +43,9 @@ var lastPort = 0
 func SetControllerContext(ctx sdk.Context) func() {
 	// We are only called by the controller, so we assume that it is billing its
 	// own meter usage.
-	controllerContext.Context = ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
+	controllerContext = sdk.WrapSDKContext(ctx.WithGasMeter(sdk.NewInfiniteGasMeter()))
 	return func() {
-		controllerContext.Context = sdk.Context{}
+		controllerContext = wrappedEmptySDKContext
 	}
 }
 
@@ -69,11 +67,3 @@ func UnregisterPortHandler(portNum int) error {
 	delete(nameToPort, name)
 	return nil
 }
-
-func ReceiveFromController(portNum int, msg string) (string, error) {
-	handler := portToHandler[portNum]
-	if handler == nil {
-		return "", fmt.Errorf("unregistered port %d", portNum)
-	}
-	return handler.Receive(&controllerContext, msg)
-}

package/vm/jsonrpcconn/jsonrpcconn.go

@@ -0,0 +1,160 @@
+/*
+Package jsonrpcconn provides a way to multiplex an io stream into two
+streams where incoming JSON-RPC requests go to one stream and incoming
+JSON-RPC responses go to another. Outputs are merged.
+
+The JSON-RPCv1 protocol is peer-to-peer, but the implementation in the Go
+standard library only supports client-server. By multiplexing a single
+io.ReadWriteCloser stream into separate server (receives requests) and
+client (receives responses) streams, two RPC halves can share the same
+underlying connection.
+*/
+package jsonrpcconn
+
+import (
+	"encoding/json"
+	"io"
+)
+
+// jsonRpcMsg can unmarshal either a JSON-RPC
+// request or response object.
+type jsonRpcMsg struct {
+	Error  json.RawMessage   `json:"error"`
+	Id     json.RawMessage   `json:"id"`
+	Method *string           `json:"method"`
+	Params []json.RawMessage `json:"params"`
+	Result json.RawMessage   `json:"result"`
+}
+
+// mux holds the underlying connection and the pipe reader/writer
+// pairs for the server (request) and client (response) sides.
+// Any protocol error or closing any channel will cause shutdown.
+type mux struct {
+	conn       io.ReadWriteCloser
+	reqReader  *io.PipeReader
+	reqWriter  *io.PipeWriter
+	respReader *io.PipeReader
+	respWriter *io.PipeWriter
+}
+
+func newMux(conn io.ReadWriteCloser) mux {
+	reqReader, reqWriter := io.Pipe()
+	respReader, respWriter := io.Pipe()
+	m := mux{
+		conn:       conn,
+		reqReader:  reqReader,
+		reqWriter:  reqWriter,
+		respReader: respReader,
+		respWriter: respWriter,
+	}
+	go m.input()
+	return m
+}
+
+func (m mux) input() {
+	var err error
+	dec := json.NewDecoder(m.conn)
+	for {
+		// read the next JSON value, preserve its wire format
+		var raw json.RawMessage
+		err = dec.Decode(&raw)
+		if err != nil {
+			break
+		}
+
+		// parse as JSON-RPC
+		var msg jsonRpcMsg
+		err = json.Unmarshal(raw, &msg)
+		if err != nil {
+			break
+		}
+
+		// send to one of the outputs
+		if msg.Method != nil {
+			// presume a request, the consumer will handle any missing fields
+			_, err = m.reqWriter.Write(raw)
+		} else {
+			// presume a response, the consumer will handle any missing fields
+			_, err = m.respWriter.Write(raw)
+		}
+		if err != nil {
+			break
+		}
+	}
+	m.reqWriter.CloseWithError(err)
+	m.respWriter.CloseWithError(err)
+	m.conn.Close()
+}
+
+// clientChan is a view of the mux for the client channel.
+type clientChan mux
+
+// Close implements the io.Closer interface.
+func (c clientChan) Close() error {
+	return c.conn.Close()
+}
+
+// Read implements the io.Reader interface.
+func (c clientChan) Read(p []byte) (int, error) {
+	return c.respReader.Read(p)
+}
+
+// Write implements the io.Writer interface.
+func (c clientChan) Write(p []byte) (int, error) {
+	return c.conn.Write(p)
+}
+
+// serverChan is a view of the mux for the server channel.
+type serverChan mux
+
+// Close implements the io.Closer interface.
+func (s serverChan) Close() error {
+	return s.conn.Close()
+}
+
+// Read implements the io.Reader interface.
+func (s serverChan) Read(p []byte) (int, error) {
+	return s.reqReader.Read(p)
+}
+
+// Write implements the io.Writer interface.
+func (s serverChan) Write(p []byte) (int, error) {
+	return s.conn.Write(p)
+}
+
+// ClientServerConn multiplexes an input/output stream for the JSON-RPCv1
+// protocol into streams specific for client traffic and server traffic.
+// Full JSON objects must be written atomically to either stream to
+// interleave correctly.
+func ClientServerConn(conn io.ReadWriteCloser) (clientConn io.ReadWriteCloser, serverConn io.ReadWriteCloser) {
+	m := newMux(conn)
+	clientConn = clientChan(m)
+	serverConn = serverChan(m)
+	return
+}
+
+type conn struct {
+	rd io.ReadCloser
+	wr io.WriteCloser
+}
+
+// Close implments the io.Closer interface.
+func (e conn) Close() error {
+	e.rd.Close()
+	return e.wr.Close()
+}
+
+// Read implements the io.Reader interface.
+func (e conn) Read(p []byte) (int, error) {
+	return e.rd.Read(p)
+}
+
+// Write implements the io.Writer interface.
+func (e conn) Write(p []byte) (int, error) {
+	return e.wr.Write(p)
+}
+
+// NewConn returns a connection from a reader and a writer.
+func NewConn(rd io.ReadCloser, wr io.WriteCloser) io.ReadWriteCloser {
+	return conn{rd: rd, wr: wr}
+}

package/vm/jsonrpcconn/jsonrpcconn_test.go

@@ -0,0 +1,126 @@
+package jsonrpcconn_test
+
+import (
+	"fmt"
+	"net"
+	"net/rpc"
+	"net/rpc/jsonrpc"
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm/jsonrpcconn"
+)
+
+/*
+type testConn struct {
+	input  *bytes.Buffer
+	output *bytes.Buffer
+	done   chan struct{}
+}
+
+func newTestConn(input string) io.ReadWriteCloser {
+	return testConn{
+		input:  bytes.NewBufferString(input),
+		output: new(bytes.Buffer),
+		done:   make(chan struct{}),
+	}
+}
+
+func (tc testConn) Read(p []byte) (int, error) {
+	n, err := tc.input.Read(p)
+	if err == io.EOF {
+		<-tc.done
+	}
+	return n, err
+}
+
+func (tc testConn) Write(p []byte) (int, error) {
+	return tc.output.Write(p)
+}
+
+func (tc testConn) Close() error {
+	close(tc.done)
+	return nil
+}
+
+func TestMux(t *testing.T) {
+	input := `{"id": 1, "method": "foo", "params": [1, 2]}
+	{"id": "aaa", "result": true, "error": null}
+	{"id": null, "method": "bar", "params": ["string", 3, false]}`
+	tc := newTestConn(input)
+	client, server := jsonrpcconn.ClientServerConn(tc)
+	client.Read
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+
+	}()
+	wg.Wait()
+} */
+
+type Args struct {
+	A, B int
+}
+
+type Arith struct{}
+
+func (a *Arith) Add(args Args, reply *int) error {
+	*reply = args.A + args.B
+	return nil
+}
+
+func (a *Arith) Mul(args Args, reply *int) error {
+	*reply = args.A * args.B
+	return nil
+}
+
+func (a *Arith) Oops(args Args, reply *int) error {
+	return fmt.Errorf("oops")
+}
+
+func TestJsonRPC(t *testing.T) {
+	left, right := net.Pipe()
+	leftClientConn, leftServerConn := jsonrpcconn.ClientServerConn(left)
+	rightClientConn, rightServerConn := jsonrpcconn.ClientServerConn(right)
+
+	leftClient := jsonrpc.NewClient(leftClientConn)
+	leftServer := rpc.NewServer()
+	err := leftServer.RegisterName("foo", new(Arith))
+	if err != nil {
+		t.Fatal(err)
+	}
+	go leftServer.ServeCodec(jsonrpc.NewServerCodec(leftServerConn))
+
+	rightClient := jsonrpc.NewClient(rightClientConn)
+	rightServer := rpc.NewServer()
+	err = rightServer.RegisterName("bar", new(Arith))
+	if err != nil {
+		t.Fatal(err)
+	}
+	go rightServer.ServeCodec(jsonrpc.NewServerCodec(rightServerConn))
+
+	var reply int
+	err = leftClient.Call("bar.Add", Args{1, 2}, &reply)
+	if err != nil {
+		t.Error(err)
+	}
+	if reply != 3 {
+		t.Errorf("bar.Add want 3, got %d", reply)
+	}
+
+	err = rightClient.Call("foo.Mul", Args{2, 3}, &reply)
+	if err != nil {
+		t.Error(err)
+	}
+	if reply != 6 {
+		t.Errorf("foo.Mul want 6, got %d", reply)
+	}
+
+	err = leftClient.Call("bar.Oops", Args{7, 11}, &reply)
+	if err == nil {
+		t.Errorf("bar.Oops want error, got reply %d", reply)
+	} else if err.Error() != "oops" {
+		t.Errorf(`bar.Oops want error "oops", got "%s"`, err.Error())
+	}
+	leftClient.Close()
+	rightClient.Close()
+}

package/vm/server.go

@@ -0,0 +1,23 @@
+package vm
+
+import (
+	"fmt"
+)
+
+type AgdServer struct {}
+
+func NewAgdServer() *AgdServer {
+	return &AgdServer{}
+}
+
+// ReceiveMessage is the method the VM calls in order to have agd receive a
+// Message.
+func (s AgdServer) ReceiveMessage(msg *Message, reply *string) error {
+	handler := portToHandler[msg.Port]
+	if handler == nil {
+		return fmt.Errorf("unregistered port %d", msg.Port)
+	}
+	resp, err := handler.Receive(controllerContext, msg.Data)
+	*reply = resp
+	return err
+}

package/x/lien/lien.go

@@ -5,6 +5,7 @@
 package lien
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"math"
@@ -70,7 +71,8 @@ const (
 // Receives and processes a bridge message, returning the
 // JSON-encoded response or error.
 // See spec/02_messages.md for the messages and responses.
-func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (string, error) {
+func (ch portHandler) Receive(cctx context.Context, str string) (string, error) {
+	ctx := sdk.UnwrapSDKContext(cctx)
 	var msg portMessage
 	err := json.Unmarshal([]byte(str), &msg)
 	if err != nil {
@@ -78,13 +80,13 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (string, er
 	}
 	switch msg.Type {
 	case LIEN_GET_ACCOUNT_STATE:
-		return ch.handleGetAccountState(ctx.Context, msg)
+		return ch.handleGetAccountState(ctx, msg)
 
 	case LIEN_GET_STAKING:
-		return ch.handleGetStaking(ctx.Context, msg)
+		return ch.handleGetStaking(ctx, msg)
 
 	case LIEN_CHANGE_LIENED:
-		return ch.handleChangeLiened(ctx.Context, msg)
+		return ch.handleChangeLiened(ctx, msg)
 	}
 	return "", fmt.Errorf("unrecognized type %s", msg.Type)
 }