Refactored ClientConfig into a Server interface.

* StartServer is now a method on Server. * What used to be Dialer.Dial is now Server.Dial. * Server.Dial handles trying to start the server if the initial connection fails. * Dialer now dials a network address. * All types that took a Dialer now take a Server. * Server now has tests!
zach-klippenstein · Jan 10, 2016 · 9f7d11a · 9f7d11a
1 parent 11dc26d
commit 9f7d11a
Show file tree

Hide file tree

Showing 15 changed files with 420 additions and 278 deletions.
diff --git a/client_config.go b/client_config.go
diff --git a/cmd/adb/main.go b/cmd/adb/main.go
@@ -36,9 +36,18 @@ var (
 	pushRemoteArg    = pushCommand.Arg("remote", "Path of destination file on device.").Required().String()
 )
 
+var server goadb.Server
+
 func main() {
 	var exitCode int
 
+	var err error
+	server, err = goadb.NewServer(goadb.ServerConfig{})
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error:", err)
+		os.Exit(1)
+	}
+
 	switch kingpin.Parse() {
 	case "devices":
 		exitCode = listDevices(*devicesLongFlag)
@@ -62,7 +71,7 @@ func parseDevice() goadb.DeviceDescriptor {
 }
 
 func listDevices(long bool) int {
-	client := goadb.NewHostClient(goadb.ClientConfig{})
+	client := goadb.NewHostClient(server)
 	devices, err := client.ListDevices()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error:", err)
@@ -99,7 +108,7 @@ func runShellCommand(commandAndArgs []string, device goadb.DeviceDescriptor) int
 		args = commandAndArgs[1:]
 	}
 
-	client := goadb.NewDeviceClient(goadb.ClientConfig{}, device)
+	client := goadb.NewDeviceClient(server, device)
 	output, err := client.RunCommand(command, args...)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "error:", err)
@@ -121,7 +130,7 @@ func pull(showProgress bool, remotePath, localPath string, device goadb.DeviceDe
 		localPath = filepath.Base(remotePath)
 	}
 
-	client := goadb.NewDeviceClient(goadb.ClientConfig{}, device)
+	client := goadb.NewDeviceClient(server, device)
 
 	info, err := client.Stat(remotePath)
 	if util.HasErrCode(err, util.FileNoExistError) {
@@ -194,7 +203,7 @@ func push(showProgress bool, localPath, remotePath string, device goadb.DeviceDe
 	}
 	defer localFile.Close()
 
-	client := goadb.NewDeviceClient(goadb.ClientConfig{}, device)
+	client := goadb.NewDeviceClient(server, device)
 	writer, err := client.OpenWrite(remotePath, perms, mtime)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "error opening remote file %s: %s\n", remotePath, err)

diff --git a/cmd/demo/demo.go b/cmd/demo/demo.go
@@ -12,15 +12,26 @@ import (
 	"github.com/zach-klippenstein/goadb/util"
 )
 
-var port = flag.Int("p", adb.AdbPort, "")
+var (
+	port = flag.Int("p", adb.AdbPort, "")
+
+	server adb.Server
+)
 
 func main() {
 	flag.Parse()
 
-	client := adb.NewHostClient(adb.ClientConfig{})
-
+	var err error
+	server, err = adb.NewServer(adb.ServerConfig{
+		Port: *port,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
 	fmt.Println("Starting server…")
-	adb.StartServer()
+	server.Start()
+
+	client := adb.NewHostClient(server)
 
 	serverVersion, err := client.GetServerVersion()
 	if err != nil {
@@ -51,7 +62,7 @@ func main() {
 
 	fmt.Println()
 	fmt.Println("Watching for device state changes.")
-	watcher := adb.NewDeviceWatcher(adb.ClientConfig{})
+	watcher := adb.NewDeviceWatcher(server)
 	for event := range watcher.C() {
 		fmt.Printf("\t[%s]%+v\n", time.Now(), event)
 	}
@@ -77,7 +88,7 @@ func printErr(err error) {
 }
 
 func PrintDeviceInfoAndError(descriptor adb.DeviceDescriptor) {
-	device := adb.NewDeviceClient(adb.ClientConfig{}, descriptor)
+	device := adb.NewDeviceClient(server, descriptor)
 	if err := PrintDeviceInfo(device); err != nil {
 		log.Println(err)
 	}

diff --git a/cmd/raw-adb/raw-adb.go b/cmd/raw-adb/raw-adb.go
@@ -49,7 +49,14 @@ func readLine() string {
 }
 
 func doCommand(cmd string) error {
-	conn, err := goadb.NewDialer("", *port).Dial()
+	server, err := goadb.NewServer(goadb.ServerConfig{
+		Port: *port,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	conn, err := server.Dial()
 	if err != nil {
 		log.Fatal(err)
 	}

diff --git a/device_client.go b/device_client.go
@@ -17,18 +17,18 @@ var MtimeOfClose = time.Time{}
 
 // DeviceClient communicates with a specific Android device.
 type DeviceClient struct {
-	config     ClientConfig
+	server     Server
 	descriptor DeviceDescriptor
 
 	// Used to get device info.
 	deviceListFunc func() ([]*DeviceInfo, error)
 }
 
-func NewDeviceClient(config ClientConfig, descriptor DeviceDescriptor) *DeviceClient {
+func NewDeviceClient(server Server, descriptor DeviceDescriptor) *DeviceClient {
 	return &DeviceClient{
-		config:         config.sanitized(),
+		server:         server,
 		descriptor:     descriptor,
-		deviceListFunc: NewHostClient(config).ListDevices,
+		deviceListFunc: NewHostClient(server).ListDevices,
 	}
 }
 
@@ -194,7 +194,7 @@ func (c *DeviceClient) OpenWrite(path string, perms os.FileMode, mtime time.Time
 // getAttribute returns the first message returned by the server by running
 // <host-prefix>:<attr>, where host-prefix is determined from the DeviceDescriptor.
 func (c *DeviceClient) getAttribute(attr string) (string, error) {
-	resp, err := roundTripSingleResponse(c.config.Dialer,
+	resp, err := roundTripSingleResponse(c.server,
 		fmt.Sprintf("%s:%s", c.descriptor.getHostPrefix(), attr))
 	if err != nil {
 		return "", err
@@ -222,7 +222,7 @@ func (c *DeviceClient) getSyncConn() (*wire.SyncConn, error) {
 // dialDevice switches the connection to communicate directly with the device
 // by requesting the transport defined by the DeviceDescriptor.
 func (c *DeviceClient) dialDevice() (*wire.Conn, error) {
-	conn, err := c.config.Dialer.Dial()
+	conn, err := c.server.Dial()
 	if err != nil {
 		return nil, err
 	}

diff --git a/device_client_test.go b/device_client_test.go
@@ -13,12 +13,7 @@ func TestGetAttribute(t *testing.T) {
 		Status:   wire.StatusSuccess,
 		Messages: []string{"value"},
 	}
-	client := NewDeviceClient(
-		ClientConfig{
-			Dialer: s,
-		},
-		DeviceWithSerial("serial"),
-	)
+	client := NewDeviceClient(s, DeviceWithSerial("serial"))
 
 	v, err := client.getAttribute("attr")
 	assert.Equal(t, "host-serial:serial:attr", s.Requests[0])
@@ -60,11 +55,9 @@ func TestGetDeviceInfo(t *testing.T) {
 
 func newDeviceClientWithDeviceLister(serial string, deviceLister func() ([]*DeviceInfo, error)) *DeviceClient {
 	client := NewDeviceClient(
-		ClientConfig{
-			Dialer: &MockServer{
-				Status:   wire.StatusSuccess,
-				Messages: []string{serial},
-			},
+		&MockServer{
+			Status:   wire.StatusSuccess,
+			Messages: []string{serial},
 		},
 		DeviceWithSerial(serial),
 	)
@@ -77,12 +70,7 @@ func TestRunCommandNoArgs(t *testing.T) {
 		Status:   wire.StatusSuccess,
 		Messages: []string{"output"},
 	}
-	client := NewDeviceClient(
-		ClientConfig{
-			Dialer: s,
-		},
-		AnyDevice(),
-	)
+	client := NewDeviceClient(s, AnyDevice())
 
 	v, err := client.RunCommand("cmd")
 	assert.Equal(t, "host:transport-any", s.Requests[0])

diff --git a/device_watcher.go b/device_watcher.go
@@ -2,10 +2,10 @@ package goadb
 
 import (
 	"log"
+	"math/rand"
 	"runtime"
 	"strings"
 	"sync/atomic"
-	"math/rand"
 	"time"
 
 	"github.com/zach-klippenstein/goadb/util"
@@ -59,22 +59,18 @@ var deviceStateStrings = map[string]DeviceState{
 }
 
 type deviceWatcherImpl struct {
-	config ClientConfig
+	server Server
 
 	// If an error occurs, it is stored here and eventChan is close immediately after.
 	err atomic.Value
 
 	eventChan chan DeviceStateChangedEvent
-
-	// Function to start the server if it's not running or dies.
-	startServer func() error
 }
 
-func NewDeviceWatcher(config ClientConfig) *DeviceWatcher {
+func NewDeviceWatcher(server Server) *DeviceWatcher {
 	watcher := &DeviceWatcher{&deviceWatcherImpl{
-		config:      config.sanitized(),
-		eventChan:   make(chan DeviceStateChangedEvent),
-		startServer: StartServer,
+		server:    server,
+		eventChan: make(chan DeviceStateChangedEvent),
 	}}
 
 	runtime.SetFinalizer(watcher, func(watcher *DeviceWatcher) {
@@ -134,7 +130,7 @@ func publishDevices(watcher *deviceWatcherImpl) {
 	finished := false
 
 	for {
-		scanner, err := connectToTrackDevices(watcher.config.Dialer)
+		scanner, err := connectToTrackDevices(watcher.server)
 		if err != nil {
 			watcher.reportErr(err)
 			return
@@ -156,7 +152,7 @@ func publishDevices(watcher *deviceWatcherImpl) {
 
 			log.Printf("[DeviceWatcher] server died, restarting in %s…", delay)
 			time.Sleep(delay)
-			if err := watcher.startServer(); err != nil {
+			if err := watcher.server.Start(); err != nil {
 				log.Println("[DeviceWatcher] error restarting server, giving up")
 				watcher.reportErr(err)
 				return
@@ -169,8 +165,8 @@ func publishDevices(watcher *deviceWatcherImpl) {
 	}
 }
 
-func connectToTrackDevices(dialer Dialer) (wire.Scanner, error) {
-	conn, err := dialer.Dial()
+func connectToTrackDevices(server Server) (wire.Scanner, error) {
+	conn, err := server.Dial()
 	if err != nil {
 		return nil, err
 	}

diff --git a/device_watcher_test.go b/device_watcher_test.go
@@ -1,7 +1,6 @@
 package goadb
 
 import (
-	"log"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -207,8 +206,7 @@ func TestWentOffline(t *testing.T) {
 }
 
 func TestPublishDevicesRestartsServer(t *testing.T) {
-	starter := &MockServerStarter{}
-	dialer := &MockServer{
+	server := &MockServer{
 		Status: wire.StatusSuccess,
 		Errs: []error{
 			nil, nil, nil, // Successful dial.
@@ -217,34 +215,17 @@ func TestPublishDevicesRestartsServer(t *testing.T) {
 		},
 	}
 	watcher := deviceWatcherImpl{
-		config:      ClientConfig{dialer},
-		eventChan:   make(chan DeviceStateChangedEvent),
-		startServer: starter.StartServer,
+		server:    server,
+		eventChan: make(chan DeviceStateChangedEvent),
 	}
 
 	publishDevices(&watcher)
 
-	assert.Empty(t, dialer.Errs)
-	assert.Equal(t, []string{"host:track-devices"}, dialer.Requests)
-	assert.Equal(t, []string{"Dial", "SendMessage", "ReadStatus", "ReadMessage", "Dial"}, dialer.Trace)
+	assert.Empty(t, server.Errs)
+	assert.Equal(t, []string{"host:track-devices"}, server.Requests)
+	assert.Equal(t, []string{"Dial", "SendMessage", "ReadStatus", "ReadMessage", "Start", "Dial"}, server.Trace)
 	err := watcher.err.Load().(*util.Err)
 	assert.Equal(t, util.ServerNotAvailable, err.Code)
-	assert.Equal(t, 1, starter.startCount)
-}
-
-type MockServerStarter struct {
-	startCount int
-	err        error
-}
-
-func (s *MockServerStarter) StartServer() error {
-	log.Printf("Starting mock server")
-	if s.err == nil {
-		s.startCount += 1
-		return nil
-	} else {
-		return s.err
-	}
 }
 
 func assertContainsOnly(t *testing.T, expected, actual []DeviceStateChangedEvent) {