RPC commands and some basic tests for this [GH-1]

packer/command.go

@@ -22,6 +22,41 @@ type Command interface {
 
 // An RPCCommand is an implementation of the Command interface where the
 // command is actually executed over an RPC connection.
-type RPCCommand struct {
+type RPCClientCommand struct {
 	client *rpc.Client
 }
+
+// An RPCServerCommand wraps a Command and makes it exportable as part
+// of a Golang RPC server.
+type RPCServerCommand struct {
+	command Command
+}
+
+type RPCCommandRunArgs struct {
+	Env Environment
+	Args []string
+}
+
+type RPCCommandSynopsisArgs byte
+
+func (c *RPCClientCommand) Run(env Environment, args []string) (result int) {
+	// TODO: Environment
+	rpcArgs := &RPCCommandRunArgs{nil, args}
+	c.client.Call("Command.Run", rpcArgs, &result)
+	return
+}
+
+func (c *RPCClientCommand) Synopsis() (result string) {
+	c.client.Call("Command.Synopsis", RPCCommandSynopsisArgs(0), &result)
+	return
+}
+
+func (c *RPCServerCommand) Run(args *RPCCommandRunArgs, reply *int) error {
+	*reply = c.command.Run(args.Env, args.Args)
+	return nil
+}
+
+func (c *RPCServerCommand) Synopsis(args *RPCCommandSynopsisArgs, reply *string) error {
+	*reply = c.command.Synopsis()
+	return nil
+}

packer/command_test.go

+package packer
+
+import (
+	"cgl.tideland.biz/asserts"
+	"net"
+	"net/rpc"
+	"testing"
+)
+
+type TestCommand struct {
+	runArgs []string
+	runCalled bool
+	runEnv Environment
+}
+
+func (tc *TestCommand) Run(env Environment, args []string) int {
+	tc.runCalled = true
+	tc.runArgs = args
+	tc.runEnv = env
+	return 0
+}
+
+func (tc *TestCommand) Synopsis() string {
+	return "foo"
+}
+
+// This starts a RPC server for the given command listening on the
+// given address. The RPC server is ready when "readyChan" receives a message
+// and the RPC server will quit when "stopChan" receives a message.
+//
+// This function should be run in a goroutine.
+func testCommandRPCServer(laddr string, command interface{}, readyChan chan int, stopChan <-chan int) {
+	listener, err := net.Listen("tcp", laddr)
+	if err != nil {
+		panic(err)
+	}
+
+	// Close the listener when we exit so that the RPC server ends
+	defer listener.Close()
+
+	// Start the RPC server
+	server := rpc.NewServer()
+	server.RegisterName("Command", command)
+
+	go func() {
+		for {
+			conn, err := listener.Accept()
+			if err != nil {
+				// If there is an error, just ignore it.
+				break
+			}
+
+			go server.ServeConn(conn)
+		}
+	}()
+
+	// We're ready!
+	readyChan <- 1
+
+	// Block on waiting to receive from the channel
+	<-stopChan
+}
+
+func TestRPCCommand(t *testing.T) {
+	assert := asserts.NewTestingAsserts(t, true)
+
+	// Create the command
+	command := new(TestCommand)
+	serverCommand := &RPCServerCommand{command}
+
+	// Start the RPC server, and make sure to exit it at the end
+	// of the test.
+	readyChan := make(chan int)
+	stopChan := make(chan int)
+	defer func() { stopChan <- 1 }()
+	go testCommandRPCServer(":1234", serverCommand, readyChan, stopChan)
+	<-readyChan
+
+	// Create the command client over RPC and run some methods to verify
+	// we get the proper behavior.
+	client, err := rpc.Dial("tcp", ":1234")
+	if err != nil {
+		panic(err)
+	}
+
+	clientComm := &RPCClientCommand{client}
+	runArgs := []string{"foo", "bar"}
+	testEnv := testEnvironment()
+	exitCode := clientComm.Run(testEnv, runArgs)
+	synopsis := clientComm.Synopsis()
+
+	assert.Equal(command.runArgs, runArgs, "Correct args should be sent")
+	assert.Equal(exitCode, 0, "Exit code should be correct")
+	assert.Equal(synopsis, "foo", "Synopsis should be correct")
+}

packer/environment_test.go

@@ -8,23 +8,6 @@ import (
 	"testing"
 )
 
-type TestCommand struct {
-	runArgs []string
-	runCalled bool
-	runEnv Environment
-}
-
-func (tc *TestCommand) Run(env Environment, args []string) int {
-	tc.runCalled = true
-	tc.runArgs = args
-	tc.runEnv = env
-	return 0
-}
-
-func (tc *TestCommand) Synopsis() string {
-	return ""
-}
-
 func testEnvironment() Environment {
 	config := &EnvironmentConfig{}
 	config.Ui = &ReaderWriterUi{