initial commit

Author: teleivo

.github/workflows/build_test.yml

@@ -0,0 +1,21 @@
+name: build and test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+      - name: Build
+        run: go build -v ./...
+      - name: Test
+        run: go test -v ./...

.gitignore

@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/

Dockerfile

@@ -0,0 +1,19 @@
+FROM golang:1.17-alpine AS build
+
+WORKDIR /src
+
+# download dependencies separately for caching
+COPY go.mod ./
+COPY go.sum ./
+RUN go mod download
+
+COPY fstat/ ./fstat
+COPY main.go ./
+
+RUN CGO_ENABLED=0 GOOS=linux go build -o /bin/diskmon
+
+FROM scratch
+
+COPY --from=build /bin/diskmon /bin/diskmon
+
+ENTRYPOINT ["/bin/diskmon"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 teleivo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,29 @@
+# Diskmon
+
+Diskmon will notify you if a disk has reached a configurable size limit.
+
+## Get started
+
+### Using Binary
+
+Build the binary or run directly using
+
+```sh
+go run main.go -basedir /home
+```
+
+### Using Docker
+
+Build the image
+
+```sh
+docker build -t dockermon .
+```
+
+Run the image
+
+```sh
+docker run --volume /home:/home:ro diskmon -basedir /hom
+```
+
+## Limitations

TODO

@@ -0,0 +1,4 @@
+* figure out why I get syscall errors on certain directories?
+* run check regularly without having to run binary as a cron job. allow
+configuration via flags (using cron like syntax?)
+* send notification to slack

docker-compose.yml

@@ -0,0 +1,13 @@
+---
+version: "3.9"
+
+services:
+  diskmon:
+    image: diskmon
+    container_name: diskmon
+    entrypoint:
+      - "/bin/diskmon"
+      - "-basedir"
+      - "/home"
+    volumes:
+      - "/home:/home:ro"

fstat/fstat.go

@@ -0,0 +1,33 @@
+package fstat
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+type FilesystemStat unix.Statfs_t
+
+func (fs FilesystemStat) Used() uint64 {
+	return (fs.Blocks - fs.Bavail) * uint64(fs.Bsize)
+}
+
+func (fs FilesystemStat) Free() uint64 {
+	return fs.Bavail * uint64(fs.Bsize)
+}
+
+func (fs FilesystemStat) Total() uint64 {
+	return fs.Blocks * uint64(fs.Bsize)
+}
+
+func (fs FilesystemStat) IsExceedingLimit(limit uint64) bool {
+	return uint64((float64(fs.Used())/float64(fs.Total()))*100) > limit
+}
+
+func GetFilesystemStat(path string) (FilesystemStat, error) {
+	var stat unix.Statfs_t
+	err := unix.Statfs(path, &stat)
+	if err != nil {
+		return FilesystemStat{}, err
+	}
+
+	return FilesystemStat(stat), nil
+}

fstat/fstat_test.go

@@ -0,0 +1,40 @@
+package fstat
+
+import (
+	"testing"
+
+	"golang.org/x/sys/unix"
+)
+
+func TestFilesystemStat(t *testing.T) {
+	t.Run("IsExceedingLimit", func(t *testing.T) {
+		// TODO use Bavail or Bfree?
+		fs := FilesystemStat(unix.Statfs_t{
+			Bavail: 100,
+			Blocks: 400,
+			Bsize:  1024,
+		})
+
+		if want := uint64(100 * 1024); fs.Free() != want {
+			t.Errorf("FilesystemStat.Free got %d, want %d", fs.Free(), want)
+		}
+		if want := uint64(400 * 1024); fs.Total() != want {
+			t.Errorf("FilesystemStat.Total got %d, want %d", fs.Free(), want)
+		}
+		if want := uint64((400 - 100) * 1024); fs.Used() != want {
+			t.Errorf("FilesystemStat.Used got %d, want %d", fs.Free(), want)
+		}
+
+		if fs.IsExceedingLimit(74) != true {
+			t.Errorf("IsExceedingLimit(74) should be true")
+		}
+
+		if fs.IsExceedingLimit(75) != false {
+			t.Errorf("IsExceedingLimit(75) should be false")
+		}
+
+		if fs.IsExceedingLimit(76) != false {
+			t.Errorf("IsExceedingLimit(76) should be false")
+		}
+	})
+}

go.mod

@@ -0,0 +1,8 @@
+module github.com/teleivo/diskmon
+
+go 1.17
+
+require (
+	github.com/dustin/go-humanize v1.0.0
+	golang.org/x/sys v0.0.0-20210903071746-97244b99971b
+)

go.sum

@@ -0,0 +1,4 @@
+github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+golang.org/x/sys v0.0.0-20210903071746-97244b99971b h1:3Dq0eVHn0uaQJmPO+/aYPI/fRMqdrVDbu7MQcku54gg=
+golang.org/x/sys v0.0.0-20210903071746-97244b99971b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

main.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/dustin/go-humanize"
+	"github.com/teleivo/diskmon/fstat"
+)
+
+func main() {
+	if err := run(os.Args, os.Stdout); err != nil {
+		fmt.Fprint(os.Stderr, err, "\n")
+		os.Exit(1)
+	}
+}
+
+func run(args []string, out io.Writer) error {
+
+	flags := flag.NewFlagSet(args[0], flag.ExitOnError)
+	basedir := flags.String("basedir", "", "statfs syscall information will be printed for each directory (depth 1) in this base directory")
+	limit := flags.Uint64("limit", 80, "percentage of disk usage at which notification should be sent")
+	err := flags.Parse(args[1:])
+	if err != nil {
+		return err
+	}
+
+	if *basedir == "" {
+		return errors.New("basedir must be provided")
+	}
+
+	files, err := ioutil.ReadDir(*basedir)
+	if err != nil {
+		return fmt.Errorf("error reading basedir: %w", err)
+	}
+
+	for _, file := range files {
+		if !file.IsDir() {
+			continue
+		}
+
+		fmt.Printf("file.Name()= %+v\n", file.Name())
+		fstat, err := fstat.GetFilesystemStat(file.Name())
+		if err != nil {
+			// TODO what do to with such errors? also send a notification?
+			// errors are weird since the directories do exist
+			// why is statfs_t returning an error like this?
+			err = fmt.Errorf("error getting filesystem stats from %q: %w", file.Name(), err)
+			fmt.Fprint(out, err, "\n")
+			continue
+		}
+
+		if fstat.IsExceedingLimit(*limit) {
+			fmt.Fprintf(out, "Free/Total %s/%s %q - reached limit of %d%%\n", humanize.Bytes(fstat.Free()), humanize.Bytes(fstat.Total()), file.Name(), *limit)
+		}
+	}
+
+	return nil
+}