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

package/app/app.go

@@ -1,6 +1,7 @@
 package gaia
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -287,7 +288,7 @@ func NewGaiaApp(
 	appOpts servertypes.AppOptions,
 	baseAppOptions ...func(*baseapp.BaseApp),
 ) *GaiaApp {
-	defaultController := func(needReply bool, str string) (string, error) {
+	defaultController := func(ctx context.Context, needReply bool, str string) (string, error) {
 		fmt.Fprintln(os.Stderr, "FIXME: Would upcall to controller with", str)
 		return "", nil
 	}
@@ -299,7 +300,7 @@ func NewGaiaApp(
 }
 
 func NewAgoricApp(
-	sendToController func(bool, string) (string, error),
+	sendToController func(context.Context, bool, string) (string, error),
 	logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bool, skipUpgradeHeights map[int64]bool,
 	homePath string, invCheckPeriod uint, encodingConfig gaiaappparams.EncodingConfig, appOpts servertypes.AppOptions, baseAppOptions ...func(*baseapp.BaseApp),
 ) *GaiaApp {
@@ -449,7 +450,7 @@ func NewAgoricApp(
 		app.CheckControllerInited(true)
 		// We use SwingSet-level metering to charge the user for the call.
 		defer vm.SetControllerContext(ctx)()
-		return sendToController(true, str)
+		return sendToController(sdk.WrapSDKContext(ctx), true, str)
 	}
 
 	setBootstrapNeeded := func() {
@@ -481,7 +482,7 @@ func NewAgoricApp(
 			if err != nil {
 				return "", err
 			}
-			return sendToController(true, string(bz))
+			return sendToController(context.Background(), true, string(bz))
 		},
 	)
 

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,36 +1,158 @@
 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) {
+	var vmClient *rpc.Client
+	var shutdown func() error
+
+	nodePort := 1
+	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
+		if vmClient == nil {
+			return "", errors.New("sendToVM called without VM client set up")
+		}
+
+		if str == "shutdown" {
+			// We could ask nicely, but don't bother.
+			if shutdown != nil {
+				return "", shutdown()
+			}
+			return "", nil
+		}
+
+		msg := vm.Message{
+			Port: nodePort,
+			NeedsReply: needReply,
+			Data: str,
+		}
+		var reply string
+		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		return reply, err
+	}
+
+	exitCode := 0
+	launchVM := func(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 {
-			panic(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())
+		}
+
+		// 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
 		}
 
-		logger.Info("agd delegating to JS executable", "binary", binary, "args", args)
-		execErr := syscall.Exec(binary, args, os.Environ())
-		if execErr != nil {
-			panic(execErr)
+		// 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", vm.NewAgdServer()); 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 (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(logger, appOpts)
+	}
 
-	daemon.RunWithController(nil)
+	daemon.RunWithController(sendToNode)
 }

package/cmd/libdaemon/main.go

@@ -10,8 +10,9 @@ package main
 import "C"
 
 import (
+	"context"
 	"encoding/json"
-	"errors"
+	"net/rpc"
 	"os"
 	"path/filepath"
 
@@ -21,6 +22,7 @@ import (
 	"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"
+	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 )
 
 type goReturn = struct {
@@ -30,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, daemoncmd.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
+}
 
 //export RunAgCosmosDaemon
 func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char) C.int {
@@ -42,46 +68,39 @@ 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(needReply bool, str string) (string, error) {
-		var rPort int
-		if needReply {
-			lastReply++
-			rPort = lastReply
-			replies[rPort] = make(chan goReturn)
-		}
+	var sendToNode daemoncmd.Sender
 
-		// 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
-		}
-
-		// 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,
+	)
+	agdServer = vm.NewAgdServer()
+
 	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) {
+		daemoncmd.OnStartHook = func(logger log.Logger, appOpts servertypes.AppOptions) error {
 			// We tried running start, which should never exit, so exit with non-zero
 			// code if we ever stop.
 			exitCode = 99
+			return nil
 		}
 		daemon.RunWithController(sendToNode)
 		// fmt.Fprintln(os.Stderr, "Shutting down Cosmos")
@@ -94,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)
 }
 
@@ -121,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/daemon/cmd/root.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"context"
 	"errors"
 	"io"
 	"os"
@@ -38,11 +39,11 @@ import (
 )
 
 // Sender is a function that sends a request to the controller.
-type Sender func(needReply bool, str string) (string, error)
+type Sender func(ctx context.Context, needReply bool, str string) (string, error)
 
 var AppName = "agd"
-var OnStartHook func(logger log.Logger)
-var OnExportHook func(logger log.Logger)
+var OnStartHook func(log.Logger, servertypes.AppOptions) error
+var OnExportHook func(log.Logger, servertypes.AppOptions) error
 
 // NewRootCmd creates a new root command for simd. It is called once in the
 // main function.
@@ -60,7 +61,7 @@ func NewRootCmd(sender Sender) (*cobra.Command, params.EncodingConfig) {
 
 	rootCmd := &cobra.Command{
 		Use:   AppName,
-		Short: "Stargate Agoric App",
+		Short: "Agoric Cosmos App",
 		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
 			// set the default command outputs
 			cmd.SetOut(cmd.OutOrStdout())
@@ -135,10 +136,9 @@ func initRootCmd(sender Sender, rootCmd *cobra.Command, encodingConfig params.En
 	}
 	server.AddCommands(rootCmd, gaia.DefaultNodeHome, ac.newApp, ac.appExport, addModuleInitFlags)
 
-	hasVMController := sender != nil
 	for _, command := range rootCmd.Commands() {
 		if command.Name() == "export" {
-			extendCosmosExportCommand(command, hasVMController)
+			extendCosmosExportCommand(command)
 			break
 		}
 	}
@@ -154,8 +154,31 @@ func initRootCmd(sender Sender, rootCmd *cobra.Command, encodingConfig params.En
 	rootCmd.AddCommand(server.RosettaCommand(encodingConfig.InterfaceRegistry, encodingConfig.Marshaler))
 }
 
+const (
+	// FlagSplitVm is the command-line flag for subcommands that can use a
+	// split-process Agoric VM.  The default is to use an embedded VM.
+	FlagSplitVm = "split-vm"
+	EmbeddedVmEnvVar = "AGD_EMBEDDED_VM"
+)
+
+// hasVMController returns true if we have a VM (are running in split-vm mode,
+// or with an embedded VM).
+func hasVMController(serverCtx *server.Context) bool {
+	return serverCtx.Viper.GetString(FlagSplitVm) != "" ||
+		os.Getenv(EmbeddedVmEnvVar) != ""
+}
+
+func addAgoricVMFlags(cmd *cobra.Command) {
+	cmd.PersistentFlags().String(
+		FlagSplitVm,
+		"",
+		"Specify the external Agoric VM program",
+	)
+}
+
 func addModuleInitFlags(startCmd *cobra.Command) {
 	crisis.AddModuleInitFlags(startCmd)
+	addAgoricVMFlags(startCmd)
 }
 
 func queryCommand() *cobra.Command {
@@ -223,7 +246,9 @@ func (ac appCreator) newApp(
 	appOpts servertypes.AppOptions,
 ) servertypes.Application {
 	if OnStartHook != nil {
-		OnStartHook(logger)
+		if err := OnStartHook(logger, appOpts); err != nil {
+			panic(err)
+		}
 	}
 
 	var cache sdk.MultiStorePersistentCache
@@ -297,8 +322,9 @@ const (
 
 // extendCosmosExportCommand monkey-patches the "export" command added by
 // cosmos-sdk to add a required "export-dir" command-line flag, and create the
-// genesis export in the specified directory.
-func extendCosmosExportCommand(cmd *cobra.Command, hasVMController bool) {
+// genesis export in the specified directory if the VM is running.
+func extendCosmosExportCommand(cmd *cobra.Command) {
+	addAgoricVMFlags(cmd)
 	cmd.Flags().String(FlagExportDir, "", "The directory where to create the genesis export")
 	err := cmd.MarkFlagRequired(FlagExportDir)
 	if err != nil {
@@ -329,25 +355,28 @@ func extendCosmosExportCommand(cmd *cobra.Command, hasVMController bool) {
 		// current genesis.
 		serverCtx.Viper.Set(gaia.FlagSwingStoreExportDir, swingStoreExportPath)
 
-		// This will fail is a genesis.json already exists in the export-dir
-		genesisFile, err := os.OpenFile(genesisPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, os.ModePerm)
-		if err != nil {
-			return err
+		if hasVMController(serverCtx) {
+			// Capture the export in the genesisPath.
+			// This will fail if a genesis.json already exists in the export-dir
+			genesisFile, err := os.OpenFile(
+				genesisPath,
+				os.O_CREATE|os.O_EXCL|os.O_WRONLY,
+				os.ModePerm,
+			)
+			if err != nil {
+				return err
+			}
+			defer genesisFile.Close()
+			cmd.SetOut(genesisFile)
 		}
-		defer genesisFile.Close()
-
-		cmd.SetOut(genesisFile)
 
+		// If we don't have a VM, appExport will just use the OnExportHook to exec
+		// the VM program, which will result in reentering this function with the VM
+		// controller set, and activate the above condition.
 		return originalRunE(cmd, args)
 	}
 
-	// Only modify the command handler when we have a VM controller to handle
-	// the full export logic. Otherwise, appExport will just exec the VM program
-	// (OnExportHook), which will result in re-entering this flow with the VM
-	// controller set.
-	if hasVMController {
-		cmd.RunE = extendedRunE
-	}
+	cmd.RunE = extendedRunE
 }
 
 func (ac appCreator) appExport(
@@ -360,7 +389,9 @@ func (ac appCreator) appExport(
 	appOpts servertypes.AppOptions,
 ) (servertypes.ExportedApp, error) {
 	if OnExportHook != nil {
-		OnExportHook(logger)
+		if err := OnExportHook(logger, appOpts); err != nil {
+			return servertypes.ExportedApp{}, err
+		}
 	}
 
 	homePath, ok := appOpts.Get(flags.FlagHome).(string)

package/daemon/main.go

@@ -1,6 +1,7 @@
 package daemon
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/signal"
@@ -17,7 +18,7 @@ import (
 )
 
 // DefaultController is a stub controller.
-var DefaultController = func(needReply bool, str string) (string, error) {
+var DefaultController = func(ctx context.Context, needReply bool, str string) (string, error) {
 	return "", fmt.Errorf("Controller not configured; did you mean to use `ag-chain-cosmos` instead?")
 }
 
@@ -34,6 +35,7 @@ func RunWithController(sendToController cmd.Sender) {
 	signal.Notify(sigs, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		<-sigs
+		_, _ = sendToController(context.Background(), false, "shutdown")
 		os.Exit(98)
 	}()
 

package/git-revision.txt

@@ -1 +1 @@
-5fcf452
+d355030

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.34.2-dev-5fcf452.0+5fcf452",
+  "version": "0.34.2-dev-d355030.0+d355030",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -35,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5fcf4525cd4238b465f925dbf42f80f87800c116"
+  "gitHead": "d35503027f8de03dfedf7bc3a5adce00d0985435"
 }