@agoric/cosmos 0.35.0-u15.0 → 0.35.0-u16.0

package/vm/action.go

@@ -18,7 +18,7 @@ var (
 type Jsonable interface{}
 
 type Action interface {
-	GetActionHeader() ActionHeader
+	GetActionHeader() *ActionHeader
 }
 
 // ActionPusher enqueues data for later consumption by the controller.
@@ -27,14 +27,14 @@ type ActionPusher func(ctx sdk.Context, action Action) error
 // ActionHeader should be embedded in all actions.  It is populated by PopulateAction.
 type ActionHeader struct {
 	// Type defaults to the `actionType:"..."` tag of the embedder's ActionHeader field.
-	Type string `json:"type"`
+	Type string `json:"type,omitempty"`
 	// BlockHeight defaults to sdk.Context.BlockHeight().
 	BlockHeight int64 `json:"blockHeight,omitempty"`
 	// BlockTime defaults to sdk.Context.BlockTime().Unix().
 	BlockTime int64 `json:"blockTime,omitempty"`
 }
 
-func (ah ActionHeader) GetActionHeader() ActionHeader {
+func (ah *ActionHeader) GetActionHeader() *ActionHeader {
 	return ah
 }
 
@@ -129,5 +129,6 @@ func PopulateAction(ctx sdk.Context, action Action) Action {
 			}
 		}
 	}
-	return newActionDesc.Interface().(Action)
+
+	return newActionDescPtr.Interface().(Action)
 }

package/vm/action_test.go

@@ -10,9 +10,11 @@ import (
 )
 
 var (
-	_ vm.Action = &Trivial{}
+	_ vm.Action = Defaults{}
 	_ vm.Action = &Defaults{}
+	_ vm.Action = dataAction{}
 	_ vm.Action = &dataAction{}
+	_ vm.Action = &Trivial{}
 )
 
 type Trivial struct {
@@ -29,8 +31,8 @@ type Defaults struct {
 	Any    interface{}
 }
 
-func (d Defaults) GetActionHeader() vm.ActionHeader {
-	return vm.ActionHeader{}
+func (d Defaults) GetActionHeader() *vm.ActionHeader {
+	return &vm.ActionHeader{}
 }
 
 type dataAction struct {
@@ -52,6 +54,10 @@ func TestActionContext(t *testing.T) {
 			&Trivial{Abc: 123, def: "zot"},
 			&Trivial{Abc: 123, def: "zot"},
 		},
+		{"not a pointer", emptyCtx,
+			&Trivial{Abc: 123, def: "zot"},
+			Trivial{Abc: 123, def: "zot"},
+		},
 		{"block height",
 			emptyCtx.WithBlockHeight(998),
 			&Trivial{Abc: 123, def: "zot"},
@@ -67,6 +73,20 @@ func TestActionContext(t *testing.T) {
 			&Defaults{},
 			&Defaults{"abc", 123, 4.56, true, nil},
 		},
+		{"data action no pointer",
+			emptyCtx,
+			dataAction{},
+			dataAction{
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION"},
+			},
+		},
+		{"data action pointer",
+			emptyCtx,
+			&dataAction{},
+			&dataAction{
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION"},
+			},
+		},
 		{"data action defaults",
 			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
 			&dataAction{Data: []byte("hello")},
@@ -75,30 +95,30 @@ func TestActionContext(t *testing.T) {
 		},
 		{"data action override Type",
 			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2"}},
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2", BlockHeight: 998, BlockTime: 1}},
 		},
 		{"data action override BlockHeight",
 			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{BlockHeight: 999}},
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION", BlockHeight: 999, BlockTime: 1}},
 		},
 		{"data action override BlockTime",
 			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{BlockTime: 2}},
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION", BlockHeight: 998, BlockTime: 2}},
 		},
 		{"data action override all defaults",
 			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2", BlockHeight: 999, BlockTime: 2}},
-			&dataAction{Data: []byte("hello2"),
+			dataAction{Data: []byte("hello2"),
 				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2", BlockHeight: 999, BlockTime: 2}},
 		},
 	}

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,182 @@
+package vm_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/rpc"
+	"testing"
+	"time"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+)
+
+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, vm.Sender) {
+	vmClientCodec := vm.NewClientCodec(ctx, sendFunc)
+	vmClient := rpc.NewClientWithCodec(vmClientCodec)
+
+	sendToNode := func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
+		if jsonRequest == "shutdown" {
+			return "", vmClientCodec.Close()
+		}
+
+		msg := vm.Message{
+			Port:       nodePort,
+			NeedsReply: needReply,
+			Data:       jsonRequest,
+		}
+		var reply string
+		err = vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		return reply, err
+	}
+
+	return vmClientCodec, sendToNode
+}
+
+type Fixture struct {
+	SendToNode vm.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{}
+	agdServer := vm.NewAgdServer()
+
+	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,
+	)
+
+	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

@@ -7,6 +7,9 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+// Sender makes a request of our associated VM.
+type Sender func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error)
+
 type ControllerAdmissionMsg interface {
 	sdk.Msg
 	CheckAdmissibility(sdk.Context, interface{}) error
@@ -21,52 +24,26 @@ type ControllerAdmissionMsg interface {
 	IsHighPriority(sdk.Context, interface{}) (bool, error)
 }
 
-var wrappedEmptySDKContext = sdk.WrapSDKContext(
-	sdk.Context{}.WithContext(context.Background()),
-)
-var controllerContext context.Context = wrappedEmptySDKContext
-
 type PortHandler interface {
 	Receive(context.Context, string) (string, error)
 }
 
-var portToHandler = make(map[int]PortHandler)
-var portToName = make(map[int]string)
-var nameToPort = make(map[string]int)
-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 = sdk.WrapSDKContext(ctx.WithGasMeter(sdk.NewInfiniteGasMeter()))
-	return func() {
-		controllerContext = wrappedEmptySDKContext
-	}
+type protectedPortHandler struct {
+	inner PortHandler
 }
 
-func GetPort(name string) int {
-	return nameToPort[name]
-}
-
-func RegisterPortHandler(name string, portHandler PortHandler) int {
-	lastPort++
-	portToHandler[lastPort] = portHandler
-	portToName[lastPort] = name
-	nameToPort[name] = lastPort
-	return lastPort
-}
-func UnregisterPortHandler(portNum int) error {
-	delete(portToHandler, portNum)
-	name := portToName[portNum]
-	delete(portToName, portNum)
-	delete(nameToPort, name)
-	return nil
+func (h protectedPortHandler) Receive(ctx context.Context, str string) (ret string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			// Propagate just the string, not the error stack or we will invite
+			// nondeterminism.
+			err = fmt.Errorf("panic: %s", r)
+		}
+	}()
+	ret, err = h.inner.Receive(ctx, str)
+	return
 }
 
-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)
+func NewProtectedPortHandler(inner PortHandler) PortHandler {
+	return protectedPortHandler{inner}
 }

package/vm/core_proposals.go

@@ -1,5 +1,10 @@
 package vm
 
+import (
+	"encoding/json"
+	"fmt"
+)
+
 // CoreProposalStep is a set of core proposal configs which are executed
 // concurrently
 type CoreProposalStep []Jsonable
@@ -11,12 +16,27 @@ type CoreProposals struct {
 	Steps []CoreProposalStep `json:"steps"`
 }
 
+type ArbitraryCoreProposal struct {
+	Json json.RawMessage
+}
+
+func NewArbitraryCoreProposal(jsonStr string) *ArbitraryCoreProposal {
+	return &ArbitraryCoreProposal{Json: []byte(jsonStr)}
+}
+
 // CoreProposalStepForModules generates a single core proposal step from
 // the given modules, which will be executed concurrently during that step
-func CoreProposalStepForModules(modules ...string) CoreProposalStep {
+func CoreProposalStepForModules(modules ...Jsonable) CoreProposalStep {
 	step := make([]Jsonable, len(modules))
 	for i := range modules {
-		step[i] = modules[i]
+		switch m := modules[i].(type) {
+		case ArbitraryCoreProposal:
+			step[i] = m.Json
+		case string:
+			step[i] = m
+		default:
+			panic(fmt.Errorf("unexpected step type %T", m))
+		}
 	}
 	return step
 }

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}
+}