Major update to add the ability to run calblink as a service.

This also includes one major change and one minor change caused
by this.

Major change: instead of sleeping for 30 seconds (or, during
skip time, up to five minutes), calblink now uses a one-second
timer.  An internal check is made of when the next API call
is needed, so this will reduce the number of API calls made
and increase fidelity in the case where a device is slept.

Minor change: In service mode, the launch header (with the
settings resulting from parsing the config file) will
be skipped and showDots will be forced off.

Author: kazrakcom

README.md

@@ -49,6 +49,11 @@ To use calblink, you need the following:
 7.  Get an OAuth 2 ID as described in step 1 of the [Google Calendar
     Quickstart](https://developers.google.com/google-apps/calendar/quickstart/go).
     Put the client\_secret.json file in your GOPATH directory.
+    
+7.  Make sure the client\_secret.json file is secure by changing its permissions
+    to only allow the user to read it:
+    
+        chmod 600 client_secret.json
 
 8.  Build the calblink program as appropriate for your environment:
     * For a Linux environment or another that doesn't use Homebrew:
@@ -77,6 +82,9 @@ To use calblink, you need the following:
 
 11. Optionally, set up a config file, as below.
 
+12. Once everything is working, you can consider enabling [service mode](SERVICE.md) to
+    have it run automatically in the background.
+
 ## What are the configuration options?
 
 First off, run it with the --help option to see what the command-line options
@@ -185,6 +193,7 @@ To comply with the new security measure and meet the new requirements, please fo
 ## Known Issues
 
 *   Occasionally the shutdown is not as clean as it should be.
+*   Something seems to cause an occasional crash.
 *   If the blink(1) becomes disconnected, sometimes the program crashes instead of failing
     gracefully.
 
@@ -214,4 +223,6 @@ To comply with the new security measure and meet the new requirements, please fo
 *   Calblink contains code from the [Google Calendar API
     Quickstart](https://developers.google.com/google-apps/calendar/quickstart/go)
     which is licensed under the Apache 2 license.
+*   Calblink uses the [Go service](https://github.com/kardianos/service/) library for
+    managing service mode.
 *   All trademarks are the property of their respective holders.

SERVICE.md

@@ -0,0 +1,47 @@
+# Running calblink as a service
+
+## What does this do?
+
+Calblink now supports a mode where it runs as a service.  This means that it is managed
+by your operating system instead of needing to manually run it.  This service can be
+turned on and survive reboots.
+
+## What operating systems does this mode support?
+
+It has only been tested on macOS.  Theoretically it should work on Linux and other
+Unix-style operating systems, and might possibly work on Windows.  Try it out and if
+you have issues, let me know.
+
+## What potential problems are there for this mode?
+
+calblink currently doesn't cope well with not having a blink(1) installed when it is run.
+It will exit after enough failures to control the blink(1), if it doesn't segfault first.
+This mode works best for cases where a machine has a blink(1) set up at all times.
+Alternately, if you have a way of controlling launch daemons based on USB events
+(EventScripts or similar on macOS) you can use that to only run calblink when there
+is a blink(1) plugged in.
+
+If you don't disable the launch daemon when there isn't a blink(1) plugged in, calblink
+will crash and be automatically restarted every ten seconds or so.
+
+## How do I set this up?
+
+These instructions assume macOS.
+
+1.  Install calblink like you normally would, then make sure your configuration
+    is set up the way you want.
+2.  Run calblink as follows:
+
+        ./calblink -runAsService -service install
+        
+    This will install a launch agent in ~/Library/LaunchAgents.
+3.  You can then control it with launchctl like any other launch agent, or run
+    calblink to control the agent:
+
+        ./calblink -runAsService -service start
+        
+    Available commands include `start`, `stop`, `restart`, `install`, and `uninstall`.
+4.  Log messages will go into your home directory, in `calblink.out.log` and
+    `calblink.err.log`.  Unless debug is turned on, there should be minimal logging.
+    One log line is created at startup and shutdown, and fatal errors will be logged
+    to the error log.

blinker.go

@@ -113,6 +113,10 @@ func (blinker *BlinkerState) reinitialize() error {
 	return err
 }
 
+func (blinker *BlinkerState) turnOff() {
+	blinker.device.SetState(blink1.OffState)
+}
+
 func (blinker *BlinkerState) setState(state blink1.State) error {
 	if blinker.failures > 0 {
 		err := blinker.reinitialize()
@@ -232,8 +236,7 @@ func signalHandler(blinker *BlinkerState) {
 			continue
 		}
 		if blinker.failures == 0 {
-			blinker.newState <- Black
-			blinker.device.SetState(blink1.OffState)
+			blinker.turnOff()
 		}
 		log.Fatalf("Quitting due to signal %v", s)
 	}

calblink.go

@@ -22,6 +22,8 @@ import (
 	"log"
 	"os"
 	"time"
+
+	"github.com/kardianos/service"
 )
 
 // flags
@@ -33,10 +35,19 @@ var pollIntervalFlag = flag.Int("poll_interval", 30, "Number of seconds between
 var responseStateFlag = flag.String("response_state", "notRejected", "Which events to consider based on response: all, accepted, or notRejected")
 var deviceFailureRetriesFlag = flag.Int("device_failure_retries", 10, "Number of times to retry initializing the device before quitting the program")
 var showDotsFlag = flag.Bool("show_dots", true, "Whether to show progress dots after every cycle of checking the calendar")
+var runAsServiceFlag = flag.Bool("runAsService", false, "Whether to run as a service or remain live in the current shell")
+var serviceFlag = flag.String("service", "", "Control the system service.")
 
 var debugOut io.Writer = ioutil.Discard
 var dotOut io.Writer = ioutil.Discard
 
+// Necessary status for running as a service
+type program struct {
+	service   service.Service
+	userPrefs *UserPrefs
+	exit      chan struct{}
+}
+
 // Time calculation methods
 
 func tomorrow() time.Time {
@@ -49,18 +60,6 @@ func setHourMinuteFromTime(t time.Time) time.Time {
 	return time.Date(now.Year(), now.Month(), now.Day(), t.Hour(), t.Minute(), 0, 0, now.Location())
 }
 
-func sleep(d time.Duration) {
-	// To fix the 'oversleeping' problem where we sleep too long if the machine goes to
-	// sleep in the meantime, sleep for no more than 5 minutes at once.
-	// TODO: Once the AbsoluteNow proposal goes in, replace this with that.
-	max := time.Duration(5) * time.Minute
-	if d > max {
-		fmt.Fprintf(debugOut, "Cutting sleep short from %d to %d", d, max)
-		d = max
-	}
-	time.Sleep(d)
-}
-
 // Print output methods
 
 func usage() {
@@ -75,8 +74,10 @@ func main() {
 	if *debugFlag {
 		debugOut = os.Stdout
 	}
-	
+
 	userPrefs := readUserPrefs()
+	isService := false
+	serviceCmd := ""
 
 	// Overrides from command-line
 	flag.Visit(func(myFlag *flag.Flag) {
@@ -94,13 +95,32 @@ func main() {
 			userPrefs.DeviceFailureRetries = myFlag.Value.(flag.Getter).Get().(int)
 		case "show_dots":
 			userPrefs.ShowDots = myFlag.Value.(flag.Getter).Get().(bool)
+		case "runAsService":
+			isService = myFlag.Value.(flag.Getter).Get().(bool)
+		case "service":
+			serviceCmd = myFlag.Value.String()
 		}
 	})
 
-	if userPrefs.ShowDots {
+	if userPrefs.ShowDots && !isService {
 		dotOut = os.Stdout
 	}
 
+	prg := &program{
+		userPrefs: userPrefs,
+		exit:      make(chan struct{}),
+	}
+
+	if isService {
+		prg.StartService(serviceCmd)
+	} else {
+		runLoop(prg)
+	}
+
+}
+
+func runLoop(p *program) {
+	userPrefs := p.userPrefs
 	srv, err := Connect()
 	if err != nil {
 		log.Fatalf("Unable to retrieve Calendar client: %v", err)
@@ -111,67 +131,80 @@ func main() {
 	go signalHandler(blinkerState)
 	go blinkerState.patternRunner()
 
-	printStartInfo(userPrefs)
+	if p.service == nil {
+		printStartInfo(userPrefs)
+	} else {
+		fmt.Printf("Calblink starting at %v\n", time.Now())
+	}
 
+	ticker := time.NewTicker(time.Second)
+	nextEvent := time.Now()
 	failures := 0
 
 	for {
-		now := time.Now()
-		weekday := now.Weekday()
-		if userPrefs.SkipDays[weekday] {
-			tomorrow := tomorrow()
-			untilTomorrow := tomorrow.Sub(now)
-			Black.Execute(blinkerState)
-			fmt.Fprintf(debugOut, "Sleeping %v until tomorrow because it's a skip day\n", untilTomorrow)
-			fmt.Fprint(dotOut, "~")
-			sleep(untilTomorrow)
-			continue
-		}
-		if userPrefs.StartTime != nil {
-			start := setHourMinuteFromTime(*userPrefs.StartTime)
-			fmt.Fprintf(debugOut, "Start time: %v\n", start)
-			if diff := time.Since(start); diff < 0 {
-				Black.Execute(blinkerState)
-				fmt.Fprintf(debugOut, "Sleeping %v because start time after now\n", -diff)
-				fmt.Fprint(dotOut, ">")
-				sleep(-diff)
+		select {
+		case <-p.exit:
+			blinkerState.turnOff()
+			fmt.Printf("Calblink exiting at %v\n", time.Now())
+			ticker.Stop()
+			return
+		case now := <-ticker.C:
+			if nextEvent.After(now) {
 				continue
 			}
-		}
-		if userPrefs.EndTime != nil {
-			end := setHourMinuteFromTime(*userPrefs.EndTime)
-			fmt.Fprintf(debugOut, "End time: %v\n", end)
-			if diff := time.Since(end); diff > 0 {
-				Black.Execute(blinkerState)
+			weekday := now.Weekday()
+			if userPrefs.SkipDays[weekday] {
 				tomorrow := tomorrow()
-				untilTomorrow := tomorrow.Sub(now)
-				fmt.Fprintf(debugOut, "Sleeping %v until tomorrow because end time %v before now\n", untilTomorrow, diff)
-				fmt.Fprint(dotOut, "<")
-				sleep(untilTomorrow)
+				Black.Execute(blinkerState)
+				fmt.Fprintf(debugOut, "Sleeping until tomorrow (%v) because it's a skip day\n", tomorrow)
+				fmt.Fprint(dotOut, "~")
+				nextEvent = tomorrow
 				continue
 			}
-		}
-		next, err := fetchEvents(now, srv, userPrefs)
-		if err != nil {
-			// Leave the same color, set a flag. If we get more than a critical number of these,
-			// set the color to blinking magenta to tell the user we are in a failed state.
-			failures++
-			if failures > failureRetries {
-				MagentaFlash.Execute(blinkerState)
+			if userPrefs.StartTime != nil {
+				start := setHourMinuteFromTime(*userPrefs.StartTime)
+				fmt.Fprintf(debugOut, "Start time: %v\n", start)
+				if diff := time.Since(start); diff < 0 {
+					Black.Execute(blinkerState)
+					fmt.Fprintf(debugOut, "Sleeping %v because start time after now\n", -diff)
+					fmt.Fprint(dotOut, ">")
+					nextEvent = start
+					continue
+				}
 			}
-			fmt.Fprintf(debugOut, "Fetch Error:\n%v\n", err)
-			fmt.Fprint(dotOut, ",")
-			sleep(time.Duration(userPrefs.PollInterval) * time.Second)
-			continue
-		} else {
-			failures = 0
-		}
-		blinkState := blinkStateForEvent(next, userPrefs.PriorityFlashSide)
+			if userPrefs.EndTime != nil {
+				end := setHourMinuteFromTime(*userPrefs.EndTime)
+				fmt.Fprintf(debugOut, "End time: %v\n", end)
+				if diff := time.Since(end); diff > 0 {
+					Black.Execute(blinkerState)
+					tomorrow := tomorrow()
+					untilTomorrow := tomorrow.Sub(now)
+					fmt.Fprintf(debugOut, "Sleeping %v until tomorrow because end time %v before now\n", untilTomorrow, diff)
+					fmt.Fprint(dotOut, "<")
+					nextEvent = tomorrow
+					continue
+				}
+			}
+			next, err := fetchEvents(now, srv, userPrefs)
+			if err != nil {
+				// Leave the same color, set a flag. If we get more than a critical number of these,
+				// set the color to blinking magenta to tell the user we are in a failed state.
+				failures++
+				if failures > failureRetries {
+					MagentaFlash.Execute(blinkerState)
+				}
+				fmt.Fprintf(debugOut, "Fetch Error:\n%v\n", err)
+				fmt.Fprint(dotOut, ",")
+				nextEvent = now.Add(time.Duration(userPrefs.PollInterval) * time.Second)
+				continue
+			} else {
+				failures = 0
+			}
+			blinkState := blinkStateForEvent(next, userPrefs.PriorityFlashSide)
 
-		blinkState.Execute(blinkerState)
-		fmt.Fprint(dotOut, ".")
-		sleep(time.Duration(userPrefs.PollInterval) * time.Second)
+			blinkState.Execute(blinkerState)
+			fmt.Fprint(dotOut, ".")
+			nextEvent = now.Add(time.Duration(userPrefs.PollInterval) * time.Second)
+		}
 	}
-	
-
 }

network.go

@@ -45,7 +45,7 @@ func loadClientCredentials(clientSecretPath string) ([]byte, error) {
 		return nil, fmt.Errorf("client secret file not found: %s", clientSecretPath)
 	}
 	// Check if the file has secure permissions (readable only by owner)
-	if info.Mode().Perm() & 077 != 0 {
+	if info.Mode().Perm()&077 != 0 {
 		return nil, fmt.Errorf("insecure permissions for client secret file: %s", clientSecretPath)
 	}
 	// Read the contents of the file