Implement device watchdog.

go/src/infra/tools/device_watchdog/main.go

-// +build !windows
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// +build android
+
+/*
+Watchdog daemon for android devices. It will attempt to reboot the device
+if its uptime exceeds a specified maximum.
+*/
 
 package main
 
+// Needed for logcat integration.
+/*
+#cgo LDFLAGS: -landroid -llog
+
+#include <android/log.h>
+#include <string.h>
+*/
+import "C"
+
 import (
-        "C"
+        "flag"
         "fmt"
+        "io/ioutil"
+        "os"
+        "strconv"
+        "strings"
+        "syscall"
+        "time"
 )
 
+var (
+        logHeader = C.CString("CIT_DeviceWatchdog")
+)
+
+func logcatInfo(msg string) {

[dnj, 2016/08/15 19:43:29]

Consider making this accept a format string:

func logcatInfo(f string, args ...interface{}) {
  msg = fmt.Sprintf(f, args...)
}

Then you can use more idiomatic log strings in your code:
logcatInfo("weird number %d in %s", mynum, mything)

[bpastene, 2016/08/15 22:42:02]

Done.

+        C.__android_log_write(C.ANDROID_LOG_INFO, logHeader, C.CString(msg))

[dnj, 2016/08/15 19:43:30]

You need to free the string that you create:

cmsg := C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
C.__android_log_write(...)

(and below)

[bpastene, 2016/08/15 22:42:02]

Done.

+}
+
+func logcatError(msg string) {
+        C.__android_log_write(C.ANDROID_LOG_ERROR, logHeader, C.CString(msg))
+}
+
+// Spawn a child process via fork, create new process group, chdir and
+// redirect std in and out to /dev/null.
+func daemonize() (int, error) {

[dnj, 2016/08/15 19:43:29]

Consider using a formal package for daemonizing:
https://github.com/sevlyar/go-daemon

Unless you've already tried that and noted that it doesn't work so well on
Android.

[bpastene, 2016/08/15 22:42:02]

Yeah, already tried that exact package. I was seeing "ExecPath not implemented
for android" errors.

+        ret, _, errno := syscall.Syscall(syscall.SYS_FORK, 0, 0, 0)
+        pid := int(ret)
+        if errno != 0 {
+                return -1, errno

[dnj, 2016/08/15 19:43:29]

nit: when returning an error code, you can assume the caller is going to check
for error condition. In this case, return the zero value of other parameters,
not "-1" (here and elsewhere).

[bpastene, 2016/08/15 22:42:02]

Done.

+        }
+        if pid > 0 {
+                return pid, nil
+        }
+
+        _, err := syscall.Setsid()
+        if err != nil {
+                return -1, err
+        }
+        os.Chdir("/")

[dnj, 2016/08/15 19:43:29]

(Note this is normally not part of daemonizing, maybe do this at the beginning
of your daemon code).

[bpastene, 2016/08/15 22:42:02]

Done.

+
+        f, err := os.Open("/dev/null")
+        if err != nil {
+                return -1, err
+        }
+        fd := f.Fd()
+        syscall.Dup2(int(fd), int(os.Stdin.Fd()))

[dnj, 2016/08/15 19:43:30]

Because "os.Stdin" can change, I would just hardcode this to 0, 1, and 2
respectively. Maybe give them some const values:

const (
  STDIN_FD = 0
  STDOUT_FD = 1
  STDERR_FD = 2
)

[bpastene, 2016/08/15 22:42:02]

Done.

+        syscall.Dup2(int(fd), int(os.Stdout.Fd()))
+        syscall.Dup2(int(fd), int(os.Stderr.Fd()))
+
+        return pid, nil
+}
+
+// Read from /proc/uptime. Expected format:
+// "uptime_in_seconds cpu_idle_time_in_seconds"
+func getDeviceUptime() (float64, error) {
+        bytes, err := ioutil.ReadFile("/proc/uptime")
+        if err != nil {
+                return -1, err
+        }
+        // Split on the space to get uptime and drop cpu idle time.
+        uptimeStr := strings.Fields(string(bytes))[0]

[dnj, 2016/08/15 19:43:29]

I would assert that the field size is what you expect:
fields := strings.Fields(...)
if len(fields) == 0 {
  return 0, fmt.Errorf("failed to parse /proc/uptime")
}

[bpastene, 2016/08/15 22:42:02]

Done.

+        uptime, err := strconv.ParseFloat(uptimeStr, 64)
+        if err != nil {
+                return -1, err

[dnj, 2016/08/15 19:43:29]

nit: surround with context:

return 0, fmt.Errorf("failed to parse uptime from %q: %s", uptimeStr, err)

[bpastene, 2016/08/15 22:42:02]

Done.

+        }
+        return uptime, nil

[dnj, 2016/08/15 19:43:30]

nit: You might want to make this a little more go idiomatic by converting the
uptime to a "time.Duration":

time.Duration(uptime * float64(time.Second))

This will make further manipulation and comparison a lot nicer.

[bpastene, 2016/08/15 22:42:02]

Done.

+}
+
+// Reboot device by writing to sysrq-trigger. See:
+// https://www.kernel.org/doc/Documentation/sysrq.txt
+func rebootDevice() {
+        err := ioutil.WriteFile("/proc/sysrq-trigger", []byte("b"), 0644)

[dnj, 2016/08/15 19:43:29]

I think rather than WriteFile (which is generally used when creating files), you
should open the existing file and write to it:

fd, err := os.OpenFile("/proc/sysrq-trigger", os.O_WRONLY)
if err != nil { ... }
defer fd.Close()

_, err = fd.Write([]byte("b"))
if err != nil { ... }

[bpastene, 2016/08/15 22:42:02]

Done.

+        if err != nil {
+                logcatError(err.Error())
+                os.Exit(1)
+        }
+        logcatError("I just rebooted. How am I still alive?!?\n")

[dnj, 2016/08/15 19:43:30]

Is the reboot that immediate? Or could this string be printed in between the
reboot request being received and the process terminating?

[bpastene, 2016/08/15 22:42:02]

For all local testing, it's been instantaneous.

+        os.Exit(1)
+}
+
 func main() {
-        fmt.Println("Is this thing working?")
+
+        maxUptimeFlag := flag.Int("max-uptime", 120, "Maximum uptime in minutes before a reboot is triggered.")
+        flag.Parse()
+
+        pid, err := daemonize()
+        if err != nil {
+                logcatError(err.Error())
+                os.Exit(1)
+        }
+        if pid > 0 {
+                logcatInfo(fmt.Sprintf("Child spawned with pid %d, exiting parent\n", pid))
+                os.Exit(0)
+        }
+
+        maxUptime := float64(*maxUptimeFlag)
+        for {
+                uptime, err := getDeviceUptime()
+                if err != nil {
+                        logcatError(err.Error())
+                        os.Exit(1)
+                }
+                uptime = uptime / 60
+
+                if uptime > maxUptime {
+                        logcatInfo(fmt.Sprintf("Max uptime exceeded: (%.2f > %.0f)\n", uptime, maxUptime))
+                        rebootDevice()
+                } else {
+                        logcatInfo(fmt.Sprintf("No need to reboot, uptime < max_uptime: (%.2f < %.2f)\n", uptime, maxUptime))
+                }
+                time.Sleep(60 * time.Second)

[dnj, 2016/08/15 19:43:30]

Any reason not to just sleep the difference? e.g.,

time.Sleep(maxUptime - uptime)

[bpastene, 2016/08/15 22:42:02]

No reason currently; changed it to sleep the difference. (I might be interested
in adding other types of checks other than uptime in the future.)

+        }
 }