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

package/app/upgrade.go

@@ -0,0 +1,77 @@
+package gaia
+
+import (
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	swingsetkeeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
+)
+
+var upgradeNamesOfThisVersion = map[string]bool{
+	"agoric-upgrade-16":   true,
+	"agoric-upgrade-16-2": true,
+}
+
+func isFirstTimeUpgradeOfThisVersion(app *GaiaApp, ctx sdk.Context) bool {
+	for name := range upgradeNamesOfThisVersion {
+		if app.UpgradeKeeper.GetDoneHeight(ctx, name) != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// upgrade16Handler performs standard upgrade actions plus custom actions for upgrade-16.
+func upgrade16Handler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgradetypes.Plan, module.VersionMap) (module.VersionMap, error) {
+	return func(ctx sdk.Context, plan upgradetypes.Plan, fromVm module.VersionMap) (module.VersionMap, error) {
+		app.CheckControllerInited(false)
+
+		CoreProposalSteps := []vm.CoreProposalStep{}
+
+		// These CoreProposalSteps are not idempotent and should only be executed
+		// as part of the first upgrade using this handler on any given chain.
+		if isFirstTimeUpgradeOfThisVersion(app, ctx) {
+			// Each CoreProposalStep runs sequentially, and can be constructed from
+			// one or more modules executing in parallel within the step.
+			CoreProposalSteps = []vm.CoreProposalStep{
+				// Upgrade Zoe + ZCF
+				vm.CoreProposalStepForModules("@agoric/builders/scripts/vats/replace-zoe.js"),
+				// Revive KREAd characters
+				vm.CoreProposalStepForModules("@agoric/builders/scripts/vats/revive-kread.js"),
+
+				// upgrade the provisioning vat
+				vm.CoreProposalStepForModules("@agoric/builders/scripts/vats/replace-provisioning.js"),
+				// Enable low-level Orchestration.
+				vm.CoreProposalStepForModules(
+					"@agoric/builders/scripts/vats/init-network.js",
+					"@agoric/builders/scripts/vats/init-localchain.js",
+					"@agoric/builders/scripts/vats/init-transfer.js",
+				),
+			}
+		}
+
+		app.upgradeDetails = &upgradeDetails{
+			// Record the plan to send to SwingSet
+			Plan: plan,
+			// Core proposals that should run during the upgrade block
+			// These will be merged with any coreProposals specified in the
+			// upgradeInfo field of the upgrade plan ran as subsequent steps
+			CoreProposals: vm.CoreProposalsFromSteps(CoreProposalSteps...),
+		}
+
+		// Always run module migrations
+		mvm, err := app.mm.RunMigrations(ctx, app.configurator, fromVm)
+		if err != nil {
+			return mvm, err
+		}
+
+		m := swingsetkeeper.NewMigrator(app.SwingSetKeeper)
+		err = m.MigrateParams(ctx)
+		if err != nil {
+			return mvm, err
+		}
+
+		return mvm, nil
+	}
+}

package/cmd/agd/agvm.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+
+	"github.com/tendermint/tendermint/libs/log"
+)
+
+// NewVMCommand creates a new OS command to run the Agoric VM.  It sets up the
+// file descriptors for the VM to communicate with agd, and passes their numbers
+// via AGVM_FROM_AGD and AGVM_TO_AGD environment variables.
+func NewVMCommand(logger log.Logger, binary string, args []string, vmFromAgd, vmToAgd *os.File) *exec.Cmd {
+	logger.Info("agd connecting to VM", "binary", binary, "args", args)
+	cmd := exec.Command(binary, args[1:]...)
+
+	// Manage the file descriptors.
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+	numStdFiles := 3 // stdin, stdout, stderr
+
+	// We start our file descriptor allocations after the standard ones, including
+	// Node.js IPC (fd=3).
+	fdFromAgd := 4
+	fdToAgd := fdFromAgd + 1
+
+	// ExtraFiles begins at fd numStdFiles, so we need to compute the array.
+	cmd.ExtraFiles = make([]*os.File, fdToAgd - numStdFiles + 1)
+	cmd.ExtraFiles[fdFromAgd - numStdFiles] = vmFromAgd
+	cmd.ExtraFiles[fdToAgd - numStdFiles] = vmToAgd
+
+	// Pass the file descriptor numbers in the environment.
+	cmd.Env = append(
+		os.Environ(),
+		fmt.Sprintf("AGVM_FROM_AGD=%d", fdFromAgd),
+		fmt.Sprintf("AGVM_TO_AGD=%d", fdToAgd),
+	)
+
+	return cmd
+}

package/cmd/agd/main.go

@@ -1,38 +1,157 @@
 package main
 
 import (
+	"context"
+	"errors"
+	"net/rpc"
+	"net/rpc/jsonrpc"
 	"os"
+	"os/exec"
 	"syscall"
+	"time"
 
+	"github.com/spf13/cast"
 	"github.com/tendermint/tendermint/libs/log"
 
 	gaia "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon"
 	daemoncmd "github.com/Agoric/agoric-sdk/golang/cosmos/daemon/cmd"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm/jsonrpcconn"
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 )
 
+// TerminateSubprocessGracePeriod is how long we wait between closing the pipe
+// waiting for it to exit, then sending a termination signal.
+const TerminateSubprocessGracePeriod = 3 * time.Second
+
+// KillSubprocessGracePeriod is how long we wait between sending a subprocess a
+// termination signal, waiting for it to exit, then killing it.
+const KillSubprocessGracePeriod = 5 * time.Second
+
+// makeShutdown returns a function that terminates the vm.
+func makeShutdown(cmd *exec.Cmd, writer *os.File) func() error {
+	return func() error {
+		// Stop talking to the subprocess.
+		_ = writer.Close()
+		go func() {
+			// Wait a bit.
+			time.Sleep(TerminateSubprocessGracePeriod)
+			// Then punch it in the shoulder.
+			_ = cmd.Process.Signal(os.Interrupt)
+			// Wait a bit.
+			time.Sleep(KillSubprocessGracePeriod)
+			// Then blow it away.
+			_ = cmd.Process.Kill()
+		}()
+		// Wait for it to keel over.
+		return cmd.Wait()
+	}
+}
+
+// main is the entry point of the agd daemon.  It determines whether to
+// initialize JSON-RPC communications with the separate `--split-vm` VM process,
+// or just to give up control entirely to another binary.
 func main() {
-	// We need to delegate to our default app for running the actual chain.
-	launchVM := func(logger log.Logger, appOpts servertypes.AppOptions) error {
+	var vmClient *rpc.Client
+	var shutdown func() error
+
+	nodePort := 1
+	var sendToNode vm.Sender = func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
+		if vmClient == nil {
+			return "", errors.New("sendToVM called without VM client set up")
+		}
+
+		if jsonRequest == "shutdown" {
+			// We could ask nicely, but don't bother.
+			if shutdown != nil {
+				return "", shutdown()
+			}
+			return "", nil
+		}
+
+		msg := vm.Message{
+			Port:       nodePort,
+			NeedsReply: needReply,
+			Data:       jsonRequest,
+		}
+		var reply string
+		err = vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		return reply, err
+	}
+
+	exitCode := 0
+	launchVM := func(agdServer *vm.AgdServer, logger log.Logger, appOpts servertypes.AppOptions) error {
 		args := []string{"ag-chain-cosmos", "--home", gaia.DefaultNodeHome}
 		args = append(args, os.Args[1:]...)
 
-		binary, lookErr := FindCosmicSwingsetBinary()
-		if lookErr != nil {
-			return lookErr
+		binary := cast.ToString(appOpts.Get(daemoncmd.FlagSplitVm))
+		if binary == "" {
+			binary, lookErr := FindCosmicSwingsetBinary()
+			if lookErr != nil {
+				return lookErr
+			}
+
+			// We completely delegate to our default app for running the actual chain.
+			logger.Info("agd delegating to JS executable", "binary", binary, "args", args)
+			return syscall.Exec(binary, args, os.Environ())
 		}
 
-		logger.Info("agd delegating to JS executable", "binary", binary, "args", args)
-		execErr := syscall.Exec(binary, args, os.Environ())
-		if execErr != nil {
-			return execErr
+		// Split the execution between us and the VM.
+		agdFromVm, vmToAgd, err := os.Pipe()
+		if err != nil {
+			return err
 		}
+		vmFromAgd, agdToVm, err := os.Pipe()
+		if err != nil {
+			return err
+		}
+
+		// Start the command running, then continue.
+		args[0] = binary
+		cmd := NewVMCommand(logger, binary, args, vmFromAgd, vmToAgd)
+		shutdown = makeShutdown(cmd, agdToVm)
+
+		if err := cmd.Start(); err != nil {
+			return err
+		}
+		if vmFromAgd.Close() != nil {
+			return err
+		}
+		if vmToAgd.Close() != nil {
+			return err
+		}
+
+		// Multiplex bidirectional JSON-RPC over the pipes.
+		agvmConn := jsonrpcconn.NewConn(agdFromVm, agdToVm)
+		clientConn, serverConn := jsonrpcconn.ClientServerConn(agvmConn)
+
+		// Set up the VM server.
+		vmServer := rpc.NewServer()
+		if err := vmServer.RegisterName("agd", agdServer); err != nil {
+			return err
+		}
+		go vmServer.ServeCodec(jsonrpc.NewServerCodec(serverConn))
+
+		// Set up the VM client.
+		vmClient = jsonrpc.NewClient(clientConn)
+
+		go func() {
+			// Premature exit from `agd start` should exit the process.
+			_ = cmd.Wait()
+			os.Exit(exitCode)
+		}()
+
 		return nil
 	}
 
-	daemoncmd.OnStartHook = launchVM
 	daemoncmd.OnExportHook = launchVM
+	daemoncmd.OnStartHook = func(agdServer *vm.AgdServer, logger log.Logger, appOpts servertypes.AppOptions) error {
+		// We tried running start, which should never exit, so exit with non-zero
+		// code if we do.
+		exitCode = 99
+		return launchVM(agdServer, logger, appOpts)
+	}
 
-	daemon.RunWithController(nil)
+	daemon.RunWithController(sendToNode)
 }

package/cmd/libdaemon/main.go

@@ -12,7 +12,7 @@ import "C"
 import (
 	"context"
 	"encoding/json"
-	"errors"
+	"net/rpc"
 	"os"
 	"path/filepath"
 
@@ -32,8 +32,32 @@ type goReturn = struct {
 
 const SwingSetPort = 123
 
-var replies = map[int]chan goReturn{}
-var lastReply = 0
+var vmClientCodec *vm.ClientCodec
+var agdServer *vm.AgdServer
+
+// 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)
+
+	var sendToNode vm.Sender = 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
+}
 
 //export RunAgCosmosDaemon
 func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char) C.int {
@@ -44,43 +68,35 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 
 	gaia.DefaultNodeHome = filepath.Join(userHomeDir, ".ag-chain-cosmos")
 	daemoncmd.AppName = "ag-chain-cosmos"
+	if err := os.Setenv(daemoncmd.EmbeddedVmEnvVar, "libdaemon"); err != nil {
+		panic(err)
+	}
 
-	// FIXME: Decouple the sending logic from the Cosmos app.
-	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
-		var rPort int
-		if needReply {
-			lastReply++
-			rPort = lastReply
-			replies[rPort] = make(chan goReturn)
-		}
-
-		// Send the message
-		C.invokeSendFunc(toNode, nodePort, C.int(rPort), C.CString(str))
-		if !needReply {
-			// Return immediately
-			// fmt.Fprintln(os.Stderr, "Don't wait")
-			return "<no-reply-requested>", nil
-		}
+	var sendToNode vm.Sender
 
-		// Block the sending goroutine while we wait for the reply
-		// fmt.Fprintln(os.Stderr, "Waiting for", rPort)
-		ret := <-replies[rPort]
-		delete(replies, rPort)
-		// fmt.Fprintln(os.Stderr, "Woken, got", ret)
-		return ret.str, ret.err
+	sendFunc := func(port int, reply int, str string) {
+		C.invokeSendFunc(toNode, C.int(port), C.int(reply), C.CString(str))
 	}
 
+	vmClientCodec, sendToNode = ConnectVMClientCodec(
+		context.Background(),
+		int(nodePort),
+		sendFunc,
+	)
+
 	args := make([]string, len(cosmosArgs))
 	for i, s := range cosmosArgs {
 		args[i] = C.GoString(s)
 	}
+
 	// fmt.Fprintln(os.Stderr, "Starting Cosmos", args)
 	os.Args = args
 	go func() {
 		// We run in the background, but exit when the job is over.
 		// swingset.SendToNode("hello from Initial Go!")
 		exitCode := 0
-		daemoncmd.OnStartHook = func(logger log.Logger, appOpts servertypes.AppOptions) error {
+		daemoncmd.OnStartHook = func(srv *vm.AgdServer, logger log.Logger, appOpts servertypes.AppOptions) error {
+			agdServer = srv
 			// We tried running start, which should never exit, so exit with non-zero
 			// code if we ever stop.
 			exitCode = 99
@@ -97,22 +113,10 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 //export ReplyToGo
 func ReplyToGo(replyPort C.int, isError C.int, resp C.Body) C.int {
 	respStr := C.GoString(resp)
-	// fmt.Fprintln(os.Stderr, "Reply to Go", respStr)
-	returnCh := replies[int(replyPort)]
-	if returnCh == nil {
-		// Unexpected reply.
-		// This is okay, since the caller decides whether or
-		// not she wants to listen for replies.
-		return C.int(0)
+	// fmt.Printf("Reply to Go %d %s\n", replyPort, respStr)
+	if err := vmClientCodec.Receive(int(replyPort), int(isError) != 0, respStr); err != nil {
+		return C.int(1)
 	}
-	// Wake up the waiting goroutine
-	ret := goReturn{}
-	if int(isError) == 0 {
-		ret.str = respStr
-	} else {
-		ret.err = errors.New(respStr)
-	}
-	returnCh <- ret
 	return C.int(0)
 }
 
@@ -124,20 +128,27 @@ type errorWrapper struct {
 func SendToGo(port C.int, msg C.Body) C.Body {
 	msgStr := C.GoString(msg)
 	// fmt.Fprintln(os.Stderr, "Send to Go", msgStr)
-	respStr, err := vm.ReceiveFromController(int(port), msgStr)
+	var respStr string
+	message := &vm.Message{
+		Port:       int(port),
+		NeedsReply: true,
+		Data:       msgStr,
+	}
+
+	err := agdServer.ReceiveMessage(message, &respStr)
+	if err == nil {
+		return C.CString(respStr)
+	}
+
+	// fmt.Fprintln(os.Stderr, "Cannot receive from controller", err)
+	errResp := errorWrapper{
+		Error: err.Error(),
+	}
+	respBytes, err := json.Marshal(&errResp)
 	if err != nil {
-		// fmt.Fprintln(os.Stderr, "Cannot receive from controller", err)
-		errResp := errorWrapper{
-			Error: err.Error(),
-		}
-		respBytes, err := json.Marshal(&errResp)
-		if err != nil {
-			panic(err)
-		}
-		// fmt.Fprintln(os.Stderr, "Marshaled", errResp, respBytes)
-		respStr = string(respBytes)
+		panic(err)
 	}
-	return C.CString(respStr)
+	return C.CString(string(respBytes))
 }
 
 // Do nothing in main.

package/cmd/libdaemon/main_test.go

@@ -5,11 +5,12 @@ import (
 	"strings"
 	"testing"
 
+	sdkioerrors "cosmossdk.io/errors"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 func TestErrorStackTraces(t *testing.T) {
-	err := sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "my error %d", 123)
+	err := sdkioerrors.Wrapf(sdkerrors.ErrInsufficientFee, "my error %d", 123)
 	expected := "my error 123: insufficient fee"
 
 	// Check that sdkerrors.Wrapf(...).Error() does not leak stack.