@agoric/cosmos 0.34.2-dev-ecf2d8e.0 → 0.35.0-other-dev-70beeb7.0

package/CHANGELOG.md

@@ -3,6 +3,51 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.35.0-u11.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/cosmos@0.34.1...@agoric/cosmos@0.35.0-u11.0) (2023-08-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* **cosmos:** add required export-dir export cmd option
+* remove deprecated `ag-cosmos-helper`
+
+### Features
+
+* **agd:** try harder to find cosmic-swingset ([a1d1666](https://github.com/Agoric/agoric-sdk/commit/a1d1666997c2f5b9c7bf14748f6d9603c0b3c5f9))
+* **cosmic-swingset:** add repair-metadata snapshot restore option ([ebbb982](https://github.com/Agoric/agoric-sdk/commit/ebbb9829f1f845c0932ae92b23d0d43be9a0e196))
+* **cosmic-swingset:** replace import/export options ([393b91b](https://github.com/Agoric/agoric-sdk/commit/393b91baaa25c61364955102e8cfcdcaec90870d))
+* **cosmic-swingset:** use x/swingset for swing-store export data ([3336b62](https://github.com/Agoric/agoric-sdk/commit/3336b62fbb10bd2293a832f8c30e590530d14213))
+* **cosmos:** add required export-dir export cmd option ([8d2571c](https://github.com/Agoric/agoric-sdk/commit/8d2571c51c2fe08d630dd2897d7e5e1b45ab45c9))
+* **cosmos:** fix and migrate swing-store ([6ba1957](https://github.com/Agoric/agoric-sdk/commit/6ba19571688518dcfdc4553a0c822695a61908b1))
+* **cosmos:** KVEntry implements json Marshaler and Unmarshaller ([6d2fe11](https://github.com/Agoric/agoric-sdk/commit/6d2fe11d144c5bbdc1611b59c84b6842e8084cb9))
+* **cosmos:** spawn JS on export command ([fe4eb56](https://github.com/Agoric/agoric-sdk/commit/fe4eb56facf83569aa343f098e97c6229556afa9))
+* **cosmos:** wire new swingset port handler ([3361b25](https://github.com/Agoric/agoric-sdk/commit/3361b25ddaa00116476d3de1107e800499ab5c21))
+* **x/swingset:** add store data to genesis ([df72903](https://github.com/Agoric/agoric-sdk/commit/df729030643a097262ad1393503d380e243107eb))
+* **x/swingset:** add WaitUntilSwingStoreExportDone ([f8acd22](https://github.com/Agoric/agoric-sdk/commit/f8acd22381ff3da4682bcb0cdcf71665095506a4))
+* **x/swingset:** allow taking snapshot latest height ([0c0e742](https://github.com/Agoric/agoric-sdk/commit/0c0e74227d34d49ac7ce76ce8e92715816d5ea6a))
+* **x/swingset:** export swing store in genesis ([e5f9425](https://github.com/Agoric/agoric-sdk/commit/e5f9425e74c7235323cd6b1b88540b73b57a69a6))
+* **x/swingset:** import swing store from genesis state ([2446cf4](https://github.com/Agoric/agoric-sdk/commit/2446cf43bb13aad7de0805cd7e33c966d2e31016))
+* Cosmos upgrade handler calls swingset ([66f7bcc](https://github.com/Agoric/agoric-sdk/commit/66f7bccce7ce30cf5b9e1e5321710567c05723cb))
+
+
+### Bug Fixes
+
+* **cosmos:** don't init controller before upgrade ([e567c21](https://github.com/Agoric/agoric-sdk/commit/e567c21a224d239c467f740bb937f84b18db9dd7))
+* **cosmos:** module order independent init and bootstrap ([3ce4012](https://github.com/Agoric/agoric-sdk/commit/3ce4012ea99b39b2d6bfd422b1d7ea7a7e904568))
+* **cosmos:** prevent Golang error wrapping stack frame divergence ([1d8acf6](https://github.com/Agoric/agoric-sdk/commit/1d8acf6270cadfbcdafb1081360155260d031ac1))
+* **cosmos:** Support building on Linux aarch64 ([475708e](https://github.com/Agoric/agoric-sdk/commit/475708e63bb95d75184072547ca92586a978c5a0))
+* **x/swingset:** enforce snapshot restore before init ([c946d58](https://github.com/Agoric/agoric-sdk/commit/c946d5866ef956c198d7ea14936eb9904aa272ae))
+* **x/swingset:** guard snapshot restore for concurrency ([5320a30](https://github.com/Agoric/agoric-sdk/commit/5320a30a873455764104e13d89131e30a93a238c))
+* **x/swingset:** switch export/import to replay artifact level ([c037ea3](https://github.com/Agoric/agoric-sdk/commit/c037ea3931877fe4d56df5b82cc7c3eb77a84a53))
+* **x/vstorage:** value can be empty in genesis data ([9a51df5](https://github.com/Agoric/agoric-sdk/commit/9a51df515b87638b869564ab08445a0ce0d55707))
+
+
+### Build System
+
+* remove deprecated `ag-cosmos-helper` ([ee43112](https://github.com/Agoric/agoric-sdk/commit/ee431121e3f93406896f8a9e7d949fbf1427c44e))
+
+
+
 ### [0.34.1](https://github.com/Agoric/agoric-sdk/compare/@agoric/cosmos@0.34.0...@agoric/cosmos@0.34.1) (2023-06-09)
 
 **Note:** Version bump only for package @agoric/cosmos

package/app/app.go

@@ -1,7 +1,6 @@
 package gaia
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -288,7 +287,7 @@ func NewGaiaApp(
 	appOpts servertypes.AppOptions,
 	baseAppOptions ...func(*baseapp.BaseApp),
 ) *GaiaApp {
-	defaultController := func(ctx context.Context, needReply bool, str string) (string, error) {
+	defaultController := func(needReply bool, str string) (string, error) {
 		fmt.Fprintln(os.Stderr, "FIXME: Would upcall to controller with", str)
 		return "", nil
 	}
@@ -300,7 +299,7 @@ func NewGaiaApp(
 }
 
 func NewAgoricApp(
-	sendToController func(context.Context, bool, string) (string, error),
+	sendToController func(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 {
@@ -450,7 +449,7 @@ func NewAgoricApp(
 		app.CheckControllerInited(true)
 		// We use SwingSet-level metering to charge the user for the call.
 		defer vm.SetControllerContext(ctx)()
-		return sendToController(sdk.WrapSDKContext(ctx), true, str)
+		return sendToController(true, str)
 	}
 
 	setBootstrapNeeded := func() {
@@ -482,7 +481,7 @@ func NewAgoricApp(
 			if err != nil {
 				return "", err
 			}
-			return sendToController(context.Background(), true, string(bz))
+			return sendToController(true, string(bz))
 		},
 	)
 
@@ -791,18 +790,13 @@ func NewAgoricApp(
 	app.SetBeginBlocker(app.BeginBlocker)
 	app.SetEndBlocker(app.EndBlocker)
 
-	const (
-		upgradeName     = "agoric-upgrade-12"
-		upgradeNameTest = "agorictest-upgrade-12"
-	)
-	
 	app.UpgradeKeeper.SetUpgradeHandler(
 		upgradeName,
-		upgrade12Handler(app, upgradeName),
+		upgrade11Handler(app, upgradeName),
 	)
 	app.UpgradeKeeper.SetUpgradeHandler(
 		upgradeNameTest,
-		upgrade12Handler(app, upgradeNameTest),
+		upgrade11Handler(app, upgradeNameTest),
 	)
 
 	if loadLatest {
@@ -825,13 +819,108 @@ func NewAgoricApp(
 	return app
 }
 
-// upgrade12Handler performs standard upgrade actions plus custom actions for upgrade-12.
-func upgrade12Handler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgradetypes.Plan, module.VersionMap) (module.VersionMap, error) {
+type swingStoreMigrationEventHandler struct {
+	swingStore sdk.KVStore
+}
+
+func (eventHandler swingStoreMigrationEventHandler) OnExportStarted(height uint64, retrieveSwingStoreExport func() error) error {
+	return retrieveSwingStoreExport()
+}
+
+func (eventHandler swingStoreMigrationEventHandler) OnExportRetrieved(provider swingsetkeeper.SwingStoreExportProvider) (err error) {
+	exportDataReader, err := provider.GetExportDataReader()
+	if err != nil {
+		return err
+	}
+	defer exportDataReader.Close()
+
+	var hasExportData bool
+
+	for {
+		entry, err := exportDataReader.Read()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+		hasExportData = true
+		if !entry.HasValue() {
+			return fmt.Errorf("no value for export data key %s", entry.Key())
+		}
+		eventHandler.swingStore.Set([]byte(entry.Key()), []byte(entry.StringValue()))
+	}
+	if !hasExportData {
+		return fmt.Errorf("export data had no entries")
+	}
+	return nil
+}
+
+// upgrade11Handler performs standard upgrade actions plus custom actions for upgrade-11.
+func upgrade11Handler(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)
 		// Record the plan to send to SwingSet
 		app.upgradePlan = &plan
 
+		// Perform swing-store migrations. We do this in the app upgrade handler
+		// since it involves multiple modules (x/vstorage and x/swingset) which
+		// don't strictly have a version change on their own.
+
+		// We are at the begining of the upgrade block, so all stores are commited
+		// as of the end of the previous block
+		savedBlockHeight := uint64(ctx.BlockHeight() - 1)
+
+		// First, repair swing-store metadata in case this node was previously
+		// initialized from a state-sync snapshot. This is done with a check on the
+		// block height to catch early any hangover related mismatch.
+		// Only entries related to missing historical metadata are imported, but we
+		// don't know what these look like here, so we provide it all.
+		getSwingStoreExportDataFromVstorage := func() (reader agorictypes.KVEntryReader, err error) {
+			return agorictypes.NewVstorageDataEntriesReader(
+				app.VstorageKeeper.ExportStorageFromPrefix(ctx, swingsetkeeper.StoragePathSwingStore),
+			), nil
+		}
+
+		// We're not restoring any artifact to swing-store, nor have any to provide
+		readNoArtifact := func() (artifact swingsettypes.SwingStoreArtifact, err error) {
+			return artifact, io.EOF
+		}
+
+		err := app.SwingStoreExportsHandler.RestoreExport(
+			swingsetkeeper.SwingStoreExportProvider{
+				BlockHeight:         savedBlockHeight,
+				GetExportDataReader: getSwingStoreExportDataFromVstorage,
+				ReadNextArtifact:    readNoArtifact,
+			},
+			swingsetkeeper.SwingStoreRestoreOptions{
+				ArtifactMode:   swingsetkeeper.SwingStoreArtifactModeNone,
+				ExportDataMode: swingsetkeeper.SwingStoreExportDataModeRepairMetadata,
+			},
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		// Then migrate the swing-store shadow copy:
+		// 1. Remove the swing-store "export data" shadow-copy entries from vstorage.
+		// 2. Export swing-store "export-data" (as of the previous block) through a
+		//    handler that writes every entry into the swingset module's new Store.
+		app.VstorageKeeper.RemoveEntriesWithPrefix(ctx, swingsetkeeper.StoragePathSwingStore)
+		err = app.SwingStoreExportsHandler.InitiateExport(
+			savedBlockHeight,
+			swingStoreMigrationEventHandler{swingStore: app.SwingSetKeeper.GetSwingStore(ctx)},
+			swingsetkeeper.SwingStoreExportOptions{
+				ArtifactMode:   swingsetkeeper.SwingStoreArtifactModeNone,
+				ExportDataMode: swingsetkeeper.SwingStoreExportDataModeAll,
+			},
+		)
+		if err == nil {
+			err = swingsetkeeper.WaitUntilSwingStoreExportDone()
+		}
+		if err != nil {
+			return nil, err
+		}
+
 		// Always run module migrations
 		mvm, err := app.mm.RunMigrations(ctx, app.configurator, fromVm)
 		if err != nil {

package/app/const.go

@@ -0,0 +1,6 @@
+package gaia
+
+const (
+	upgradeName     = "agoric-upgrade-11"
+	upgradeNameTest = "agorictest-upgrade-11"
+)

package/cmd/agd/main.go

@@ -1,158 +1,36 @@
 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() {
-	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 {
+	// We need to delegate to our default app for running the actual chain.
+	launchVM := func(logger log.Logger) {
 		args := []string{"ag-chain-cosmos", "--home", gaia.DefaultNodeHome}
 		args = append(args, os.Args[1:]...)
 
-		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
+		binary, lookErr := FindCosmicSwingsetBinary()
+		if lookErr != nil {
+			panic(lookErr)
 		}
 
-		// 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
+		logger.Info("agd delegating to JS executable", "binary", binary, "args", args)
+		execErr := syscall.Exec(binary, args, os.Environ())
+		if execErr != nil {
+			panic(execErr)
 		}
-		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(sendToNode)
+	daemon.RunWithController(nil)
 }

package/cmd/libdaemon/main.go

@@ -10,9 +10,8 @@ package main
 import "C"
 
 import (
-	"context"
 	"encoding/json"
-	"net/rpc"
+	"errors"
 	"os"
 	"path/filepath"
 
@@ -22,7 +21,6 @@ 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 {
@@ -32,32 +30,8 @@ type goReturn = struct {
 
 const SwingSetPort = 123
 
-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
-}
+var replies = map[int]chan goReturn{}
+var lastReply = 0
 
 //export RunAgCosmosDaemon
 func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char) C.int {
@@ -68,39 +42,46 @@ 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)
-	}
 
-	var sendToNode daemoncmd.Sender
+	// 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)
+		}
 
-	sendFunc := func(port int, reply int, str string) {
-		C.invokeSendFunc(toNode, C.int(port), C.int(reply), C.CString(str))
-	}
+		// 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
+		}
 
-	vmClientCodec, sendToNode = ConnectVMClientCodec(
-		context.Background(),
-		int(nodePort),
-		sendFunc,
-	)
-	agdServer = vm.NewAgdServer()
+		// 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
+	}
 
 	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(logger log.Logger) {
 			// 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")
@@ -113,10 +94,22 @@ 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.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)
+	// 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)
 	}
+	// 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)
 }
 
@@ -128,27 +121,20 @@ 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)
-	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)
+	respStr, err := vm.ReceiveFromController(int(port), msgStr)
 	if err != nil {
-		panic(err)
+		// 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)
 	}
-	return C.CString(string(respBytes))
+	return C.CString(respStr)
 }
 
 // Do nothing in main.