diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..ef79b4e
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,7 @@
+frontend/node_modules
+tailon
+scripts/
+testdata/
+config.toml
+*.bat
+*.log
diff --git a/.github/workflows/ghcr-publish.yml b/.github/workflows/ghcr-publish.yml
new file mode 100644
index 0000000..16ceca8
--- /dev/null
+++ b/.github/workflows/ghcr-publish.yml
@@ -0,0 +1,79 @@
+name: Build and Push to GHCR
+
+on:
+ workflow_dispatch:
+ repository_dispatch:
+ types: [Build and Push to GHCR]
+ push:
+ branches:
+ - master
+
+jobs:
+ build-and-push-to-ghcr:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: benjlevesque/short-sha@v1.2
+ id: short-sha
+ with:
+ length: 7
+ - uses: actions/checkout@v2
+ - name: Log into GitHub Container Registry
+ run: echo "${{ secrets.GIT_TOKEN }}" | docker login https://ghcr.io -u ${{ github.actor }} --password-stdin
+
+ - name: Set up QEMU
+ uses: docker/setup-qemu-action@v1
+ with:
+ image: tonistiigi/binfmt:latest
+ platforms: all
+
+ - name: Set up Docker Buildx
+ id: buildx
+ uses: docker/setup-buildx-action@v1
+ with:
+ install: true
+ version: latest
+ driver-opts: image=moby/buildkit:master
+
+ - name: Build and push
+ id: docker_build_amd64
+ uses: docker/build-push-action@v2
+ with:
+ context: ./
+ file: ./Dockerfile
+ push: true
+ tags: |
+ ghcr.io/niniyas/tailon:beta
+ ghcr.io/${{ secrets.GIT_USER }}/tailon:beta-${{ steps.short-sha.outputs.sha }}
+ platforms: linux/amd64,linux/arm64
+
+ - name: ntfy success notifications
+ uses: niniyas/ntfy-action@master
+ if: success()
+ with:
+ url: ${{ secrets.NTFY_URL }}
+ topic: ${{ secrets.NTFY_TOPIC }}
+ tags: github,action,+1,partying_face
+ priority: 4
+ details: 'Workflow has been completed successfully!'
+ headers: '${{ secrets.NTFY_HEADERS }}'
+
+ - name: ntfy failed notifications
+ uses: niniyas/ntfy-action@master
+ if: failure()
+ with:
+ url: ${{ secrets.NTFY_URL }}
+ topic: ${{ secrets.NTFY_TOPIC }}
+ tags: github,action,failed,rotating_light
+ priority: 5
+ details: 'Workflow has failed!'
+ headers: '${{ secrets.NTFY_HEADERS }}'
+
+ - name: ntfy cancelled notifications
+ uses: niniyas/ntfy-action@master
+ if: cancelled()
+ with:
+ url: ${{ secrets.NTFY_URL }}
+ topic: ${{ secrets.NTFY_TOPIC }}
+ tags: github,action,cancelled,skull
+ details: 'Workflow has been cancelled!'
+ headers: '${{ secrets.NTFY_HEADERS }}'
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..99bcd0d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,34 @@
+# Project
+node_modules/
+/tailon
+/gin-bin
+.pytest_cache
+testdata/
+### Editors ###
+*~
+\#*\#
+.\#*
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+### Go ###
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+*.log
+*.bat
+
+dist/
diff --git a/.goreleaser.yml b/.goreleaser.yml
new file mode 100644
index 0000000..f8e8ad8
--- /dev/null
+++ b/.goreleaser.yml
@@ -0,0 +1,8 @@
+builds:
+ - binary: tailon
+ goos:
+ - linux
+ goarch:
+ - amd64
+ - arm64
+ - arm
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..fc9c707
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,71 @@
+# Changelog
+
+## [1.0.0] - 2022-07-06
+First of all, I am not familiar with GO or JavaScript. I learned them while I was trying to make this better. \
+So you may find some codes here and there that were not meant to be and I apologize for that.
+
+## UI
+- A bunch of CSS tweaks
+- Wrapped lines mode will have alternative colors between lines.
+- Configuration dialog will now be hidden when clicking elsewhere.
+- The logs will now fit most of the screens properly.
+- Added the option to change background color and font color. Thanks to [nurzico/tailon](https://github.com/nurzico/tailon).
+- Added labels for log levels. Thanks to [fquinto/tailon](https://github.com/fquinto/tailon) for the code. I added the rest of them.
+- Added labels for all the HTTP methods.
+- Added the ability to clear search field with escape button. Thanks to [bformet/tailon](https://github.com/bformet/tailon/commit/03d08ab3b36c9b982c09754d93ecfb8fdbd54284)
+- Favicon is now displaying properly.
+- Added a separate configuration for UI changes.
+- Added the option for changing font type.
+- Download file option now opens in a new window.
+- Changed toolbar icons. They were from:
+ - [Eraser](https://www.svgrepo.com/svg/72555/eraser)
+ - [Settings](https://www.svgrepo.com/svg/10074/settings)
+ - [Download](https://www.svgrepo.com/svg/14689/download)
+ - [UI Tools](https://www.reshot.com/free-svg-icons/item/tool-YANDWEVLTJ/)
+- Added a range slider to change font size. It is from [W3Schools](https://www.w3schools.com/howto/howto_js_rangeslider.asp).
+
+## CLI
+- Added command line `lines-to-tail` and `lines-of-history`. Thanks to [ebbeknudsen/tailon](https://github.com/ebbeknudsen/tailon/commit/944862f466790dfe67715c8c82f6edbd5605915a)
+- Formatted help message.
+
+## Config File
+- Added the ability to load files from config.toml. Thanks to [joshuaboniface/tailon](https://github.com/joshuaboniface/tailon/commit/8d1a949e563a719938c1d74be693e49d57e246ed). \
+You can view the example in [README](README.md#config-file) or [config.toml](config.toml). This code would only load multiple files from toml file but shows only the last one when using command line. I somehow managed to fix this. I am not sure how reliable it is. I just put one or two lines in 314-316 lines in main.go file. But in my testing it worked fine.
+
+## Dependencies
+- Updated frontend dependencies:
+ - autoprefixer: 8.6.1 -> 10.4.7
+ - clean-css: 4.1.11 -> 5.3.0
+ - clean-css-cli: 4.1.11 -> 5.6.0
+ - debounce: 1.1.0 -> 1.2.1
+ - node-sass: 4.11.0 -> 7.0.1
+ - npm: 6.13.4 -> 8.13.2
+ - postcss-cli: 5.0.0 -> 10.0.0
+ - sockjs-client: 1.3.0 -> 1.6.1
+ - uglify-js: 3.4.4 -> 3.16.2
+ - vue: 2.5.16 -> 2.7.2
+ - vue-loading-overlay: 2.1.0 -> 3.4.2
+ - vue-multiselect: 2.1.0 -> 2.1.6
+- Added `@mdi/font` as a dependency.
+- Updated updated materialdesignicons webfonts and css in `dist` folder from v5.8.55 -> v6.9.96.
+- Updated sockjsv2 -> sockjsv3 in `server.go` file. Thanks to [GChuf/tailon](https://github.com/GChuf/tailon/commit/5684abaf7cae3722e1a659afcf0ff2ea8172a707).
+
+## Development
+- Added developement requirements and steps in [README](README.md). Huge thanks to [fquinto/tailon](https://github.com/fquinto/tailon) for including how to build in their README.
+- Added `license`, `description`, `scripts`, `keywords`, `bugs` and `homepage` fields in `package.json` file.
+- Added `npm run` commands to build frontend and tailon.
+ - `npm run build` will build dependencies, upgrade them, delete old .css and .js files and rebuilds them and exits.
+ - `npm run build-and-watch` will also build dependencies, upgrade them, delete old .css and .js files and rebuilds them and watches for changes in frontend files. This requires [entr](https://github.com/eradman/entr).
+ - `npm run build-tailon` will build tailon for your arch and exits.
+ - `npm run build-frontend-and-tailon` will build dependencies, upgrade them, delete old .css and .js files, rebuilds them and also build tailon and exits.
+
+## Docker
+- Added Dockerfile healthcheck.
+- Removed `upx` dependency.
+- Added multi-arch docker images, built with GitHub Actions.
+
+## Miscellaneous
+- `make all` command in frontend directory will beautify all the .js files and .css files that it creates.
+- Favicon location was moved from `frontend/dist` directory to `frontend/dist/static/favicon` folder.
+- Added `grep -v` command. Thanks to [alexeykobzev/tailon](https://github.com/alexeykobzev/tailon/commit/034b17b66c08d8ab3430b6e1521821969ddb7d99).
+- `make README.md` command in root folder is broken. I have commented it out.
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..20d06b6
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,27 @@
+FROM golang:alpine as build
+
+WORKDIR /tailon
+
+ADD . .
+
+RUN apk add --upgrade binutils
+
+RUN cd /tailon && \
+ go get && \
+ go build && \
+ strip tailon
+
+RUN apk del binutils
+
+FROM alpine:latest
+
+RUN apk add gawk grep sed
+
+COPY --from=build /tailon/tailon /usr/local/bin/tailon
+
+CMD ["--help"]
+ENTRYPOINT ["/usr/local/bin/tailon"]
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=60s --retries=3 \
+ CMD wget --no-verbose --tries=1 --spider http://localhost:8080 || exit 1
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..b1c129a
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,24 @@
+BUILD ?= prod
+
+dev:
+ go build -tags dev
+ $(MAKE) frontend BUILD=dev
+
+test:
+ go test -v
+ #cd tests && pytest -v
+
+frontend:
+ cd frontend && $(MAKE) clean ; $(MAKE) BUILD=$(BUILD)
+
+frontend-watch:
+ cd frontend && $(MAKE) watch BUILD=$(BUILD)
+
+docker-build:
+ docker buildx build --push --tag ghcr.io/niniyas/tailon:beta --platform linux/arm64,linux/amd64,linux/armv7 .
+
+#README.md:
+ #sudo chmod +x build_readme.sh
+ #./build_readme.sh
+
+.PHONY: test frontend frontend-watch docker-build README.md
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c770cfd
--- /dev/null
+++ b/README.md
@@ -0,0 +1,360 @@
+# Tailon [](https://github.com/NiNiyas/tailon/blob/master/LICENSE) [](https://github.com/NiNiyas/tailon/releases)
+
+
+ 
+
+
+Fork of [gvalkov/tailon](https://github.com/gvalkov/tailon).
+
+Tailon is a webapp for looking at and searching through files and streams. \
+In a nutshell, it is a fancy web wrapper around the following commands:
+
+```
+tail -f
+tail -f | grep
+tail -f | awk
+tail -f | sed
+```
+
+What sets tailon apart from other similar projects is:
+
+* Fully self-contained executable. Just download (or build) and run.
+* Responsive and minimal user-interface.
+
+## Install
+
+### Docker
+#### docker run
+
+```
+docker run --rm ghcr.io/niniyas/tailon:beta --help
+```
+
+#### docker compose
+```
+version: "3.9"
+services:
+ tailon:
+ container_name: Tailon
+ image: ghcr.io/niniyas/tailon:beta
+ ports:
+ - 8080:8080
+ volumes:
+ - /var/log/syslog:/syslog
+ - /var/log/log1:/log1
+ - .tailon/config:/config # If you need to load from config file, put your config.toml in this folder.
+ command: -b :8080 "group=Syslog,alias=syslog,/syslog" "group=group1,/log1/*.log"
+ command: -c /config/config.toml # If you need to load from config file
+```
+
+### Releases
+
+Download a build for your platform from the [releases](https://github.com/NiNiyas/tailon/releases) page.
+
+## Changelog
+
+See [changelog](CHANGELOG.md).
+
+## Usage
+
+Tailon is a command-line program that starts a local HTTP server, which in turn streams the output of commands such as `tail` and `grep`. \
+It can be configured from its command-line interface or through the convenience of a [toml](https://github.com/toml-lang/toml) config file. \
+Some options, like adding new commands, are only available through the configuration file.
+
+To get started, run tailon with the list of files that you wish to monitor.
+
+```
+tailon /var/log/apache/access.log /var/log/apache/error.log /var/log/messages
+```
+
+Tailon can serve single files, globs or whole directory trees. \
+Tailon’s server-side functionality is summarized entirely in its help message:
+
+[//]: # (run "make README.md" to update the next section with the output of tailon --help)
+
+[//]: # (BEGIN HELP)
+```
+Usage: tailon -c
+Usage: tailon [options] [ ...]
+
+Tailon is a webapp for looking at and searching through files and streams.
+
+ -a, --allow-download Allow file downloads. (default true)
+ -b, --bind string Listen on the specified address and port (default ":8080")
+ -c, --config string Config.toml file location.
+ -h, --help Show this help message and exit
+ -e, --help-config Show configuration file help and exit
+ --history-lines int No. of history lines to tail.
+ --lines-to-tail int No. of lines to tail. (default 100)
+ -r, --relative-root string Webapp relative root. (default "/")
+
+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]
+
+where 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.
+```
+[//]: # (END HELP)
+
+### Config File
+Tailon can be configured through a TOML config file. \
+The config file allows more configurability than the command-line interface.
+
+```
+ # The 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"]
+
+ 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 = "^$"
+```
+
+### Labels
+
+Tailon will automatically convert the following to labels:
+
+#### Log levels
+
+- EMERGENCY
+- ALERT
+- CRITICAL
+- ERROR
+- WARNING
+- NOTICE
+- INFO
+- DEBUG
+
+#### HTTP Methods
+
+- GET
+- POST
+- PUT
+- HEAD
+- DELETE
+- PATCH
+- OPTIONS
+- CONNECT
+- TRACE
+
+#### Others
+- FAILED
+- FAILURE
+
+## Security
+
+Tailon runs commands on the server it is installed on. While commands that
+accept a script argument (such as awk, sed and grep) should be invulnerable to
+shell injection, they may still allow for arbitrary command execution and
+unrestricted access to the filesystem.
+
+To clarify this point, consider the following input to the sed command:
+
+```
+s/a/b'; cat /etc/secrets
+```
+
+This will result in an error, as tailon does not invoke commands through a
+shell. On the other hand, the following command is a perfectly valid sed script
+that has the same effect as the above attempt for shell injection:
+
+```
+r /etc/secrets
+```
+
+The default set of enabled commands - tail, grep and awk - should be safe to
+use. GNU awk is run in [sandbox](http://www.gnu.org/software/gawk/manual/html_node/Options.html#index-g_t_0040code_007b_002dS_007d-option-277) mode, which prevents scripts from accessing your
+system, either through the `system()` builtin or by using input redirection.
+
+By default, tailon is accessible to anyone who knows the server address and
+port.
+
+
+## Development
+
+### Requirements
+
+If you are on Windows, use WSL2. Install [Ubuntu](https://apps.microsoft.com/store/detail/ubuntu/9PDXGNCFSCZV) from Microsoft Store.
+
+- GO: v1.18. I followed [this](https://www.digitalocean.com/community/tutorials/how-to-install-go-on-ubuntu-20-04) guide.
+- Node.js: v16.*. I followed [this](https://github.com/nodesource/distributions/blob/master/README.md) guide.
+- Make: `sudo apt-get install make`
+- [entr](https://github.com/eradman/entr): `sudo apt-get install entr`
+
+
+```
+git clone https://github.com/NiNiyas/tailon.git
+cd tailon
+export GOROOT=/usr/local/go
+export GOPATH=$HOME/go
+export PATH=$PATH:$GOROOT/bin
+go get
+```
+
+**Note**: The paths above might be different for you. Set this accordingly.
+
+### Frontend
+
+The web interface is a written in plain ES5 with the help of some Vue.js. A
+simple makefile is used to bundle and compress the frontend assets. To work on
+the frontend, make sure you're building with the `dev` build tag:
+
+```
+go build -tags dev
+```
+
+This will ensure that the `tailon` binary is reading assets from the
+`frontend/dist` directory instead of from `frontend/assets_vfsdata.go`. To
+compile the web assets, use `make all` or `make all BUILD=dev` in case you want
+to simply concatenate files instead of also compressing them.
+
+The `make watch` goal can be used to continuously update the bundles as you make
+changes to the sources. This requires [entr](#requirements).
+
+Note that the minified frontend bundles are committed in order to avoid people
+wanting to work only on the backend from having to pull the full `node_modules`.
+
+To build frontend, I have included a simple [build_frontend](https://github.com/NiNiyas/tailon/blob/master/build_frontend.sh) script. \
+Make it executable with `sudo chmod +x build_frontend.sh` and run it `./build_frontend.sh`.
+
+### Backend
+
+The backend is written in straightforward go that tries to do as much as
+possible using only the standard library.
+
+#### Alpine Linux build
+
+- INFO: http://krolow.com.br/til/go-compile-binary-not-running-in-alpine-and-busybox/
+
+`CGO_ENABLED=0 go build -tags netgo -a -v`
+
+
+## Backlog
+
+See [TODO](TODO.md).
+
+## Known Bugs
+
+- When toolbar is hidden, last few lines are not visible in Fennec FDroid 101.1.1 build#1011120 8092b4e74+ and possibly other Firefox versions as well. Works fine on Bromite.
+
+### Testing
+
+The project has unit-tests, which you can run with `go test` and integration
+tests which you can run with `cd tests; pytest`. \
+Alternatively, you can run both with `make test`.
+
+The integration tests are written in Python and use `pytest` and `aiohttp` to
+interact with a running `tailon` instance. \
+To run the integration tests, you first need to install the needed dependencies:
+
+**Note**: Python testing is broken. I have commented out the line in [Makefile](Makefile), I will take a look at it when I have time.
+
+```shell
+# Option 1: Using a virtualenv
+python3 -m venv path/to/venv
+source path/to/venv/bin/activate
+python3 -m pip install -r tests/requirements.txt
+
+# Option 2: User site-packages
+python3 -m pip install --user -r tests/requirements.txt
+```
+
+### Contribute
+
+Please do contribute! Issues and pull requests are welcome. I could use some help.
+
+<!--## What about the other tailon project?
+
+This project is a full rewrite of the original [tailon](https://github.com/gvalkov/tailon-legacy) with the following goals in mind:
+
+* Reduce maintenance overhead (especially on the frontend).
+* Remove unwanted features and fix poor design choices.
+* Learn more about Go and Vue.js.
+
+In terms of tech, the following has changed:
+
+* Backend from Python+Tornado to Go.
+* Frontend from a very-custom Typescript solution to a simple ES5 + Vue.js app.
+* Simplified asset pipeline (a short Makefile).
+* Config file is now toml based.
+* Fully self-contained executable.
+
+
+## Similar Projects
+
+* [clarity](https://github.com/tobi/clarity)
+* [errorlog](http://www.psychogenic.com/en/products/Errorlog.php)
+* [log.io](http://logio.org/)
+* [rtail](http://rtail.org/)
+* [tailon](https://github.com/gvalkov/tailon-legacy) -->
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..0fa829a
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,15 @@
+# Todo
+
+- [ ] Directory serving.*
+- [ ] User-specified TOML configuration files.*
+- [ ] Basic and digest authentication.*
+- [ ] Add a 'command' filespec - e.g. `"command,journalctl -u nginx"`.*
+- [ ] Better configuration dialog.*
+- [ ] Add interface themes - e.g. light, dark and solarized.*
+- [ ] Windows support (can use one of the Go tail implementations).*
+- [ ] Implement [wtee](https://github.com/gvalkov/wtee).*
+- [ ] Stderr is streamed to the client, but it is not handled at the moment.*
+- [ ] Update to Vue3 and update dependencies.
+- [x] Add ability to change font family and size.
+
+\* - Probably not by me.
diff --git a/build_frontend.sh b/build_frontend.sh
new file mode 100644
index 0000000..0228805
--- /dev/null
+++ b/build_frontend.sh
@@ -0,0 +1,5 @@
+cd frontend
+go install github.com/shurcooL/vfsgen/cmd/vfsgendev@latest
+go get -u github.com/shurcooL/vfsgen/cmd/vfsgendev
+npm run build
+# Running 'npm run build-frontend-and-tailon' will build frontend as well as tailon.
diff --git a/build_readme.sh b/build_readme.sh
new file mode 100644
index 0000000..b79817f
--- /dev/null
+++ b/build_readme.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+go build
+ed README.md <<< '/BEGIN HELP/+2,/END HELP/-2d\n/BEGIN HELP/+1r ./tailon --help 2>&1\n,w'
+sed -i 's/[ \t]*$$//' README.md
diff --git a/cmd/cmd.go b/cmd/cmd.go
new file mode 100644
index 0000000..2b3ad48
--- /dev/null
+++ b/cmd/cmd.go
@@ -0,0 +1,617 @@
+// Package cmd runs external commands with concurrent access to output and
+// status. It wraps the Go standard library os/exec.Command to correctly handle
+// reading output (STDOUT and STDERR) while a command is running and killing a
+// command. All operations are safe to call from multiple goroutines.
+//
+// A basic example that runs env and prints its output:
+//
+// import (
+// "fmt"
+// "github.com/go-cmd/cmd"
+// )
+//
+// func main() {
+// // Create Cmd, buffered output
+// envCmd := cmd.NewCmd("env")
+//
+// // Run and wait for Cmd to return Status
+// status := <-envCmd.Start()
+//
+// // Print each line of STDOUT from Cmd
+// for _, line := range status.Stdout {
+// fmt.Println(line)
+// }
+// }
+//
+// Commands can be ran synchronously (blocking) or asynchronously (non-blocking):
+//
+// envCmd := cmd.NewCmd("env") // create
+//
+// status := <-envCmd.Start() // run blocking
+//
+// statusChan := envCmd.Start() // run non-blocking
+// // Do other work while Cmd is running...
+// status <- statusChan // blocking
+//
+// Start returns a channel to which the final Status is sent when the command
+// finishes for any reason. The first example blocks receiving on the channel.
+// The second example is non-blocking because it saves the channel and receives
+// on it later. Only one final status is sent to the channel; use Done for
+// multiple goroutines to wait for the command to finish, then call Status to
+// get the final status.
+package cmd
+
+import (
+ "bufio"
+ "bytes"
+ "errors"
+ "fmt"
+ "io"
+ "os/exec"
+ "sync"
+ "syscall"
+ "time"
+)
+
+// Cmd represents an external command, similar to the Go built-in os/exec.Cmd.
+// A Cmd cannot be reused after calling Start. Exported fields are read-only and
+// should not be modified, except Env which can be set before calling Start.
+// To create a new Cmd, call NewCmd or NewCmdOptions.
+type Cmd struct {
+ Name string
+ Args []string
+ Env []string
+ Stdin io.ReadCloser
+ Stdout chan string // streaming STDOUT if enabled, else nil (see Options)
+ Stderr chan string // streaming STDERR if enabled, else nil (see Options)
+ *sync.Mutex
+ started bool // cmd.Start called, no error
+ stopped bool // Stop called
+ done bool // run() done
+ final bool // status finalized in Status
+ startTime time.Time // if started true
+ stdout *OutputBuffer // low-level stdout buffering and streaming
+ stderr *OutputBuffer // low-level stderr buffering and streaming
+ status Status
+ statusChan chan Status // nil until Start() called
+ doneChan chan struct{} // closed when done running
+ buffered bool // buffer STDOUT and STDERR to Status.Stdout and Std
+}
+
+// Status represents the running status and consolidated return of a Cmd. It can
+// be obtained any time by calling Cmd.Status. If StartTs > 0, the command has
+// started. If StopTs > 0, the command has stopped. After the command finishes
+// for any reason, this combination of values indicates success (presuming the
+// command only exits zero on success):
+//
+// Exit = 0
+// Error = nil
+// Complete = true
+//
+// Error is a Go error from the underlying os/exec.Cmd.Start or os/exec.Cmd.Wait.
+// If not nil, the command either failed to start (it never ran) or it started
+// but was terminated unexpectedly (probably signaled). In either case, the
+// command failed. Callers should check Error first. If nil, then check Exit and
+// Complete.
+type Status struct {
+ Cmd string
+ PID int
+ Complete bool // false if stopped or signaled
+ Exit int // exit code of process
+ Error error // Go error
+ StartTs int64 // Unix ts (nanoseconds), zero if Cmd not started
+ StopTs int64 // Unix ts (nanoseconds), zero if Cmd not started or running
+ Runtime float64 // seconds, zero if Cmd not started
+ Stdout []string // buffered STDOUT; see Cmd.Status for more info
+ Stderr []string // buffered STDERR; see Cmd.Status for more info
+}
+
+// NewCmd creates a new Cmd for the given command name and arguments. The command
+// is not started until Start is called. Output buffering is on, streaming output
+// is off. To control output, use NewCmdOptions instead.
+func NewCmd(name string, args ...string) *Cmd {
+ return &Cmd{
+ Name: name,
+ Args: args,
+ buffered: true,
+ Mutex: &sync.Mutex{},
+ status: Status{
+ Cmd: name,
+ PID: 0,
+ Complete: false,
+ Exit: -1,
+ Error: nil,
+ Runtime: 0,
+ },
+ doneChan: make(chan struct{}),
+ }
+}
+
+// Options represents customizations for NewCmdOptions.
+type Options struct {
+ // If Buffered is true, STDOUT and STDERR are written to Status.Stdout and
+ // Status.Stderr. The caller can call Cmd.Status to read output at intervals.
+ // See Cmd.Status for more info.
+ Buffered bool
+
+ // If Streaming is true, Cmd.Stdout and Cmd.Stderr channels are created and
+ // STDOUT and STDERR output lines are written them in real time. This is
+ // faster and more efficient than polling Cmd.Status. The caller must read both
+ // streaming channels, else lines are dropped silently.
+ Streaming bool
+}
+
+// NewCmdOptions creates a new Cmd with options. The command is not started
+// until Start is called.
+func NewCmdOptions(options Options, name string, args ...string) *Cmd {
+ out := NewCmd(name, args...)
+ out.buffered = options.Buffered
+ if options.Streaming {
+ out.Stdout = make(chan string, DEFAULT_STREAM_CHAN_SIZE)
+ out.Stderr = make(chan string, DEFAULT_STREAM_CHAN_SIZE)
+ }
+ return out
+}
+
+// Start starts the command and immediately returns a channel that the caller
+// can use to receive the final Status of the command when it ends. The caller
+// can start the command and wait like,
+//
+// status := <-myCmd.Start() // blocking
+//
+// or start the command asynchronously and be notified later when it ends,
+//
+// statusChan := myCmd.Start() // non-blocking
+// // Do other work while Cmd is running...
+// status := <-statusChan // blocking
+//
+// Exactly one Status is sent on the channel when the command ends. The channel
+// is not closed. Any Go error is set to Status.Error. Start is idempotent; it
+// always returns the same channel.
+func (c *Cmd) Start() <-chan Status {
+ c.Lock()
+ defer c.Unlock()
+
+ if c.statusChan != nil {
+ return c.statusChan
+ }
+
+ c.statusChan = make(chan Status, 1)
+ go c.run()
+ return c.statusChan
+}
+
+// Stop stops the command by sending its process group a SIGTERM signal.
+// Stop is idempotent. An error should only be returned in the rare case that
+// Stop is called immediately after the command ends but before Start can
+// update its internal state.
+func (c *Cmd) Stop() error {
+ c.Lock()
+ defer c.Unlock()
+
+ // Nothing to stop if Start hasn't been called, or the proc hasn't started,
+ // or it's already done.
+ if c.statusChan == nil || !c.started || c.done {
+ return nil
+ }
+
+ // Flag that command was stopped, it didn't complete. This results in
+ // status.Complete = false
+ c.stopped = true
+
+ // Signal the process group (-pid), not just the process, so that the process
+ // and all its children are signaled. Else, child procs can keep running and
+ // keep the stdout/stderr fd open and cause cmd.Wait to hang.
+ return syscall.Kill(-c.status.PID, syscall.SIGTERM)
+}
+
+// Status returns the Status of the command at any time. It is safe to call
+// concurrently by multiple goroutines.
+//
+// With buffered output, Status.Stdout and Status.Stderr contain the full output
+// as of the Status call time. For example, if the command counts to 3 and three
+// calls are made between counts, Status.Stdout contains:
+//
+// "1"
+// "1 2"
+// "1 2 3"
+//
+// The caller is responsible for tailing the buffered output if needed. Else,
+// consider using streaming output. When the command finishes, buffered output
+// is complete and final.
+//
+// Status.Runtime is updated while the command is running and final when it
+// finishes.
+func (c *Cmd) Status() Status {
+ c.Lock()
+ defer c.Unlock()
+
+ // Return default status if cmd hasn't been started
+ if c.statusChan == nil || !c.started {
+ return c.status
+ }
+
+ if c.done {
+ // No longer running
+ if !c.final {
+ if c.buffered {
+ c.status.Stdout = c.stdout.Lines()
+ c.status.Stderr = c.stderr.Lines()
+ c.stdout = nil // release buffers
+ c.stderr = nil
+ }
+ c.final = true
+ }
+ } else {
+ // Still running
+ c.status.Runtime = time.Now().Sub(c.startTime).Seconds()
+ if c.buffered {
+ c.status.Stdout = c.stdout.Lines()
+ c.status.Stderr = c.stderr.Lines()
+ }
+ }
+
+ return c.status
+}
+
+// Done returns a channel that's closed when the command stops running.
+// This method is useful for multiple goroutines to wait for the command
+// to finish.Call Status after the command finishes to get its final status.
+func (c *Cmd) Done() <-chan struct{} {
+ return c.doneChan
+}
+
+// --------------------------------------------------------------------------
+
+func (c *Cmd) run() {
+ defer func() {
+ c.statusChan <- c.Status() // unblocks Start if caller is waiting
+ close(c.doneChan)
+ }()
+
+ // //////////////////////////////////////////////////////////////////////
+ // Setup command
+ // //////////////////////////////////////////////////////////////////////
+ cmd := exec.Command(c.Name, c.Args...)
+
+ // Set process group ID so the cmd and all its children become a new
+ // process group. This allows Stop to SIGTERM the cmd's process group
+ // without killing this process (i.e. this code here).
+ cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+ if c.Stdin != nil {
+ cmd.Stdin = c.Stdin
+ }
+
+ // Write stdout and stderr to buffers that are safe to read while writing
+ // and don't cause a race condition.
+ if c.buffered && c.Stdout != nil {
+ // Buffered and streaming, create both and combine with io.MultiWriter
+ c.stdout = NewOutputBuffer()
+ c.stderr = NewOutputBuffer()
+ cmd.Stdout = io.MultiWriter(NewOutputStream(c.Stdout), c.stdout)
+ cmd.Stderr = io.MultiWriter(NewOutputStream(c.Stderr), c.stderr)
+ } else if c.buffered {
+ // Buffered only
+ c.stdout = NewOutputBuffer()
+ c.stderr = NewOutputBuffer()
+ cmd.Stdout = c.stdout
+ cmd.Stderr = c.stderr
+ } else {
+ // Streaming only
+ cmd.Stdout = NewOutputStream(c.Stdout)
+ cmd.Stderr = NewOutputStream(c.Stderr)
+ }
+
+ // Set the runtime environment for the command as per os/exec.Cmd. If Env
+ // is nil, use the current process' environment.
+ cmd.Env = c.Env
+
+ // //////////////////////////////////////////////////////////////////////
+ // Start command
+ // //////////////////////////////////////////////////////////////////////
+ now := time.Now()
+ if err := cmd.Start(); err != nil {
+ c.Lock()
+ c.status.Error = err
+ c.status.StartTs = now.UnixNano()
+ c.status.StopTs = time.Now().UnixNano()
+ c.done = true
+ c.Unlock()
+ return
+ }
+
+ // Set initial status
+ c.Lock()
+ c.startTime = now // command is running
+ c.status.PID = cmd.Process.Pid // command is running
+ c.status.StartTs = now.UnixNano()
+ c.started = true
+ c.Unlock()
+
+ // //////////////////////////////////////////////////////////////////////
+ // Wait for command to finish or be killed
+ // //////////////////////////////////////////////////////////////////////
+ err := cmd.Wait()
+ now = time.Now()
+
+ // Get exit code of the command. According to the manual, Wait() returns:
+ // "If the command fails to run or doesn't complete successfully, the error
+ // is of type *ExitError. Other error types may be returned for I/O problems."
+ exitCode := 0
+ signaled := false
+ if err != nil {
+ switch err.(type) {
+ case *exec.ExitError:
+ // This is the normal case which is not really an error. It's string
+ // representation is only "*exec.ExitError". It only means the cmd
+ // did not exit zero and caller should see ExitError.Stderr, which
+ // we already have. So first we'll have this as the real/underlying
+ // type, then discard err so status.Error doesn't contain a useless
+ // "*exec.ExitError". With the real type we can get the non-zero
+ // exit code and determine if the process was signaled, which yields
+ // a more specific error message, so we set err again in that case.
+ exiterr := err.(*exec.ExitError)
+ err = nil
+ if waitStatus, ok := exiterr.Sys().(syscall.WaitStatus); ok {
+ exitCode = waitStatus.ExitStatus() // -1 if signaled
+ if waitStatus.Signaled() {
+ signaled = true
+ err = errors.New(exiterr.Error()) // "signal: terminated"
+ }
+ }
+ default:
+ // I/O problem according to the manual ^. Don't change err.
+ }
+ }
+
+ // Set final status
+ c.Lock()
+ if !c.stopped && !signaled {
+ c.status.Complete = true
+ }
+ c.status.Runtime = now.Sub(c.startTime).Seconds()
+ c.status.StopTs = now.UnixNano()
+ c.status.Exit = exitCode
+ c.status.Error = err
+ c.done = true
+ c.Unlock()
+}
+
+// //////////////////////////////////////////////////////////////////////////
+// Output
+// //////////////////////////////////////////////////////////////////////////
+
+// os/exec.Cmd.StdoutPipe is usually used incorrectly. The docs are clear:
+// "it is incorrect to call Wait before all reads from the pipe have completed."
+// Therefore, we can't read from the pipe in another goroutine because it
+// causes a race condition: we'll read in one goroutine and the original
+// goroutine that calls Wait will write on close which is what Wait does.
+// The proper solution is using an io.Writer for cmd.Stdout. I couldn't find
+// an io.Writer that's also safe for concurrent reads (as lines in a []string
+// no less), so I created one:
+
+// OutputBuffer represents command output that is saved, line by line, in an
+// unbounded buffer. It is safe for multiple goroutines to read while the command
+// is running and after it has finished. If output is small (a few megabytes)
+// and not read frequently, an output buffer is a good solution.
+//
+// A Cmd in this package uses an OutputBuffer for both STDOUT and STDERR by
+// default when created by calling NewCmd. To use OutputBuffer directly with
+// a Go standard library os/exec.Command:
+//
+// import "os/exec"
+// import "github.com/go-cmd/cmd"
+// runnableCmd := exec.Command(...)
+// stdout := cmd.NewOutputBuffer()
+// runnableCmd.Stdout = stdout
+//
+// While runnableCmd is running, call stdout.Lines() to read all output
+// currently written.
+type OutputBuffer struct {
+ buf *bytes.Buffer
+ lines []string
+ *sync.Mutex
+}
+
+// NewOutputBuffer creates a new output buffer. The buffer is unbounded and safe
+// for multiple goroutines to read while the command is running by calling Lines.
+func NewOutputBuffer() *OutputBuffer {
+ out := &OutputBuffer{
+ buf: &bytes.Buffer{},
+ lines: []string{},
+ Mutex: &sync.Mutex{},
+ }
+ return out
+}
+
+// Write makes OutputBuffer implement the io.Writer interface. Do not call
+// this function directly.
+func (rw *OutputBuffer) Write(p []byte) (n int, err error) {
+ rw.Lock()
+ n, err = rw.buf.Write(p) // and bytes.Buffer implements io.Writer
+ rw.Unlock()
+ return // implicit
+}
+
+// Lines returns lines of output written by the Cmd. It is safe to call while
+// the Cmd is running and after it has finished. Subsequent calls returns more
+// lines, if more lines were written. "\r\n" are stripped from the lines.
+func (rw *OutputBuffer) Lines() []string {
+ rw.Lock()
+ // Scanners are io.Readers which effectively destroy the buffer by reading
+ // to EOF. So once we scan the buf to lines, the buf is empty again.
+ s := bufio.NewScanner(rw.buf)
+ for s.Scan() {
+ rw.lines = append(rw.lines, s.Text())
+ }
+ rw.Unlock()
+ return rw.lines
+}
+
+// --------------------------------------------------------------------------
+
+const (
+ // DEFAULT_LINE_BUFFER_SIZE is the default size of the OutputStream line buffer.
+ // The default value is usually sufficient, but if ErrLineBufferOverflow errors
+ // occur, try increasing the size by calling OutputBuffer.SetLineBufferSize.
+ DEFAULT_LINE_BUFFER_SIZE = 16384
+
+ // DEFAULT_STREAM_CHAN_SIZE is the default string channel size for a Cmd when
+ // Options.Streaming is true. The string channel size can have a minor
+ // performance impact if too small by causing OutputStream.Write to block
+ // excessively.
+ DEFAULT_STREAM_CHAN_SIZE = 1000
+)
+
+// ErrLineBufferOverflow is returned by OutputStream.Write when the internal
+// line buffer is filled before a newline character is written to terminate a
+// line. Increasing the line buffer size by calling OutputStream.SetLineBufferSize
+// can help prevent this error.
+type ErrLineBufferOverflow struct {
+ Line string // Unterminated line that caused the error
+ BufferSize int // Internal line buffer size
+ BufferFree int // Free bytes in line buffer
+}
+
+func (e ErrLineBufferOverflow) Error() string {
+ return fmt.Sprintf("line does not contain newline and is %d bytes too long to buffer (buffer size: %d)",
+ len(e.Line)-e.BufferSize, e.BufferSize)
+}
+
+// OutputStream represents real time, line by line output from a running Cmd.
+// Lines are terminated by a single newline preceded by an optional carriage
+// return. Both newline and carriage return are stripped from the line when
+// sent to a caller-provided channel.
+//
+// The caller must begin receiving before starting the Cmd. Write blocks on the
+// channel; the caller must always read the channel. The channel is not closed
+// by the OutputStream.
+//
+// A Cmd in this package uses an OutputStream for both STDOUT and STDERR when
+// created by calling NewCmdOptions and Options.Streaming is true. To use
+// OutputStream directly with a Go standard library os/exec.Command:
+//
+// import "os/exec"
+// import "github.com/go-cmd/cmd"
+//
+// stdoutChan := make(chan string, 100)
+// go func() {
+// for line := range stdoutChan {
+// // Do something with the line
+// }
+// }()
+//
+// runnableCmd := exec.Command(...)
+// stdout := cmd.NewOutputStream(stdoutChan)
+// runnableCmd.Stdout = stdout
+//
+//
+// While runnableCmd is running, lines are sent to the channel as soon as they
+// are written and newline-terminated by the command. After the command finishes,
+// the caller should wait for the last lines to be sent:
+//
+// for len(stdoutChan) > 0 {
+// time.Sleep(10 * time.Millisecond)
+// }
+//
+// Since the channel is not closed by the OutputStream, the two indications that
+// all lines have been sent and received are the command finishing and the
+// channel size being zero.
+type OutputStream struct {
+ streamChan chan string
+ bufSize int
+ buf []byte
+ lastChar int
+}
+
+// NewOutputStream creates a new streaming output on the given channel. The
+// caller must begin receiving on the channel before the command is started.
+// The OutputStream never closes the channel.
+func NewOutputStream(streamChan chan string) *OutputStream {
+ out := &OutputStream{
+ streamChan: streamChan,
+ // --
+ bufSize: DEFAULT_LINE_BUFFER_SIZE,
+ buf: make([]byte, DEFAULT_LINE_BUFFER_SIZE),
+ lastChar: 0,
+ }
+ return out
+}
+
+// Write makes OutputStream implement the io.Writer interface. Do not call
+// this function directly.
+func (rw *OutputStream) Write(p []byte) (n int, err error) {
+ n = len(p) // end of buffer
+ firstChar := 0
+
+LINES:
+ for {
+ // Find next newline in stream buffer. nextLine starts at 0, but buff
+ // can contain multiple lines, like "foo\nbar". So in that case nextLine
+ // will be 0 ("foo\nbar\n") then 4 ("bar\n") on next iteration. And i
+ // will be 3 and 7, respectively. So lines are [0:3] are [4:7].
+ newlineOffset := bytes.IndexByte(p[firstChar:], '\n')
+ if newlineOffset < 0 {
+ break LINES // no newline in stream, next line incomplete
+ }
+
+ // End of line offset is start (nextLine) + newline offset. Like bufio.Scanner,
+ // we allow \r\n but strip the \r too by decrementing the offset for that byte.
+ lastChar := firstChar + newlineOffset // "line\n"
+ if newlineOffset > 0 && p[newlineOffset-1] == '\r' {
+ lastChar -= 1 // "line\r\n"
+ }
+
+ // Send the line, prepend line buffer if set
+ var line string
+ if rw.lastChar > 0 {
+ line = string(rw.buf[0:rw.lastChar])
+ rw.lastChar = 0 // reset buffer
+ }
+ line += string(p[firstChar:lastChar])
+ rw.streamChan <- line // blocks if chan full
+
+ // Next line offset is the first byte (+1) after the newline (i)
+ firstChar += newlineOffset + 1
+ }
+
+ if firstChar < n {
+ remain := len(p[firstChar:])
+ bufFree := len(rw.buf[rw.lastChar:])
+ if remain > bufFree {
+ var line string
+ if rw.lastChar > 0 {
+ line = string(rw.buf[0:rw.lastChar])
+ }
+ line += string(p[firstChar:])
+ err = ErrLineBufferOverflow{
+ Line: line,
+ BufferSize: rw.bufSize,
+ BufferFree: bufFree,
+ }
+ n = firstChar
+ return // implicit
+ }
+ copy(rw.buf[rw.lastChar:], p[firstChar:])
+ rw.lastChar += remain
+ }
+
+ return // implicit
+}
+
+// Lines returns the channel to which lines are sent. This is the same channel
+// passed to NewOutputStream.
+func (rw *OutputStream) Lines() <-chan string {
+ return rw.streamChan
+}
+
+// SetLineBufferSize sets the internal line buffer size. The default is DEFAULT_LINE_BUFFER_SIZE.
+// This function must be called immediately after NewOutputStream, and it is not
+// safe to call by multiple goroutines.
+//
+// Increasing the line buffer size can help reduce ErrLineBufferOverflow errors.
+func (rw *OutputStream) SetLineBufferSize(n int) {
+ rw.bufSize = n
+ rw.buf = make([]byte, rw.bufSize)
+}
diff --git a/config.toml b/config.toml
new file mode 100644
index 0000000..771cb4b
--- /dev/null
+++ b/config.toml
@@ -0,0 +1,36 @@
+title = "Tailon"
+relative-root = "/"
+listen-addr = [":8080"]
+allow-download = true
+lines-of-history = 0
+lines-to-tail = 20000
+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 = "^$"