main.go

// A webapp for looking at and searching through files.
package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net"
	"os"
	"strings"
	"sync"

	"github.com/mitchellh/mapstructure"
	"github.com/pelletier/go-toml"
	flag "github.com/spf13/pflag"
)

const scriptDescription = `
Usage: tailon -c <config file>
Usage: tailon [options] <filespec> [<filespec> ...]

Tailon is a webapp for looking at and searching through files and streams.
`

const scriptEpilog = `
Tailon can be configured through a config file or with command-line flags.

The command-line interface expects one or more filespec arguments, which
specify the files to be served. The expected format is:

  [alias=name,group=name]<spec>

where <spec> can be a file name, glob or directory. The optional 'alias='
and 'group=' specifiers change the display name of the files in the UI and
the group in which they appear.

A file specifier points to a single, possibly non-existent file. The file
name in the UI can be overwritten with 'alias='. For example:

  tailon alias=error.log,/var/log/apache/error.log

A glob evaluates to the list of files that match a shell file name pattern.
The pattern is evaluated each time the file list is refreshed. An 'alias='
specifier overwrites the parent directory of each matched file in the UI.

  tailon "/var/log/apache/*.log" "alias=nginx,/var/log/nginx/*.log"

If a directory is given, all files under it are served recursively.

  tailon /var/log/apache/ /var/log/nginx/

Example usage:
  tailon file1.txt file2.txt file3.txt
  tailon alias=messages,/var/log/messages "/var/log/*.log"
  tailon -b localhost:8080,localhost:8081 -c config.toml

For information on usage through the configuration file, please refer to the
'--help-config' option.
`

const configFileHelp = `
Tailon can be configured through a TOML config file. The config file allows
more configurability than the command-line interface.

  # The <title> of the index page.
  title = "Tailon"

  # The root of the web application.
  relative-root = "/"

  # The addresses to listen on. Can be an address:port combination or an unix socket.
  listen-addr = [":8080"]

  # Allow download of know files (only those matched by a filespec).
  allow-download = true

  # Commands that will appear in the UI.
  allow-commands = ["tail", "grep", "grep -v", "sed", "awk"]
`

const defaultTomlConfig = `
  title = "Tailon"
  relative-root = "/"
  listen-addr = [":8080"]
  allow-download = true
  lines-of-history = 0
  lines-to-tail = 100
  allow-commands = ["tail", "grep", "grep -v", "sed", "awk"]

  [files]
    file1 = "alias=test,group=test_group,log.log"
    file2 = "alias=test1,group=test_group1,log.log"

  [commands]
    [commands.tail]
    action = ["tail", "-n", "$lines", "-F", "$path"]

    [commands.grep]
    stdin = "tail"
    action = ["grep", "-e", "$script"]
    default = ".*"

    [commands.sed]
    stdin = "tail"
    action = ["sed", "-u", "-e", "$script"]
    default = "s/.*/&/"

    [commands.awk]
    stdin = "tail"
    action = ["awk", "--sandbox", "$script"]
    default = "{print $0; fflush()}"

    [commands."grep -v"]
    stdin = "tail"
    action = ["grep", "-v", "--text", "--line-buffered", "--color=never", "-e", "$script"]
    default = "^$"
`

// CommandSpec defines a command that the server can execute.
type CommandSpec struct {
	Stdin   string
	Action  []string
	Default string
}

func parseTomlConfig(config string) (*toml.Tree, map[string]CommandSpec, []FileSpec) {
	cfg, err := toml.Load(config)
	if err != nil {
		log.Fatal("Error parsing config: ", err)
	}

	commands := make(map[string]CommandSpec)

	cfgCommands := cfg.Get("commands").(*toml.Tree).ToMap()
	for key, value := range cfgCommands {
		command := CommandSpec{}
		err := mapstructure.Decode(value, &command)
		if err != nil {
			log.Fatal(err)
		}
		commands[key] = command
	}

	cfgFiles := cfg.Get("files").(*toml.Tree).ToMap()
	filespecs := make([]FileSpec, 0)
	for _, value := range cfgFiles {
        if value == nil {
            continue
        }
        strvalue := fmt.Sprint(value)
		if file, err := parseFileSpec(strvalue); err != nil {
			fmt.Fprintf(os.Stderr, "Error parsing argument '%s': %s\n", strvalue, err)
			os.Exit(1)
		} else {
            filespecs = append(filespecs, file)
		}
	}

	return cfg, commands, filespecs
}

// FileSpec is an instance of a file to be monitored. These are mapped to
// os.Args or the [files] elements in the config file.
type FileSpec struct {
	Path  string
	Type  string
	Alias string
	Group string
}

// Parse a string into a filespec. Example inputs are:
//   alias=1,group=2,/var/log/messages
//   /var/log/
//   /var/log/*
func parseFileSpec(spec string) (FileSpec, error) {
	var filespec FileSpec
	var path string
	parts := strings.Split(spec, ",")

	if length := len(parts); length == 1 {
		path = parts[0]
	} else {
		// The last part is the path. We'll probably need a more robust
		// solution in the future.
		path, parts = parts[len(parts)-1], parts[:len(parts)-1]
	}

	if strings.ContainsAny(path, "*?[]") {
		filespec.Type = "glob"
	} else {
		stat, err := os.Lstat(path)
		if os.IsNotExist(err) || stat.Mode().IsRegular() {
			filespec.Type = "file"
		} else if stat.Mode().IsDir() {
			filespec.Type = "dir"
		}
	}

	for _, part := range parts {
		if strings.HasPrefix(part, "group=") {
			group := strings.SplitN(part, "=", 2)[1]
			group = strings.Trim(group, "'\" ")
			filespec.Group = group
		} else if strings.HasPrefix(part, "alias=") {
			filespec.Alias = strings.SplitN(part, "=", 2)[1]
		}
	}

	if filespec.Type == "" {
		filespec.Type = "file"
	}
	filespec.Path = path
	return filespec, nil

}

// Config contains all backend and frontend configuration options and relevant state.
type Config struct {
	RelativeRoot      string
	BindAddr          []string
	ConfigPath        string
	WrapLinesInitial  bool
	TailLinesInitial  int
	LinesToTail       int64
	LinesOfHistory    int64
	AllowCommandNames []string
	AllowDownload     bool

	CommandSpecs   map[string]CommandSpec
	CommandScripts map[string]string
	FileSpecs      []FileSpec
}

func makeConfig(configContent string) *Config {
	defaults, commandSpecs, fileSpecs := parseTomlConfig(configContent)

	// Convert the list of bind addresses from []interface{} to []string.
	addrsA := defaults.Get("listen-addr").([]interface{})
	addrsB := make([]string, len(addrsA))
	for i := range addrsA {
		addrsB[i] = addrsA[i].(string)
	}

	config := Config{
		BindAddr:       addrsB,
		RelativeRoot:   defaults.Get("relative-root").(string),
		LinesToTail:    defaults.Get("lines-to-tail").(int64),
		LinesOfHistory: defaults.Get("lines-of-history").(int64),
		AllowDownload:  defaults.Get("allow-download").(bool),
		CommandSpecs:   commandSpecs,
		FileSpecs:     fileSpecs,
	}

	mapstructure.Decode(defaults.Get("allow-commands"), &config.AllowCommandNames)
	return &config
}

var config = &Config{}

func main() {
	config = makeConfig(defaultTomlConfig)

	printHelp := flag.BoolP("help", "h", false, "Show this help message and exit")
	printConfigHelp := flag.BoolP("help-config", "e", false, "Show configuration file help and exit")
	bindAddr := flag.StringP("bind", "b", strings.Join(config.BindAddr, ","), "Listen on the specified address and port")

	flag.StringVarP(&config.RelativeRoot, "relative-root", "r", config.RelativeRoot, "Webapp relative root.")
	flag.BoolVarP(&config.AllowDownload, "allow-download", "a", config.AllowDownload, "Allow file downloads.")
	flag.Int64Var(&config.LinesToTail, "lines-to-tail", config.LinesToTail, "No. of lines to tail.")
	flag.Int64Var(&config.LinesOfHistory, "history-lines", config.LinesOfHistory, "No. of history lines to tail.")
	flag.StringVarP(&config.ConfigPath, "config", "c", "", "Config.toml file location.")
	flag.Parse()

	flag.Usage = func() {
		fmt.Fprintln(os.Stderr, strings.TrimLeft(scriptDescription, "\n"))
		flag.PrintDefaults()
		fmt.Fprintln(os.Stderr, strings.TrimRight(scriptEpilog, "\n"))
		os.Exit(0)
	}

	if *printHelp {
		flag.Usage()
		os.Exit(0)
	}

	if *printConfigHelp {
		fmt.Fprintf(os.Stderr, "%s\n\n%s\n", strings.Trim(configFileHelp, "\n"), strings.Trim(defaultTomlConfig, "\n"))
		os.Exit(0)
	}

	config.BindAddr = strings.Split(*bindAddr, ",")

	// If a configuration file is specified, read all options from it. This discards all options set on the command-line.
	if config.ConfigPath != "" {
		if b, err := ioutil.ReadFile(config.ConfigPath); err != nil {
			fmt.Fprintf(os.Stderr, "Error reading config file '%s': %s\n", config.ConfigPath, err)
			os.Exit(1)
		} else {
			config = makeConfig(string(b))
		}
	}

	// Ensure that relative root is always '/' or '/$arg/'.
	config.RelativeRoot = "/" + strings.TrimLeft(config.RelativeRoot, "/")
	config.RelativeRoot = strings.TrimRight(config.RelativeRoot, "/") + "/"

	// Handle command-line file specs
	filespecs := make([]FileSpec, len(flag.Args()))
	for _, spec := range flag.Args() {
		if filespec, err := parseFileSpec(spec); err != nil {
			fmt.Fprintf(os.Stderr, "Error parsing argument '%s': %s\n", spec, err)
			os.Exit(1)
		} else {
			config.FileSpecs = append(filespecs, filespec) // from joshuaboniface fork
			filespecs = append(filespecs, filespec) // original one
			config.FileSpecs = filespecs // this wasn't here. It was on 319
		}
	}
	//config.FileSpecs = filespecs was here

	if len(config.FileSpecs) == 0 {
		fmt.Fprintln(os.Stderr, "No files specified on command-line or in config file")
		os.Exit(2)
	}

	config.CommandScripts = make(map[string]string)
	for cmd, values := range config.CommandSpecs {
		config.CommandScripts[cmd] = values.Default
	}

	log.Print("Generating initial file listing...")
	createListing(config.FileSpecs)

	var wg sync.WaitGroup
	for _, addr := range config.BindAddr {
		wg.Add(1)
		go startServer(config, addr)
	}
	wg.Wait()

}

func startServer(config *Config, bindAddr string) {
	loggerHTML := log.New(os.Stdout, "", log.LstdFlags)
	loggerHTML.Printf("Server start, relative-root: %s, bind-addr: %s\n", config.RelativeRoot, bindAddr)

	server := setupServer(config, bindAddr, loggerHTML)

	if strings.Contains(bindAddr, ":") {
		server.ListenAndServe()
	} else {
		os.Remove(bindAddr)

		unixAddr, _ := net.ResolveUnixAddr("unix", bindAddr)
		unixListener, err := net.ListenUnix("unix", unixAddr)
		unixListener.SetUnlinkOnClose(true)

		if err != nil {
			panic(err)
		}

		defer unixListener.Close()
		server.Serve(unixListener)
	}
}