testing, but not sure how well

.gitignore

@@ -1,4 +1,2 @@
-/bin/
-/pkg/
-/src/
 /ve/
+/.test/

core.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+    "github.com/ActiveState/tail"
+    "fmt"
+)
+
+type LogDriver struct {
+    directory string
+    tails []*tail.Tail
+}
+
+func NewLogDriver(directory string) (l LogDriver) {
+    return LogDriver{directory, make([]*tail.Tail, 0, 0)}
+}
+
+func (l LogDriver) Tail(filepath string) (t *tail.Tail, err error) {
+    t, err = tail.TailFile(filepath, tail.Config{Follow: true})
+    l.tails = append(l.tails, t)
+    return t, err
+}
+
+func (l LogDriver) Start() {
+    // when function completes, notify via the channel
+}
+
+func (l LogDriver) Stop() {
+    for _, tail := range l.tails {
+        err := tail.Stop()
+        if err != nil {
+            fmt.Println(err)
+        }
+        tail.Cleanup()
+    }
+}
+
+func (l LogDriver) StopOnReceive(done <-chan bool) {
+    <- done
+    l.Stop()
+}
+
+/*
+
+defer func() { done <- true }()
+
+tail, err := LogDriver.tail()
+
+func tailFile(filename string, messages chan<- string, done chan<- bool) {
+
+    // start tailing
+    t, err := tail.TailFile(filename, tail.Config{Follow: true})
+    if err != nil {
+        fmt.Fprintln(os.Stderr, err)
+        return
+    }
+    for line := range t.Lines {
+        messages <- line.Text
+    }
+    err = t.Wait()
+    if err != nil {
+        fmt.Fprintln(os.Stderr, err)
+    }
+}
+
+*/

core_test.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+	"github.com/ActiveState/tail"
+)
+
+type LogDriverTest struct {
+	Name string
+	path string
+	*testing.T
+}
+
+// NOTE:	This is me learning more of go by studying the tail
+//			test cases. A bunch of this code is copied & paste across
+//			from tail's test suite.
+func NewLogDriverTest(name string, t *testing.T) LogDriverTest {
+	lt := LogDriverTest{name, ".test/" + name, t}
+	err := os.MkdirAll(lt.path, os.ModeTemporary|0700)
+	if err != nil {
+		lt.Fatal(err)
+	}
+	return lt
+}
+
+func (lt LogDriverTest) CreateFile(name string, contents string) (path string) {
+	err := ioutil.WriteFile(lt.path+"/"+name, []byte(contents), 0600)
+	if err != nil {
+		lt.Fatal(err)
+	}
+	return lt.path + "/" + name
+}
+
+func (lt LogDriverTest) AppendFile(name string, contents string) {
+	f, err := os.OpenFile(lt.path+"/"+name, os.O_APPEND|os.O_WRONLY, 0600)
+	if err != nil {
+		lt.Fatal(err)
+	}
+	defer f.Close()
+	_, err = f.WriteString(contents)
+	if err != nil {
+		lt.Fatal(err)
+	}
+}
+
+func (lt LogDriverTest) AssertTailOutput(tail *tail.Tail, lines []string, done chan bool) {
+	defer func () {done <- true}()
+
+	for idx, line := range lines {
+		tailedLine, ok := <-tail.Lines
+		if !ok {
+			// tail.Lines is closed and empty.
+			err := tail.Err()
+			if err != nil {
+				lt.Fatalf("tail ended with error: %v", err)
+			}
+			lt.Fatalf("tail ended early; expecting more: %v", lines[idx:])
+		}
+		if tailedLine == nil {
+			lt.Fatalf("tail.Lines returned nil; not possible")
+		}
+		// Note: not checking .Err as the `lines` argument is designed
+		// to match error strings as well.
+		if tailedLine.Text != line {
+			lt.Fatalf(
+				"unexpected line/err from tail: "+
+					"expecting <<%s>>>, but got <<<%s>>>",
+				line, tailedLine.Text)
+		}
+	}
+}
+
+func TestTail(t *testing.T) {
+
+	lt := NewLogDriverTest("test_tail_file", t)
+	filePath := lt.CreateFile("test.txt", "foo\n")
+
+	ld := NewLogDriver("test_tail_file")
+	tail, _ := ld.Tail(filePath)
+
+	lt.AppendFile("test.txt", "bar\nbaz\n")
+	done := make(chan bool)
+	go lt.AssertTailOutput(tail, []string{"foo", "bar", "baz"}, done)
+	ld.StopOnReceive(done)
+}

install-go-tool.sh

@@ -2,12 +2,11 @@
 
 set -e
 
-GOPATH=`pwd`
-go get -u golang.org/x/tools/cmd/goimports
-go get -u github.com/golang/lint/golint
-go get -u github.com/nsf/gocode
-go get -u code.google.com/p/rog-go/exp/cmd/godef
-go get -u sourcegraph.com/sqs/goreturns
-go get -u golang.org/x/tools/cmd/vet
-go get -u golang.org/x/tools/cmd/oracle
-go get -u github.com/ActiveState/tail
+go get -v -u golang.org/x/tools/cmd/goimports
+go get -v -u github.com/golang/lint/golint
+go get -v -u github.com/nsf/gocode
+go get -v -u code.google.com/p/rog-go/exp/cmd/godef
+go get -v -u sourcegraph.com/sqs/goreturns
+go get -v -u golang.org/x/tools/cmd/vet
+go get -v -u golang.org/x/tools/cmd/oracle
+go get -v -u github.com/ActiveState/tail

logdriver.go

@@ -2,44 +2,20 @@ package main
 
 import (
 	"flag"
-	"fmt"
-	"os"
-
-	"github.com/ActiveState/tail"
 )
 
 func main() {
 
-	var filename string
-	flag.StringVar(&filename, "filename", "", "The file to tail.")
-	flag.StringVar(&filename, "F", "", " (shorthand for -filename)")
+	var directory string
+	flag.StringVar(&directory, "directory", "", "The directory to tail log files from.")
+	flag.StringVar(&directory, "d", "", " (shorthand for -directory)")
 	flag.Parse()
 
-	if filename == "" {
+	if directory == "" {
 		flag.Usage()
 		return
 	}
 
-	done := make(chan bool)
-	go tailFile(filename, tail.Config{Follow: true}, done)
-	<-done
-}
-
-func tailFile(filename string, config tail.Config, done chan bool) {
-	// when function completes, notify via the channel
-	defer func() { done <- true }()
-
-	// start tailing
-	t, err := tail.TailFile(filename, config)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return
-	}
-	for line := range t.Lines {
-		fmt.Println(line.Text)
-	}
-	err = t.Wait()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-	}
+	ld := NewLogDriver(directory)
+	ld.Start()
 }