Move Linux client & common packages into a public repo.

logtail/filch/filch.go

@@ -0,0 +1,238 @@
+// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package filch is a file system queue that pilfers your stderr.
+// (A FILe CHannel that filches.)
+package filch
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"sync"
+)
+
+var stderrFD = 2 // a variable for testing
+
+type Options struct {
+	ReplaceStderr bool // dup over fd 2 so everything written to stderr comes here
+}
+
+type Filch struct {
+	OrigStderr *os.File
+
+	mu        sync.Mutex
+	cur       *os.File
+	alt       *os.File
+	altscan   *bufio.Scanner
+	recovered int64
+}
+
+func (f *Filch) TryReadLine() ([]byte, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	if f.altscan != nil {
+		if b, err := f.scan(); b != nil || err != nil {
+			return b, err
+		}
+	}
+
+	f.cur, f.alt = f.alt, f.cur
+	if f.OrigStderr != nil {
+		if err := dup2Stderr(f.cur); err != nil {
+			return nil, err
+		}
+	}
+	if _, err := f.alt.Seek(0, os.SEEK_SET); err != nil {
+		return nil, err
+	}
+	f.altscan = bufio.NewScanner(f.alt)
+	f.altscan.Split(splitLines)
+	return f.scan()
+}
+
+func (f *Filch) scan() ([]byte, error) {
+	if f.altscan.Scan() {
+		return f.altscan.Bytes(), nil
+	}
+	err := f.altscan.Err()
+	err2 := f.alt.Truncate(0)
+	_, err3 := f.alt.Seek(0, os.SEEK_SET)
+	f.altscan = nil
+	if err != nil {
+		return nil, err
+	}
+	if err2 != nil {
+		return nil, err2
+	}
+	if err3 != nil {
+		return nil, err3
+	}
+	return nil, nil
+}
+
+func (f *Filch) Write(b []byte) (int, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	if len(b) == 0 || b[len(b)-1] != '\n' {
+		bnl := make([]byte, len(b)+1)
+		copy(bnl, b)
+		bnl[len(bnl)-1] = '\n'
+		return f.cur.Write(bnl)
+	}
+	return f.cur.Write(b)
+}
+
+func (f *Filch) Close() (err error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	if f.OrigStderr != nil {
+		if err2 := unsaveStderr(f.OrigStderr); err == nil {
+			err = err2
+		}
+		f.OrigStderr = nil
+	}
+
+	if err2 := f.cur.Close(); err == nil {
+		err = err2
+	}
+	if err2 := f.alt.Close(); err == nil {
+		err = err2
+	}
+
+	return err
+}
+
+func New(filePrefix string, opts Options) (f *Filch, err error) {
+	var f1, f2 *os.File
+	defer func() {
+		if err != nil {
+			if f1 != nil {
+				f1.Close()
+			}
+			if f2 != nil {
+				f2.Close()
+			}
+			err = fmt.Errorf("filch: %s", err)
+		}
+	}()
+
+	path1 := filePrefix + ".log1.txt"
+	path2 := filePrefix + ".log2.txt"
+
+	f1, err = os.OpenFile(path1, os.O_CREATE|os.O_RDWR, 0666)
+	if err != nil {
+		return nil, err
+	}
+	f2, err = os.OpenFile(path2, os.O_CREATE|os.O_RDWR, 0666)
+	if err != nil {
+		return nil, err
+	}
+
+	fi1, err := f1.Stat()
+	if err != nil {
+		return nil, err
+	}
+	fi2, err := f2.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	f = &Filch{
+		OrigStderr: os.Stderr, // temporary, for past logs recovery
+	}
+
+	// Neither, either, or both files may exist and contain logs from
+	// the last time the process ran. The three cases are:
+	//
+	//	- neither: all logs were read out and files were truncated
+	//	- either: logs were being written into one of the files
+	//	- both: the files were swapped and were starting to be
+	//		read out, while new logs streamed into the other
+	//		file, but the read out did not complete
+	if n := fi1.Size() + fi2.Size(); n > 0 {
+		f.recovered = n
+	}
+	switch {
+	case fi1.Size() > 0 && fi2.Size() == 0:
+		f.cur, f.alt = f2, f1
+	case fi2.Size() > 0 && fi1.Size() == 0:
+		f.cur, f.alt = f1, f2
+	case fi1.Size() > 0 && fi2.Size() > 0: // both
+		// We need to pick one of the files to be the elder,
+		// which we do using the mtime.
+		var older, newer *os.File
+		if fi1.ModTime().Before(fi2.ModTime()) {
+			older, newer = f1, f2
+		} else {
+			older, newer = f2, f1
+		}
+		if err := moveContents(older, newer); err != nil {
+			fmt.Fprintf(f.OrigStderr, "filch: recover move failed: %v\n", err)
+			fmt.Fprintf(older, "filch: recover move failed: %v\n", err)
+		}
+		f.cur, f.alt = newer, older
+	default:
+		f.cur, f.alt = f1, f2 // does not matter
+	}
+	if f.recovered > 0 {
+		f.altscan = bufio.NewScanner(f.alt)
+		f.altscan.Split(splitLines)
+	}
+
+	f.OrigStderr = nil
+	if opts.ReplaceStderr {
+		f.OrigStderr, err = saveStderr()
+		if err != nil {
+			return nil, err
+		}
+		if err := dup2Stderr(f.cur); err != nil {
+			return nil, err
+		}
+	}
+
+	return f, nil
+}
+
+func moveContents(dst, src *os.File) (err error) {
+	defer func() {
+		_, err2 := src.Seek(0, os.SEEK_SET)
+		err3 := src.Truncate(0)
+		_, err4 := dst.Seek(0, os.SEEK_SET)
+		if err == nil {
+			err = err2
+		}
+		if err == nil {
+			err = err3
+		}
+		if err == nil {
+			err = err4
+		}
+	}()
+	if _, err := src.Seek(0, os.SEEK_SET); err != nil {
+		return err
+	}
+	if _, err := io.Copy(dst, src); err != nil {
+		return err
+	}
+	return nil
+}
+
+func splitLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	if atEOF && len(data) == 0 {
+		return 0, nil, nil
+	}
+	if i := bytes.IndexByte(data, '\n'); i >= 0 {
+		return i + 1, data[0 : i+1], nil
+	}
+	if atEOF {
+		return len(data), data, nil
+	}
+	return 0, nil, nil
+}

logtail/filch/filch_test.go

@@ -0,0 +1,178 @@
+// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package filch
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"unicode"
+)
+
+type filchTest struct {
+	*Filch
+}
+
+func newFilchTest(t *testing.T, filePrefix string, opts Options) *filchTest {
+	f, err := New(filePrefix, opts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &filchTest{Filch: f}
+}
+
+func (f *filchTest) write(t *testing.T, s string) {
+	t.Helper()
+	if _, err := f.Write([]byte(s)); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func (f *filchTest) read(t *testing.T, want string) {
+	t.Helper()
+	if b, err := f.TryReadLine(); err != nil {
+		t.Fatalf("r.ReadLine() err=%v", err)
+	} else if got := strings.TrimRightFunc(string(b), unicode.IsSpace); got != want {
+		t.Errorf("r.ReadLine()=%q, want %q", got, want)
+	}
+}
+
+func (f *filchTest) readEOF(t *testing.T) {
+	t.Helper()
+	if b, err := f.TryReadLine(); b != nil || err != nil {
+		t.Fatalf("r.ReadLine()=%q err=%v, want nil slice", string(b), err)
+	}
+}
+
+func (f *filchTest) close(t *testing.T) {
+	t.Helper()
+	if err := f.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func genFilePrefix(t *testing.T) string {
+	t.Helper()
+	filePrefix, err := ioutil.TempDir("", "filch")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return filepath.Join(filePrefix, "ringbuffer-")
+}
+
+func TestQueue(t *testing.T) {
+	filePrefix := genFilePrefix(t)
+	defer os.RemoveAll(filepath.Dir(filePrefix))
+
+	f := newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+
+	f.readEOF(t)
+	const line1 = "Hello, World!"
+	const line2 = "This is a test."
+	const line3 = "Of filch."
+	f.write(t, line1)
+	f.write(t, line2)
+	f.read(t, line1)
+	f.write(t, line3)
+	f.read(t, line2)
+	f.read(t, line3)
+	f.readEOF(t)
+	f.write(t, line1)
+	f.read(t, line1)
+	f.readEOF(t)
+	f.close(t)
+}
+
+func TestRecover(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		filePrefix := genFilePrefix(t)
+		defer os.RemoveAll(filepath.Dir(filePrefix))
+		f := newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+		f.write(t, "hello")
+		f.read(t, "hello")
+		f.readEOF(t)
+		f.close(t)
+
+		f = newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+		f.readEOF(t)
+		f.close(t)
+	})
+
+	t.Run("cur", func(t *testing.T) {
+		filePrefix := genFilePrefix(t)
+		defer os.RemoveAll(filepath.Dir(filePrefix))
+		f := newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+		f.write(t, "hello")
+		f.close(t)
+
+		f = newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+		f.read(t, "hello")
+		f.readEOF(t)
+		f.close(t)
+	})
+
+	t.Run("alt", func(t *testing.T) {
+		t.Skip("currently broken on linux, passes on macOS")
+		/* --- FAIL: TestRecover/alt (0.00s)
+		filch_test.go:128: r.ReadLine()="world", want "hello"
+		filch_test.go:129: r.ReadLine()="hello", want "world"
+		*/
+
+		filePrefix := genFilePrefix(t)
+		defer os.RemoveAll(filepath.Dir(filePrefix))
+		f := newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+		f.write(t, "hello")
+		f.read(t, "hello")
+		f.write(t, "world")
+		f.close(t)
+
+		f = newFilchTest(t, filePrefix, Options{ReplaceStderr: false})
+		// TODO(crawshaw): The "hello" log is replayed in recovery.
+		//                 We could reduce replays by risking some logs loss.
+		//                 What should our policy here be?
+		f.read(t, "hello")
+		f.read(t, "world")
+		f.readEOF(t)
+		f.close(t)
+	})
+}
+
+func TestFilchStderr(t *testing.T) {
+	pipeR, pipeW, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer pipeR.Close()
+	defer pipeW.Close()
+
+	stderrFD = int(pipeW.Fd())
+	defer func() {
+		stderrFD = 2
+	}()
+
+	filePrefix := genFilePrefix(t)
+	defer os.RemoveAll(filepath.Dir(filePrefix))
+	f := newFilchTest(t, filePrefix, Options{ReplaceStderr: true})
+	f.write(t, "hello")
+	if _, err := fmt.Fprintf(pipeW, "filch\n"); err != nil {
+		t.Fatal(err)
+	}
+	f.read(t, "hello")
+	f.read(t, "filch")
+	f.readEOF(t)
+	f.close(t)
+
+	pipeW.Close()
+	b, err := ioutil.ReadAll(pipeR)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(b) > 0 {
+		t.Errorf("unexpected write to fake stderr: %s", b)
+	}
+}

logtail/filch/filch_unix.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2020 Tailscale Inc & 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 !windows
+
+package filch
+
+import (
+	"os"
+	"syscall"
+)
+
+func saveStderr() (*os.File, error) {
+	fd, err := syscall.Dup(stderrFD)
+	if err != nil {
+		return nil, err
+	}
+	return os.NewFile(uintptr(fd), "stderr"), nil
+}
+
+func unsaveStderr(f *os.File) error {
+	err := dup2Stderr(f)
+	f.Close()
+	return err
+}
+
+func dup2Stderr(f *os.File) error {
+	return syscall.Dup2(int(f.Fd()), stderrFD)
+}

logtail/filch/filch_windows.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package filch
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+)
+
+var kernel32 = syscall.MustLoadDLL("kernel32.dll")
+var procSetStdHandle = kernel32.MustFindProc("SetStdHandle")
+
+func setStdHandle(stdHandle int32, handle syscall.Handle) error {
+	r, _, e := syscall.Syscall(procSetStdHandle.Addr(), 2, uintptr(stdHandle), uintptr(handle), 0)
+	if r == 0 {
+		if e != 0 {
+			return error(e)
+		}
+		return syscall.EINVAL
+	}
+	return nil
+}
+
+func saveStderr() (*os.File, error) {
+	return os.Stderr, nil
+}
+
+func unsaveStderr(f *os.File) error {
+	os.Stderr = f
+	return nil
+}
+
+func dup2Stderr(f *os.File) error {
+	fd := int(f.Fd())
+	err := setStdHandle(syscall.STD_ERROR_HANDLE, syscall.Handle(fd))
+	if err != nil {
+		return fmt.Errorf("dup2Stderr: %w", err)
+	}
+	os.Stderr = f
+	return nil
+}