Home | History | Annotate | Download | only in android 
      1 // Copyright 2014 The Go Authors.  All rights reserved.
      2 // Use of this source code is governed by a BSD-style
      3 // license that can be found in the LICENSE file.
      4 
      5 // This program can be used as go_android_GOARCH_exec by the Go tool.
      6 // It executes binaries on an android device using adb.
      7 package main
      8 
      9 import (
     10 	"bytes"
     11 	"fmt"
     12 	"go/build"
     13 	"io"
     14 	"log"
     15 	"os"
     16 	"os/exec"
     17 	"path/filepath"
     18 	"runtime"
     19 	"strconv"
     20 	"strings"
     21 )
     22 
     23 func run(args ...string) string {
     24 	buf := new(bytes.Buffer)
     25 	cmd := exec.Command("adb", args...)
     26 	cmd.Stdout = io.MultiWriter(os.Stdout, buf)
     27 	cmd.Stderr = os.Stderr
     28 	log.Printf("adb %s", strings.Join(args, " "))
     29 	err := cmd.Run()
     30 	if err != nil {
     31 		log.Fatalf("adb %s: %v", strings.Join(args, " "), err)
     32 	}
     33 	return buf.String()
     34 }
     35 
     36 const (
     37 	// Directory structure on the target device androidtest.bash assumes.
     38 	deviceGoroot = "/data/local/tmp/goroot"
     39 	deviceGopath = "/data/local/tmp/gopath"
     40 )
     41 
     42 func main() {
     43 	log.SetFlags(0)
     44 	log.SetPrefix("go_android_exec: ")
     45 
     46 	// Prepare a temporary directory that will be cleaned up at the end.
     47 	deviceGotmp := fmt.Sprintf("/data/local/tmp/%s-%d",
     48 		filepath.Base(os.Args[1]), os.Getpid())
     49 	run("shell", "mkdir", "-p", deviceGotmp)
     50 
     51 	// Determine the package by examining the current working
     52 	// directory, which will look something like
     53 	// "$GOROOT/src/mime/multipart" or "$GOPATH/src/golang.org/x/mobile".
     54 	// We extract everything after the $GOROOT or $GOPATH to run on the
     55 	// same relative directory on the target device.
     56 	subdir, inGoRoot := subdir()
     57 	deviceCwd := filepath.Join(deviceGoroot, subdir)
     58 	if !inGoRoot {
     59 		deviceCwd = filepath.Join(deviceGopath, subdir)
     60 	}
     61 
     62 	// Binary names can conflict.
     63 	// E.g. template.test from the {html,text}/template packages.
     64 	binName := filepath.Base(os.Args[1])
     65 	deviceBin := fmt.Sprintf("%s/%s-%d", deviceGotmp, binName, os.Getpid())
     66 
     67 	// The push of the binary happens in parallel with other tests.
     68 	// Unfortunately, a simultaneous call to adb shell hold open
     69 	// file descriptors, so it is necessary to push then move to
     70 	// avoid a "text file busy" error on execution.
     71 	// https://code.google.com/p/android/issues/detail?id=65857
     72 	run("push", os.Args[1], deviceBin+"-tmp")
     73 	run("shell", "cp '"+deviceBin+"-tmp' '"+deviceBin+"'")
     74 	run("shell", "rm '"+deviceBin+"-tmp'")
     75 
     76 	// The adb shell command will return an exit code of 0 regardless
     77 	// of the command run. E.g.
     78 	//      $ adb shell false
     79 	//      $ echo $?
     80 	//      0
     81 	// https://code.google.com/p/android/issues/detail?id=3254
     82 	// So we append the exitcode to the output and parse it from there.
     83 	const exitstr = "exitcode="
     84 	cmd := `export TMPDIR="` + deviceGotmp + `"` +
     85 		`; export GOROOT="` + deviceGoroot + `"` +
     86 		`; export GOPATH="` + deviceGopath + `"` +
     87 		`; cd "` + deviceCwd + `"` +
     88 		"; '" + deviceBin + "' " + strings.Join(os.Args[2:], " ") +
     89 		"; echo -n " + exitstr + "$?"
     90 	output := run("shell", cmd)
     91 
     92 	run("shell", "rm", "-rf", deviceGotmp) // Clean up.
     93 
     94 	output = output[strings.LastIndex(output, "\n")+1:]
     95 	if !strings.HasPrefix(output, exitstr) {
     96 		log.Fatalf("no exit code: %q", output)
     97 	}
     98 	code, err := strconv.Atoi(output[len(exitstr):])
     99 	if err != nil {
    100 		log.Fatalf("bad exit code: %v", err)
    101 	}
    102 	os.Exit(code)
    103 }
    104 
    105 // subdir determines the package based on the current working directory,
    106 // and returns the path to the package source relative to $GOROOT (or $GOPATH).
    107 func subdir() (pkgpath string, underGoRoot bool) {
    108 	cwd, err := os.Getwd()
    109 	if err != nil {
    110 		log.Fatal(err)
    111 	}
    112 	if root := runtime.GOROOT(); strings.HasPrefix(cwd, root) {
    113 		subdir, err := filepath.Rel(root, cwd)
    114 		if err != nil {
    115 			log.Fatal(err)
    116 		}
    117 		return subdir, true
    118 	}
    119 
    120 	for _, p := range filepath.SplitList(build.Default.GOPATH) {
    121 		if !strings.HasPrefix(cwd, p) {
    122 			continue
    123 		}
    124 		subdir, err := filepath.Rel(p, cwd)
    125 		if err == nil {
    126 			return subdir, false
    127 		}
    128 	}
    129 	log.Fatalf("the current path %q is not in either GOROOT(%q) or GOPATH(%q)",
    130 		cwd, runtime.GOROOT(), build.Default.GOPATH)
    131 	return "", false
    132 }
    133