Get all XCUITest logs (danielpaulus#398)

Starting with iOS 17 XCUITest logs are sent over two channels. There are debug logs that come over the DTX connection (like they did in the past), but the non-debug messages are sent over a different connection to the com.apple.coredevice.openstdiosocket service.

We now open a connection to the openstdiosocket-service before we launch the test runner, and we tell the appservice to which socket it should connect stdio. And after that we pipe the data we get from the stdio-socket to the logoutput.

Author: dmissmann

ios/appservice/appservice.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/danielpaulus/go-ios/ios"
 	"github.com/danielpaulus/go-ios/ios/coredevice"
+	"github.com/danielpaulus/go-ios/ios/openstdio"
 	"github.com/danielpaulus/go-ios/ios/xpc"
 	"github.com/google/uuid"
 	"howett.net/plist"
@@ -22,6 +23,7 @@ import (
 type Connection struct {
 	conn     *xpc.Connection
 	deviceId string
+	device   ios.DeviceEntry
 }
 
 const (
@@ -39,13 +41,28 @@ func New(deviceEntry ios.DeviceEntry) (*Connection, error) {
 		return nil, fmt.Errorf("new: %w", err)
 	}
 
-	return &Connection{conn: xpcConn, deviceId: uuid.New().String()}, nil
+	return &Connection{conn: xpcConn, deviceId: uuid.New().String(), device: deviceEntry}, nil
 }
 
-// AppLaunch represents the result of launching an app on the device for iOS17+.
-// It contains the PID of the launched app.
-type AppLaunch struct {
-	Pid int
+// LaunchedAppWithStdIo is the launched app with a connection to the stdio-socket
+type LaunchedAppWithStdIo struct {
+	stdIoConnection openstdio.Connection
+	Pid             int
+}
+
+// Read reads from the stdio socket of the launched app
+func (a LaunchedAppWithStdIo) Read(p []byte) (n int, err error) {
+	return a.stdIoConnection.Read(p)
+}
+
+// Write reads from the stdio socket of the launched app
+func (a LaunchedAppWithStdIo) Write(p []byte) (n int, err error) {
+	return a.stdIoConnection.Write(p)
+}
+
+// Close closes the connection to stdio-socket of the launched app
+func (a LaunchedAppWithStdIo) Close() error {
+	return a.stdIoConnection.Close()
 }
 
 // Process represents a process running on the device for iOS17+.
@@ -56,21 +73,55 @@ type Process struct {
 }
 
 // LaunchApp launches an app on the device with the given bundleId and arguments for iOS17+.
-func (c *Connection) LaunchApp(bundleId string, args []interface{}, env map[string]interface{}, options map[string]interface{}, terminateExisting bool) (AppLaunch, error) {
-	msg := buildAppLaunchPayload(c.deviceId, bundleId, args, env, options, terminateExisting)
+// On a successful launch it returns the PID of the launched process.
+func (c *Connection) LaunchApp(bundleId string, args []interface{}, env map[string]interface{}, options map[string]interface{}, terminateExisting bool) (int, error) {
+	pid, err := c.launchApp(bundleId, args, env, options, terminateExisting, map[string]any{})
+	if err != nil {
+		return 0, fmt.Errorf("LaunchApp: failed to launch app: %w", err)
+	}
+	return pid, nil
+}
+
+// LaunchAppWithStdIo launches an app and connects to the stdio-socket
+// the returned value implements the io.ReadWriteCloser interface and needs to be closed when finished using the stdio-socket
+func (c *Connection) LaunchAppWithStdIo(bundleId string, args []interface{}, env map[string]interface{}, options map[string]interface{}, terminateExisting bool) (LaunchedAppWithStdIo, error) {
+	stdio, err := openstdio.NewOpenStdIoSocket(c.device)
+	if err != nil {
+		return LaunchedAppWithStdIo{}, fmt.Errorf("LaunchAppWithStdIo: failed to open stdio socket: %w", err)
+	}
+
+	// this is also how Xcode handles it. It uses the same socket for stdOut/stdErr/stdIn
+	stdIoConfig := map[string]any{
+		"standardInput":  stdio.ID,
+		"standardOutput": stdio.ID,
+		"standardError":  stdio.ID,
+	}
+
+	pid, err := c.launchApp(bundleId, args, env, options, terminateExisting, stdIoConfig)
+	if err != nil {
+		return LaunchedAppWithStdIo{}, fmt.Errorf("LaunchAppWithStdIo: failed to launch app: %w", err)
+	}
+	return LaunchedAppWithStdIo{
+		stdIoConnection: stdio,
+		Pid:             pid,
+	}, nil
+}
+
+func (c *Connection) launchApp(bundleId string, args []interface{}, env map[string]interface{}, options map[string]interface{}, terminateExisting bool, stdio map[string]any) (int, error) {
+	msg := buildAppLaunchPayload(c.deviceId, bundleId, args, env, options, terminateExisting, map[string]any{})
 	err := c.conn.Send(msg, xpc.HeartbeatRequestFlag)
 	if err != nil {
-		return AppLaunch{}, fmt.Errorf("LaunchApp: failed to send launch-app request: %w", err)
+		return 0, fmt.Errorf("launchApp: failed to send launch-app request: %w", err)
 	}
 	m, err := c.conn.ReceiveOnServerClientStream()
 	if err != nil {
-		return AppLaunch{}, fmt.Errorf("launchApp2: %w", err)
+		return 0, fmt.Errorf("launchApp: failed to read response: %w", err)
 	}
 	pid, err := pidFromResponse(m)
 	if err != nil {
-		return AppLaunch{}, fmt.Errorf("launchApp3: %w", err)
+		return 0, fmt.Errorf("launchApp: failed to get PID: %w", err)
 	}
-	return AppLaunch{Pid: int(pid)}, nil
+	return int(pid), nil
 }
 
 // Close closes the connection to the appservice
@@ -181,7 +232,7 @@ func (p Process) ExecutableName() string {
 	return file
 }
 
-func buildAppLaunchPayload(deviceId string, bundleId string, args []interface{}, env map[string]interface{}, options map[string]interface{}, terminateExisting bool) map[string]interface{} {
+func buildAppLaunchPayload(deviceId string, bundleId string, args []interface{}, env map[string]interface{}, options map[string]interface{}, terminateExisting bool, stdIo map[string]any) map[string]interface{} {
 	platformSpecificOptions := bytes.NewBuffer(nil)
 	plistEncoder := plist.NewBinaryEncoder(platformSpecificOptions)
 	err := plistEncoder.Encode(options)
@@ -207,7 +258,7 @@ func buildAppLaunchPayload(deviceId string, bundleId string, args []interface{},
 			},
 			"workingDirectory": nil,
 		},
-		"standardIOIdentifiers": map[string]interface{}{},
+		"standardIOIdentifiers": stdIo,
 	})
 }
 

ios/appservice/appservice_integration_test.go

@@ -3,13 +3,14 @@
 package appservice_test
 
 import (
+	"os"
+	"slices"
+	"testing"
+
 	"github.com/danielpaulus/go-ios/ios"
 	"github.com/danielpaulus/go-ios/ios/appservice"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"os"
-	"slices"
-	"testing"
 )
 
 func TestLaunchAndKillApps(t *testing.T) {
@@ -71,12 +72,12 @@ func testKillInvalidPidReturnsError(t *testing.T, device ios.DeviceEntry) {
 	require.NoError(t, err)
 	defer as.Close()
 
-	launched, err := as.LaunchApp("com.apple.mobilesafari", nil, nil, nil, true)
+	pid, err := as.LaunchApp("com.apple.mobilesafari", nil, nil, nil, true)
 	require.NoError(t, err)
 
-	err = as.KillProcess(launched.Pid)
+	err = as.KillProcess(pid)
 	require.NoError(t, err)
 
-	err = as.KillProcess(launched.Pid)
+	err = as.KillProcess(pid)
 	assert.Error(t, err)
 }

ios/connect.go

@@ -113,7 +113,7 @@ func ConnectToShimService(device DeviceEntry, service string) (DeviceConnectionI
 	}
 
 	port := device.Rsd.GetPort(service)
-	conn, err := connectToTunnel(device, port)
+	conn, err := ConnectToTunnel(device, port)
 	if err != nil {
 		return nil, err
 	}
@@ -145,7 +145,7 @@ func ConnectToServiceTunnelIface(device DeviceEntry, serviceName string) (Device
 	}
 	port := device.Rsd.GetPort(serviceName)
 
-	conn, err := connectToTunnel(device, port)
+	conn, err := ConnectToTunnel(device, port)
 	if err != nil {
 		return nil, fmt.Errorf("ConnectToServiceTunnelIface: failed to connect to tunnel: %w", err)
 	}
@@ -175,24 +175,25 @@ func ConnectToHttp2(device DeviceEntry, port int) (*http.HttpConnection, error)
 	return http.NewHttpConnection(conn)
 }
 
-func connectToTunnel(device DeviceEntry, port int) (*net.TCPConn, error) {
+// ConnectToTunnel opens a new connection to the tunnel interface of the specified device and on the specified port
+func ConnectToTunnel(device DeviceEntry, port int) (*net.TCPConn, error) {
 	addr, err := net.ResolveTCPAddr("tcp6", fmt.Sprintf("[%s]:%d", device.Address, port))
 	if err != nil {
-		return nil, fmt.Errorf("connectToTunnel: failed to resolve address: %w", err)
+		return nil, fmt.Errorf("ConnectToTunnel: failed to resolve address: %w", err)
 	}
 
 	conn, err := net.DialTCP("tcp", nil, addr)
 	if err != nil {
-		return nil, fmt.Errorf("connectToTunnel: failed to dial: %w", err)
+		return nil, fmt.Errorf("ConnectToTunnel: failed to dial: %w", err)
 	}
 
 	err = conn.SetKeepAlive(true)
 	if err != nil {
-		return nil, fmt.Errorf("connectToTunnel: failed to set keepalive: %w", err)
+		return nil, fmt.Errorf("ConnectToTunnel: failed to set keepalive: %w", err)
 	}
 	err = conn.SetKeepAlivePeriod(1 * time.Second)
 	if err != nil {
-		return nil, fmt.Errorf("connectToTunnel: failed to set keepalive period: %w", err)
+		return nil, fmt.Errorf("ConnectToTunnel: failed to set keepalive period: %w", err)
 	}
 
 	return conn, nil

ios/openstdio/service.go

@@ -0,0 +1,77 @@
+// Package openstdio is used to open a new socket connection that can be used to connect an app launched with appservice
+package openstdio
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+
+	"github.com/danielpaulus/go-ios/ios"
+	"github.com/google/uuid"
+)
+
+// Connection is a single connection to the stdio socket
+type Connection struct {
+	// ID is required whenever we need to tell iOS which socket should be used
+	// (for example when we launch an app we need to pass this id so that the system knows which socket should be used)
+	ID         uuid.UUID
+	connection io.ReadWriteCloser
+}
+
+// NewOpenStdIoSocket creates a new stdio-socket on the device and the returned connection can be used
+// to read and write from this socket
+func NewOpenStdIoSocket(device ios.DeviceEntry) (Connection, error) {
+	if device.Rsd == nil {
+		return Connection{}, errors.New("NewOpenStdIoSocket: no rsd device found")
+	}
+	port := device.Rsd.GetPort("com.apple.coredevice.openstdiosocket")
+	conn, err := ios.ConnectToTunnel(device, port)
+	if err != nil {
+		return Connection{}, fmt.Errorf("NewOpenStdIoSocket: failed to open connection: %w", err)
+	}
+
+	uuidBytes := make([]byte, 16)
+	_, err = conn.Read(uuidBytes)
+	if err != nil {
+		return Connection{}, fmt.Errorf("NewOpenStdIoSocket: failed to read UUID: %w", err)
+	}
+
+	u, err := uuid.FromBytes(uuidBytes)
+	if err != nil {
+		return Connection{}, fmt.Errorf("NewOpenStdIoSocket: failed to parse UUID: %w", err)
+	}
+
+	return Connection{
+		ID:         u,
+		connection: conn,
+	}, nil
+}
+
+// Read reads from the connected stdio-socket
+func (s Connection) Read(p []byte) (n int, err error) {
+	if s.connection == nil {
+		return 0, fmt.Errorf("Read: not connected to service")
+	}
+	n, err = s.connection.Read(p)
+	if err != nil && errors.Is(err, net.ErrClosed) {
+		return n, io.EOF
+	}
+	return n, err
+}
+
+// Write writes to the connected stdio-socket
+func (s Connection) Write(p []byte) (n int, err error) {
+	if s.connection == nil {
+		return 0, fmt.Errorf("Write: not connected to service")
+	}
+	return s.connection.Write(p)
+}
+
+// Close closes the connected stdio-socket
+func (s Connection) Close() error {
+	if s.connection == nil {
+		return fmt.Errorf("Close: not connected to service")
+	}
+	return s.connection.Close()
+}

ios/testmanagerd/xcuitestrunner.go

@@ -3,6 +3,7 @@ package testmanagerd
 import (
 	"context"
 	"fmt"
+	"io"
 	"path"
 	"strings"
 
@@ -358,18 +359,26 @@ func runXUITestWithBundleIdsXcode15Ctx(
 	}
 	defer appserviceConn.Close()
 
-	pid, err := startTestRunner17(device, appserviceConn, "", testRunnerBundleID, strings.ToUpper(testSessionID.String()), info.testApp.path+"/PlugIns/"+xctestConfigFileName, args, env)
+	testRunnerLaunch, err := startTestRunner17(device, appserviceConn, "", testRunnerBundleID, strings.ToUpper(testSessionID.String()), info.testApp.path+"/PlugIns/"+xctestConfigFileName, args, env)
 	if err != nil {
 		return make([]TestSuite, 0), fmt.Errorf("runXUITestWithBundleIdsXcode15Ctx: cannot start test runner: %w", err)
 	}
 
+	defer testRunnerLaunch.Close()
+	go func() {
+		_, err := io.Copy(testListener.logWriter, testRunnerLaunch)
+		if err != nil {
+			log.Warn("copying stdout failed", log.WithError(err))
+		}
+	}()
+
 	ideDaemonProxy2 := newDtxProxyWithConfig(conn2, testconfig, testListener)
 	caps, err := ideDaemonProxy2.daemonConnection.initiateControlSessionWithCapabilities(nskeyedarchiver.XCTCapabilities{CapabilitiesDictionary: map[string]interface{}{}})
 	if err != nil {
 		return make([]TestSuite, 0), fmt.Errorf("runXUITestWithBundleIdsXcode15Ctx: cannot initiate a control session with capabilities: %w", err)
 	}
 	log.WithField("caps", caps).Info("got capabilities")
-	authorized, err := ideDaemonProxy2.daemonConnection.authorizeTestSessionWithProcessID(uint64(pid))
+	authorized, err := ideDaemonProxy2.daemonConnection.authorizeTestSessionWithProcessID(uint64(testRunnerLaunch.Pid))
 	if err != nil {
 		return make([]TestSuite, 0), fmt.Errorf("runXUITestWithBundleIdsXcode15Ctx: cannot authorize test session: %w", err)
 	}
@@ -387,10 +396,10 @@ func runXUITestWithBundleIdsXcode15Ctx(
 	case <-testListener.Done():
 		break
 	case <-ctx.Done():
-		log.Infof("Killing test runner with pid %d ...", pid)
-		err = killTestRunner(appserviceConn, pid)
+		log.Infof("Killing test runner with pid %d ...", testRunnerLaunch.Pid)
+		err = killTestRunner(appserviceConn, testRunnerLaunch.Pid)
 		if err != nil {
-			log.Infof("Nothing to kill, process with pid %d is already dead", pid)
+			log.Infof("Nothing to kill, process with pid %d is already dead", testRunnerLaunch.Pid)
 		} else {
 			log.Info("Test runner killed with success")
 		}
@@ -416,9 +425,7 @@ func killTestRunner(killer processKiller, pid int) error {
 	return nil
 }
 
-func startTestRunner17(device ios.DeviceEntry, appserviceConn *appservice.Connection, xctestConfigPath string, bundleID string,
-	sessionIdentifier string, testBundlePath string, testArgs []string, testEnv []string,
-) (int, error) {
+func startTestRunner17(device ios.DeviceEntry, appserviceConn *appservice.Connection, xctestConfigPath string, bundleID string, sessionIdentifier string, testBundlePath string, testArgs []string, testEnv []string) (appservice.LaunchedAppWithStdIo, error) {
 	args := []interface{}{}
 	for _, arg := range testArgs {
 		args = append(args, arg)
@@ -454,7 +461,7 @@ func startTestRunner17(device ios.DeviceEntry, appserviceConn *appservice.Connec
 		"StartSuspendedKey": uint64(0),
 	}
 
-	appLaunch, err := appserviceConn.LaunchApp(
+	appLaunch, err := appserviceConn.LaunchAppWithStdIo(
 		bundleID,
 		args,
 		env,
@@ -463,10 +470,10 @@ func startTestRunner17(device ios.DeviceEntry, appserviceConn *appservice.Connec
 	)
 
 	if err != nil {
-		return 0, err
+		return appservice.LaunchedAppWithStdIo{}, err
 	}
 
-	return appLaunch.Pid, nil
+	return appLaunch, nil
 }
 
 func setupXcuiTest(device ios.DeviceEntry, bundleID string, testRunnerBundleID string, xctestConfigFileName string, testsToRun []string, testsToSkip []string) (uuid.UUID, string, nskeyedarchiver.XCTestConfiguration, testInfo, error) {