Fix linter warnings

.gitignore

@@ -1,2 +1,2 @@
-i3status-go
-i3status-go.json
+/i3status-go
+/battery-test

.golangci.yml

@@ -1,28 +1,12 @@
+version: "2"
 run:
-  tests: false
-  skip-dirs:
-    - data
-    - vendor
+  go: "1.24"
   modules-download-mode: readonly
+  tests: false
   allow-parallel-runners: true
-  go: '1.21'
-output:
-  sort-results: true
-linters-settings:
-  gosec:
-    excludes:
-      # not relevant here
-      - G404 # Insecure random number source (rand)
-      - G306 # Expect WriteFile permissions to be 0600 or less (gosec)
 linters:
-  disable-all: true
+  default: none
   enable:
-    - errcheck
-    - gosimple
-    - govet
-    - ineffassign
-    - staticcheck
-    - unused
     - asasalint
     - asciicheck
     - bodyclose
@@ -30,20 +14,20 @@ linters:
     - contextcheck
     - decorder
     - durationcheck
+    - err113
+    - errcheck
     - errchkjson
     - errorlint
-    - exportloopref
     - ginkgolinter
     - gocheckcompilerdirectives
     - gocritic
     - godot
-    - goerr113
-    - gofmt
-    - goimports
     - gosec
     - gosmopolitan
+    - govet
     - grouper
     - importas
+    - ineffassign
     - ireturn
     - makezero
     - mirror
@@ -59,8 +43,39 @@ linters:
     - reassign
     - revive
     - rowserrcheck
-    - stylecheck
+    - staticcheck
     - unconvert
+    - unused
     - wastedassign
     - whitespace
     - wsl
+  settings:
+    gosec:
+      excludes:
+        - G404
+        - G306
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - data
+      - vendor
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gofmt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - data
+      - vendor
+      - third_party$
+      - builtin$
+      - examples$

Makefile

@@ -1,28 +1,34 @@
 #!/usr/bin/env gmake -f
 
-BUILDOPTS=-ldflags="-s -w" -a -gcflags=all=-l -trimpath
-FILELIST=batteries.go clock.go collection.go config.go cputemp.go cron.go i3.go ifmon.go la.go main.go memory.go \
-         pulseaudio.go signal.go spawn.go stdin.go vpn.go
+BUILDOPTS=-ldflags="-s -w" -a -gcflags=all=-l -trimpath -buildvcs=false
 
 BINARY=i3status-go
+TEST1=battery-test
+TEST2=cmdrun-test
 
 ## Use calssic targets where first one is deafult target
 all: clean build
 
 ## This target compiles binary
 build:
-	go build ${BUILDOPTS} -o ${BINARY} ${FILELIST}
+	go build ${BUILDOPTS} -o ${BINARY} ./cmd/${BINARY}
 
+battery-test:
+	rm -rf ${TEST1}
+	go build ${BUILDOPTS} -o ${TEST1} ./cmd/${TEST1}
+
+cmdrun-test:
+	rm -rf ${TEST1}
+	go build ${BUILDOPTS} -o ${TEST2} ./cmd/${TEST2}
 
 ## Remove binary with golang compiler' means
 clean:
-	go clean
-
+	rm -rf ${BINARY} ${TEST1} ${TEST2}
 
 ## Misc target, for development purposes. Updates vendored libs, brutal way.
 upgrade:
 	$(RM) -r vendor
-	go get -d -u -t ./...
+	go get -u -t ./...
 	go mod tidy
 	go mod vendor
 

README.md

@@ -14,11 +14,12 @@ It is i3bar text generator.
 * PulseAudio volume indicator, can adjust master volume too
 * Clock
 * Cron jobs (intended to use for show periodic desktop notifications but not limited to)
+* Show output of one-shot system command
 
 ## How to build it
 
-This appliction was tested to compile with go v1.21 but can be built with earlier versions (seems down to 1.18, not
-sure).
+This application was tested to compile with go v1.24.
+
 All you need is go lang compiler and gnu make utility. Invoke
 
 ```bash

batteries.go

@@ -1,175 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math"
-	"time"
-
-	"github.com/distatus/battery"
-)
-
-// Batt shows battery charge on i3bar.
-var Batt = "<big>⚡</big> ??% •"
-
-// UpdateBatteryInfo updates info about battery charge.
-func UpdateBatteryInfo() {
-	var (
-		ch     int
-		status string
-		Batts  string
-	)
-
-	for {
-		batteries, err := battery.GetAll()
-
-		if err != nil {
-			Batts = fmt.Sprintf(
-				"<span font='%s' size='%s'>%s</span><span font='%s' size='%s'> no batt</span>",
-				Conf.Battery.SymbolFont,
-				Conf.Battery.SymbolFontSize,
-				Conf.Battery.Symbol,
-				Conf.Battery.Font,
-				Conf.Battery.FontSize,
-			)
-		} else {
-			var (
-				battsInfo string
-				chStr     string
-			)
-
-			for i, b := range batteries {
-				switch b.State.Raw {
-				case battery.Charging:
-					status = `▲`
-				case battery.Discharging:
-					status = `▼`
-				case battery.Empty:
-					status = `✘`
-				default:
-					status = `•`
-				}
-
-				// N.B. there can be case when battery is overcharged and shows >100%. It also can indicate that
-				//      calibration data is out of date and battery should be re-calibrated.
-				ch = int(math.Round((b.Full - b.Current) * (100 / b.Full)))
-
-				switch {
-				case ch > 85:
-					if Conf.Battery.ChargeColor.Full == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.Full,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-
-				case ch < 85 && ch > 40:
-					if Conf.Battery.ChargeColor.AlmostFull == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.AlmostFull,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-
-				case ch <= 40 && ch >= 10:
-					if Conf.Battery.ChargeColor.AlmostEmpty == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.AlmostEmpty,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-
-				case ch < 10:
-					if Conf.Battery.ChargeColor.Empty == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.Empty,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-				}
-
-				battsInfo += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>%s</span><span color='%s' background='%s' font='%s' size='%s'>B%d </span>%s<span color='%s' background='%s' font='%s' size='%s'> %s</span>",
-					Conf.Battery.Color,
-					Conf.Battery.Background,
-					Conf.Battery.SymbolFont,
-					Conf.Battery.SymbolFontSize,
-					Conf.Battery.Symbol,
-					Conf.Battery.Color,
-					Conf.Battery.Background,
-					Conf.Battery.Font,
-					Conf.Battery.FontSize,
-					i,
-					chStr,
-					Conf.Battery.Color,
-					Conf.Battery.Background,
-					Conf.Battery.Font,
-					Conf.Battery.FontSize,
-					status,
-				)
-			}
-
-			if battsInfo != "" {
-				Batts = battsInfo
-			}
-		}
-
-		if Batt == Batts {
-			Batt = Batts
-			UpdateReady <- true
-		}
-
-		time.Sleep(5 * time.Second)
-	}
-}

cmd/battery-test/main.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/distatus/battery"
+)
+
+// Program entry point.
+func main() {
+	for {
+		batteries, _ := battery.GetAll()
+
+		for index, battery := range batteries {
+			fmt.Printf("Battery %d: %s\n", index, spew.Sdump(battery))
+		}
+
+		time.Sleep(1 * time.Second)
+	}
+}

cmd/i3status-go/default-config.json

@@ -518,6 +518,15 @@
 "battery": {
 	"enabled": false,
 
+	// Valid only on linux, where we have mounted sysfs and /sys/class/power_supply/BAT0/capacity available
+	"use_sysfs": false,
+
+	// it is possible to set files here, if none set, /sys/class/power_supply/BAT0/capacity will be taken.
+	"sysfs_files": [
+		"/sys/class/power_supply/BAT0/capacity",
+		"/sys/class/power_supply/HIDP0/capacity"
+	],
+
 	// If omitted set to default color defined up here.
 	"color": "#3e78fd",
 
@@ -693,6 +702,78 @@
 	]
 },
 
+// Prints stdout of command to panel.
+"cmdrun" : {
+	"enabled": false,
+
+	// Delay between two consecutive command batch runs.
+	"delay": 3,
+
+	// command' binary.
+	"cmd": "/bin/bash",
+
+	// Arguments for command binary.
+	"args": ["-c", "echo 42"],
+
+	// If omitted set to default color defined up here.
+	"color": "#3e78fd",
+
+	// If omitted set to default background color defined up here.
+	"background": "#000000",
+
+	// If omitted set to default font defined up here.
+	"font": "Noto Sans",
+
+	// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+	// ‘smaller’ or ‘larger’. If omitted set to default font size defined up here.
+	"font_size": "medium",
+
+	// Re-define separator parameters for each command block here.
+	"separator": {
+		"left": {
+			// Set to false if omitted.
+			"enabled": true,
+
+			// If omitted set to default color defined for separator up here.
+			"color": "#3e78fd",
+
+			// If omitted set to default background color defined for separator up here.
+			"background": "#000000",
+
+			// If omitted set to default symbol defined for separator up here.
+			"symbol": "▶",
+
+			// If omitted set to default font defined for separator up here.
+			"font": "Noto Sans",
+
+			// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+			// ‘smaller’ or ‘larger’. If omitted set to default font size defined for separator up here.
+			"font_size": "medium"
+		},
+
+		"right": {
+			// Set to false if omitted.
+			"enabled": true,
+
+			// If omitted set to default color defined for separator up here.
+			"color": "#3e78fd",
+
+			// If omitted set to default background color defined for separator up here.
+			"background": "#000000",
+
+			// If omitted set to default symbol defined for separator up here.
+			"symbol": "◀",
+
+			// If omitted set to default font defined for separator up here.
+			"font": "Noto Sans",
+
+			// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+			// ‘smaller’ or ‘larger’. If omitted set to default font size defined for separator up here.
+			"font_size": "medium"
+		}
+	}
+}
+
 // Whether to display Application Buttons.
 "app_buttons": {
 	"enabled": true,

cmd/i3status-go/main.go

@@ -0,0 +1,643 @@
+package main
+
+import (
+	"bytes"
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	"i3status-go/internal/lib"
+)
+
+//go:embed default-config.json
+var DefaultConfig []byte
+
+// Program entry point.
+func main() {
+	Conf, err := lib.ReadConf(DefaultConfig)
+
+	if err != nil {
+		log.Panicf("Unable to read config: %s", err)
+	}
+
+	Conf.Channels.UpdateReady = make(chan bool)
+	Conf.Channels.SVPAHandlerChan = make(chan lib.ClickEvent, 256)
+	Conf.Channels.MsgChan = make(chan []lib.I3BarOutBlock, 64)
+	Conf.Channels.SigChan = make(chan os.Signal, 1)
+	Conf.Channels.RunChan = make(chan []string, 128)
+	Conf.Values.PrintOutput = true
+	Conf.Values.BatteryString = "<big>⚡</big> ??% •"
+	Conf.Values.ClockTime = "Thu, 1 Jan 1970   1:00"
+	Conf.Values.IfStatus = ""
+	Conf.Values.VPNStatus = ""
+	Conf.Values.Memory.Shared = 0
+	Conf.Values.Memory.Usedpct = 0
+	Conf.Values.Memory.Swap = 0
+	Conf.Values.La = "-1"
+	// Conf.Values.PA
+	Conf.Values.SoundVolume = "🔊:0%"
+
+	// TODO: Проставить дефолтные значения для глобальных переменных модулей.
+	Conf.Values.BatteryString = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+		Conf.Battery.Color,
+		Conf.Battery.Background,
+		Conf.Battery.SymbolFont,
+		Conf.Battery.SymbolFontSize,
+		Conf.Battery.Symbol,
+	)
+
+	Conf.Values.BatteryString += fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'> ??%% •</span>",
+		Conf.Battery.Color,
+		Conf.Battery.Background,
+		Conf.Battery.Font,
+		Conf.Battery.FontSize,
+	)
+
+	Conf.Values.SoundVolume = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>🔊</span>",
+		Conf.SimpleVolumePa.Color,
+		Conf.SimpleVolumePa.Background,
+		Conf.SimpleVolumePa.SymbolFont,
+		Conf.SimpleVolumePa.SymbolFontSize,
+	)
+
+	Conf.Values.SoundVolume += fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>:0%%</span>",
+		Conf.SimpleVolumePa.Color,
+		Conf.SimpleVolumePa.Background,
+		Conf.SimpleVolumePa.Font,
+		Conf.SimpleVolumePa.FontSize,
+	)
+
+	Conf.Values.ClockTime = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>Thu, 1 Jan 1970   1:00</span>",
+		Conf.Clock.Color,
+		Conf.Clock.Background,
+		Conf.Clock.Font,
+		Conf.Clock.FontSize,
+	)
+
+	Conf.Values.RunCommandOutput = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>?</span>",
+		Conf.CmdRun.Color,
+		Conf.CmdRun.Background,
+		Conf.CmdRun.Font,
+		Conf.CmdRun.FontSize,
+	)
+
+	go Conf.Spawner()
+	go Conf.ParseStdin()
+	go Conf.CleanZombies()
+	go Conf.SVPAHandler()
+	go PrintToI3bar(Conf)
+
+	if Conf.AppButtons.Enabled {
+		go Conf.UpdateI3WinList()
+	}
+
+	// Kick signal handler
+	go Conf.SigHandler()
+	signal.Notify(Conf.Channels.SigChan,
+		syscall.SIGUSR1,
+		syscall.SIGUSR2,
+		syscall.SIGQUIT,
+		syscall.SIGTERM,
+		syscall.SIGINT)
+
+	// Populate memory stats
+	if Conf.Mem.Enabled {
+		go Conf.UpdateMemStats()
+	}
+
+	// Populate LA stats
+	if Conf.LA.Enabled {
+		go Conf.UpdateLaStats()
+	}
+
+	// Populate CPUTemperature
+	if Conf.CPUTemp.Enabled {
+		go Conf.UpdateCPUTemperature()
+	}
+
+	// Populate Clock
+	if Conf.Clock.Enabled {
+		go Conf.UpdateClock()
+	}
+
+	if Conf.Battery.Enabled {
+		go Conf.UpdateBatteryInfo()
+	}
+
+	if Conf.SimpleVolumePa.Enabled {
+		go Conf.UpdateVolumeInfo()
+	}
+
+	if Conf.NetIf.Enabled {
+		go Conf.UpdateIfStatus()
+	}
+
+	if Conf.Cron.Enabled {
+		go Conf.RunCron()
+	}
+
+	if Conf.Vpn.Enabled {
+		go Conf.UpdateVPNStatus()
+	}
+
+	if Conf.CmdRun.Enabled {
+		go Conf.RunCommand()
+	}
+
+	/*
+		I3bar documentation pretends that message protocol must be valid json. In practice, we only have to print valid
+		header, empty json array and (potentially infinite) json lines (line that is valid json by itself) that is
+		actually json arrays. We do not need to *close* this json at all.
+		Gracefully closed json required when i3bar initiates our program to stop|quit, this (should) happens just before
+		i3bar itself terminating. So we don't care.
+	*/
+
+	// Print header and one empty message and wait for updates
+	fmt.Printf(
+		"{\"version\": 1, \"stop_signal\": %d, \"cont_signal\": %d, \"click_events\": true}\n",
+		syscall.SIGUSR1,
+		syscall.SIGUSR2,
+	)
+
+	fmt.Println("[ [],")
+
+	for range Conf.Channels.UpdateReady {
+		// Actually build json struct, marshal it and print result
+		var j []lib.I3BarOutBlock
+
+		// TODO: впилить для первого и последнего батона separator
+		if Conf.AppButtons.Enabled {
+			for num, app := range Conf.Apps {
+				var b lib.I3BarOutBlock
+
+				if num == 0 {
+					b.FullText = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+						Conf.AppButtons.Separator.Left.Color,
+						Conf.AppButtons.Separator.Left.Background,
+						Conf.AppButtons.Separator.Left.Font,
+						Conf.AppButtons.Separator.Left.FontSize,
+						Conf.AppButtons.Separator.Left.Symbol,
+					)
+				}
+
+				b.FullText = app.FullText
+
+				if num == len(Conf.Apps) {
+					b.FullText = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+						Conf.AppButtons.Separator.Right.Color,
+						Conf.AppButtons.Separator.Right.Background,
+						Conf.AppButtons.Separator.Right.Font,
+						Conf.AppButtons.Separator.Right.FontSize,
+						Conf.AppButtons.Separator.Right.Symbol,
+					)
+				}
+
+				b.Background = app.Background
+				b.Color = app.Color
+				b.Instance = app.Instance
+				b.Markup = `pango`
+				b.Separator = app.Separator
+				b.SeparatorBlockWidth = app.SeparatorBlockWidth
+				b.Name = app.Name
+
+				if lib.HasWindows(app.Class, app.Instance) {
+					b.Border = app.BorderActive
+				} else {
+					b.Border = app.Border
+				}
+
+				b.BorderTop = 1
+				b.BorderRight = 1
+				b.BorderBottom = 1
+				b.BorderLeft = 1
+
+				j = append(j, b)
+			}
+		}
+
+		if Conf.CPUTemp.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.CPUTemp.Color
+			b.Background = Conf.CPUTemp.Background
+
+			if Conf.CPUTemp.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CPUTemp.Separator.Left.Color,
+					Conf.CPUTemp.Separator.Left.Background,
+					Conf.CPUTemp.Separator.Left.Font,
+					Conf.CPUTemp.Separator.Left.FontSize,
+					Conf.CPUTemp.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>CPU: %d°</span>",
+				Conf.CPUTemp.Color,
+				Conf.CPUTemp.Background,
+				Conf.CPUTemp.Font,
+				Conf.CPUTemp.FontSize,
+				Conf.Values.CPUTemperature,
+			)
+
+			if Conf.CPUTemp.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CPUTemp.Separator.Right.Color,
+					Conf.CPUTemp.Separator.Right.Background,
+					Conf.CPUTemp.Separator.Right.Font,
+					Conf.CPUTemp.Separator.Right.FontSize,
+					Conf.CPUTemp.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Mem.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.Mem.Color
+			b.Background = Conf.Mem.Background
+
+			if Conf.Mem.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Mem.Separator.Left.Color,
+					Conf.Mem.Separator.Left.Background,
+					Conf.Mem.Separator.Left.Font,
+					Conf.Mem.Separator.Left.FontSize,
+					Conf.Mem.Separator.Left.Symbol,
+				)
+			}
+
+			if Conf.Mem.ShowSwap {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM SW:%dM</span>",
+					Conf.Mem.Color,
+					Conf.Mem.Background,
+					Conf.Mem.Font,
+					Conf.Mem.FontSize,
+					Conf.Values.Memory.Usedpct,
+					Conf.Values.Memory.Shared,
+					Conf.Values.Memory.Swap,
+				)
+			} else {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM</span>",
+					Conf.Mem.Color,
+					Conf.Mem.Background,
+					Conf.Mem.Font,
+					Conf.Mem.FontSize,
+					Conf.Values.Memory.Usedpct,
+					Conf.Values.Memory.Shared,
+				)
+			}
+
+			if Conf.Mem.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Mem.Separator.Right.Color,
+					Conf.Mem.Separator.Right.Background,
+					Conf.Mem.Separator.Right.Font,
+					Conf.Mem.Separator.Right.FontSize,
+					Conf.Mem.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.LA.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.LA.Color
+			b.Background = Conf.LA.Background
+
+			if Conf.LA.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.LA.Separator.Left.Color,
+					Conf.LA.Separator.Left.Background,
+					Conf.LA.Separator.Left.Font,
+					Conf.LA.Separator.Left.FontSize,
+					Conf.LA.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>LA:%s</span>",
+				Conf.LA.Color,
+				Conf.LA.Background,
+				Conf.LA.Font,
+				Conf.LA.FontSize,
+				Conf.Values.La,
+			)
+
+			if Conf.LA.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.LA.Separator.Right.Color,
+					Conf.LA.Separator.Right.Background,
+					Conf.LA.Separator.Right.Font,
+					Conf.LA.Separator.Right.FontSize,
+					Conf.LA.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.NetIf.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.NetIf.Color
+			b.Background = Conf.NetIf.Background
+
+			if Conf.NetIf.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.NetIf.Separator.Left.Color,
+					Conf.NetIf.Separator.Left.Background,
+					Conf.NetIf.Separator.Left.Font,
+					Conf.NetIf.Separator.Left.FontSize,
+					Conf.NetIf.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size= '%s'>%s</span>",
+				Conf.NetIf.Color,
+				Conf.NetIf.Background,
+				Conf.NetIf.Font,
+				Conf.NetIf.FontSize,
+				Conf.Values.IfStatus,
+			)
+
+			if Conf.NetIf.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.NetIf.Separator.Right.Color,
+					Conf.NetIf.Separator.Right.Background,
+					Conf.NetIf.Separator.Right.Font,
+					Conf.NetIf.Separator.Right.FontSize,
+					Conf.NetIf.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Vpn.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.Vpn.Color
+			b.Background = Conf.Vpn.Background
+
+			if Conf.Vpn.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Vpn.Separator.Left.Color,
+					Conf.Vpn.Separator.Left.Background,
+					Conf.Vpn.Separator.Left.Font,
+					Conf.Vpn.Separator.Left.FontSize,
+					Conf.Vpn.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+				Conf.Vpn.Color,
+				Conf.Vpn.Background,
+				Conf.Vpn.Font,
+				Conf.Vpn.FontSize,
+				Conf.Values.VPNStatus,
+			)
+
+			if Conf.Vpn.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Vpn.Separator.Right.Color,
+					Conf.Vpn.Separator.Right.Background,
+					Conf.Vpn.Separator.Right.Font,
+					Conf.Vpn.Separator.Right.FontSize,
+					Conf.Vpn.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Battery.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.Battery.Color
+			b.Background = Conf.Battery.Background
+
+			if Conf.Battery.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Battery.Separator.Left.Color,
+					Conf.Battery.Separator.Left.Background,
+					Conf.Battery.Separator.Left.Font,
+					Conf.Battery.Separator.Left.FontSize,
+					Conf.Battery.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += Conf.Values.BatteryString
+
+			if Conf.Battery.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Battery.Separator.Right.Color,
+					Conf.Battery.Separator.Right.Background,
+					Conf.Battery.Separator.Right.Font,
+					Conf.Battery.Separator.Right.FontSize,
+					Conf.Battery.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.SimpleVolumePa.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Name = "simple-volume-pa"
+			b.Color = Conf.SimpleVolumePa.Color
+			b.Background = Conf.SimpleVolumePa.Background
+
+			if Conf.SimpleVolumePa.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.SimpleVolumePa.Separator.Left.Color,
+					Conf.SimpleVolumePa.Separator.Left.Background,
+					Conf.SimpleVolumePa.Separator.Left.Font,
+					Conf.SimpleVolumePa.Separator.Left.FontSize,
+					Conf.SimpleVolumePa.Separator.Left.Symbol,
+				)
+			}
+
+			// Pango format is already applied in plugin src.
+			b.FullText += Conf.Values.SoundVolume
+
+			if Conf.SimpleVolumePa.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.SimpleVolumePa.Separator.Right.Color,
+					Conf.SimpleVolumePa.Separator.Right.Background,
+					Conf.SimpleVolumePa.Separator.Right.Font,
+					Conf.SimpleVolumePa.Separator.Right.FontSize,
+					Conf.SimpleVolumePa.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.CmdRun.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Name = `runcommandoutput`
+			b.Color = Conf.CmdRun.Color
+			b.Background = Conf.CmdRun.Background
+
+			if Conf.CmdRun.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CmdRun.Separator.Left.Color,
+					Conf.CmdRun.Separator.Left.Background,
+					Conf.CmdRun.Separator.Left.Font,
+					Conf.CmdRun.Separator.Left.FontSize,
+					Conf.CmdRun.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+				Conf.CmdRun.Color,
+				Conf.CmdRun.Background,
+				Conf.CmdRun.Font,
+				Conf.CmdRun.FontSize,
+				Conf.Values.RunCommandOutput,
+			)
+
+			if Conf.CmdRun.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CmdRun.Separator.Right.Color,
+					Conf.CmdRun.Separator.Right.Background,
+					Conf.CmdRun.Separator.Right.Font,
+					Conf.CmdRun.Separator.Right.FontSize,
+					Conf.CmdRun.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Clock.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Name = `wallclock`
+			b.Color = Conf.Clock.Color
+			b.Background = Conf.Clock.Background
+
+			if Conf.Clock.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Clock.Separator.Left.Color,
+					Conf.Clock.Separator.Left.Background,
+					Conf.Clock.Separator.Left.Font,
+					Conf.Clock.Separator.Left.FontSize,
+					Conf.Clock.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+				Conf.Clock.Color,
+				Conf.Clock.Background,
+				Conf.Clock.Font,
+				Conf.Clock.FontSize,
+				Conf.Values.ClockTime,
+			)
+
+			if Conf.Clock.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Clock.Separator.Right.Color,
+					Conf.Clock.Separator.Right.Background,
+					Conf.Clock.Separator.Right.Font,
+					Conf.Clock.Separator.Right.FontSize,
+					Conf.Clock.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Values.PrintOutput && len(j) > 0 {
+			Conf.Channels.MsgChan <- j
+		}
+	}
+}
+
+// PrintToI3bar prints info to stdout according to ipc docs (https://i3wm.org/docs/i3bar-protocol.html)
+func PrintToI3bar(c *lib.MyConfig) {
+	for message := range c.Channels.MsgChan {
+		// we do not need to html-encode output, json.Marshal does this forcefully, so invent our own Marshal
+		buf := new(bytes.Buffer)
+		encoder := json.NewEncoder(buf)
+		encoder.SetEscapeHTML(false)
+		err := encoder.Encode(message)
+
+		if err != nil {
+			log.Printf("Unable to json-encode message, %s\n", err)
+		}
+
+		fmt.Println(strings.TrimSuffix(buf.String(), "\n") + ",")
+	}
+}

configs/i3status-go-example.json

@@ -0,0 +1 @@
+../cmd/i3status-go/default-config.json

go.mod

@@ -1,11 +1,12 @@
-module github.com/eleksir/i3status-go
+module i3status-go
 
-go 1.21
+go 1.24.2
 
 require (
-	github.com/adrg/xdg v0.5.0
+	github.com/adrg/xdg v0.5.3
+	github.com/davecgh/go-spew v1.1.1
 	github.com/distatus/battery v0.11.0
-	github.com/go-co-op/gocron/v2 v2.11.0
+	github.com/go-co-op/gocron/v2 v2.16.1
 	github.com/hjson/hjson-go v3.3.0+incompatible
 	github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e
 	github.com/shirou/gopsutil v3.21.11+incompatible
@@ -16,11 +17,18 @@ require (
 	github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc // indirect
 	github.com/BurntSushi/xgbutil v0.0.0-20190907113008-ad855c713046 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/jonboulle/clockwork v0.4.0 // indirect
+	github.com/jonboulle/clockwork v0.5.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 // indirect
-	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/sync v0.12.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
 	howett.net/plist v1.0.1 // indirect
 )
+
+tool (
+	i3status-go/cmd/battery-test
+	i3status-go/cmd/i3status-go
+	i3status-go/internal/lib
+)

go.sum

@@ -4,14 +4,14 @@ github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc/go.mod h1:IVnqGOEym
 github.com/BurntSushi/xgbutil v0.0.0-20160919175755-f7c97cef3b4e/go.mod h1:uw9h2sd4WWHOPdJ13MQpwK5qYWKYDumDqxWWIknEQ+k=
 github.com/BurntSushi/xgbutil v0.0.0-20190907113008-ad855c713046 h1:O/r2Sj+8QcMF7V5IcmiE2sMFV2q3J47BEirxbXJAdzA=
 github.com/BurntSushi/xgbutil v0.0.0-20190907113008-ad855c713046/go.mod h1:uw9h2sd4WWHOPdJ13MQpwK5qYWKYDumDqxWWIknEQ+k=
-github.com/adrg/xdg v0.5.0 h1:dDaZvhMXatArP1NPHhnfaQUqWBLBsmx1h1HXQdMoFCY=
-github.com/adrg/xdg v0.5.0/go.mod h1:dDdY4M4DF9Rjy4kHPeNL+ilVF+p2lK8IdM9/rTSGcI4=
+github.com/adrg/xdg v0.5.3 h1:xRnxJXne7+oWDatRhR1JLnvuccuIeCoBu2rtuLqQB78=
+github.com/adrg/xdg v0.5.3/go.mod h1:nlTsY+NNiCBGCK2tpm09vRqfVzrc2fLmXGpBLF0zlTQ=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/distatus/battery v0.11.0 h1:KJk89gz90Iq/wJtbjjM9yUzBXV+ASV/EG2WOOL7N8lc=
 github.com/distatus/battery v0.11.0/go.mod h1:KmVkE8A8hpIX4T78QRdMktYpEp35QfOL8A8dwZBxq2k=
-github.com/go-co-op/gocron/v2 v2.11.0 h1:IOowNA6SzwdRFnD4/Ol3Kj6G2xKfsoiiGq2Jhhm9bvE=
-github.com/go-co-op/gocron/v2 v2.11.0/go.mod h1:xY7bJxGazKam1cz04EebrlP4S9q4iWdiAylMGP3jY9w=
+github.com/go-co-op/gocron/v2 v2.16.1 h1:ux/5zxVRveCaCuTtNI3DiOk581KC1KpJbpJFYUEVYwo=
+github.com/go-co-op/gocron/v2 v2.16.1/go.mod h1:opexeOFy5BplhsKdA7bzY9zeYih8I8/WNJ4arTIFPVc=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
@@ -23,8 +23,8 @@ github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/hjson/hjson-go v3.3.0+incompatible h1:Rqr+Ya+0aCJMjaE4s8E9YKvuJLuLVpEvz4ONum52vnI=
 github.com/hjson/hjson-go v3.3.0+incompatible/go.mod h1:qsetwF8NlsTsOTwZTApNlTCerV+b2GjYRRcIk4JMFio=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4=
-github.com/jonboulle/clockwork v0.4.0/go.mod h1:xgRqUGwRcjKCO1vbZUEtSLrqKoPSsUpK7fnezOII0kc=
+github.com/jonboulle/clockwork v0.5.0 h1:Hyh9A8u51kptdkR+cqRpT1EebBwTn1oK9YfGYbdFz6I=
+github.com/jonboulle/clockwork v0.5.0/go.mod h1:3mZlmanh0g2NDKO5TWZVJAfofYk64M7XN3SzBPjZF60=
 github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e h1:y6jINFpNNS+IEizD6s9j35aKVNRsfsoEKN8IStRDQm0=
 github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e/go.mod h1:dlpd1fnLAhI6g9tM/aCobgN/Yka1/SkHrBTfAgDdb9Q=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -33,24 +33,22 @@ github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.i3wm.org/i3 v0.0.0-20190720062127-36e6ec85cc5a h1:yeQv6GWN8DsA2f3b+u1zhRIJg2HmsGYqXsd+W7ULr7Q=
 go.i3wm.org/i3 v0.0.0-20190720062127-36e6ec85cc5a/go.mod h1:7w17+r1F28Yxb1pHu8SxARJo+RGvJCAGOEf+GLw+2aQ=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 h1:e66Fs6Z+fZTbFBAxKfP3PALWBtpfqks2bwGcexMxgtk=
-golang.org/x/exp v0.0.0-20240909161429-701f63a606c0/go.mod h1:2TbTHSBQa924w8M6Xs1QcRcFwyucIwBGpK1p2f1YFFY=
 golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/lib/batteries.go

@@ -0,0 +1,255 @@
+package lib
+
+import (
+	"fmt"
+	"log"
+	"math"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/distatus/battery"
+)
+
+// UpdateBatteryInfo updates info about battery charge.
+func (c *MyConfig) UpdateBatteryInfo() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 5 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		var (
+			batteries = []*battery.Battery{}
+			Batts     string
+			ch        int
+			status    string
+		)
+
+		if c.Battery.UseSysfs {
+			for _, file := range c.Battery.SysfsFiles {
+				var batt battery.Battery
+
+				_, err := os.Stat(file)
+
+				// If file exists.
+				if !os.IsNotExist(err) {
+					var (
+						myCharge string
+						myStatus string
+					)
+
+					b, err := os.ReadFile(file)
+
+					if err != nil {
+						log.Printf("Unable to read file %s: %s", file, err)
+
+						continue
+					}
+
+					myCharge = strings.Trim(string(b), "\n")
+
+					statusFile := filepath.Dir(file) + "/status"
+
+					// If file exists.
+					if !os.IsNotExist(err) {
+						b, err := os.ReadFile(statusFile)
+
+						if err != nil {
+							log.Printf("Unable to read file %s: %s", statusFile, err)
+
+							continue
+						}
+
+						myStatus = strings.Trim(string(b), "\n")
+					} else {
+						continue
+					}
+
+					// Make stub battery class :) .
+					switch myStatus {
+					case "Charging":
+						batt.State.Raw = battery.Charging
+					case "Discharging":
+						batt.State.Raw = battery.Discharging
+					case "Empty":
+						batt.State.Raw = battery.Empty
+					case "Full":
+						batt.State.Raw = battery.Full
+					default:
+						batt.State.Raw = battery.Unknown
+					}
+
+					ch, err := strconv.Atoi(myCharge)
+
+					if err != nil {
+						log.Printf("Unable to convert string from file %s to integer", file)
+
+						continue
+					}
+
+					batt.Current = float64(ch)
+
+					batteries = append(batteries, &batt)
+				}
+			}
+		} else {
+			// In theory, this module should give for each entry its separate err, but in practice it gives
+			// one single err for all entries, so we cannot detemine whist exatly entry errored.
+			batteries, _ = battery.GetAll()
+		}
+
+		var (
+			battsInfo string
+			chStr     string
+		)
+
+		for i, b := range batteries {
+			switch b.State.Raw {
+			case battery.Charging:
+				status = `▲`
+			case battery.Discharging:
+				status = `▼`
+			case battery.Empty:
+				status = `✘`
+			default:
+				status = `•`
+			}
+
+			// N.B. there can be case when battery is overcharged and shows >100%. It also can indicate that
+			//      calibration data is out of date and battery should be re-calibrated.
+			if c.Battery.UseSysfs {
+				ch = int(b.Current)
+			} else {
+				ch = int(math.Round((b.Full - (b.Full - b.Current)) * (100 / b.Full)))
+			}
+
+			switch {
+			case ch <= 500 && ch >= 84:
+				if c.Battery.ChargeColor.Full == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.Full,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			case ch < 85 && ch > 40:
+				if c.Battery.ChargeColor.AlmostFull == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.AlmostFull,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			case ch <= 40 && ch >= 10:
+				if c.Battery.ChargeColor.AlmostEmpty == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.AlmostEmpty,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			case ch < 10 && ch >= 0:
+				if c.Battery.ChargeColor.Empty == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.Empty,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			default:
+				continue
+			}
+
+			battsInfo += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span><span color='%s' background='%s' font='%s' size='%s'>B%d </span>%s<span color='%s' background='%s' font='%s' size='%s'> %s</span>",
+				c.Battery.Color,
+				c.Battery.Background,
+				c.Battery.SymbolFont,
+				c.Battery.SymbolFontSize,
+				c.Battery.Symbol,
+				c.Battery.Color,
+				c.Battery.Background,
+				c.Battery.Font,
+				c.Battery.FontSize,
+				i,
+				chStr,
+				c.Battery.Color,
+				c.Battery.Background,
+				c.Battery.Font,
+				c.Battery.FontSize,
+				status,
+			)
+		}
+
+		if battsInfo != "" {
+			Batts = battsInfo
+		}
+
+		if c.Values.BatteryString != Batts {
+			c.Values.BatteryString = Batts
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/clock.go

@@ -1,16 +1,25 @@
-package main
+package lib
 
 import (
 	"fmt"
 	"time"
 )
 
-// Clock shows current date and time on i3bar.
-var Clock = "Thu, 1 Jan 1970   1:00"
-
 // UpdateClock get and updates (on i3bar) info about system clock.
-func UpdateClock() {
-	for {
+func (c *MyConfig) UpdateClock() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 1 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
 		currentTime := time.Now()
 		hours, minutes, _ := currentTime.Clock()
 		year, month, day := currentTime.Date()
@@ -20,11 +29,9 @@ func UpdateClock() {
 
 		myclock := fmt.Sprintf("     %s, %d %s %d  % 2d:%02d  ", rdow[dow], day, rmonth[month-1], year, hours, minutes)
 
-		if myclock != Clock {
-			Clock = myclock
-			UpdateReady <- true
-		}
-
-		time.Sleep(1 * time.Second)
+		if myclock != c.Values.ClockTime {
+			c.Values.ClockTime = myclock
+			c.Channels.UpdateReady <- true
+		}
 	}
 }

internal/lib/collection.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"sync"
@@ -12,7 +12,7 @@ type Collection struct {
 
 // Item just interface for stoing any data.
 type item struct {
-	data interface{}
+	data any
 }
 
 // NewCollection creates new instance of "collection".
@@ -25,7 +25,7 @@ func NewCollection() *Collection {
 }
 
 // Get returns value by given key. Or empty value.
-func (collection *Collection) Get(key interface{}) (interface{}, bool) {
+func (collection *Collection) Get(key any) (any, bool) {
 	obj, exists := collection.items.Load(key)
 
 	if !exists {
@@ -38,15 +38,15 @@ func (collection *Collection) Get(key interface{}) (interface{}, bool) {
 }
 
 // Set saves value to given "collection".
-func (collection *Collection) Set(key interface{}, value interface{}) {
+func (collection *Collection) Set(key any, value any) {
 	collection.items.Store(key, item{
 		data: value,
 	})
 }
 
 // Range apply function f to all keys/values in collection. Retuns immediatly on first error.
-func (collection *Collection) Range(f func(key, value interface{}) bool) {
-	fn := func(key, value interface{}) bool {
+func (collection *Collection) Range(f func(key, value any) bool) {
+	fn := func(key, value any) bool {
 		item := value.(item)
 
 		return f(key, item.data)
@@ -56,7 +56,7 @@ func (collection *Collection) Range(f func(key, value interface{}) bool) {
 }
 
 // Delete deletes key and corresponding value from collection.
-func (collection *Collection) Delete(key interface{}) {
+func (collection *Collection) Delete(key any) {
 	collection.items.Delete(key)
 }
 

internal/lib/config.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"encoding/json"
@@ -11,8 +11,32 @@ import (
 
 	"github.com/adrg/xdg"
 	"github.com/hjson/hjson-go"
+	p "github.com/mafik/pulseaudio"
 )
 
+// I3BarOutBlock is structure element for I3BarOut, it represents i3bar output json block format.
+type I3BarOutBlock struct {
+	FullText string `json:"full_text"`
+	// ShortText will be shown if not enough room for FullText, threshold width defined in MinWidth
+	ShortText    string `json:"short_text,omitempty"`
+	Color        string `json:"color,omitempty"`
+	Background   string `json:"background,omitempty"`
+	Border       string `json:"border,omitempty"`
+	BorderTop    int    `json:"border_top"`
+	BorderRight  int    `json:"border_right"`
+	BorderBottom int    `json:"border_bottom"`
+	BorderLeft   int    `json:"border_left"`
+	// measured either in pixels or in characters, so either int or string, let's make it string :)
+	MinWidth            string `json:"min_width,omitempty"`
+	Align               string `json:"align,omitempty"`
+	Name                string `json:"name,omitempty"`
+	Instance            string `json:"instance,omitempty"`
+	Urgent              bool   `json:"urgent,omitempty"`
+	Separator           bool   `json:"separator"`
+	SeparatorBlockWidth int    `json:"separator_block_width"`
+	Markup              string `json:"markup,omitempty"`
+}
+
 type Separator struct {
 	Left struct {
 		Enabled    bool   `json:"enabled,omitempty"`
@@ -34,6 +58,27 @@ type Separator struct {
 }
 
 type MyConfig struct {
+	Values struct {
+		PrintOutput      bool
+		CPUTemperature   int64
+		BatteryString    string
+		ClockTime        string
+		IfStatus         string
+		VPNStatus        string
+		Memory           Mem
+		La               string
+		PA               *p.Client
+		SoundVolume      string
+		RunCommandOutput string
+	}
+
+	Channels struct {
+		UpdateReady     chan bool
+		MsgChan         chan []I3BarOutBlock
+		SigChan         chan os.Signal
+		SVPAHandlerChan chan ClickEvent
+		RunChan         chan []string
+	}
 
 	// Default text color
 	Color string `json:"color,omitempty"`
@@ -91,6 +136,8 @@ type MyConfig struct {
 
 	Battery struct {
 		Enabled        bool     `json:"enabled,omitempty"`
+		UseSysfs       bool     `json:"use_sysfs,omitempty"`
+		SysfsFiles     []string `json:"sysfs_files,omitempty"`
 		Color          string   `json:"color,omitempty"`
 		Background     string   `json:"background,omitempty"`
 		Font           string   `json:"font,omitempty"`
@@ -185,6 +232,18 @@ type MyConfig struct {
 		} `json:"tasks,omitempty"`
 	} `json:"cron,omitempty"`
 
+	CmdRun struct {
+		Enabled    bool      `json:"enabled,omitempty"`
+		Color      string    `json:"color,omitempty"`
+		Background string    `json:"background,omitempty"`
+		Font       string    `json:"font,omitempty"`
+		FontSize   string    `json:"font_size,omitempty"`
+		Separator  Separator `json:"separator,omitempty"`
+		Cmd        string    `json:"cmd,omitempty"`
+		Delay      int       `json:"delay,omitempty"`
+		Args       []string  `json:"args,omitempty"`
+	}
+
 	AppButtons struct {
 		Enabled   bool      `json:"enabled,omitempty"`
 		Separator Separator `json:"separator,omitempty"`
@@ -206,15 +265,12 @@ type MyConfig struct {
 	} `json:"apps,omitempty"`
 }
 
-// Conf global variable with application config.
-var Conf MyConfig
-
 // readConf reads and validates config if config does not exist, it puts default config to the same dir where i3 config
 // is located.
-func readConf() (MyConfig, error) {
+func ReadConf(defaultConfig []byte) (*MyConfig, error) {
 	var (
 		path   string
-		config MyConfig
+		config *MyConfig
 		err    error
 		buf    []byte
 	)
@@ -231,7 +287,7 @@ func readConf() (MyConfig, error) {
 	// about it for now.
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
-			buf = DefaultConfig
+			buf = defaultConfig
 
 			if err := os.WriteFile(path, buf, 0644); err != nil {
 				return config, err
@@ -242,7 +298,7 @@ func readConf() (MyConfig, error) {
 	} else {
 		// Config file looks too long for config...
 		if fileInfo.Size() > 65535 {
-			err := fmt.Errorf("config file %s is too long for config", path) //nolint: goerr113
+			err := fmt.Errorf("config file %s is too long for config", path) //nolint: err113
 
 			return config, err
 		}
@@ -260,8 +316,8 @@ func readConf() (MyConfig, error) {
 	// We interested in struct as output product: so we parse config to intermediate map then marshal it to json and
 	// then produced json unmarshal to struct. Not very effective way, but in app lifetime it happens only once.
 	var (
-		sampleConfig MyConfig
-		tmp          map[string]interface{}
+		sampleConfig *MyConfig
+		tmp          map[string]any
 	)
 
 	err = hjson.Unmarshal(buf, &tmp)
@@ -320,6 +376,10 @@ func readConf() (MyConfig, error) {
 		sampleConfig.Separator.Left.Font = sampleConfig.Font
 	}
 
+	if sampleConfig.Separator.Left.FontSize == "" {
+		sampleConfig.Separator.Left.FontSize = sampleConfig.FontSize
+	}
+
 	matched, err := regexp.MatchString(
 		`^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger)$`,
 		sampleConfig.Separator.Left.FontSize,
@@ -362,6 +422,10 @@ func readConf() (MyConfig, error) {
 		sampleConfig.Separator.Right.Font = sampleConfig.Font
 	}
 
+	if sampleConfig.Separator.Right.FontSize == "" {
+		sampleConfig.Separator.Right.FontSize = sampleConfig.FontSize
+	}
+
 	matched, err = regexp.MatchString(
 		`^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger)$`,
 		sampleConfig.Separator.Right.FontSize,
@@ -729,6 +793,15 @@ func readConf() (MyConfig, error) {
 	}
 
 	// sampleConfig.Battery.Enabled will be false if not set in config
+	// sampleConfig.Battery.UseSysfs will be false if not set in config
+
+	if len(sampleConfig.Battery.SysfsFiles) == 0 {
+		sampleConfig.Battery.SysfsFiles = append(
+			sampleConfig.Battery.SysfsFiles,
+			"/sys/class/power_supply/BAT0/capacity",
+		)
+	}
+
 	if sampleConfig.Battery.Color == "" {
 		sampleConfig.Battery.Color = sampleConfig.Color
 	}
@@ -976,7 +1049,7 @@ func readConf() (MyConfig, error) {
 	}
 
 	if sampleConfig.Vpn.Font == "" {
-		sampleConfig.Vpn.FontSize = sampleConfig.Font
+		sampleConfig.Vpn.Font = sampleConfig.Font
 	}
 
 	if sampleConfig.Vpn.FontSize == "" {
@@ -1386,6 +1459,122 @@ func readConf() (MyConfig, error) {
 		}
 	}
 
+	// sampleConfig.CmdRun.Enabled will false if not set in config
+
+	if sampleConfig.CmdRun.Cmd == "" && sampleConfig.CmdRun.Enabled {
+		sampleConfig.CmdRun.Enabled = false
+
+		log.Print(
+			"Setting sampleConfig.CmdRun.Enabled to false because sampleConfig.CmdRun.Cmd is not set",
+		)
+	}
+
+	// sampleConfig.CmdRun.Args can be empty
+
+	if sampleConfig.CmdRun.Color == "" {
+		sampleConfig.CmdRun.Color = sampleConfig.Color
+	}
+
+	if sampleConfig.CmdRun.Background == "" {
+		sampleConfig.CmdRun.Background = sampleConfig.Background
+	}
+
+	if sampleConfig.CmdRun.Font == "" {
+		sampleConfig.CmdRun.Font = sampleConfig.Font
+	}
+
+	if sampleConfig.CmdRun.FontSize == "" {
+		sampleConfig.CmdRun.FontSize = sampleConfig.FontSize
+	}
+
+	if sampleConfig.CmdRun.Separator.Left.Color == "" {
+		sampleConfig.CmdRun.Separator.Left.Color = sampleConfig.Separator.Left.Color
+	}
+
+	if sampleConfig.CmdRun.Separator.Left.Background == "" {
+		sampleConfig.CmdRun.Separator.Left.Background = sampleConfig.Separator.Left.Background
+	}
+
+	if sampleConfig.CmdRun.Separator.Left.Symbol == "" {
+		sampleConfig.CmdRun.Separator.Left.Symbol = sampleConfig.Separator.Left.Symbol
+	}
+
+	if sampleConfig.CmdRun.Separator.Left.Font == "" {
+		sampleConfig.CmdRun.Separator.Left.Font = sampleConfig.Separator.Left.Font
+	}
+
+	if sampleConfig.CmdRun.Separator.Left.FontSize == "" {
+		sampleConfig.CmdRun.Separator.Left.FontSize = sampleConfig.Separator.Left.FontSize
+	} else {
+		matched, err := regexp.MatchString(
+			`^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger)$`,
+			sampleConfig.CmdRun.Separator.Left.FontSize,
+		)
+
+		if err != nil {
+			log.Printf(
+				"Unable to set sampleConfig.CmdRun.Separator.Left.FontSize: %s, fallback to %s",
+				err,
+				sampleConfig.Separator.Left.FontSize,
+			)
+
+			sampleConfig.CmdRun.Separator.Left.FontSize = sampleConfig.Separator.Left.FontSize
+		}
+
+		if !matched {
+			log.Printf(
+				"Unable to set sampleConfig.CmdRun.Separator.Left.FontSize, fallback to %s",
+				sampleConfig.Separator.Left.FontSize,
+			)
+
+			sampleConfig.CmdRun.Separator.Left.FontSize = sampleConfig.Separator.Left.FontSize
+		}
+	}
+
+	if sampleConfig.CmdRun.Separator.Right.Color == "" {
+		sampleConfig.CmdRun.Separator.Right.Color = sampleConfig.Separator.Right.Color
+	}
+
+	if sampleConfig.CmdRun.Separator.Right.Background == "" {
+		sampleConfig.CmdRun.Separator.Right.Background = sampleConfig.Separator.Right.Background
+	}
+
+	if sampleConfig.CmdRun.Separator.Right.Symbol == "" {
+		sampleConfig.CmdRun.Separator.Right.Symbol = sampleConfig.Separator.Right.Symbol
+	}
+
+	if sampleConfig.CmdRun.Separator.Right.Font == "" {
+		sampleConfig.CmdRun.Separator.Right.Font = sampleConfig.Separator.Right.Font
+	}
+
+	if sampleConfig.CmdRun.Separator.Right.FontSize == "" {
+		sampleConfig.CmdRun.Separator.Right.FontSize = sampleConfig.Separator.Right.FontSize
+	} else {
+		matched, err := regexp.MatchString(
+			`^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger)$`,
+			sampleConfig.CmdRun.Separator.Right.FontSize,
+		)
+
+		if err != nil {
+			log.Printf(
+				"Unable to set sampleConfig.CmdRun.Separator.Right.FontSize: %s, fallback to %s",
+				err,
+				sampleConfig.Separator.Right.FontSize,
+			)
+
+			sampleConfig.CmdRun.Separator.Right.FontSize = sampleConfig.Separator.Right.FontSize
+		}
+
+		if !matched {
+			log.Printf(
+				"Unable to set sampleConfig.CmdRun.Separator.Right.FontSize, fallback to %s",
+				sampleConfig.Separator.Right.FontSize,
+			)
+
+			sampleConfig.CmdRun.Separator.Right.FontSize = sampleConfig.Separator.Right.FontSize
+		}
+	}
+
 	// sampleConfig.AppButtons.Enabled will false if not set in config
 
 	if sampleConfig.AppButtons.Separator.Left.Color == "" {
@@ -1481,39 +1670,36 @@ func readConf() (MyConfig, error) {
 		for num, app := range sampleConfig.Apps {
 			// app.Instance can be missing.
 			// app.Class can be missing.
-
 			if app.Name == "" {
 				app.Name = fmt.Sprintf("app%d", num)
 			}
 
 			// app.Args can be empty slice. In that case command will be run without aruments.
-
 			if app.Cmd == "" {
 				app.Cmd = "true"
 			}
 
 			if app.Color == "" {
-				app.Color = Conf.Color
+				app.Color = sampleConfig.Color
 			}
 
 			if app.Background == "" {
-				app.Background = Conf.Background
+				app.Background = sampleConfig.Background
 			}
 
 			if app.Border == "" {
-				app.Border = Conf.Color
+				app.Border = sampleConfig.Color
 			}
 
 			if app.BorderActive == "" {
-				app.BorderActive = Conf.Color
-			}
-
-			if app.FullText == "" {
-				app.FullText = fmt.Sprintf(" %d ", num)
+				app.BorderActive = sampleConfig.Color
 			}
 
 			// app.Separator can be omitted, in that case it is false
 			// app.SeparatorBlockWidth can be missing
+			if app.FullText == "" {
+				app.FullText = fmt.Sprintf(" %d ", num)
+			}
 		}
 	}
 

internal/lib/cputemp.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"bufio"
@@ -8,21 +8,29 @@ import (
 	"time"
 )
 
-// CPUTemperature stores average temperature among all cores.
-var CPUTemperature int64
-
 // UpdateCPUTemperature gets and updates average CPU cores temperature.
-func UpdateCPUTemperature() {
-	n := len(Conf.CPUTemp.File)
+func (c *MyConfig) UpdateCPUTemperature() {
+	var (
+		n                  = len(c.CPUTemp.File)
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
 
-	for {
+	for range ticker.C {
 		var (
 			temperature = make([]int64, n)
 			tSum        int64
 			tAvg        int64
 		)
 
-		for i, filename := range Conf.CPUTemp.File {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		for i, filename := range c.CPUTemp.File {
 			file, err := os.Open(filename)
 
 			if err != nil {
@@ -70,11 +78,9 @@ func UpdateCPUTemperature() {
 			tAvg = tSum / int64(len(temperature))
 		}
 
-		if CPUTemperature != tAvg {
-			CPUTemperature = tAvg
-			UpdateReady <- true
-		}
-
-		time.Sleep(3 * time.Second)
+		if c.Values.CPUTemperature != tAvg {
+			c.Values.CPUTemperature = tAvg
+			c.Channels.UpdateReady <- true
+		}
 	}
 }

internal/lib/cron.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -10,7 +10,7 @@ import (
 var myCron gocron.Scheduler
 
 // RunCron parses config part, related to cron tasks and kicks cron to run.
-func RunCron() {
+func (c MyConfig) RunCron() {
 	var err error
 
 	myCron, err = gocron.NewScheduler()
@@ -21,14 +21,14 @@ func RunCron() {
 		return
 	}
 
-	for _, job := range Conf.Cron.Tasks {
+	for _, job := range c.Cron.Tasks {
 		_, err := myCron.NewJob(
 			gocron.CronJob(job.Time, false),
 			gocron.NewTask(
 				// Сука, просто заспавнить бинарь, ну почему это надо делать через жопу-то?
 				any(
 					func() bool {
-						RunChan <- job.Cmd
+						c.Channels.RunChan <- job.Cmd
 
 						return true
 					},

internal/lib/i3.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -18,7 +18,7 @@ type WinList struct {
 var WL WinList
 
 // UpdateI3WinList subsribes to all window-related events and send them to I3EventParser() for more detailed parsing.
-func UpdateI3WinList() {
+func (c *MyConfig) UpdateI3WinList() {
 	// TODO: Здесь получить начальный список окон, управляемых i3wm (через GetTree()) и сложить их атрибутику в переменную WL
 	Tree, err := i3.GetTree()
 
@@ -26,20 +26,20 @@ func UpdateI3WinList() {
 		log.Printf("Unable to get list of windows: %s", err)
 	}
 
-	ExtractProps(Tree.Root)
+	c.ExtractProps(Tree.Root)
 
 	i3wm := i3.Subscribe(i3.WindowEventType)
 
 	for i3wm.Next() {
 		e := i3wm.Event().(*i3.WindowEvent)
-		go I3EventParser(e)
+		go c.I3EventParser(e)
 	}
 
 	log.Fatal(i3wm.Close())
 }
 
 // I3EventParser parses i3wm events and updates WL (aka Windows List).
-func I3EventParser(e *i3.WindowEvent) {
+func (c *MyConfig) I3EventParser(e *i3.WindowEvent) {
 	switch e.Change {
 	case "new":
 		var (
@@ -68,7 +68,7 @@ func I3EventParser(e *i3.WindowEvent) {
 		count++
 		WL.Instance.Set(e.Container.WindowProperties.Instance, count)
 
-		UpdateReady <- true
+		c.Channels.UpdateReady <- true
 
 	case "close":
 		countI, exist := WL.Class.Get(e.Container.WindowProperties.Class)
@@ -99,7 +99,7 @@ func I3EventParser(e *i3.WindowEvent) {
 			}
 		}
 
-		UpdateReady <- true
+		c.Channels.UpdateReady <- true
 	}
 }
 
@@ -152,10 +152,10 @@ func HasWindows(className string, instanceName string) bool {
 func FindWindowInstance(regexpStr string) bool {
 	var found = false
 
-	f := func(key interface{}, value interface{}) bool {
+	f := func(key any, value any) bool { //nolint: revive
 		keyStr := reflect.ValueOf(key).String()
 
-		re, err := regexp.Compile(regexpStr) //nolint:nolintlint, gocritic, we do not want shit our pants and panic on
+		re, err := regexp.Compile(regexpStr) // we do not want shit our pants and panic on
 		//        erroneous regexp, we want log it to stderr, that it.
 
 		if err != nil {
@@ -183,10 +183,10 @@ func FindWindowInstance(regexpStr string) bool {
 func FindWindowClass(regexpStr string) bool {
 	var found = false
 
-	f := func(key interface{}, value interface{}) bool {
+	f := func(key any, value any) bool { //nolint: revive
 		keyStr := reflect.ValueOf(key).String()
 
-		re, err := regexp.Compile(regexpStr) //nolint:nolintlint, gocritic, we do not want shit our pants and panic on
+		re, err := regexp.Compile(regexpStr) // we do not want shit our pants and panic on
 		//        erroneous regexp, we want log it to stderr, that it.
 
 		if err != nil {
@@ -210,18 +210,18 @@ func FindWindowClass(regexpStr string) bool {
 }
 
 // ExtractProps fills WL stricture collections with instance name and class name of given node (x11, that is).
-func ExtractProps(n *i3.Node) {
+func (c *MyConfig) ExtractProps(n *i3.Node) {
 	var e i3.WindowEvent
 	e.Change = "new"
 	e.Container = *n
 
-	I3EventParser(&e)
+	c.I3EventParser(&e)
 
 	for _, node := range n.Nodes {
-		ExtractProps(node)
+		c.ExtractProps(node)
 	}
 
 	for _, node := range n.FloatingNodes {
-		ExtractProps(node)
+		c.ExtractProps(node)
 	}
 }

internal/lib/ifmon.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"fmt"
@@ -9,15 +9,24 @@ import (
 	"time"
 )
 
-// IfStatus global var conaining cumulative status of all monitored net intefaces.
-var IfStatus string
-
 // UpdateIfStatus updates network interfaces status for i3bar.
-func UpdateIfStatus() {
-	for {
+func (c *MyConfig) UpdateIfStatus() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
 		var statusSum string
 
-		for _, item := range Conf.NetIf.If {
+		for _, item := range c.NetIf.If {
 			var (
 				name = item.Name
 			)
@@ -35,10 +44,10 @@ func UpdateIfStatus() {
 			} else {
 				switch strings.TrimSpace(string(operstate)) {
 				case "up":
-					StatusStr := fmt.Sprintf("<span foreground=\"%s\">⍋</span>", Conf.NetIf.UpColor)
+					StatusStr := fmt.Sprintf("<span foreground=\"%s\">⍋</span>", c.NetIf.UpColor)
 					operstate = []byte(StatusStr)
 				case "down":
-					statusStr := fmt.Sprintf("<span foreground=\"%s\">⍒</span>", Conf.NetIf.DownColor)
+					statusStr := fmt.Sprintf("<span foreground=\"%s\">⍒</span>", c.NetIf.DownColor)
 					operstate = []byte(statusStr)
 				default:
 					operstate = []byte(`?`)
@@ -52,11 +61,9 @@ func UpdateIfStatus() {
 			statusSum += fmt.Sprintf("%s:%s", name, operstate)
 		}
 
-		if IfStatus != statusSum {
-			IfStatus = statusSum
-			UpdateReady <- true
-		}
-
-		time.Sleep(3 * time.Second)
+		if c.Values.IfStatus != statusSum {
+			c.Values.IfStatus = statusSum
+			c.Channels.UpdateReady <- true
+		}
 	}
 }

internal/lib/la.go

@@ -0,0 +1,34 @@
+package lib
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/shirou/gopsutil/load"
+)
+
+// UpdateLaStats вытаскивает показание LA за последнюю минуту.
+func (c *MyConfig) UpdateLaStats() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		l, _ := load.Avg()
+
+		lav := fmt.Sprintf("%.2f", l.Load1)
+
+		if c.Values.La != lav {
+			c.Values.La = lav
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/memory.go

@@ -0,0 +1,65 @@
+package lib
+
+import (
+	"log"
+	"time"
+
+	"github.com/shirou/gopsutil/mem"
+)
+
+// Mem struct with mem stats.
+type Mem struct {
+	Usedpct uint64
+	Shared  uint64
+	Swap    uint64
+}
+
+// UpdateMemStats parses mem info stats.
+func (c *MyConfig) UpdateMemStats() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		v, err := mem.VirtualMemory()
+
+		if err != nil {
+			log.Printf("Unable to get memory statistics: %s", err)
+			time.Sleep(1 * time.Second)
+
+			continue
+		}
+
+		sw, err := mem.SwapMemory()
+
+		if err != nil {
+			log.Printf("Unable to get swap statistics: %s", err)
+			time.Sleep(1 * time.Second)
+
+			continue
+		}
+
+		if c.Mem.ShowSwap {
+			if c.Values.Memory.Usedpct != uint64(v.UsedPercent) || c.Values.Memory.Shared != v.Shared/1024/1024 || c.Values.Memory.Swap != v.SwapTotal-v.SwapFree {
+				c.Values.Memory.Usedpct = uint64(v.UsedPercent)
+				c.Values.Memory.Shared = v.Shared / 1024 / 1024
+				c.Values.Memory.Swap = sw.Used / 1024 / 1024
+				c.Channels.UpdateReady <- true
+			}
+		} else {
+			if c.Values.Memory.Usedpct != uint64(v.UsedPercent) || c.Values.Memory.Shared != v.Shared/1024/1024 {
+				c.Values.Memory.Usedpct = uint64(v.UsedPercent)
+				c.Values.Memory.Shared = v.Shared / 1024 / 1024
+				c.Channels.UpdateReady <- true
+			}
+		}
+	}
+}

internal/lib/pulseaudio.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"errors"
@@ -10,30 +10,25 @@ import (
 	p "github.com/mafik/pulseaudio"
 )
 
-var SoundVolume = "🔊:0%"
-var pa *p.Client
-
-var SVPAHandlerChan = make(chan ClickEvent, 256)
-
 // TODO: https://twin.sh/articles/44/add-a-timeout-to-any-function-in-go timeout pulseaudio calls
 
 // UpdateVolumeInfo updates info about current Sound Volume.
-func UpdateVolumeInfo() {
+func (c *MyConfig) UpdateVolumeInfo() {
 	var err error
 
-	pa, err = p.NewClient()
+	c.Values.PA, err = p.NewClient()
 
 	// It can happen if no pulseaudio server running for current user.
 	// If no server running we have to run one.
 	if err != nil {
-		if err := PaReinit(); err != nil {
+		if err := c.PaReinit(); err != nil {
 			log.Print(err)
 
 			return
 		}
 	}
 
-	vol, err := pa.Volume()
+	vol, err := c.Values.PA.Volume()
 
 	if err != nil {
 		log.Printf("Unable get volume from pulseaudio server: %s", err)
@@ -41,29 +36,29 @@ func UpdateVolumeInfo() {
 		return
 	}
 
-	SoundVolume = fmt.Sprintf(
+	c.Values.SoundVolume = fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.SymbolFont,
-		Conf.SimpleVolumePa.SymbolFontSize,
-		Conf.SimpleVolumePa.Symbol,
+		c.SimpleVolumePa.Color,
+		c.SimpleVolumePa.Background,
+		c.SimpleVolumePa.SymbolFont,
+		c.SimpleVolumePa.SymbolFontSize,
+		c.SimpleVolumePa.Symbol,
 	)
 
-	SoundVolume += fmt.Sprintf(
+	c.Values.SoundVolume += fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>:%d%%</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.Font,
-		Conf.SimpleVolumePa.FontSize,
+		c.SimpleVolumePa.Color,
+		c.SimpleVolumePa.Background,
+		c.SimpleVolumePa.Font,
+		c.SimpleVolumePa.FontSize,
 		int64(vol*100),
 	)
 
-	UpdateReady <- true
+	c.Channels.UpdateReady <- true
 
 	for {
 		// Subscribe to update notification channel, to get info that volume changed.
-		pulseUpdate, err := pa.Updates()
+		pulseUpdate, err := c.Values.PA.Updates()
 
 		if err != nil {
 			log.Printf("Unable to subscribe to pulseaudio updates: %s", err)
@@ -73,7 +68,7 @@ func UpdateVolumeInfo() {
 
 		// Rake update events.
 		for range pulseUpdate {
-			vol, err = pa.Volume()
+			vol, err = c.Values.PA.Volume()
 
 			if err != nil {
 				log.Printf("Unable get volume from pulseaudio server: %s", err)
@@ -81,28 +76,28 @@ func UpdateVolumeInfo() {
 				return
 			}
 
-			SoundVolume = fmt.Sprintf(
+			c.Values.SoundVolume = fmt.Sprintf(
 				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-				Conf.SimpleVolumePa.Color,
-				Conf.SimpleVolumePa.Background,
-				Conf.SimpleVolumePa.SymbolFont,
-				Conf.SimpleVolumePa.SymbolFontSize,
-				Conf.SimpleVolumePa.Symbol,
+				c.SimpleVolumePa.Color,
+				c.SimpleVolumePa.Background,
+				c.SimpleVolumePa.SymbolFont,
+				c.SimpleVolumePa.SymbolFontSize,
+				c.SimpleVolumePa.Symbol,
 			)
 
-			SoundVolume += fmt.Sprintf(
+			c.Values.SoundVolume += fmt.Sprintf(
 				"<span color='%s' background='%s' font='%s' size='%s'>:%d%%</span>",
-				Conf.SimpleVolumePa.Color,
-				Conf.SimpleVolumePa.Background,
-				Conf.SimpleVolumePa.Font,
-				Conf.SimpleVolumePa.FontSize,
+				c.SimpleVolumePa.Color,
+				c.SimpleVolumePa.Background,
+				c.SimpleVolumePa.Font,
+				c.SimpleVolumePa.FontSize,
 				int64(vol*100),
 			)
 
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
 		}
 
-		if err := PaReinit(); err != nil {
+		if err := c.PaReinit(); err != nil {
 			log.Print(err)
 
 			return
@@ -110,11 +105,11 @@ func UpdateVolumeInfo() {
 	}
 
 	// This code is unreachable :(
-	pa.Close() //nolint:govet
+	c.Values.PA.Close() //nolint:govet
 }
 
 // PaReinit re-inits pulseaudio and connection to it.
-func PaReinit() error {
+func (c *MyConfig) PaReinit() error {
 	var err error
 
 	// If we out of updates, seems someone killed pulseaudio server. Restart it.
@@ -140,7 +135,7 @@ func PaReinit() error {
 			}
 
 			if cnt >= 5 {
-				return errors.New("timeout waiting pulseaudio to exit") //nolint: goerr113
+				return errors.New("timeout waiting pulseaudio to exit") //nolint: err113
 			}
 
 			log.Print("Waiting for pulseaudio to exit")
@@ -157,7 +152,7 @@ func PaReinit() error {
 	// This setting defines if pulseaudio will be run in manner that allows it to exit is other login detected (how
 	// they guess it - I do not know). In general case we do not want to allow pa to exit and leave our session without
 	// audio.
-	if Conf.SimpleVolumePa.DontExitOnLogin {
+	if c.SimpleVolumePa.DontExitOnLogin {
 		// Do not exit on any kind of login/logout events.
 		cmd = exec.Command("pulseaudio", "--exit-idle-time=-1", "--start")
 	} else {
@@ -169,7 +164,7 @@ func PaReinit() error {
 		return fmt.Errorf("unable to initialize pulseaudio server instance: %w", err)
 	}
 
-	pa, err = p.NewClient()
+	c.Values.PA, err = p.NewClient()
 
 	if err != nil {
 		return fmt.Errorf("unable to make client connection to pulseaudio: %w", err)
@@ -178,21 +173,21 @@ func PaReinit() error {
 	return err
 }
 
-func SVPAHandler() {
-	for e := range SVPAHandlerChan {
+func (c *MyConfig) SVPAHandler() {
+	for e := range c.Channels.SVPAHandlerChan {
 		if e.Button == 3 {
-			RunChan <- Conf.SimpleVolumePa.RightClickCmd
+			c.Channels.RunChan <- c.SimpleVolumePa.RightClickCmd
 
 			continue
 		}
 
-		vol, err := pa.Volume()
+		vol, err := c.Values.PA.Volume()
 
 		if err != nil {
-			if err := PaReinit(); err != nil {
+			if err := c.PaReinit(); err != nil {
 				log.Printf("Unable to get pulseaudio volume: %s", err)
 			} else {
-				vol, err = pa.Volume()
+				vol, err = c.Values.PA.Volume()
 
 				if err != nil {
 					log.Printf("Unable to get volume pulseaudio server behaves weirdly: %s", err)
@@ -201,25 +196,25 @@ func SVPAHandler() {
 		}
 
 		switch e.Button {
-		case Conf.SimpleVolumePa.WheelUp:
-			vol += float32(Conf.SimpleVolumePa.Step) / 100
+		case c.SimpleVolumePa.WheelUp:
+			vol += float32(c.SimpleVolumePa.Step) / 100
 
-			if vol > (float32(Conf.SimpleVolumePa.MaxVolumeLimit) / 100) {
-				vol = float32(Conf.SimpleVolumePa.MaxVolumeLimit) / 100
+			if vol > (float32(c.SimpleVolumePa.MaxVolumeLimit) / 100) {
+				vol = float32(c.SimpleVolumePa.MaxVolumeLimit) / 100
 			}
 
-			if err := pa.SetVolume(vol); err != nil {
+			if err := c.Values.PA.SetVolume(vol); err != nil {
 				log.Printf("Unable to set pulseaudio volume: %s", err)
 			}
 
-		case Conf.SimpleVolumePa.WheelDown:
-			vol -= float32(Conf.SimpleVolumePa.Step) / 100
+		case c.SimpleVolumePa.WheelDown:
+			vol -= float32(c.SimpleVolumePa.Step) / 100
 
 			if vol < 0 {
 				vol = 0
 			}
 
-			if err := pa.SetVolume(vol); err != nil {
+			if err := c.Values.PA.SetVolume(vol); err != nil {
 				log.Printf("Unable to set pulseaudio volume: %s", err)
 			}
 		}

internal/lib/runcommand.go

@@ -0,0 +1,41 @@
+package lib
+
+import (
+	"log"
+	"time"
+)
+
+// RunCommands gets list of commands runs them sequentally and conacatenates their output.
+func (c *MyConfig) RunCommand() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = time.Duration(c.CmdRun.Delay) * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		var (
+			outputString string
+			command      = []string{c.CmdRun.Cmd}
+		)
+
+		if len(c.CmdRun.Args) > 0 {
+			command = append(command, c.CmdRun.Args...)
+		}
+
+		outputString += RunProcess(command)
+
+		log.Println(c.Values.RunCommandOutput)
+
+		if c.Values.RunCommandOutput != outputString {
+			c.Values.RunCommandOutput = outputString
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/signal.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -7,23 +7,22 @@ import (
 )
 
 var PrintOutput = true
-var sigChan = make(chan os.Signal, 1)
 
-// sigHandler OS signal handler.
-func sigHandler() {
-	for s := range sigChan {
+// SigHandler OS signal handler.
+func (c *MyConfig) SigHandler() {
+	for s := range c.Channels.SigChan {
 		switch s {
 		case syscall.SIGUSR1:
 			log.Print("Got SIGUSR1, stopping output")
 
-			PrintOutput = false
+			c.Values.PrintOutput = false
 
 		case syscall.SIGUSR2:
 			log.Print("Got SIGUSR2, resuming output")
 
-			PrintOutput = true
+			c.Values.PrintOutput = true
 
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
 
 		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
 			os.Exit(0)

internal/lib/spawn.go

@@ -0,0 +1,98 @@
+package lib
+
+import (
+	"bytes"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+)
+
+// Spawner forks and execs given program, and also detaches form its control tty.
+func (c *MyConfig) Spawner() {
+	for prg := range c.Channels.RunChan {
+		<-time.After(25 * time.Millisecond)
+
+		devnullR, _ := os.Open(os.DevNull)
+		devnullW, _ := os.OpenFile(os.DevNull, os.O_WRONLY|os.O_APPEND, 0644)
+
+		spa := syscall.SysProcAttr{
+			Setsid:     true,
+			Foreground: false,
+		}
+
+		pa := syscall.ProcAttr{
+			Dir:   os.Getenv(`HOME`),
+			Env:   os.Environ(),
+			Files: []uintptr{devnullR.Fd(), devnullW.Fd(), devnullW.Fd()},
+			Sys:   &spa,
+		}
+
+		bin, err := exec.LookPath(prg[0])
+
+		if err != nil {
+			log.Printf("Unable to spawn %s: %s", prg[0], err)
+		}
+
+		_, err = syscall.ForkExec(bin, prg, &pa)
+
+		if err != nil {
+			log.Printf("Unable to spawn %s: %s", prg[0], err)
+		}
+
+		// Close file errors we don't handle :) at all.
+		_ = devnullR.Close()
+		_ = devnullW.Close()
+	}
+}
+
+// CleanZombies reaps processes spawned by Spawner() and already exited.
+func (c *MyConfig) CleanZombies() {
+	r := syscall.Rusage{}
+
+	for {
+		_, _ = syscall.Wait4(-1, nil, 0, &r)
+
+		time.Sleep(1 * time.Minute)
+	}
+}
+
+// RunProcess runs given command and returns contens of command stdout. On error prints error on stderr and returns
+// empty syting.
+func RunProcess(command []string) string {
+	var (
+		cmd            *exec.Cmd
+		stdout, stderr bytes.Buffer
+	)
+
+	switch len(command) {
+	case 1:
+		cmd = exec.Command(command[0], "") //nolint: gosec
+	default:
+		cmd = exec.Command(command[0], command[1:]...) //nolint: gosec
+	}
+
+	cmd.Dir = "/"
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+
+	if err != nil {
+		if stdout.String() != "" {
+			log.Printf("Unable to run '%s': %s, %s", strings.Join(command, " "), err, stdout.String())
+		} else {
+			log.Printf("Unable to run '%s': %s", strings.Join(command, " "), err)
+		}
+
+		return ""
+	}
+
+	if stderr.String() != "" {
+		log.Printf("%s: %s", strings.Join(command, " "), stderr.String())
+	}
+
+	return strings.TrimRight(stdout.String(), "\n")
+}

internal/lib/stdin.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"bufio"
@@ -26,7 +26,7 @@ type ClickEvent struct {
 
 // ParseStdin tries to parse text that i3bar prints to our stdin. Currently - it is mouse click events on different
 // area names of i3bar.
-func ParseStdin() {
+func (c *MyConfig) ParseStdin() {
 	reader := bufio.NewReader(os.Stdin)
 
 	// De-facto it is jsonl, except first line is garbage. Also, first symbol in each strint garbage too.
@@ -84,35 +84,35 @@ func ParseStdin() {
 
 		// Clock clicks parse.
 		if e.Name == "wallclock" {
-			if Conf.Clock.LeftClick.Enabled && e.Button == 1 {
-				RunChan <- Conf.Clock.LeftClick.Cmd
-			} else if Conf.Clock.RightClick.Enabled && e.Button == 3 {
-				RunChan <- Conf.Clock.RightClick.Cmd
+			if c.Clock.LeftClick.Enabled && e.Button == 1 {
+				c.Channels.RunChan <- c.Clock.LeftClick.Cmd
+			} else if c.Clock.RightClick.Enabled && e.Button == 3 {
+				c.Channels.RunChan <- c.Clock.RightClick.Cmd
 			}
 
 			continue
 		}
 
 		if e.Name == "simple-volume-pa" {
-			if Conf.SimpleVolumePa.Enabled {
-				SVPAHandlerChan <- e
+			if c.SimpleVolumePa.Enabled {
+				c.Channels.SVPAHandlerChan <- e
 			}
 
 			continue
 		}
 
-		if !Conf.AppButtons.Enabled {
+		if !c.AppButtons.Enabled {
 			continue
 		}
 
-		for _, app := range Conf.Apps {
+		for _, app := range c.Apps {
 			switch {
 			case app.Name != "" && app.Instance != "":
 				if app.Name == e.Name && app.Instance == e.Instance {
 					prg := append([]string{}, app.Cmd)
 					prg = append(prg, app.Args...)
 
-					RunChan <- prg
+					c.Channels.RunChan <- prg
 
 					break
 				}
@@ -120,13 +120,13 @@ func ParseStdin() {
 				prg := append([]string{}, app.Cmd)
 				prg = append(prg, app.Args...)
 
-				RunChan <- prg
+				c.Channels.RunChan <- prg
 
 			case app.Instance != "" && e.Instance == app.Instance:
 				prg := append([]string{}, app.Cmd)
 				prg = append(prg, app.Args...)
 
-				RunChan <- prg
+				c.Channels.RunChan <- prg
 			}
 		}
 	}

internal/lib/vpn.go

@@ -0,0 +1,102 @@
+package lib
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"time"
+)
+
+// UpdateVPNStatus periodically update status of openvpn daemon.
+func (c *MyConfig) UpdateVPNStatus() {
+	var (
+		vpnCStatus         string
+		tcpCheck           string
+		vpnCheck           string
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		if c.VPNFileCheck() {
+			if c.Vpn.UpColor == "" {
+				vpnCheck = `⍋`
+			} else {
+				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍋</span>`, c.Vpn.UpColor)
+			}
+		} else {
+			if c.Vpn.DownColor == "" {
+				vpnCheck = `⍒`
+			} else {
+				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍒</span>`, c.Vpn.DownColor)
+			}
+		}
+
+		if c.Vpn.TCPCheck.Enabled {
+			if c.VPNTCPCheck() {
+				if c.Vpn.UpColor == "" {
+					tcpCheck = `✔`
+				} else {
+					tcpCheck = fmt.Sprintf(`<span foreground="%s">✔</span>`, c.Vpn.UpColor)
+				}
+			} else {
+				if c.Vpn.DownColor == "" {
+					tcpCheck = `✘`
+				} else {
+					tcpCheck = fmt.Sprintf(`<span foreground="%s">✘</span>`, c.Vpn.DownColor)
+				}
+			}
+
+			vpnCStatus = fmt.Sprintf("VPN:%s:%s", vpnCheck, tcpCheck)
+		} else {
+			vpnCStatus = fmt.Sprintf("VPN:%s", vpnCheck)
+		}
+
+		if c.Values.VPNStatus != vpnCStatus {
+			c.Values.VPNStatus = vpnCStatus
+			c.Channels.UpdateReady <- true
+		}
+	}
+}
+
+// VPNTCPCheck intended to check arbitrary service inside vpn segment, to indicate that openvpn sevice not stoned.
+func (c *MyConfig) VPNTCPCheck() bool {
+	conn, err := net.DialTimeout(
+		"tcp",
+		fmt.Sprintf("%s:%d", c.Vpn.TCPCheck.Host, c.Vpn.TCPCheck.Port), //nolint: hostport
+		time.Second*time.Duration(c.Vpn.TCPCheck.Timeout),
+	)
+
+	if err == nil {
+		_ = conn.Close()
+
+		return true
+	}
+
+	return false
+}
+
+// VPNFileCheck checks modification time of openvpn-status file.
+func (c *MyConfig) VPNFileCheck() bool {
+	var (
+		fi  os.FileInfo
+		err error
+	)
+
+	if fi, err = os.Stat(c.Vpn.StatusFile); err != nil {
+		return false
+	}
+
+	if time.Since(fi.ModTime()).Seconds() > float64(c.Vpn.MtimeThreshold) {
+		return false
+	}
+
+	return true
+}

la.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/shirou/gopsutil/load"
-)
-
-// La переменная, хранящая значение LA за последнюю минуту.
-var La = "-1"
-
-// UpdateLaStats вытаскивает показание LA за последнюю минуту.
-func UpdateLaStats() {
-	for {
-		l, _ := load.Avg()
-
-		lav := fmt.Sprintf("%.2f", l.Load1)
-
-		if La != lav {
-			La = lav
-			UpdateReady <- true
-		}
-
-		time.Sleep(3 * time.Second)
-	}
-}

main.go

@@ -1,603 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"embed"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os/signal"
-	"strings"
-	"syscall"
-)
-
-// I3BarOutBlock is structure element for I3BarOut, it represents i3bar output json block format.
-type I3BarOutBlock struct {
-	FullText string `json:"full_text"`
-	// ShortText will be shown if not enough room for FullText, threshold width defined in MinWidth
-	ShortText    string `json:"short_text,omitempty"`
-	Color        string `json:"color,omitempty"`
-	Background   string `json:"background,omitempty"`
-	Border       string `json:"border,omitempty"`
-	BorderTop    int    `json:"border_top"`
-	BorderRight  int    `json:"border_right"`
-	BorderBottom int    `json:"border_bottom"`
-	BorderLeft   int    `json:"border_left"`
-	// measured either in pixels or in characters, so either int or string, let's make it string :)
-	MinWidth            string `json:"min_width,omitempty"`
-	Align               string `json:"align,omitempty"`
-	Name                string `json:"name,omitempty"`
-	Instance            string `json:"instance,omitempty"`
-	Urgent              bool   `json:"urgent,omitempty"`
-	Separator           bool   `json:"separator"`
-	SeparatorBlockWidth int    `json:"separator_block_width"`
-	Markup              string `json:"markup,omitempty"`
-}
-
-// UpdateReady channel that "refreshes" i3bar (generates stdout json line).
-var UpdateReady = make(chan bool)
-var MsgChan = make(chan []I3BarOutBlock, 64)
-
-//go:embed i3status-go-example.json
-var EmbeddedDefaultConfig embed.FS
-var DefaultConfig []byte
-
-func init() {
-	DefaultConfig, _ = EmbeddedDefaultConfig.ReadFile("i3status-go-example.json")
-}
-
-// Program entry point.
-func main() {
-	var err error
-
-	Conf, err = readConf()
-
-	// TODO: Проставить дефолтные значения для глобальных переменных модулей.
-	Batt = fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-		Conf.Battery.Color,
-		Conf.Battery.Background,
-		Conf.Battery.SymbolFont,
-		Conf.Battery.SymbolFontSize,
-		Conf.Battery.Symbol,
-	)
-
-	Batt += fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'> ??%% •</span>",
-		Conf.Battery.Color,
-		Conf.Battery.Background,
-		Conf.Battery.Font,
-		Conf.Battery.FontSize,
-	)
-
-	SoundVolume = fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>🔊</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.SymbolFont,
-		Conf.SimpleVolumePa.SymbolFontSize,
-	)
-
-	SoundVolume += fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>:0%%</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.Font,
-		Conf.SimpleVolumePa.FontSize,
-	)
-
-	Clock = fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>Thu, 1 Jan 1970   1:00</span>",
-		Conf.Clock.Color,
-		Conf.Clock.Background,
-		Conf.Clock.Font,
-		Conf.Clock.FontSize,
-	)
-
-	if err != nil {
-		log.Panicln(err)
-	}
-
-	go Spawner()
-	go ParseStdin()
-	go CleanZombies()
-	go SVPAHandler()
-	go PrintToI3bar()
-
-	if Conf.AppButtons.Enabled {
-		go UpdateI3WinList()
-	}
-
-	// Kick signal handler
-	go sigHandler()
-	signal.Notify(sigChan,
-		syscall.SIGUSR1,
-		syscall.SIGUSR2,
-		syscall.SIGQUIT,
-		syscall.SIGTERM,
-		syscall.SIGINT)
-
-	// Populate memory stats
-	if Conf.Mem.Enabled {
-		go UpdateMemStats()
-	}
-
-	// Populate LA stats
-	if Conf.LA.Enabled {
-		go UpdateLaStats()
-	}
-
-	// Populate CPUTemperature
-	if Conf.CPUTemp.Enabled {
-		go UpdateCPUTemperature()
-	}
-
-	// Populate Clock
-	if Conf.Clock.Enabled {
-		go UpdateClock()
-	}
-
-	if Conf.Battery.Enabled {
-		go UpdateBatteryInfo()
-	}
-
-	if Conf.SimpleVolumePa.Enabled {
-		go UpdateVolumeInfo()
-	}
-
-	if Conf.NetIf.Enabled {
-		go UpdateIfStatus()
-	}
-
-	if Conf.Cron.Enabled {
-		go RunCron()
-	}
-
-	if Conf.Vpn.Enabled {
-		go UpdateVPNStatus()
-	}
-
-	/*
-		I3bar documentation pretends that message protocol must be valid json. In practice, we only have to print valid
-		header, empty json array and (potentially infinite) json lines (line that is valid json by itself) that is
-		actually json arrays. We do not need to *close* this json at all.
-		Gracefully closed json required when i3bar initiates our program to stop|quit, this (should) happens just before
-		i3bar itself terminating. So we don't care.
-	*/
-
-	// Print header and one empty message and wait for updates
-	fmt.Printf(
-		"{\"version\": 1, \"stop_signal\": %d, \"cont_signal\": %d, \"click_events\": true}\n",
-		syscall.SIGUSR1,
-		syscall.SIGUSR2,
-	)
-
-	fmt.Println("[ [],")
-
-	for {
-		if <-UpdateReady {
-			// Actually build json struct, marshal it and print result
-			var j []I3BarOutBlock
-
-			// TODO: впилить для первого и последнего батона separator
-			if Conf.AppButtons.Enabled {
-				for num, app := range Conf.Apps {
-					var b I3BarOutBlock
-
-					if num == 0 {
-						b.FullText = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-							Conf.AppButtons.Separator.Left.Color,
-							Conf.AppButtons.Separator.Left.Background,
-							Conf.AppButtons.Separator.Left.Font,
-							Conf.AppButtons.Separator.Left.FontSize,
-							Conf.AppButtons.Separator.Left.Symbol,
-						)
-					}
-
-					b.FullText = app.FullText
-
-					if num == len(Conf.Apps) {
-						b.FullText = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-							Conf.AppButtons.Separator.Right.Color,
-							Conf.AppButtons.Separator.Right.Background,
-							Conf.AppButtons.Separator.Right.Font,
-							Conf.AppButtons.Separator.Right.FontSize,
-							Conf.AppButtons.Separator.Right.Symbol,
-						)
-					}
-
-					b.Background = app.Background
-					b.Color = app.Color
-					b.Instance = app.Instance
-					b.Markup = `pango`
-					b.Separator = app.Separator
-					b.SeparatorBlockWidth = app.SeparatorBlockWidth
-					b.Name = app.Name
-
-					if HasWindows(app.Class, app.Instance) {
-						b.Border = app.BorderActive
-					} else {
-						b.Border = app.Border
-					}
-
-					b.BorderTop = 1
-					b.BorderRight = 1
-					b.BorderBottom = 1
-					b.BorderLeft = 1
-
-					j = append(j, b)
-				}
-			}
-
-			if Conf.CPUTemp.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.CPUTemp.Color
-				b.Background = Conf.CPUTemp.Background
-
-				if Conf.CPUTemp.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.CPUTemp.Separator.Left.Color,
-						Conf.CPUTemp.Separator.Left.Background,
-						Conf.CPUTemp.Separator.Left.Font,
-						Conf.CPUTemp.Separator.Left.FontSize,
-						Conf.CPUTemp.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>CPU: %d°</span>",
-					Conf.CPUTemp.Color,
-					Conf.CPUTemp.Background,
-					Conf.CPUTemp.Font,
-					Conf.CPUTemp.FontSize,
-					CPUTemperature,
-				)
-
-				if Conf.CPUTemp.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.CPUTemp.Separator.Right.Color,
-						Conf.CPUTemp.Separator.Right.Background,
-						Conf.CPUTemp.Separator.Right.Font,
-						Conf.CPUTemp.Separator.Right.FontSize,
-						Conf.CPUTemp.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Mem.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.Mem.Color
-				b.Background = Conf.Mem.Background
-
-				if Conf.Mem.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Mem.Separator.Left.Color,
-						Conf.Mem.Separator.Left.Background,
-						Conf.Mem.Separator.Left.Font,
-						Conf.Mem.Separator.Left.FontSize,
-						Conf.Mem.Separator.Left.Symbol,
-					)
-				}
-
-				if Conf.Mem.ShowSwap {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM SW:%dM</span>",
-						Conf.Mem.Color,
-						Conf.Mem.Background,
-						Conf.Mem.Font,
-						Conf.Mem.FontSize,
-						Memory.Usedpct,
-						Memory.Shared,
-						Memory.Swap,
-					)
-				} else {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM</span>",
-						Conf.Mem.Color,
-						Conf.Mem.Background,
-						Conf.Mem.Font,
-						Conf.Mem.FontSize,
-						Memory.Usedpct,
-						Memory.Shared,
-					)
-				}
-
-				if Conf.Mem.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Mem.Separator.Right.Color,
-						Conf.Mem.Separator.Right.Background,
-						Conf.Mem.Separator.Right.Font,
-						Conf.Mem.Separator.Right.FontSize,
-						Conf.Mem.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.LA.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.LA.Color
-				b.Background = Conf.LA.Background
-
-				if Conf.LA.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.LA.Separator.Left.Color,
-						Conf.LA.Separator.Left.Background,
-						Conf.LA.Separator.Left.Font,
-						Conf.LA.Separator.Left.FontSize,
-						Conf.LA.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>LA:%s</span>",
-					Conf.LA.Color,
-					Conf.LA.Background,
-					Conf.LA.Font,
-					Conf.LA.FontSize,
-					La,
-				)
-
-				if Conf.LA.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.LA.Separator.Right.Color,
-						Conf.LA.Separator.Right.Background,
-						Conf.LA.Separator.Right.Font,
-						Conf.LA.Separator.Right.FontSize,
-						Conf.LA.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.NetIf.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.NetIf.Color
-				b.Background = Conf.NetIf.Background
-
-				if Conf.NetIf.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.NetIf.Separator.Left.Color,
-						Conf.NetIf.Separator.Left.Background,
-						Conf.NetIf.Separator.Left.Font,
-						Conf.NetIf.Separator.Left.FontSize,
-						Conf.NetIf.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size= '%s'>%s</span>",
-					Conf.NetIf.Color,
-					Conf.NetIf.Background,
-					Conf.NetIf.Font,
-					Conf.NetIf.FontSize,
-					IfStatus,
-				)
-
-				if Conf.NetIf.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.NetIf.Separator.Right.Color,
-						Conf.NetIf.Separator.Right.Background,
-						Conf.NetIf.Separator.Right.Font,
-						Conf.NetIf.Separator.Right.FontSize,
-						Conf.NetIf.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Vpn.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.Vpn.Color
-				b.Background = Conf.Vpn.Background
-
-				if Conf.Vpn.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Vpn.Separator.Left.Color,
-						Conf.Vpn.Separator.Left.Background,
-						Conf.Vpn.Separator.Left.Font,
-						Conf.Vpn.Separator.Left.FontSize,
-						Conf.Vpn.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-					Conf.Vpn.Color,
-					Conf.Vpn.Background,
-					Conf.Vpn.Font,
-					Conf.Vpn.FontSize,
-					VPNStatus,
-				)
-
-				if Conf.Vpn.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Vpn.Separator.Right.Color,
-						Conf.Vpn.Separator.Right.Background,
-						Conf.Vpn.Separator.Right.Font,
-						Conf.Vpn.Separator.Right.FontSize,
-						Conf.Vpn.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Battery.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.Battery.Color
-				b.Background = Conf.Battery.Background
-
-				if Conf.Battery.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Battery.Separator.Left.Color,
-						Conf.Battery.Separator.Left.Background,
-						Conf.Battery.Separator.Left.Font,
-						Conf.Battery.Separator.Left.FontSize,
-						Conf.Battery.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += Batt
-
-				if Conf.Battery.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Battery.Separator.Right.Color,
-						Conf.Battery.Separator.Right.Background,
-						Conf.Battery.Separator.Right.Font,
-						Conf.Battery.Separator.Right.FontSize,
-						Conf.Battery.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.SimpleVolumePa.Enabled {
-				var b I3BarOutBlock
-
-				b.Name = "simple-volume-pa"
-				b.Color = Conf.SimpleVolumePa.Color
-				b.Background = Conf.SimpleVolumePa.Background
-
-				if Conf.SimpleVolumePa.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.SimpleVolumePa.Separator.Left.Color,
-						Conf.SimpleVolumePa.Separator.Left.Background,
-						Conf.SimpleVolumePa.Separator.Left.Font,
-						Conf.SimpleVolumePa.Separator.Left.FontSize,
-						Conf.SimpleVolumePa.Separator.Left.Symbol,
-					)
-				}
-
-				// Pango format is already applied in plugin src.
-				b.FullText += SoundVolume
-
-				if Conf.SimpleVolumePa.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.SimpleVolumePa.Separator.Right.Color,
-						Conf.SimpleVolumePa.Separator.Right.Background,
-						Conf.SimpleVolumePa.Separator.Right.Font,
-						Conf.SimpleVolumePa.Separator.Right.FontSize,
-						Conf.SimpleVolumePa.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Clock.Enabled {
-				var b I3BarOutBlock
-
-				b.Name = `wallclock`
-				b.Color = Conf.Clock.Color
-				b.Background = Conf.Clock.Background
-
-				if Conf.Clock.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Clock.Separator.Left.Color,
-						Conf.Clock.Separator.Left.Background,
-						Conf.Clock.Separator.Left.Font,
-						Conf.Clock.Separator.Left.FontSize,
-						Conf.Clock.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-					Conf.Clock.Color,
-					Conf.Clock.Background,
-					Conf.Clock.Font,
-					Conf.Clock.FontSize,
-					Clock,
-				)
-
-				if Conf.Clock.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Clock.Separator.Right.Color,
-						Conf.Clock.Separator.Right.Background,
-						Conf.Clock.Separator.Right.Font,
-						Conf.Clock.Separator.Right.FontSize,
-						Conf.Clock.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if PrintOutput && len(j) > 0 {
-				MsgChan <- j
-			}
-		}
-	}
-}
-
-// PrintToI3bar prints info to stdout according to ipc docs (https://i3wm.org/docs/i3bar-protocol.html)
-func PrintToI3bar() {
-	for message := range MsgChan {
-		// we do not need to html-encode output, json.Marshal does this forcefully, so invent our own Marshal
-		buf := new(bytes.Buffer)
-		encoder := json.NewEncoder(buf)
-		encoder.SetEscapeHTML(false)
-		err := encoder.Encode(message)
-
-		if err != nil {
-			log.Printf("Unable to json-encode message, %s\n", err)
-		}
-
-		fmt.Println(strings.TrimSuffix(buf.String(), "\n") + ",")
-	}
-}

memory.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"log"
-	"time"
-
-	"github.com/shirou/gopsutil/mem"
-)
-
-// Mem struct with mem stats.
-type Mem struct {
-	Usedpct uint64
-	Shared  uint64
-	Swap    uint64
-}
-
-// Memory stores string with mem stats for i3bar.
-var Memory Mem
-
-// UpdateMemStats parses mem info stats.
-func UpdateMemStats() {
-	for {
-		v, err := mem.VirtualMemory()
-
-		if err != nil {
-			log.Printf("Unable to get memory statistics: %s", err)
-			time.Sleep(1 * time.Second)
-
-			continue
-		}
-
-		sw, err := mem.SwapMemory()
-
-		if err != nil {
-			log.Printf("Unable to get swap statistics: %s", err)
-			time.Sleep(1 * time.Second)
-
-			continue
-		}
-
-		if Conf.Mem.ShowSwap {
-			if Memory.Usedpct != uint64(v.UsedPercent) || Memory.Shared != v.Shared/1024/1024 ||
-				Memory.Swap != v.SwapTotal-v.SwapFree {
-				Memory.Usedpct = uint64(v.UsedPercent)
-				Memory.Shared = v.Shared / 1024 / 1024
-				Memory.Swap = sw.Used
-				UpdateReady <- true
-			}
-		} else {
-			if Memory.Usedpct != uint64(v.UsedPercent) || Memory.Shared != v.Shared/1024/1024 {
-				Memory.Usedpct = uint64(v.UsedPercent)
-				Memory.Shared = v.Shared / 1024 / 1024
-				UpdateReady <- true
-			}
-		}
-
-		time.Sleep(3 * time.Second)
-	}
-}

spawn.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-	"os/exec"
-	"syscall"
-	"time"
-)
-
-// RunChan to this channel we send command and its argv to execute as separate process.
-var RunChan = make(chan []string, 128)
-
-// Spawner forks and execs given program, and also detaches form its control tty.
-func Spawner() {
-	for prg := range RunChan {
-		devnullR, _ := os.Open(os.DevNull)
-		devnullW, _ := os.OpenFile(os.DevNull, os.O_WRONLY|os.O_APPEND, 0644)
-
-		spa := syscall.SysProcAttr{
-			Setsid:     true,
-			Foreground: false,
-		}
-
-		pa := syscall.ProcAttr{
-			Dir:   os.Getenv(`HOME`),
-			Env:   os.Environ(),
-			Files: []uintptr{devnullR.Fd(), devnullW.Fd(), devnullW.Fd()},
-			Sys:   &spa,
-		}
-
-		bin, err := exec.LookPath(prg[0])
-
-		if err != nil {
-			log.Printf("Unable to spawn %s: %s", prg[0], err)
-		}
-
-		_, err = syscall.ForkExec(bin, prg, &pa)
-
-		if err != nil {
-			log.Printf("Unable to spawn %s: %s", prg[0], err)
-		}
-
-		// Close file errors we don't handle :) at all.
-		_ = devnullR.Close()
-		_ = devnullW.Close()
-	}
-}
-
-// CleanZombies reaps processes spawned by Spawner() and already exited.
-func CleanZombies() {
-	r := syscall.Rusage{}
-
-	for {
-		_, _ = syscall.Wait4(-1, nil, 0, &r)
-
-		time.Sleep(1 * time.Minute)
-	}
-}

vendor/github.com/adrg/xdg/README.md

@@ -41,8 +41,9 @@ Provides an implementation of the [XDG Base Directory Specification](https://spe
 The specification defines a set of standard paths for storing application files,
 including data and configuration files. For portability and flexibility reasons,
 applications should use the XDG defined locations instead of hardcoding paths.
-The package also includes the locations of well known [user directories](https://wiki.archlinux.org/index.php/XDG_user_directories), as well as
-other common directories such as fonts and applications.
+
+The package also includes the locations of well known [user directories](https://wiki.archlinux.org/index.php/XDG_user_directories),
+support for the non-standard `XDG_BIN_HOME` directory, as well as other common directories such as fonts and applications.
 
 The current implementation supports **most flavors of Unix**, **Windows**, **macOS** and **Plan 9**.  
 On Windows, where XDG environment variables are not usually set, the package uses [Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/known-folders)
@@ -71,14 +72,15 @@ Sensible fallback locations are used for the folders which are not set.
     <br/>
 
 | <a href="#xdg-base-directory"><img width="400" height="0"></a> | <a href="#xdg-base-directory"><img width="500" height="0"></a><p>Unix</p> | <a href="#xdg-base-directory"><img width="600" height="0"></a><p>macOS</p>                                                                          | <a href="#xdg-base-directory"><img width="500" height="0"></a><p>Plan 9</p> |
-| :------------------------------------------------------------: | :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------: |
+| :------------------------------------------------------------: | :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------: |
 | <kbd><b>XDG_DATA_HOME</b></kbd>                                | <kbd>~/.local/share</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>$home/lib</kbd>                                                        |
-| <kbd><b>XDG_DATA_DIRS</b></kbd>                                | <kbd>/usr/local/share</kbd><br/><kbd>/usr/share</kbd>                     | <kbd>/Library/Application&nbsp;Support</kbd>                                                                          | <kbd>/lib</kbd>                                                             |
+| <kbd><b>XDG_DATA_DIRS</b></kbd>                                | <kbd>/usr/local/share</kbd><br/><kbd>/usr/share</kbd>                     | <kbd>/Library/Application&nbsp;Support</kbd><kbd>~/.local/share</kbd>                                                                               | <kbd>/lib</kbd>                                                             |
 | <kbd><b>XDG_CONFIG_HOME</b></kbd>                              | <kbd>~/.config</kbd>                                                      | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>$home/lib</kbd>                                                        |
-| <kbd><b>XDG_CONFIG_DIRS</b></kbd>                              | <kbd>/etc/xdg</kbd>                                                       | <kbd>~/Library/Preferences</kbd><br/><kbd>/Library/Application&nbsp;Support</kbd><br/><kbd>/Library/Preferences</kbd> | <kbd>/lib</kbd>                                                             |
+| <kbd><b>XDG_CONFIG_DIRS</b></kbd>                              | <kbd>/etc/xdg</kbd>                                                       | <kbd>~/Library/Preferences</kbd><br/><kbd>/Library/Application&nbsp;Support</kbd><br/><kbd>/Library/Preferences</kbd><br/><kbd>&#126;/.config</kbd> | <kbd>/lib</kbd>                                                             |
 | <kbd><b>XDG_STATE_HOME</b></kbd>                               | <kbd>~/.local/state</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>$home/lib/state</kbd>                                                  |
 | <kbd><b>XDG_CACHE_HOME</b></kbd>                               | <kbd>~/.cache</kbd>                                                       | <kbd>~/Library/Caches</kbd>                                                                                                                         | <kbd>$home/lib/cache</kbd>                                                  |
-| <kbd><b>XDG_RUNTIME_DIR</b></kbd>                              | <kbd>/run/user/UID</kbd>                                                  | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                         | <kbd>/tmp</kbd>                                                             |
+| <kbd><b>XDG_RUNTIME_DIR</b></kbd>                              | <kbd>/run/user/$UID</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>/tmp</kbd>                                                             |
+| <kbd><b>XDG_BIN_HOME</b></kbd>                                 | <kbd>~/.local/bin</kbd>                                                   | <kbd>~/.local/bin</kbd>                                                                                                                             | <kbd>$home/bin</kbd>                                                        |
 
 </details>
 
@@ -95,6 +97,7 @@ Sensible fallback locations are used for the folders which are not set.
 | <kbd><b>XDG_STATE_HOME</b></kbd>                               | <kbd>LocalAppData</kbd>                                                                   | <kbd>%LOCALAPPDATA%</kbd>                                                        |
 | <kbd><b>XDG_CACHE_HOME</b></kbd>                               | <kbd>LocalAppData\cache</kbd>                                                             | <kbd>%LOCALAPPDATA%\cache</kbd>                                                  |
 | <kbd><b>XDG_RUNTIME_DIR</b></kbd>                              | <kbd>LocalAppData</kbd>                                                                   | <kbd>%LOCALAPPDATA%</kbd>                                                        |
+| <kbd><b>XDG_BIN_HOME</b></kbd>                                 | <kbd>UserProgramFiles</kbd>                                                               | <kbd>%LOCALAPPDATA%\Programs</kbd>                                               |
 
 </details>
 
@@ -164,9 +167,9 @@ as shown in the following tables.
     <br/>
 
 | <a href="#other-directories"><img width="400" height="0"></a> | <a href="#other-directories"><img width="300" height="0"></a><p>Known&nbsp;Folder(s)</p>                                                                                               | <a href="#other-directories"><img width="1300" height="0"></a><p>Fallback(s)</p>                                                                                                                                                                                                                     |
-| :-----------------------------------------------------------: | :--------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------: |
+| :-----------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
 | <kbd><b>Home</b></kbd>                                        | <kbd>Profile</kbd>                                                                                                                                                                     | <kbd>%USERPROFILE%</kbd>                                                                                                                                                                                                                                                                             |
-| <kbd><b>Applications</b></kbd>                                | <kbd>Programs</kbd><br/><kbd>CommonPrograms</kbd>                                        | <kbd>%APPDATA%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd><br/><kbd>%ProgramData%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd> |
+| <kbd><b>Applications</b></kbd>                                | <kbd>Programs</kbd><br/><kbd>CommonPrograms</kbd> <br/><kbd>ProgramFiles</kbd><br/><kbd>ProgramFilesCommon</kbd><br/><kbd>UserProgramFiles</kbd><br/><kbd>UserProgramFilesCommon</kbd> | <kbd>%APPDATA%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd><br/><kbd>%ProgramData%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd><br/><kbd>%ProgramFiles%</kbd><br/><kbd>%ProgramFiles%\Common Files</kbd><br/><kbd>%LOCALAPPDATA%\Programs</kbd><br/><kbd>%LOCALAPPDATA%\Programs\Common</kbd>|
 | <kbd><b>Fonts</b></kbd>                                       | <kbd>Fonts</kbd>                                                                                                                                                                       | <kbd>%SystemRoot%\Fonts</kbd><br/><kbd>%LOCALAPPDATA%\Microsoft\Windows\Fonts</kbd>                                                                                                                                                                                                                  |
 
 </details>
@@ -193,6 +196,7 @@ func main() {
 	log.Println("Home state directory:", xdg.StateHome)
 	log.Println("Cache directory:", xdg.CacheHome)
 	log.Println("Runtime directory:", xdg.RuntimeDir)
+	log.Println("Home binaries directory:", xdg.BinHome)
 
 	// Other common directories.
 	log.Println("Home directory:", xdg.Home)
@@ -203,6 +207,9 @@ func main() {
 	// ConfigFile takes one parameter which must contain the name of the file,
 	// but it can also contain a set of parent directories. If the directories
 	// don't exist, they will be created relative to the base config directory.
+	// It is recommended for files to be saved inside an application directory
+	// relative to the base directory rather than directly inside the base
+	// directory (e.g. `appname/config.yaml` instead of `appname-config.yaml`).
 	configFilePath, err := xdg.ConfigFile("appname/config.yaml")
 	if err != nil {
 		log.Fatal(err)
@@ -277,7 +284,8 @@ See [CONTRIBUTING.MD](CONTRIBUTING.md).
 [djdv](https://github.com/djdv),
 [rrjjvv](https://github.com/rrjjvv),
 [GreyXor](https://github.com/GreyXor),
-[Rican7](https://github.com/Rican7).
+[Rican7](https://github.com/Rican7),
+[nothub](https://github.com/nothub).
 
 ## References
 

vendor/github.com/adrg/xdg/base_dirs.go

@@ -1,6 +1,10 @@
 package xdg
 
-import "github.com/adrg/xdg/internal/pathutil"
+import (
+	"os"
+
+	"github.com/adrg/xdg/internal/pathutil"
+)
 
 // XDG Base Directory environment variables.
 const (
@@ -11,6 +15,9 @@ const (
 	envStateHome  = "XDG_STATE_HOME"
 	envCacheHome  = "XDG_CACHE_HOME"
 	envRuntimeDir = "XDG_RUNTIME_DIR"
+
+	// Non-standard.
+	envBinHome = "XDG_BIN_HOME"
 )
 
 type baseDirectories struct {
@@ -22,7 +29,8 @@ type baseDirectories struct {
 	cacheHome  string
 	runtime    string
 
-	// Non-standard directories.
+	// Non-standard.
+	binHome      string
 	fonts        []string
 	applications []string
 }
@@ -44,7 +52,13 @@ func (bd baseDirectories) cacheFile(relPath string) (string, error) {
 }
 
 func (bd baseDirectories) runtimeFile(relPath string) (string, error) {
-	return pathutil.Create(relPath, []string{bd.runtime})
+	var paths []string
+	for _, p := range pathutil.Unique([]string{bd.runtime, os.TempDir()}) {
+		if pathutil.Exists(p) {
+			paths = append(paths, p)
+		}
+	}
+	return pathutil.Create(relPath, paths)
 }
 
 func (bd baseDirectories) searchDataFile(relPath string) (string, error) {
@@ -64,5 +78,5 @@ func (bd baseDirectories) searchCacheFile(relPath string) (string, error) {
 }
 
 func (bd baseDirectories) searchRuntimeFile(relPath string) (string, error) {
-	return pathutil.Search(relPath, []string{bd.runtime})
+	return pathutil.Search(relPath, pathutil.Unique([]string{bd.runtime, os.TempDir()}))
 }

vendor/github.com/adrg/xdg/doc.go

@@ -16,9 +16,10 @@ The current implementation supports most flavors of Unix, Windows, Mac OS and Pl
 	For more information regarding the Windows Known Folders see:
 	https://docs.microsoft.com/en-us/windows/win32/shell/known-folders
 
-Usage
+# Usage
 
 XDG Base Directory
+
 	package main
 
 	import (
@@ -36,6 +37,7 @@ XDG Base Directory
 		log.Println("Home state directory:", xdg.StateHome)
 		log.Println("Cache directory:", xdg.CacheHome)
 		log.Println("Runtime directory:", xdg.RuntimeDir)
+		log.Println("Home binaries directory:", xdg.BinHome)
 
 		// Other common directories.
 		log.Println("Home directory:", xdg.Home)
@@ -46,6 +48,9 @@ XDG Base Directory
 		// ConfigFile takes one parameter which must contain the name of the file,
 		// but it can also contain a set of parent directories. If the directories
 		// don't exist, they will be created relative to the base config directory.
+		// It is recommended for files to be saved inside an application directory
+		// relative to the base directory rather than directly inside the base
+		// directory (e.g. `appname/config.yaml` instead of `appname-config.yaml`).
 		configFilePath, err := xdg.ConfigFile("appname/config.yaml")
 		if err != nil {
 			log.Fatal(err)
@@ -76,6 +81,7 @@ XDG Base Directory
 	}
 
 XDG user directories
+
 	package main
 
 	import (

vendor/github.com/adrg/xdg/internal/pathutil/pathutil.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 )
 
 // Unique eliminates the duplicate paths from the provided slice and returns
@@ -52,7 +51,6 @@ func First(paths []string) string {
 // relative to the selected parent path.
 func Create(name string, paths []string) (string, error) {
 	searchedPaths := make([]string, 0, len(paths))
-
 	for _, p := range paths {
 		p = filepath.Join(p, name)
 
@@ -67,8 +65,8 @@ func Create(name string, paths []string) (string, error) {
 		searchedPaths = append(searchedPaths, dir)
 	}
 
-	return "", fmt.Errorf("could not create any of the following paths: %s",
-		strings.Join(searchedPaths, ", "))
+	return "", fmt.Errorf("could not create any of the following paths: %v",
+		searchedPaths)
 }
 
 // Search searches for the file with the specified `name` in the provided
@@ -76,7 +74,6 @@ func Create(name string, paths []string) (string, error) {
 // but it can also contain a set of parent directories.
 func Search(name string, paths []string) (string, error) {
 	searchedPaths := make([]string, 0, len(paths))
-
 	for _, p := range paths {
 		p = filepath.Join(p, name)
 		if Exists(p) {
@@ -86,8 +83,8 @@ func Search(name string, paths []string) (string, error) {
 		searchedPaths = append(searchedPaths, filepath.Dir(p))
 	}
 
-	return "", fmt.Errorf("could not locate `%s` in any of the following paths: %s",
-		filepath.Base(name), strings.Join(searchedPaths, ", "))
+	return "", fmt.Errorf("could not locate `%s` in any of the following paths: %v",
+		filepath.Base(name), searchedPaths)
 }
 
 // EnvPath returns the value of the environment variable with the specified

vendor/github.com/adrg/xdg/paths_darwin.go

@@ -18,18 +18,24 @@ func initBaseDirs(home string) {
 
 	// Initialize standard directories.
 	baseDirs.dataHome = pathutil.EnvPath(envDataHome, homeAppSupport)
-	baseDirs.data = pathutil.EnvPathList(envDataDirs, rootAppSupport)
+	baseDirs.data = pathutil.EnvPathList(envDataDirs,
+		rootAppSupport,
+		filepath.Join(home, ".local", "share"),
+	)
 	baseDirs.configHome = pathutil.EnvPath(envConfigHome, homeAppSupport)
 	baseDirs.config = pathutil.EnvPathList(envConfigDirs,
 		filepath.Join(home, "Library", "Preferences"),
 		rootAppSupport,
 		"/Library/Preferences",
+		filepath.Join(home, ".config"),
 	)
 	baseDirs.stateHome = pathutil.EnvPath(envStateHome, homeAppSupport)
 	baseDirs.cacheHome = pathutil.EnvPath(envCacheHome, filepath.Join(home, "Library", "Caches"))
 	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, homeAppSupport)
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, filepath.Join(home, ".local", "bin"))
+
 	baseDirs.applications = []string{
 		"/Applications",
 	}

vendor/github.com/adrg/xdg/paths_plan9.go

@@ -26,6 +26,8 @@ func initBaseDirs(home string) {
 	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, "/tmp")
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, filepath.Join(home, "bin"))
+
 	baseDirs.applications = []string{
 		filepath.Join(home, "bin"),
 		"/bin",

vendor/github.com/adrg/xdg/paths_unix.go

@@ -27,6 +27,8 @@ func initBaseDirs(home string) {
 	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, filepath.Join("/run/user", strconv.Itoa(os.Getuid())))
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, filepath.Join(home, ".local", "bin"))
+
 	appDirs := []string{
 		filepath.Join(baseDirs.dataHome, "applications"),
 		filepath.Join(home, ".local/share/applications"),

vendor/github.com/adrg/xdg/paths_windows.go

@@ -25,10 +25,17 @@ func initBaseDirs(home string, kf *knownFolders) {
 	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, kf.localAppData)
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, kf.userProgramFiles)
+
 	baseDirs.applications = []string{
 		kf.programs,
 		kf.commonPrograms,
+		kf.programFiles,
+		kf.programFilesCommon,
+		kf.userProgramFiles,
+		kf.userProgramFilesCommon,
 	}
+
 	baseDirs.fonts = []string{
 		kf.fonts,
 		filepath.Join(kf.localAppData, "Microsoft", "Windows", "Fonts"),
@@ -65,6 +72,10 @@ type knownFolders struct {
 	fonts                  string
 	programs               string
 	commonPrograms         string
+	programFiles           string
+	programFilesCommon     string
+	userProgramFiles       string
+	userProgramFilesCommon string
 }
 
 func initKnownFolders(home string) *knownFolders {
@@ -156,6 +167,30 @@ func initKnownFolders(home string) *knownFolders {
 		nil,
 		[]string{filepath.Join(kf.programData, "Microsoft", "Windows", "Start Menu", "Programs")},
 	)
+	kf.programFiles = pathutil.KnownFolder(
+		windows.FOLDERID_ProgramFiles,
+		[]string{"ProgramFiles"},
+		[]string{filepath.Join(kf.systemDrive, "Program Files")},
+	)
+	kf.programFilesCommon = pathutil.KnownFolder(
+		windows.FOLDERID_ProgramFilesCommon,
+		nil,
+		[]string{filepath.Join(kf.programFiles, "Common Files")},
+	)
+	kf.userProgramFiles = pathutil.KnownFolder(
+		windows.FOLDERID_UserProgramFiles,
+		nil,
+		[]string{
+			filepath.Join(kf.localAppData, "Programs"),
+		},
+	)
+	kf.userProgramFilesCommon = pathutil.KnownFolder(
+		windows.FOLDERID_UserProgramFilesCommon,
+		nil,
+		[]string{
+			filepath.Join(kf.userProgramFiles, "Common"),
+		},
+	)
 
 	return kf
 }

vendor/github.com/adrg/xdg/xdg.go

@@ -67,6 +67,12 @@ var (
 	// swapped out to disk.
 	RuntimeDir string
 
+	// BinHome defines the base directory relative to which user-specific
+	// binary files should be written. This directory is defined by
+	// the non-standard $XDG_BIN_HOME environment variable. If the variable is
+	// not set, a default equal to $HOME/.local/bin should be used.
+	BinHome string
+
 	// UserDirs defines the locations of well known user directories.
 	UserDirs UserDirectories
 
@@ -104,6 +110,7 @@ func Reload() {
 	RuntimeDir = baseDirs.runtime
 
 	// Set non-standard directories.
+	BinHome = baseDirs.binHome
 	FontDirs = baseDirs.fonts
 	ApplicationDirs = baseDirs.applications
 }
@@ -154,8 +161,9 @@ func CacheFile(relPath string) (string, error) {
 // The relPath parameter must contain the name of the runtime file, and
 // optionally, a set of parent directories (e.g. appname/app.pid).
 // If the specified directories do not exist, they will be created relative
-// to the base runtime directory. On failure, an error containing the
-// attempted paths is returned.
+// to the base runtime directory. If the base runtime directory does not exist,
+// the operating system's temporary directory is used as a fallback. On failure,
+// an error containing the attempted paths is returned.
 func RuntimeFile(relPath string) (string, error) {
 	return baseDirs.runtimeFile(relPath)
 }
@@ -194,8 +202,11 @@ func SearchCacheFile(relPath string) (string, error) {
 
 // SearchRuntimeFile searches for the specified file in the runtime search path.
 // The relPath parameter must contain the name of the runtime file, and
-// optionally, a set of parent directories (e.g. appname/app.pid). If the
-// file cannot be found, an error specifying the searched path is returned.
+// optionally, a set of parent directories (e.g. appname/app.pid). The runtime
+// file is also searched in the operating system's temporary directory in order
+// to cover cases in which the runtime base directory does not exist or is not
+// accessible. If the file cannot be found, an error specifying the searched
+// paths is returned.
 func SearchRuntimeFile(relPath string) (string, error) {
 	return baseDirs.searchRuntimeFile(relPath)
 }

vendor/github.com/davecgh/go-spew/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/davecgh/go-spew/spew/bypass.go

@@ -0,0 +1,145 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// Go versions prior to 1.4 are disabled because they use a different layout
+// for interfaces which make the implementation of unsafeReflectValue more complex.
+// +build !js,!appengine,!safe,!disableunsafe,go1.4
+
+package spew
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = false
+
+	// ptrSize is the size of a pointer on the current arch.
+	ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+type flag uintptr
+
+var (
+	// flagRO indicates whether the value field of a reflect.Value
+	// is read-only.
+	flagRO flag
+
+	// flagAddr indicates whether the address of the reflect.Value's
+	// value may be taken.
+	flagAddr flag
+)
+
+// flagKindMask holds the bits that make up the kind
+// part of the flags field. In all the supported versions,
+// it is in the lower 5 bits.
+const flagKindMask = flag(0x1f)
+
+// Different versions of Go have used different
+// bit layouts for the flags type. This table
+// records the known combinations.
+var okFlags = []struct {
+	ro, addr flag
+}{{
+	// From Go 1.4 to 1.5
+	ro:   1 << 5,
+	addr: 1 << 7,
+}, {
+	// Up to Go tip.
+	ro:   1<<5 | 1<<6,
+	addr: 1 << 8,
+}}
+
+var flagValOffset = func() uintptr {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	return field.Offset
+}()
+
+// flagField returns a pointer to the flag field of a reflect.Value.
+func flagField(v *reflect.Value) *flag {
+	return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data.  It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
+		return v
+	}
+	flagFieldPtr := flagField(&v)
+	*flagFieldPtr &^= flagRO
+	*flagFieldPtr |= flagAddr
+	return v
+}
+
+// Sanity checks against future reflect package changes
+// to the type or semantics of the Value.flag field.
+func init() {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
+		panic("reflect.Value flag field has changed kind")
+	}
+	type t0 int
+	var t struct {
+		A t0
+		// t0 will have flagEmbedRO set.
+		t0
+		// a will have flagStickyRO set
+		a t0
+	}
+	vA := reflect.ValueOf(t).FieldByName("A")
+	va := reflect.ValueOf(t).FieldByName("a")
+	vt0 := reflect.ValueOf(t).FieldByName("t0")
+
+	// Infer flagRO from the difference between the flags
+	// for the (otherwise identical) fields in t.
+	flagPublic := *flagField(&vA)
+	flagWithRO := *flagField(&va) | *flagField(&vt0)
+	flagRO = flagPublic ^ flagWithRO
+
+	// Infer flagAddr from the difference between a value
+	// taken from a pointer and not.
+	vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
+	flagNoPtr := *flagField(&vA)
+	flagPtr := *flagField(&vPtrA)
+	flagAddr = flagNoPtr ^ flagPtr
+
+	// Check that the inferred flags tally with one of the known versions.
+	for _, f := range okFlags {
+		if flagRO == f.ro && flagAddr == f.addr {
+			return
+		}
+	}
+	panic("reflect.Value read-only flag has changed semantics")
+}

vendor/github.com/davecgh/go-spew/spew/bypasssafe.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is running on Google App Engine, compiled by GopherJS, or
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build js appengine safe disableunsafe !go1.4
+
+package spew
+
+import "reflect"
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data.  However, doing this relies on access to
+// the unsafe package.  This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	return v
+}

vendor/github.com/davecgh/go-spew/spew/common.go

@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+)
+
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
+// the technique used in the fmt package.
+var (
+	panicBytes            = []byte("(PANIC=")
+	plusBytes             = []byte("+")
+	iBytes                = []byte("i")
+	trueBytes             = []byte("true")
+	falseBytes            = []byte("false")
+	interfaceBytes        = []byte("(interface {})")
+	commaNewlineBytes     = []byte(",\n")
+	newlineBytes          = []byte("\n")
+	openBraceBytes        = []byte("{")
+	openBraceNewlineBytes = []byte("{\n")
+	closeBraceBytes       = []byte("}")
+	asteriskBytes         = []byte("*")
+	colonBytes            = []byte(":")
+	colonSpaceBytes       = []byte(": ")
+	openParenBytes        = []byte("(")
+	closeParenBytes       = []byte(")")
+	spaceBytes            = []byte(" ")
+	pointerChainBytes     = []byte("->")
+	nilAngleBytes         = []byte("<nil>")
+	maxNewlineBytes       = []byte("<max depth reached>\n")
+	maxShortBytes         = []byte("<max>")
+	circularBytes         = []byte("<already shown>")
+	circularShortBytes    = []byte("<shown>")
+	invalidAngleBytes     = []byte("<invalid>")
+	openBracketBytes      = []byte("[")
+	closeBracketBytes     = []byte("]")
+	percentBytes          = []byte("%")
+	precisionBytes        = []byte(".")
+	openAngleBytes        = []byte("<")
+	closeAngleBytes       = []byte(">")
+	openMapBytes          = []byte("map[")
+	closeMapBytes         = []byte("]")
+	lenEqualsBytes        = []byte("len=")
+	capEqualsBytes        = []byte("cap=")
+)
+
+// hexDigits is used to map a decimal value to a hex digit.
+var hexDigits = "0123456789abcdef"
+
+// catchPanic handles any panics that might occur during the handleMethods
+// calls.
+func catchPanic(w io.Writer, v reflect.Value) {
+	if err := recover(); err != nil {
+		w.Write(panicBytes)
+		fmt.Fprintf(w, "%v", err)
+		w.Write(closeParenBytes)
+	}
+}
+
+// handleMethods attempts to call the Error and String methods on the underlying
+// type the passed reflect.Value represents and outputes the result to Writer w.
+//
+// It handles panics in any called methods by catching and displaying the error
+// as the formatted value.
+func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
+	// We need an interface to check if the type implements the error or
+	// Stringer interface.  However, the reflect package won't give us an
+	// interface on certain things like unexported struct fields in order
+	// to enforce visibility rules.  We use unsafe, when it's available,
+	// to bypass these restrictions since this package does not mutate the
+	// values.
+	if !v.CanInterface() {
+		if UnsafeDisabled {
+			return false
+		}
+
+		v = unsafeReflectValue(v)
+	}
+
+	// Choose whether or not to do error and Stringer interface lookups against
+	// the base type or a pointer to the base type depending on settings.
+	// Technically calling one of these methods with a pointer receiver can
+	// mutate the value, however, types which choose to satisify an error or
+	// Stringer interface with a pointer receiver should not be mutating their
+	// state inside these interface methods.
+	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
+		v = unsafeReflectValue(v)
+	}
+	if v.CanAddr() {
+		v = v.Addr()
+	}
+
+	// Is it an error or Stringer?
+	switch iface := v.Interface().(type) {
+	case error:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.Error()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+
+		w.Write([]byte(iface.Error()))
+		return true
+
+	case fmt.Stringer:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.String()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+		w.Write([]byte(iface.String()))
+		return true
+	}
+	return false
+}
+
+// printBool outputs a boolean value as true or false to Writer w.
+func printBool(w io.Writer, val bool) {
+	if val {
+		w.Write(trueBytes)
+	} else {
+		w.Write(falseBytes)
+	}
+}
+
+// printInt outputs a signed integer value to Writer w.
+func printInt(w io.Writer, val int64, base int) {
+	w.Write([]byte(strconv.FormatInt(val, base)))
+}
+
+// printUint outputs an unsigned integer value to Writer w.
+func printUint(w io.Writer, val uint64, base int) {
+	w.Write([]byte(strconv.FormatUint(val, base)))
+}
+
+// printFloat outputs a floating point value using the specified precision,
+// which is expected to be 32 or 64bit, to Writer w.
+func printFloat(w io.Writer, val float64, precision int) {
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+}
+
+// printComplex outputs a complex value using the specified float precision
+// for the real and imaginary parts to Writer w.
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
+	r := real(c)
+	w.Write(openParenBytes)
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+	i := imag(c)
+	if i >= 0 {
+		w.Write(plusBytes)
+	}
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+	w.Write(iBytes)
+	w.Write(closeParenBytes)
+}
+
+// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
+// prefix to Writer w.
+func printHexPtr(w io.Writer, p uintptr) {
+	// Null pointer.
+	num := uint64(p)
+	if num == 0 {
+		w.Write(nilAngleBytes)
+		return
+	}
+
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+	buf := make([]byte, 18)
+
+	// It's simpler to construct the hex string right to left.
+	base := uint64(16)
+	i := len(buf) - 1
+	for num >= base {
+		buf[i] = hexDigits[num%base]
+		num /= base
+		i--
+	}
+	buf[i] = hexDigits[num]
+
+	// Add '0x' prefix.
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+
+	// Strip unused leading bytes.
+	buf = buf[i:]
+	w.Write(buf)
+}
+
+// valuesSorter implements sort.Interface to allow a slice of reflect.Value
+// elements to be sorted.
+type valuesSorter struct {
+	values  []reflect.Value
+	strings []string // either nil or same len and values
+	cs      *ConfigState
+}
+
+// newValuesSorter initializes a valuesSorter instance, which holds a set of
+// surrogate keys on which the data should be sorted.  It uses flags in
+// ConfigState to decide if and how to populate those surrogate keys.
+func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
+	vs := &valuesSorter{values: values, cs: cs}
+	if canSortSimply(vs.values[0].Kind()) {
+		return vs
+	}
+	if !cs.DisableMethods {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			b := bytes.Buffer{}
+			if !handleMethods(cs, &b, vs.values[i]) {
+				vs.strings = nil
+				break
+			}
+			vs.strings[i] = b.String()
+		}
+	}
+	if vs.strings == nil && cs.SpewKeys {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
+		}
+	}
+	return vs
+}
+
+// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
+// directly, or whether it should be considered for sorting by surrogate keys
+// (if the ConfigState allows it).
+func canSortSimply(kind reflect.Kind) bool {
+	// This switch parallels valueSortLess, except for the default case.
+	switch kind {
+	case reflect.Bool:
+		return true
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return true
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return true
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Uintptr:
+		return true
+	case reflect.Array:
+		return true
+	}
+	return false
+}
+
+// Len returns the number of values in the slice.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Len() int {
+	return len(s.values)
+}
+
+// Swap swaps the values at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Swap(i, j int) {
+	s.values[i], s.values[j] = s.values[j], s.values[i]
+	if s.strings != nil {
+		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
+	}
+}
+
+// valueSortLess returns whether the first value should sort before the second
+// value.  It is used by valueSorter.Less as part of the sort.Interface
+// implementation.
+func valueSortLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return a.Int() < b.Int()
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return a.Uint() < b.Uint()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.String:
+		return a.String() < b.String()
+	case reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Array:
+		// Compare the contents of both arrays.
+		l := a.Len()
+		for i := 0; i < l; i++ {
+			av := a.Index(i)
+			bv := b.Index(i)
+			if av.Interface() == bv.Interface() {
+				continue
+			}
+			return valueSortLess(av, bv)
+		}
+	}
+	return a.String() < b.String()
+}
+
+// Less returns whether the value at index i should sort before the
+// value at index j.  It is part of the sort.Interface implementation.
+func (s *valuesSorter) Less(i, j int) bool {
+	if s.strings == nil {
+		return valueSortLess(s.values[i], s.values[j])
+	}
+	return s.strings[i] < s.strings[j]
+}
+
+// sortValues is a sort function that handles both native types and any type that
+// can be converted to error or Stringer.  Other inputs are sorted according to
+// their Value.String() value to ensure display stability.
+func sortValues(values []reflect.Value, cs *ConfigState) {
+	if len(values) == 0 {
+		return
+	}
+	sort.Sort(newValuesSorter(values, cs))
+}

vendor/github.com/davecgh/go-spew/spew/config.go

@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+// ConfigState houses the configuration options used by spew to format and
+// display values.  There is a global instance, Config, that is used to control
+// all top-level Formatter and Dump functionality.  Each ConfigState instance
+// provides methods equivalent to the top-level functions.
+//
+// The zero value for ConfigState provides no indentation.  You would typically
+// want to set it to a space or a tab.
+//
+// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
+// with default settings.  See the documentation of NewDefaultConfig for default
+// values.
+type ConfigState struct {
+	// Indent specifies the string to use for each indentation level.  The
+	// global config instance that all top-level functions use set this to a
+	// single space by default.  If you would like more indentation, you might
+	// set this to a tab with "\t" or perhaps two spaces with "  ".
+	Indent string
+
+	// MaxDepth controls the maximum number of levels to descend into nested
+	// data structures.  The default, 0, means there is no limit.
+	//
+	// NOTE: Circular data structures are properly detected, so it is not
+	// necessary to set this value unless you specifically want to limit deeply
+	// nested data structures.
+	MaxDepth int
+
+	// DisableMethods specifies whether or not error and Stringer interfaces are
+	// invoked for types that implement them.
+	DisableMethods bool
+
+	// DisablePointerMethods specifies whether or not to check for and invoke
+	// error and Stringer interfaces on types which only accept a pointer
+	// receiver when the current type is not a pointer.
+	//
+	// NOTE: This might be an unsafe action since calling one of these methods
+	// with a pointer receiver could technically mutate the value, however,
+	// in practice, types which choose to satisify an error or Stringer
+	// interface with a pointer receiver should not be mutating their state
+	// inside these interface methods.  As a result, this option relies on
+	// access to the unsafe package, so it will not have any effect when
+	// running in environments without access to the unsafe package such as
+	// Google App Engine or with the "safe" build tag specified.
+	DisablePointerMethods bool
+
+	// DisablePointerAddresses specifies whether to disable the printing of
+	// pointer addresses. This is useful when diffing data structures in tests.
+	DisablePointerAddresses bool
+
+	// DisableCapacities specifies whether to disable the printing of capacities
+	// for arrays, slices, maps and channels. This is useful when diffing
+	// data structures in tests.
+	DisableCapacities bool
+
+	// ContinueOnMethod specifies whether or not recursion should continue once
+	// a custom error or Stringer interface is invoked.  The default, false,
+	// means it will print the results of invoking the custom error or Stringer
+	// interface and return immediately instead of continuing to recurse into
+	// the internals of the data type.
+	//
+	// NOTE: This flag does not have any effect if method invocation is disabled
+	// via the DisableMethods or DisablePointerMethods options.
+	ContinueOnMethod bool
+
+	// SortKeys specifies map keys should be sorted before being printed. Use
+	// this to have a more deterministic, diffable output.  Note that only
+	// native types (bool, int, uint, floats, uintptr and string) and types
+	// that support the error or Stringer interfaces (if methods are
+	// enabled) are supported, with other types sorted according to the
+	// reflect.Value.String() output which guarantees display stability.
+	SortKeys bool
+
+	// SpewKeys specifies that, as a last resort attempt, map keys should
+	// be spewed to strings and sorted by those strings.  This is only
+	// considered if SortKeys is true.
+	SpewKeys bool
+}
+
+// Config is the active configuration of the top-level functions.
+// The configuration can be changed by modifying the contents of spew.Config.
+var Config = ConfigState{Indent: " "}
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the formatted string as a value that satisfies error.  See NewFormatter
+// for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, c.convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, c.convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, c.convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a Formatter interface returned by c.NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, c.convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(c.convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, c.convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(c.convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprint(a ...interface{}) string {
+	return fmt.Sprint(c.convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, c.convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a Formatter interface returned by c.NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(c.convertArgs(a)...)
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+c.Printf, c.Println, or c.Printf.
+*/
+func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(c, v)
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
+	fdump(c, w, a...)
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by modifying the public members
+of c.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func (c *ConfigState) Dump(a ...interface{}) {
+	fdump(c, os.Stdout, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func (c *ConfigState) Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(c, &buf, a...)
+	return buf.String()
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a spew Formatter interface using
+// the ConfigState associated with s.
+func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = newFormatter(c, arg)
+	}
+	return formatters
+}
+
+// NewDefaultConfig returns a ConfigState with the following default settings.
+//
+// 	Indent: " "
+// 	MaxDepth: 0
+// 	DisableMethods: false
+// 	DisablePointerMethods: false
+// 	ContinueOnMethod: false
+// 	SortKeys: false
+func NewDefaultConfig() *ConfigState {
+	return &ConfigState{Indent: " "}
+}

vendor/github.com/davecgh/go-spew/spew/doc.go

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package spew implements a deep pretty printer for Go data structures to aid in
+debugging.
+
+A quick overview of the additional features spew provides over the built-in
+printing facilities for Go data types are as follows:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output (only when using
+	  Dump style)
+
+There are two different approaches spew allows for dumping Go data structures:
+
+	* Dump style which prints with newlines, customizable indentation,
+	  and additional debug information such as types and all pointer addresses
+	  used to indirect to the final value
+	* A custom Formatter interface that integrates cleanly with the standard fmt
+	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+	  similar to the default %v while providing the additional functionality
+	  outlined above and passing unsupported format verbs such as %x and %q
+	  along to fmt
+
+Quick Start
+
+This section demonstrates how to quickly get started with spew.  See the
+sections below for further details on formatting and configuration options.
+
+To dump a variable with full newlines, indentation, type, and pointer
+information use Dump, Fdump, or Sdump:
+	spew.Dump(myVar1, myVar2, ...)
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Alternatively, if you would prefer to use format strings with a compacted inline
+printing style, use the convenience wrappers Printf, Fprintf, etc with
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+%#+v (adds types and pointer addresses):
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+Configuration Options
+
+Configuration of spew is handled by fields in the ConfigState type.  For
+convenience, all of the top-level functions use a global state available
+via the spew.Config global.
+
+It is also possible to create a ConfigState instance that provides methods
+equivalent to the top-level functions.  This allows concurrent configuration
+options.  See the ConfigState documentation for more details.
+
+The following configuration options are available:
+	* Indent
+		String to use for each indentation level for Dump functions.
+		It is a single space by default.  A popular alternative is "\t".
+
+	* MaxDepth
+		Maximum number of levels to descend into nested data structures.
+		There is no limit by default.
+
+	* DisableMethods
+		Disables invocation of error and Stringer interface methods.
+		Method invocation is enabled by default.
+
+	* DisablePointerMethods
+		Disables invocation of error and Stringer interface methods on types
+		which only accept pointer receivers from non-pointer variables.
+		Pointer method invocation is enabled by default.
+
+	* DisablePointerAddresses
+		DisablePointerAddresses specifies whether to disable the printing of
+		pointer addresses. This is useful when diffing data structures in tests.
+
+	* DisableCapacities
+		DisableCapacities specifies whether to disable the printing of
+		capacities for arrays, slices, maps and channels. This is useful when
+		diffing data structures in tests.
+
+	* ContinueOnMethod
+		Enables recursion into types after invoking error and Stringer interface
+		methods. Recursion after method invocation is disabled by default.
+
+	* SortKeys
+		Specifies map keys should be sorted before being printed. Use
+		this to have a more deterministic, diffable output.  Note that
+		only native types (bool, int, uint, floats, uintptr and string)
+		and types which implement error or Stringer interfaces are
+		supported with other types sorted according to the
+		reflect.Value.String() output which guarantees display
+		stability.  Natural map order is used by default.
+
+	* SpewKeys
+		Specifies that, as a last resort attempt, map keys should be
+		spewed to strings and sorted by those strings.  This is only
+		considered if SortKeys is true.
+
+Dump Usage
+
+Simply call spew.Dump with a list of variables you want to dump:
+
+	spew.Dump(myVar1, myVar2, ...)
+
+You may also call spew.Fdump if you would prefer to output to an arbitrary
+io.Writer.  For example, to dump to standard error:
+
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+
+A third option is to call spew.Sdump to get the formatted output as a string:
+
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Sample Dump Output
+
+See the Dump example for details on the setup of the types and variables being
+shown here.
+
+	(main.Foo) {
+	 unexportedField: (*main.Bar)(0xf84002e210)({
+	  flag: (main.Flag) flagTwo,
+	  data: (uintptr) <nil>
+	 }),
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
+	  (string) (len=3) "one": (bool) true
+	 }
+	}
+
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+command as shown.
+	([]uint8) (len=32 cap=32) {
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	 00000020  31 32                                             |12|
+	}
+
+Custom Formatter
+
+Spew provides a custom formatter that implements the fmt.Formatter interface
+so that it integrates cleanly with standard fmt package printing functions. The
+formatter is useful for inline printing of smaller data types similar to the
+standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Custom Formatter Usage
+
+The simplest way to make use of the spew custom formatter is to call one of the
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
+functions have syntax you are most likely already familiar with:
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Println(myVar, myVar2)
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+See the Index for the full list convenience functions.
+
+Sample Formatter Output
+
+Double pointer to a uint8:
+	  %v: <**>5
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
+	 %#v: (**uint8)5
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+
+Pointer to circular struct with a uint8 field and a pointer to itself:
+	  %v: <*>{1 <*><shown>}
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+
+See the Printf example for details on the setup of variables being shown
+here.
+
+Errors
+
+Since it is possible for custom Stringer/error interfaces to panic, spew
+detects them and handles them internally by printing the panic information
+inline with the output.  Since spew is intended to provide deep pretty printing
+capabilities on structures, it intentionally does not return any errors.
+*/
+package spew

vendor/github.com/davecgh/go-spew/spew/dump.go

@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	// uint8Type is a reflect.Type representing a uint8.  It is used to
+	// convert cgo types to uint8 slices for hexdumping.
+	uint8Type = reflect.TypeOf(uint8(0))
+
+	// cCharRE is a regular expression that matches a cgo char.
+	// It is used to detect character arrays to hexdump them.
+	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
+
+	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
+	// char.  It is used to detect unsigned character arrays to hexdump
+	// them.
+	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
+
+	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
+	// It is used to detect uint8_t arrays to hexdump them.
+	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
+)
+
+// dumpState contains information about the state of a dump operation.
+type dumpState struct {
+	w                io.Writer
+	depth            int
+	pointers         map[uintptr]int
+	ignoreNextType   bool
+	ignoreNextIndent bool
+	cs               *ConfigState
+}
+
+// indent performs indentation according to the depth level and cs.Indent
+// option.
+func (d *dumpState) indent() {
+	if d.ignoreNextIndent {
+		d.ignoreNextIndent = false
+		return
+	}
+	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		v = v.Elem()
+	}
+	return v
+}
+
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
+func (d *dumpState) dumpPtr(v reflect.Value) {
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range d.pointers {
+		if depth >= d.depth {
+			delete(d.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by dereferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		d.pointers[addr] = d.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type information.
+	d.w.Write(openParenBytes)
+	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
+	d.w.Write([]byte(ve.Type().String()))
+	d.w.Write(closeParenBytes)
+
+	// Display pointer information.
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
+		d.w.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				d.w.Write(pointerChainBytes)
+			}
+			printHexPtr(d.w, addr)
+		}
+		d.w.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	d.w.Write(openParenBytes)
+	switch {
+	case nilFound:
+		d.w.Write(nilAngleBytes)
+
+	case cycleFound:
+		d.w.Write(circularBytes)
+
+	default:
+		d.ignoreNextType = true
+		d.dump(ve)
+	}
+	d.w.Write(closeParenBytes)
+}
+
+// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
+// reflection) arrays and slices are dumped in hexdump -C fashion.
+func (d *dumpState) dumpSlice(v reflect.Value) {
+	// Determine whether this type should be hex dumped or not.  Also,
+	// for types which should be hexdumped, try to use the underlying data
+	// first, then fall back to trying to convert them to a uint8 slice.
+	var buf []uint8
+	doConvert := false
+	doHexDump := false
+	numEntries := v.Len()
+	if numEntries > 0 {
+		vt := v.Index(0).Type()
+		vts := vt.String()
+		switch {
+		// C types that need to be converted.
+		case cCharRE.MatchString(vts):
+			fallthrough
+		case cUnsignedCharRE.MatchString(vts):
+			fallthrough
+		case cUint8tCharRE.MatchString(vts):
+			doConvert = true
+
+		// Try to use existing uint8 slices and fall back to converting
+		// and copying if that fails.
+		case vt.Kind() == reflect.Uint8:
+			// We need an addressable interface to convert the type
+			// to a byte slice.  However, the reflect package won't
+			// give us an interface on certain things like
+			// unexported struct fields in order to enforce
+			// visibility rules.  We use unsafe, when available, to
+			// bypass these restrictions since this package does not
+			// mutate the values.
+			vs := v
+			if !vs.CanInterface() || !vs.CanAddr() {
+				vs = unsafeReflectValue(vs)
+			}
+			if !UnsafeDisabled {
+				vs = vs.Slice(0, numEntries)
+
+				// Use the existing uint8 slice if it can be
+				// type asserted.
+				iface := vs.Interface()
+				if slice, ok := iface.([]uint8); ok {
+					buf = slice
+					doHexDump = true
+					break
+				}
+			}
+
+			// The underlying data needs to be converted if it can't
+			// be type asserted to a uint8 slice.
+			doConvert = true
+		}
+
+		// Copy and convert the underlying type if needed.
+		if doConvert && vt.ConvertibleTo(uint8Type) {
+			// Convert and copy each element into a uint8 byte
+			// slice.
+			buf = make([]uint8, numEntries)
+			for i := 0; i < numEntries; i++ {
+				vv := v.Index(i)
+				buf[i] = uint8(vv.Convert(uint8Type).Uint())
+			}
+			doHexDump = true
+		}
+	}
+
+	// Hexdump the entire slice as needed.
+	if doHexDump {
+		indent := strings.Repeat(d.cs.Indent, d.depth)
+		str := indent + hex.Dump(buf)
+		str = strings.Replace(str, "\n", "\n"+indent, -1)
+		str = strings.TrimRight(str, d.cs.Indent)
+		d.w.Write([]byte(str))
+		return
+	}
+
+	// Recursively call dump for each item.
+	for i := 0; i < numEntries; i++ {
+		d.dump(d.unpackValue(v.Index(i)))
+		if i < (numEntries - 1) {
+			d.w.Write(commaNewlineBytes)
+		} else {
+			d.w.Write(newlineBytes)
+		}
+	}
+}
+
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
+// value to figure out what kind of object we are dealing with and formats it
+// appropriately.  It is a recursive function, however circular data structures
+// are detected and handled properly.
+func (d *dumpState) dump(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		d.w.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		d.indent()
+		d.dumpPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !d.ignoreNextType {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(v.Type().String()))
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+	d.ignoreNextType = false
+
+	// Display length and capacity if the built-in len and cap functions
+	// work with the value's kind and the len/cap itself is non-zero.
+	valueLen, valueCap := 0, 0
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Chan:
+		valueLen, valueCap = v.Len(), v.Cap()
+	case reflect.Map, reflect.String:
+		valueLen = v.Len()
+	}
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
+		d.w.Write(openParenBytes)
+		if valueLen != 0 {
+			d.w.Write(lenEqualsBytes)
+			printInt(d.w, int64(valueLen), 10)
+		}
+		if !d.cs.DisableCapacities && valueCap != 0 {
+			if valueLen != 0 {
+				d.w.Write(spaceBytes)
+			}
+			d.w.Write(capEqualsBytes)
+			printInt(d.w, int64(valueCap), 10)
+		}
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+
+	// Call Stringer/error interfaces if they exist and the handle methods flag
+	// is enabled
+	if !d.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(d.cs, d.w, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(d.w, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(d.w, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(d.w, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(d.w, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(d.w, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(d.w, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(d.w, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			d.dumpSlice(v)
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.String:
+		d.w.Write([]byte(strconv.Quote(v.String())))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			numEntries := v.Len()
+			keys := v.MapKeys()
+			if d.cs.SortKeys {
+				sortValues(keys, d.cs)
+			}
+			for i, key := range keys {
+				d.dump(d.unpackValue(key))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.MapIndex(key)))
+				if i < (numEntries - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Struct:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			vt := v.Type()
+			numFields := v.NumField()
+			for i := 0; i < numFields; i++ {
+				d.indent()
+				vtf := vt.Field(i)
+				d.w.Write([]byte(vtf.Name))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.Field(i)))
+				if i < (numFields - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(d.w, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(d.w, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it in case any new
+	// types are added.
+	default:
+		if v.CanInterface() {
+			fmt.Fprintf(d.w, "%v", v.Interface())
+		} else {
+			fmt.Fprintf(d.w, "%v", v.String())
+		}
+	}
+}
+
+// fdump is a helper function to consolidate the logic from the various public
+// methods which take varying writers and config states.
+func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
+	for _, arg := range a {
+		if arg == nil {
+			w.Write(interfaceBytes)
+			w.Write(spaceBytes)
+			w.Write(nilAngleBytes)
+			w.Write(newlineBytes)
+			continue
+		}
+
+		d := dumpState{w: w, cs: cs}
+		d.pointers = make(map[uintptr]int)
+		d.dump(reflect.ValueOf(arg))
+		d.w.Write(newlineBytes)
+	}
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func Fdump(w io.Writer, a ...interface{}) {
+	fdump(&Config, w, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(&Config, &buf, a...)
+	return buf.String()
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by an exported package global,
+spew.Config.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func Dump(a ...interface{}) {
+	fdump(&Config, os.Stdout, a...)
+}

vendor/github.com/davecgh/go-spew/spew/format.go

@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// supportedFlags is a list of all the character flags supported by fmt package.
+const supportedFlags = "0-+# "
+
+// formatState implements the fmt.Formatter interface and contains information
+// about the state of a formatting operation.  The NewFormatter function can
+// be used to get a new Formatter which can be used directly as arguments
+// in standard fmt package printing calls.
+type formatState struct {
+	value          interface{}
+	fs             fmt.State
+	depth          int
+	pointers       map[uintptr]int
+	ignoreNextType bool
+	cs             *ConfigState
+}
+
+// buildDefaultFormat recreates the original format string without precision
+// and width information to pass in to fmt.Sprintf in the case of an
+// unrecognized type.  Unless new types are added to the language, this
+// function won't ever be called.
+func (f *formatState) buildDefaultFormat() (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	buf.WriteRune('v')
+
+	format = buf.String()
+	return format
+}
+
+// constructOrigFormat recreates the original format string including precision
+// and width information to pass along to the standard fmt package.  This allows
+// automatic deferral of all format strings this package doesn't support.
+func (f *formatState) constructOrigFormat(verb rune) (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	if width, ok := f.fs.Width(); ok {
+		buf.WriteString(strconv.Itoa(width))
+	}
+
+	if precision, ok := f.fs.Precision(); ok {
+		buf.Write(precisionBytes)
+		buf.WriteString(strconv.Itoa(precision))
+	}
+
+	buf.WriteRune(verb)
+
+	format = buf.String()
+	return format
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible and
+// ensures that types for values which have been unpacked from an interface
+// are displayed when the show types flag is also set.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface {
+		f.ignoreNextType = false
+		if !v.IsNil() {
+			v = v.Elem()
+		}
+	}
+	return v
+}
+
+// formatPtr handles formatting of pointers by indirecting them as necessary.
+func (f *formatState) formatPtr(v reflect.Value) {
+	// Display nil if top level pointer is nil.
+	showTypes := f.fs.Flag('#')
+	if v.IsNil() && (!showTypes || f.ignoreNextType) {
+		f.fs.Write(nilAngleBytes)
+		return
+	}
+
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range f.pointers {
+		if depth >= f.depth {
+			delete(f.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to possibly show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by derferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		f.pointers[addr] = f.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type or indirection level depending on flags.
+	if showTypes && !f.ignoreNextType {
+		f.fs.Write(openParenBytes)
+		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
+		f.fs.Write([]byte(ve.Type().String()))
+		f.fs.Write(closeParenBytes)
+	} else {
+		if nilFound || cycleFound {
+			indirects += strings.Count(ve.Type().String(), "*")
+		}
+		f.fs.Write(openAngleBytes)
+		f.fs.Write([]byte(strings.Repeat("*", indirects)))
+		f.fs.Write(closeAngleBytes)
+	}
+
+	// Display pointer information depending on flags.
+	if f.fs.Flag('+') && (len(pointerChain) > 0) {
+		f.fs.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				f.fs.Write(pointerChainBytes)
+			}
+			printHexPtr(f.fs, addr)
+		}
+		f.fs.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	switch {
+	case nilFound:
+		f.fs.Write(nilAngleBytes)
+
+	case cycleFound:
+		f.fs.Write(circularShortBytes)
+
+	default:
+		f.ignoreNextType = true
+		f.format(ve)
+	}
+}
+
+// format is the main workhorse for providing the Formatter interface.  It
+// uses the passed reflect value to figure out what kind of object we are
+// dealing with and formats it appropriately.  It is a recursive function,
+// however circular data structures are detected and handled properly.
+func (f *formatState) format(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		f.fs.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		f.formatPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !f.ignoreNextType && f.fs.Flag('#') {
+		f.fs.Write(openParenBytes)
+		f.fs.Write([]byte(v.Type().String()))
+		f.fs.Write(closeParenBytes)
+	}
+	f.ignoreNextType = false
+
+	// Call Stringer/error interfaces if they exist and the handle methods
+	// flag is enabled.
+	if !f.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(f.cs, f.fs, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(f.fs, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(f.fs, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(f.fs, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(f.fs, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(f.fs, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(f.fs, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(f.fs, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		f.fs.Write(openBracketBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			numEntries := v.Len()
+			for i := 0; i < numEntries; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.Index(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBracketBytes)
+
+	case reflect.String:
+		f.fs.Write([]byte(v.String()))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+
+		f.fs.Write(openMapBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			keys := v.MapKeys()
+			if f.cs.SortKeys {
+				sortValues(keys, f.cs)
+			}
+			for i, key := range keys {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(key))
+				f.fs.Write(colonBytes)
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.MapIndex(key)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeMapBytes)
+
+	case reflect.Struct:
+		numFields := v.NumField()
+		f.fs.Write(openBraceBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			vt := v.Type()
+			for i := 0; i < numFields; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				vtf := vt.Field(i)
+				if f.fs.Flag('+') || f.fs.Flag('#') {
+					f.fs.Write([]byte(vtf.Name))
+					f.fs.Write(colonBytes)
+				}
+				f.format(f.unpackValue(v.Field(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(f.fs, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(f.fs, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it if any get added.
+	default:
+		format := f.buildDefaultFormat()
+		if v.CanInterface() {
+			fmt.Fprintf(f.fs, format, v.Interface())
+		} else {
+			fmt.Fprintf(f.fs, format, v.String())
+		}
+	}
+}
+
+// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
+// details.
+func (f *formatState) Format(fs fmt.State, verb rune) {
+	f.fs = fs
+
+	// Use standard formatting for verbs that are not v.
+	if verb != 'v' {
+		format := f.constructOrigFormat(verb)
+		fmt.Fprintf(fs, format, f.value)
+		return
+	}
+
+	if f.value == nil {
+		if fs.Flag('#') {
+			fs.Write(interfaceBytes)
+		}
+		fs.Write(nilAngleBytes)
+		return
+	}
+
+	f.format(reflect.ValueOf(f.value))
+}
+
+// newFormatter is a helper function to consolidate the logic from the various
+// public methods which take varying config states.
+func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
+	fs := &formatState{value: v, cs: cs}
+	fs.pointers = make(map[uintptr]int)
+	return fs
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+Printf, Println, or Fprintf.
+*/
+func NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(&Config, v)
+}

vendor/github.com/davecgh/go-spew/spew/spew.go

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"fmt"
+	"io"
+)
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the formatted string as a value that satisfies error.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a default Formatter interface returned by NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
+func Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
+func Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprint(a ...interface{}) string {
+	return fmt.Sprint(convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(convertArgs(a)...)
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a default spew Formatter interface.
+func convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = NewFormatter(arg)
+	}
+	return formatters
+}

vendor/github.com/go-co-op/gocron/v2/.golangci.yaml

@@ -20,10 +20,9 @@ issues:
 linters:
   enable:
     - bodyclose
-    - exportloopref
+    - copyloopvar
     - gofumpt
     - goimports
-    - gosec
     - gosimple
     - govet
     - ineffassign
@@ -39,6 +38,5 @@ output:
     - format: colored-line-number
   print-issued-lines: true
   print-linter-name: true
-  uniq-by-line: true
   path-prefix: ""
   sort-results: true

vendor/github.com/go-co-op/gocron/v2/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/golangci/golangci-lint
-    rev: v1.55.2
+    rev: v1.64.5
     hooks:
       - id: golangci-lint
   - repo: https://github.com/TekWizely/pre-commit-golang

vendor/github.com/go-co-op/gocron/v2/Makefile

@@ -6,7 +6,7 @@ fmt:
 	@go list -f {{.Dir}} ./... | xargs -I{} gofmt -w -s {}
 
 lint:
-	@grep "^func " example_test.go | sort -c
+	@grep "^func [a-zA-Z]" example_test.go | sort -c
 	@golangci-lint run
 
 test:
@@ -16,7 +16,7 @@ test_coverage:
 	@go test -race -v $(GO_FLAGS) -count=1 -coverprofile=coverage.out -covermode=atomic $(GO_PKGS)
 
 test_ci:
-	@TEST_ENV=ci go test -race -v $(GO_FLAGS) -count=1 $(GO_PKGS)
+	@go test -race -v $(GO_FLAGS) -count=1 $(GO_PKGS)
 
 mocks:
 	@go generate ./...

vendor/github.com/go-co-op/gocron/v2/README.md

@@ -151,6 +151,7 @@ The provided NewLogger uses the standard library's log package.
 ### Metrics
 Metrics may be collected from the execution of each job.
 - [**Monitor**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#Monitor):
+- [**MonitorStatus**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#MonitorStatus) (includes status and error (if any) of the Job)
 A monitor can be used to collect metrics for each job from a scheduler.
   - Implementations: [go-co-op monitors](https://github.com/go-co-op?q=-monitor&type=all&language=&sort=)
     (don't see what you need? request on slack to get a repo created to contribute it!)
@@ -168,8 +169,20 @@ We appreciate the support for free and open source software!
 
 This project is supported by:
 
-- [Jetbrains](https://www.jetbrains.com/?from=gocron)
-- [Sentry](https://sentry.io/welcome/)
+[Jetbrains](https://www.jetbrains.com/?from=gocron)
+
+![JetBrains logo](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.png)
+
+
+[Sentry](https://sentry.io/welcome/)
+
+<p align="left">
+  <p align="left">
+    <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+      <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84" />
+    </a>
+  </p>
+</p>
 
 ## Star History
 

vendor/github.com/go-co-op/gocron/v2/errors.go

@@ -4,10 +4,12 @@ import "fmt"
 
 // Public error definitions
 var (
+	ErrCronJobInvalid                = fmt.Errorf("gocron: CronJob: invalid crontab")
 	ErrCronJobParse                  = fmt.Errorf("gocron: CronJob: crontab parse failure")
 	ErrDailyJobAtTimeNil             = fmt.Errorf("gocron: DailyJob: atTime within atTimes must not be nil")
 	ErrDailyJobAtTimesNil            = fmt.Errorf("gocron: DailyJob: atTimes must not be nil")
 	ErrDailyJobHours                 = fmt.Errorf("gocron: DailyJob: atTimes hours must be between 0 and 23 inclusive")
+	ErrDailyJobZeroInterval          = fmt.Errorf("gocron: DailyJob: interval must be greater than 0")
 	ErrDailyJobMinutesSeconds        = fmt.Errorf("gocron: DailyJob: atTimes minutes and seconds must be between 0 and 59 inclusive")
 	ErrDurationJobIntervalZero       = fmt.Errorf("gocron: DurationJob: time interval is 0")
 	ErrDurationRandomJobMinMax       = fmt.Errorf("gocron: DurationRandomJob: minimum duration must be less than maximum duration")
@@ -19,6 +21,7 @@ var (
 	ErrMonthlyJobAtTimesNil          = fmt.Errorf("gocron: MonthlyJob: atTimes must not be nil")
 	ErrMonthlyJobDaysNil             = fmt.Errorf("gocron: MonthlyJob: daysOfTheMonth must not be nil")
 	ErrMonthlyJobHours               = fmt.Errorf("gocron: MonthlyJob: atTimes hours must be between 0 and 23 inclusive")
+	ErrMonthlyJobZeroInterval        = fmt.Errorf("gocron: MonthlyJob: interval must be greater than 0")
 	ErrMonthlyJobMinutesSeconds      = fmt.Errorf("gocron: MonthlyJob: atTimes minutes and seconds must be between 0 and 59 inclusive")
 	ErrNewJobTaskNil                 = fmt.Errorf("gocron: NewJob: Task must not be nil")
 	ErrNewJobTaskNotFunc             = fmt.Errorf("gocron: NewJob: Task.Function must be of kind reflect.Func")
@@ -32,9 +35,11 @@ var (
 	ErrWeeklyJobAtTimesNil           = fmt.Errorf("gocron: WeeklyJob: atTimes must not be nil")
 	ErrWeeklyJobDaysOfTheWeekNil     = fmt.Errorf("gocron: WeeklyJob: daysOfTheWeek must not be nil")
 	ErrWeeklyJobHours                = fmt.Errorf("gocron: WeeklyJob: atTimes hours must be between 0 and 23 inclusive")
+	ErrWeeklyJobZeroInterval         = fmt.Errorf("gocron: WeeklyJob: interval must be greater than 0")
 	ErrWeeklyJobMinutesSeconds       = fmt.Errorf("gocron: WeeklyJob: atTimes minutes and seconds must be between 0 and 59 inclusive")
 	ErrPanicRecovered                = fmt.Errorf("gocron: panic recovered")
 	ErrWithClockNil                  = fmt.Errorf("gocron: WithClock: clock must not be nil")
+	ErrWithContextNil                = fmt.Errorf("gocron: WithContext: context must not be nil")
 	ErrWithDistributedElectorNil     = fmt.Errorf("gocron: WithDistributedElector: elector must not be nil")
 	ErrWithDistributedLockerNil      = fmt.Errorf("gocron: WithDistributedLocker: locker must not be nil")
 	ErrWithDistributedJobLockerNil   = fmt.Errorf("gocron: WithDistributedJobLocker: locker must not be nil")

vendor/github.com/go-co-op/gocron/v2/executor.go

@@ -31,8 +31,13 @@ type executor struct {
 	// used to request jobs from the scheduler
 	jobOutRequest chan jobOutRequest
 
+	// sends out job needs to update the next runs
+	jobUpdateNextRuns chan uuid.UUID
+
 	// used by the executor to receive a stop signal from the scheduler
 	stopCh chan struct{}
+	// ensure that stop runs before the next call to start and only runs once
+	stopOnce *sync.Once
 	// the timeout value when stopping
 	stopTimeout time.Duration
 	// used to signal that the executor has completed shutdown
@@ -49,6 +54,8 @@ type executor struct {
 	locker Locker
 	// monitor for reporting metrics
 	monitor Monitor
+	// monitorStatus for reporting metrics
+	monitorStatus MonitorStatus
 }
 
 type jobIn struct {
@@ -83,6 +90,7 @@ func (e *executor) start() {
 	// any other uses within the executor should create a context
 	// using the executor context as parent.
 	e.ctx, e.cancel = context.WithCancel(context.Background())
+	e.stopOnce = &sync.Once{}
 
 	// the standardJobsWg tracks
 	standardJobsWg := &waitGroupWithMutex{}
@@ -126,7 +134,7 @@ func (e *executor) start() {
 
 			// spin off into a goroutine to unblock the executor and
 			// allow for processing for more work
-			go func() {
+			go func(executorCtx context.Context) {
 				// make sure to cancel the above context per the docs
 				// // Canceling this context releases resources associated with it, so code should
 				// // call cancel as soon as the operations running in this Context complete.
@@ -196,7 +204,7 @@ func (e *executor) start() {
 							default:
 								// runner is busy, reschedule the work for later
 								// which means we just skip it here and do nothing
-								// TODO when metrics are added, this should increment a rescheduled metric
+								e.incrementJobCounter(*j, SingletonRescheduled)
 								e.sendOutForRescheduling(&jIn)
 							}
 						} else {
@@ -206,8 +214,7 @@ func (e *executor) start() {
 						}
 					} else {
 						select {
-						case <-e.stopCh:
-							e.stop(standardJobsWg, singletonJobsWg, limitModeJobsWg)
+						case <-executorCtx.Done():
 							return
 						default:
 						}
@@ -223,7 +230,7 @@ func (e *executor) start() {
 						}(*j)
 					}
 				}
-			}()
+			}(e.ctx)
 		case <-e.stopCh:
 			e.stop(standardJobsWg, singletonJobsWg, limitModeJobsWg)
 			return
@@ -245,6 +252,14 @@ func (e *executor) sendOutForRescheduling(jIn *jobIn) {
 	jIn.shouldSendOut = false
 }
 
+func (e *executor) sendOutForNextRunUpdate(jIn *jobIn) {
+	select {
+	case e.jobUpdateNextRuns <- jIn.id:
+	case <-e.ctx.Done():
+		return
+	}
+}
+
 func (e *executor) limitModeRunner(name string, in chan jobIn, wg *waitGroupWithMutex, limitMode LimitMode, rescheduleLimiter chan struct{}) {
 	e.logger.Debug("gocron: limitModeRunner starting", "name", name)
 	for {
@@ -368,27 +383,42 @@ func (e *executor) runJob(j internalJob, jIn jobIn) {
 			e.incrementJobCounter(j, Skip)
 			return
 		}
-	} else if j.locker != nil {
+	} else if !j.disabledLocker && j.locker != nil {
 		lock, err := j.locker.Lock(j.ctx, j.name)
 		if err != nil {
 			_ = callJobFuncWithParams(j.afterLockError, j.id, j.name, err)
 			e.sendOutForRescheduling(&jIn)
 			e.incrementJobCounter(j, Skip)
+			e.sendOutForNextRunUpdate(&jIn)
 			return
 		}
 		defer func() { _ = lock.Unlock(j.ctx) }()
-	} else if e.locker != nil {
+	} else if !j.disabledLocker && e.locker != nil {
 		lock, err := e.locker.Lock(j.ctx, j.name)
 		if err != nil {
 			_ = callJobFuncWithParams(j.afterLockError, j.id, j.name, err)
 			e.sendOutForRescheduling(&jIn)
 			e.incrementJobCounter(j, Skip)
+			e.sendOutForNextRunUpdate(&jIn)
 			return
 		}
 		defer func() { _ = lock.Unlock(j.ctx) }()
 	}
+
 	_ = callJobFuncWithParams(j.beforeJobRuns, j.id, j.name)
 
+	err := callJobFuncWithParams(j.beforeJobRunsSkipIfBeforeFuncErrors, j.id, j.name)
+	if err != nil {
+		e.sendOutForRescheduling(&jIn)
+
+		select {
+		case e.jobsOutCompleted <- j.id:
+		case <-e.ctx.Done():
+		}
+
+		return
+	}
+
 	e.sendOutForRescheduling(&jIn)
 	select {
 	case e.jobsOutCompleted <- j.id:
@@ -396,16 +426,20 @@ func (e *executor) runJob(j internalJob, jIn jobIn) {
 	}
 
 	startTime := time.Now()
-	err := e.callJobWithRecover(j)
-	if e.monitor != nil {
-		e.monitor.RecordJobTiming(startTime, time.Now(), j.id, j.name, j.tags)
+	if j.afterJobRunsWithPanic != nil {
+		err = e.callJobWithRecover(j)
+	} else {
+		err = callJobFuncWithParams(j.function, j.parameters...)
 	}
+	e.recordJobTiming(startTime, time.Now(), j)
 	if err != nil {
 		_ = callJobFuncWithParams(j.afterJobRunsWithError, j.id, j.name, err)
 		e.incrementJobCounter(j, Fail)
+		e.recordJobTimingWithStatus(startTime, time.Now(), j, Fail, err)
 	} else {
 		_ = callJobFuncWithParams(j.afterJobRuns, j.id, j.name)
 		e.incrementJobCounter(j, Success)
+		e.recordJobTimingWithStatus(startTime, time.Now(), j, Success, nil)
 	}
 }
 
@@ -422,6 +456,18 @@ func (e *executor) callJobWithRecover(j internalJob) (err error) {
 	return callJobFuncWithParams(j.function, j.parameters...)
 }
 
+func (e *executor) recordJobTiming(start time.Time, end time.Time, j internalJob) {
+	if e.monitor != nil {
+		e.monitor.RecordJobTiming(start, end, j.id, j.name, j.tags)
+	}
+}
+
+func (e *executor) recordJobTimingWithStatus(start time.Time, end time.Time, j internalJob, status JobStatus, err error) {
+	if e.monitorStatus != nil {
+		e.monitorStatus.RecordJobTimingWithStatus(start, end, j.id, j.name, j.tags, status, err)
+	}
+}
+
 func (e *executor) incrementJobCounter(j internalJob, status JobStatus) {
 	if e.monitor != nil {
 		e.monitor.IncrementJob(j.id, j.name, j.tags, status)
@@ -429,6 +475,7 @@ func (e *executor) incrementJobCounter(j internalJob, status JobStatus) {
 }
 
 func (e *executor) stop(standardJobsWg, singletonJobsWg, limitModeJobsWg *waitGroupWithMutex) {
+	e.stopOnce.Do(func() {
 		e.logger.Debug("gocron: stopping executor")
 		// we've been asked to stop. This is either because the scheduler has been told
 		// to stop all jobs or the scheduler has been asked to completely shutdown.
@@ -511,4 +558,5 @@ func (e *executor) stop(standardJobsWg, singletonJobsWg, limitModeJobsWg *waitGr
 		if e.limitMode != nil {
 			e.limitMode.started = false
 		}
+	})
 }

vendor/github.com/go-co-op/gocron/v2/job.go

@@ -6,23 +6,25 @@ import (
 	"errors"
 	"fmt"
 	"math/rand"
+	"slices"
 	"strings"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/jonboulle/clockwork"
 	"github.com/robfig/cron/v3"
-	"golang.org/x/exp/slices"
 )
 
 // internalJob stores the information needed by the scheduler
 // to manage scheduling, starting and stopping the job
 type internalJob struct {
 	ctx       context.Context
+	parentCtx context.Context
 	cancel    context.CancelFunc
 	id        uuid.UUID
 	name      string
 	tags      []string
+	cron      Cron
 	jobSchedule
 
 	// as some jobs may queue up, it's possible to
@@ -42,9 +44,11 @@ type internalJob struct {
 	// event listeners
 	afterJobRuns                        func(jobID uuid.UUID, jobName string)
 	beforeJobRuns                       func(jobID uuid.UUID, jobName string)
+	beforeJobRunsSkipIfBeforeFuncErrors func(jobID uuid.UUID, jobName string) error
 	afterJobRunsWithError               func(jobID uuid.UUID, jobName string, err error)
 	afterJobRunsWithPanic               func(jobID uuid.UUID, jobName string, recoverData any)
 	afterLockError                      func(jobID uuid.UUID, jobName string, err error)
+	disabledLocker                      bool
 
 	locker Locker
 }
@@ -80,6 +84,10 @@ type task struct {
 type Task func() task
 
 // NewTask provides the job's task function and parameters.
+// If you set the first argument of your Task func to be a context.Context,
+// gocron will pass in a context (either the default Job context, or one
+// provided via WithContext) to the job and will cancel the context on shutdown.
+// This allows you to listen for and handle cancellation within your job.
 func NewTask(function any, parameters ...any) Task {
 	return func() task {
 		return task{
@@ -97,6 +105,20 @@ type limitRunsTo struct {
 	runCount uint
 }
 
+// -----------------------------------------------
+// -----------------------------------------------
+// --------------- Custom Cron -------------------
+// -----------------------------------------------
+// -----------------------------------------------
+
+// Cron defines the interface that must be
+// implemented to provide a custom cron implementation for
+// the job. Pass in the implementation using the JobOption WithCronImplementation.
+type Cron interface {
+	IsValid(crontab string, location *time.Location, now time.Time) error
+	Next(lastRun time.Time) time.Time
+}
+
 // -----------------------------------------------
 // -----------------------------------------------
 // --------------- Job Variants ------------------
@@ -109,21 +131,29 @@ type JobDefinition interface {
 	setup(j *internalJob, l *time.Location, now time.Time) error
 }
 
-var _ JobDefinition = (*cronJobDefinition)(nil)
+// Default cron implementation
 
-type cronJobDefinition struct {
-	crontab     string
+func newDefaultCronImplementation(withSeconds bool) Cron {
+	return &defaultCron{
+		withSeconds: withSeconds,
+	}
+}
+
+var _ Cron = (*defaultCron)(nil)
+
+type defaultCron struct {
+	cronSchedule cron.Schedule
 	withSeconds  bool
 }
 
-func (c cronJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
+func (c *defaultCron) IsValid(crontab string, location *time.Location, now time.Time) error {
 	var withLocation string
-	if strings.HasPrefix(c.crontab, "TZ=") || strings.HasPrefix(c.crontab, "CRON_TZ=") {
-		withLocation = c.crontab
+	if strings.HasPrefix(crontab, "TZ=") || strings.HasPrefix(crontab, "CRON_TZ=") {
+		withLocation = crontab
 	} else {
 		// since the user didn't provide a timezone default to the location
 		// passed in by the scheduler. Default: time.Local
-		withLocation = fmt.Sprintf("CRON_TZ=%s %s", location.String(), c.crontab)
+		withLocation = fmt.Sprintf("CRON_TZ=%s %s", location.String(), crontab)
 	}
 
 	var (
@@ -140,8 +170,35 @@ func (c cronJobDefinition) setup(j *internalJob, location *time.Location, _ time
 	if err != nil {
 		return errors.Join(ErrCronJobParse, err)
 	}
+	if cronSchedule.Next(now).IsZero() {
+		return ErrCronJobInvalid
+	}
+	c.cronSchedule = cronSchedule
+	return nil
+}
 
-	j.jobSchedule = &cronJob{cronSchedule: cronSchedule}
+func (c *defaultCron) Next(lastRun time.Time) time.Time {
+	return c.cronSchedule.Next(lastRun)
+}
+
+// default cron job implementation
+var _ JobDefinition = (*cronJobDefinition)(nil)
+
+type cronJobDefinition struct {
+	crontab string
+	cron    Cron
+}
+
+func (c cronJobDefinition) setup(j *internalJob, location *time.Location, now time.Time) error {
+	if j.cron != nil {
+		c.cron = j.cron
+	}
+
+	if err := c.cron.IsValid(c.crontab, location, now); err != nil {
+		return err
+	}
+
+	j.jobSchedule = &cronJob{crontab: c.crontab, cronSchedule: c.cron}
 	return nil
 }
 
@@ -154,7 +211,7 @@ func (c cronJobDefinition) setup(j *internalJob, location *time.Location, _ time
 func CronJob(crontab string, withSeconds bool) JobDefinition {
 	return cronJobDefinition{
 		crontab: crontab,
-		withSeconds: withSeconds,
+		cron:    newDefaultCronImplementation(withSeconds),
 	}
 }
 
@@ -249,6 +306,10 @@ func (d dailyJobDefinition) setup(j *internalJob, location *time.Location, _ tim
 		return ErrDailyJobMinutesSeconds
 	}
 
+	if d.interval == 0 {
+		return ErrDailyJobZeroInterval
+	}
+
 	ds := dailyJob{
 		interval: d.interval,
 		atTimes:  atTimesDate,
@@ -267,6 +328,9 @@ type weeklyJobDefinition struct {
 
 func (w weeklyJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
 	var ws weeklyJob
+	if w.interval == 0 {
+		return ErrWeeklyJobZeroInterval
+	}
 	ws.interval = w.interval
 
 	if w.daysOfTheWeek == nil {
@@ -301,8 +365,7 @@ type Weekdays func() []time.Weekday
 // NewWeekdays provide the days of the week the job should run.
 func NewWeekdays(weekday time.Weekday, weekdays ...time.Weekday) Weekdays {
 	return func() []time.Weekday {
-		weekdays = append(weekdays, weekday)
-		return weekdays
+		return append([]time.Weekday{weekday}, weekdays...)
 	}
 }
 
@@ -332,6 +395,9 @@ type monthlyJobDefinition struct {
 
 func (m monthlyJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
 	var ms monthlyJob
+	if m.interval == 0 {
+		return ErrMonthlyJobZeroInterval
+	}
 	ms.interval = m.interval
 
 	if m.daysOfTheMonth == nil {
@@ -350,11 +416,9 @@ func (m monthlyJobDefinition) setup(j *internalJob, location *time.Location, _ t
 		}
 	}
 	daysStart = removeSliceDuplicatesInt(daysStart)
-	slices.Sort(daysStart)
 	ms.days = daysStart
 
 	daysEnd = removeSliceDuplicatesInt(daysEnd)
-	slices.Sort(daysEnd)
 	ms.daysFromEnd = daysEnd
 
 	atTimesDate, err := convertAtTimesToDateTime(m.atTimes, location)
@@ -387,8 +451,7 @@ type DaysOfTheMonth func() days
 //	-5 == 5 days before the end of the month.
 func NewDaysOfTheMonth(day int, moreDays ...int) DaysOfTheMonth {
 	return func() days {
-		moreDays = append(moreDays, day)
-		return moreDays
+		return append([]int{day}, moreDays...)
 	}
 }
 
@@ -400,6 +463,14 @@ func (a atTime) time(location *time.Location) time.Time {
 	return time.Date(0, 0, 0, int(a.hours), int(a.minutes), int(a.seconds), 0, location)
 }
 
+// TimeFromAtTime is a helper function to allow converting AtTime into a time.Time value
+// Note: the time.Time value will have zero values for all Time fields except Hours, Minutes, Seconds.
+//
+//	For example: time.Date(0, 0, 0, 1, 1, 1, 0, time.UTC)
+func TimeFromAtTime(at AtTime, loc *time.Location) time.Time {
+	return at().time(loc)
+}
+
 // AtTime defines a function that returns the internal atTime
 type AtTime func() atTime
 
@@ -418,8 +489,7 @@ type AtTimes func() []AtTime
 // the job should be run
 func NewAtTimes(atTime AtTime, atTimes ...AtTime) AtTimes {
 	return func() []AtTime {
-		atTimes = append(atTimes, atTime)
-		return atTimes
+		return append([]AtTime{atTime}, atTimes...)
 	}
 }
 
@@ -456,6 +526,8 @@ type oneTimeJobDefinition struct {
 func (o oneTimeJobDefinition) setup(j *internalJob, _ *time.Location, now time.Time) error {
 	sortedTimes := o.startAt(j)
 	slices.SortStableFunc(sortedTimes, ascendingTime)
+	// deduplicate the times
+	sortedTimes = removeSliceDuplicatesTimeOnSortedSlice(sortedTimes)
 	// keep only schedules that are in the future
 	idx, found := slices.BinarySearchFunc(sortedTimes, now, ascendingTime)
 	if found {
@@ -469,6 +541,16 @@ func (o oneTimeJobDefinition) setup(j *internalJob, _ *time.Location, now time.T
 	return nil
 }
 
+func removeSliceDuplicatesTimeOnSortedSlice(times []time.Time) []time.Time {
+	ret := make([]time.Time, 0, len(times))
+	for i, t := range times {
+		if i == 0 || t != times[i-1] {
+			ret = append(ret, t)
+		}
+	}
+	return ret
+}
+
 // OneTimeJobStartAtOption defines when the one time job is run
 type OneTimeJobStartAtOption func(*internalJob) []time.Time
 
@@ -526,6 +608,16 @@ func WithDistributedJobLocker(locker Locker) JobOption {
 	}
 }
 
+// WithDisabledDistributedJobLocker disables the distributed job locker.
+// This is useful when a global distributed locker has been set on the scheduler
+// level using WithDistributedLocker and need to be disabled for specific jobs.
+func WithDisabledDistributedJobLocker(disabled bool) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		j.disabledLocker = disabled
+		return nil
+	}
+}
+
 // WithEventListeners sets the event listeners that should be
 // run for the job.
 func WithEventListeners(eventListeners ...EventListener) JobOption {
@@ -563,6 +655,15 @@ func WithName(name string) JobOption {
 	}
 }
 
+// WithCronImplementation sets the custom Cron implementation for the job.
+// This is only utilized for the CronJob type.
+func WithCronImplementation(c Cron) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		j.cron = c
+		return nil
+	}
+}
+
 // WithSingletonMode keeps the job from running again if it is already running.
 // This is useful for jobs that should not overlap, and that occasionally
 // (but not consistently) run longer than the interval between job runs.
@@ -661,6 +762,22 @@ func WithIdentifier(id uuid.UUID) JobOption {
 	}
 }
 
+// WithContext sets the parent context for the job.
+// If you set the first argument of your Task func to be a context.Context,
+// gocron will pass in the provided context to the job and will cancel the
+// context on shutdown. If you cancel the context the job will no longer be
+// scheduled as well. This allows you to both control the job via a context
+// and listen for and handle cancellation within your job.
+func WithContext(ctx context.Context) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		if ctx == nil {
+			return ErrWithContextNil
+		}
+		j.parentCtx = ctx
+		return nil
+	}
+}
+
 // -----------------------------------------------
 // -----------------------------------------------
 // ------------- Job Event Listeners -------------
@@ -683,6 +800,19 @@ func BeforeJobRuns(eventListenerFunc func(jobID uuid.UUID, jobName string)) Even
 	}
 }
 
+// BeforeJobRunsSkipIfBeforeFuncErrors is used to listen for when a job is about to run and
+// then runs the provided function. If the provided function returns an error, the job will be
+// rescheduled and the current run will be skipped.
+func BeforeJobRunsSkipIfBeforeFuncErrors(eventListenerFunc func(jobID uuid.UUID, jobName string) error) EventListener {
+	return func(j *internalJob) error {
+		if eventListenerFunc == nil {
+			return ErrEventListenerFuncNil
+		}
+		j.beforeJobRunsSkipIfBeforeFuncErrors = eventListenerFunc
+		return nil
+	}
+}
+
 // AfterJobRuns is used to listen for when a job has run
 // without an error, and then run the provided function.
 func AfterJobRuns(eventListenerFunc func(jobID uuid.UUID, jobName string)) EventListener {
@@ -744,7 +874,8 @@ type jobSchedule interface {
 var _ jobSchedule = (*cronJob)(nil)
 
 type cronJob struct {
-	cronSchedule cron.Schedule
+	crontab      string
+	cronSchedule Cron
 }
 
 func (j *cronJob) next(lastRun time.Time) time.Time {
@@ -788,7 +919,7 @@ func (d dailyJob) next(lastRun time.Time) time.Time {
 	}
 	firstPass = false
 
-	startNextDay := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(d.interval), 0, 0, 0, lastRun.Nanosecond(), lastRun.Location())
+	startNextDay := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(d.interval), 0, 0, 0, 0, lastRun.Location())
 	return d.nextDay(startNextDay, firstPass)
 }
 
@@ -796,7 +927,7 @@ func (d dailyJob) nextDay(lastRun time.Time, firstPass bool) time.Time {
 	for _, at := range d.atTimes {
 		// sub the at time hour/min/sec onto the lastScheduledRun's values
 		// to use in checks to see if we've got our next run time
-		atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day(), at.Hour(), at.Minute(), at.Second(), lastRun.Nanosecond(), lastRun.Location())
+		atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day(), at.Hour(), at.Minute(), at.Second(), 0, lastRun.Location())
 
 		if firstPass && atDate.After(lastRun) {
 			// checking to see if it is after i.e. greater than,
@@ -842,7 +973,7 @@ func (w weeklyJob) nextWeekDayAtTime(lastRun time.Time, firstPass bool) time.Tim
 			for _, at := range w.atTimes {
 				// sub the at time hour/min/sec onto the lastScheduledRun's values
 				// to use in checks to see if we've got our next run time
-				atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(weekDayDiff), at.Hour(), at.Minute(), at.Second(), lastRun.Nanosecond(), lastRun.Location())
+				atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(weekDayDiff), at.Hour(), at.Minute(), at.Second(), 0, lastRun.Location())
 
 				if firstPass && atDate.After(lastRun) {
 					// checking to see if it is after i.e. greater than,
@@ -910,7 +1041,7 @@ func (m monthlyJob) nextMonthDayAtTime(lastRun time.Time, days []int, firstPass
 			for _, at := range m.atTimes {
 				// sub the day, and the at time hour/min/sec onto the lastScheduledRun's values
 				// to use in checks to see if we've got our next run time
-				atDate := time.Date(lastRun.Year(), lastRun.Month(), day, at.Hour(), at.Minute(), at.Second(), lastRun.Nanosecond(), lastRun.Location())
+				atDate := time.Date(lastRun.Year(), lastRun.Month(), day, at.Hour(), at.Minute(), at.Second(), 0, lastRun.Location())
 
 				if atDate.Month() != lastRun.Month() {
 					// this check handles if we're setting a day not in the current month
@@ -1074,12 +1205,14 @@ func (j job) RunNow() error {
 	defer cancel()
 	resp := make(chan error, 1)
 
+	t := time.NewTimer(100 * time.Millisecond)
 	select {
 	case j.runJobRequest <- runJobRequest{
 		id:      j.id,
 		outChan: resp,
 	}:
-	case <-time.After(100 * time.Millisecond):
+		t.Stop()
+	case <-t.C:
 		return ErrJobRunNowFailed
 	}
 	var err error

vendor/github.com/go-co-op/gocron/v2/monitor.go

@@ -14,6 +14,7 @@ const (
 	Fail                 JobStatus = "fail"
 	Success              JobStatus = "success"
 	Skip                 JobStatus = "skip"
+	SingletonRescheduled JobStatus = "singleton_rescheduled"
 )
 
 // Monitor represents the interface to collect jobs metrics.
@@ -25,3 +26,11 @@ type Monitor interface {
 	// to handle instantiating and recording the value
 	RecordJobTiming(startTime, endTime time.Time, id uuid.UUID, name string, tags []string)
 }
+
+// MonitorStatus extends RecordJobTiming with the job status.
+type MonitorStatus interface {
+	Monitor
+	// RecordJobTimingWithStatus will provide details about the job, its status, error and the timing and expects the underlying implementation
+	// to handle instantiating and recording the value
+	RecordJobTimingWithStatus(startTime, endTime time.Time, id uuid.UUID, name string, tags []string, status JobStatus, err error)
+}

vendor/github.com/go-co-op/gocron/v2/scheduler.go

@@ -5,11 +5,12 @@ import (
 	"context"
 	"reflect"
 	"runtime"
+	"slices"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/jonboulle/clockwork"
-	"golang.org/x/exp/slices"
 )
 
 var _ Scheduler = (*scheduler)(nil)
@@ -21,6 +22,10 @@ type Scheduler interface {
 	// NewJob creates a new job in the Scheduler. The job is scheduled per the provided
 	// definition when the Scheduler is started. If the Scheduler is already running
 	// the job will be scheduled when the Scheduler is started.
+	// If you set the first argument of your Task func to be a context.Context,
+	// gocron will pass in a context (either the default Job context, or one
+	// provided via WithContext) to the job and will cancel the context on shutdown.
+	// This allows you to listen for and handle cancellation within your job.
 	NewJob(JobDefinition, Task, ...JobOption) (Job, error)
 	// RemoveByTags removes all jobs that have at least one of the provided tags.
 	RemoveByTags(...string)
@@ -133,9 +138,10 @@ func NewScheduler(options ...SchedulerOption) (Scheduler, error) {
 
 		jobsIn:                 make(chan jobIn),
 		jobsOutForRescheduling: make(chan uuid.UUID),
+		jobUpdateNextRuns:      make(chan uuid.UUID),
 		jobsOutCompleted:       make(chan uuid.UUID),
 		jobOutRequest:          make(chan jobOutRequest, 1000),
-		done:                   make(chan error),
+		done:                   make(chan error, 1),
 	}
 
 	s := &scheduler{
@@ -171,7 +177,8 @@ func NewScheduler(options ...SchedulerOption) (Scheduler, error) {
 			select {
 			case id := <-s.exec.jobsOutForRescheduling:
 				s.selectExecJobsOutForRescheduling(id)
-
+			case id := <-s.exec.jobUpdateNextRuns:
+				s.updateNextScheduled(id)
 			case id := <-s.exec.jobsOutCompleted:
 				s.selectExecJobsOutCompleted(id)
 
@@ -233,20 +240,34 @@ func (s *scheduler) stopScheduler() {
 	for _, j := range s.jobs {
 		j.stop()
 	}
-	for id, j := range s.jobs {
+	for _, j := range s.jobs {
 		<-j.ctx.Done()
-
-		j.ctx, j.cancel = context.WithCancel(s.shutdownCtx)
-		s.jobs[id] = j
 	}
 	var err error
 	if s.started {
+		t := time.NewTimer(s.exec.stopTimeout + 1*time.Second)
 		select {
 		case err = <-s.exec.done:
-		case <-time.After(s.exec.stopTimeout + 1*time.Second):
+			t.Stop()
+		case <-t.C:
 			err = ErrStopExecutorTimedOut
 		}
 	}
+	for id, j := range s.jobs {
+		oldCtx := j.ctx
+		if j.parentCtx == nil {
+			j.parentCtx = s.shutdownCtx
+		}
+		j.ctx, j.cancel = context.WithCancel(j.parentCtx)
+
+		// also replace the old context with the new one in the parameters
+		if len(j.parameters) > 0 && j.parameters[0] == oldCtx {
+			j.parameters[0] = j.ctx
+		}
+
+		s.jobs[id] = j
+	}
+
 	s.stopErrCh <- err
 	s.started = false
 	s.logger.Debug("gocron: scheduler stopped")
@@ -261,14 +282,7 @@ func (s *scheduler) selectAllJobsOutRequest(out allJobsOutRequest) {
 	}
 	slices.SortFunc(outJobs, func(a, b Job) int {
 		aID, bID := a.ID().String(), b.ID().String()
-		switch {
-		case aID < bID:
-			return -1
-		case aID > bID:
-			return 1
-		default:
-			return 0
-		}
+		return strings.Compare(aID, bID)
 	})
 	select {
 	case <-s.shutdownCtx.Done():
@@ -311,7 +325,7 @@ func (s *scheduler) selectRemoveJob(id uuid.UUID) {
 }
 
 // Jobs coming back from the executor to the scheduler that
-// need to evaluated for rescheduling.
+// need to be evaluated for rescheduling.
 func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
 	select {
 	case <-s.shutdownCtx.Done():
@@ -329,7 +343,7 @@ func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
 		return
 	}
 
-	scheduleFrom := j.lastRun
+	var scheduleFrom time.Time
 	if len(j.nextScheduled) > 0 {
 		// always grab the last element in the slice as that is the furthest
 		// out in the future and the time from which we want to calculate
@@ -359,6 +373,22 @@ func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
 			next = j.next(next)
 		}
 	}
+
+	if slices.Contains(j.nextScheduled, next) {
+		// if the next value is a duplicate of what's already in the nextScheduled slice, for example:
+		// - the job is being rescheduled off the same next run value as before
+		// increment to the next, next value
+		for slices.Contains(j.nextScheduled, next) {
+			next = j.next(next)
+		}
+	}
+
+	// Clean up any existing timer to prevent leaks
+	if j.timer != nil {
+		j.timer.Stop()
+		j.timer = nil // Ensure timer is cleared for GC
+	}
+
 	j.nextScheduled = append(j.nextScheduled, next)
 	j.timer = s.exec.clock.AfterFunc(next.Sub(s.now()), func() {
 		// set the actual timer on the job here and listen for
@@ -377,6 +407,22 @@ func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
 	s.jobs[id] = j
 }
 
+func (s *scheduler) updateNextScheduled(id uuid.UUID) {
+	j, ok := s.jobs[id]
+	if !ok {
+		return
+	}
+	var newNextScheduled []time.Time
+	for _, t := range j.nextScheduled {
+		if t.Before(s.now()) {
+			continue
+		}
+		newNextScheduled = append(newNextScheduled, t)
+	}
+	j.nextScheduled = newNextScheduled
+	s.jobs[id] = j
+}
+
 func (s *scheduler) selectExecJobsOutCompleted(id uuid.UUID) {
 	j, ok := s.jobs[id]
 	if !ok {
@@ -639,8 +685,6 @@ func (s *scheduler) addOrUpdateJob(id uuid.UUID, definition JobDefinition, taskW
 		j.id = id
 	}
 
-	j.ctx, j.cancel = context.WithCancel(s.shutdownCtx)
-
 	if taskWrapper == nil {
 		return nil, ErrNewJobTaskNil
 	}
@@ -655,10 +699,6 @@ func (s *scheduler) addOrUpdateJob(id uuid.UUID, definition JobDefinition, taskW
 		return nil, ErrNewJobTaskNotFunc
 	}
 
-	if err := s.verifyParameterType(taskFunc, tsk); err != nil {
-		return nil, err
-	}
-
 	j.name = runtime.FuncForPC(taskFunc.Pointer()).Name()
 	j.function = tsk.function
 	j.parameters = tsk.parameters
@@ -677,6 +717,28 @@ func (s *scheduler) addOrUpdateJob(id uuid.UUID, definition JobDefinition, taskW
 		}
 	}
 
+	if j.parentCtx == nil {
+		j.parentCtx = s.shutdownCtx
+	}
+	j.ctx, j.cancel = context.WithCancel(j.parentCtx)
+
+	if !taskFunc.IsZero() && taskFunc.Type().NumIn() > 0 {
+		// if the first parameter is a context.Context and params have no context.Context, add current ctx to the params
+		if taskFunc.Type().In(0) == reflect.TypeOf((*context.Context)(nil)).Elem() {
+			if len(tsk.parameters) == 0 {
+				tsk.parameters = []any{j.ctx}
+				j.parameters = []any{j.ctx}
+			} else if _, ok := tsk.parameters[0].(context.Context); !ok {
+				tsk.parameters = append([]any{j.ctx}, tsk.parameters...)
+				j.parameters = append([]any{j.ctx}, j.parameters...)
+			}
+		}
+	}
+
+	if err := s.verifyParameterType(taskFunc, tsk); err != nil {
+		return nil, err
+	}
+
 	if err := definition.setup(&j, s.location, s.exec.clock.Now()); err != nil {
 		return nil, err
 	}
@@ -734,20 +796,27 @@ func (s *scheduler) StopJobs() error {
 		return nil
 	case s.stopCh <- struct{}{}:
 	}
+
+	t := time.NewTimer(s.exec.stopTimeout + 2*time.Second)
 	select {
 	case err := <-s.stopErrCh:
+		t.Stop()
 		return err
-	case <-time.After(s.exec.stopTimeout + 2*time.Second):
+	case <-t.C:
 		return ErrStopSchedulerTimedOut
 	}
 }
 
 func (s *scheduler) Shutdown() error {
 	s.shutdownCancel()
+
+	t := time.NewTimer(s.exec.stopTimeout + 2*time.Second)
 	select {
 	case err := <-s.stopErrCh:
+
+		t.Stop()
 		return err
-	case <-time.After(s.exec.stopTimeout + 2*time.Second):
+	case <-t.C:
 		return ErrStopSchedulerTimedOut
 	}
 }
@@ -802,6 +871,8 @@ func WithDistributedElector(elector Elector) SchedulerOption {
 // WithDistributedLocker sets the locker to be used by multiple
 // Scheduler instances to ensure that only one instance of each
 // job is run.
+// To disable this global locker for specific jobs, see
+// WithDisabledDistributedJobLocker.
 func WithDistributedLocker(locker Locker) SchedulerOption {
 	return func(s *scheduler) error {
 		if locker == nil {
@@ -938,3 +1009,14 @@ func WithMonitor(monitor Monitor) SchedulerOption {
 		return nil
 	}
 }
+
+// WithMonitorStatus sets the metrics provider to be used by the Scheduler.
+func WithMonitorStatus(monitor MonitorStatus) SchedulerOption {
+	return func(s *scheduler) error {
+		if monitor == nil {
+			return ErrWithMonitorNil
+		}
+		s.exec.monitorStatus = monitor
+		return nil
+	}
+}

vendor/github.com/go-co-op/gocron/v2/util.go

@@ -3,12 +3,11 @@ package gocron
 import (
 	"context"
 	"reflect"
+	"slices"
 	"sync"
 	"time"
 
 	"github.com/google/uuid"
-	"golang.org/x/exp/maps"
-	"golang.org/x/exp/slices"
 )
 
 func callJobFuncWithParams(jobFunc any, params ...any) error {
@@ -63,12 +62,8 @@ func requestJobCtx(ctx context.Context, id uuid.UUID, ch chan jobOutRequest) *in
 }
 
 func removeSliceDuplicatesInt(in []int) []int {
-	m := make(map[int]struct{})
-
-	for _, i := range in {
-		m[i] = struct{}{}
-	}
-	return maps.Keys(m)
+	slices.Sort(in)
+	return slices.Compact(in)
 }
 
 func convertAtTimesToDateTime(atTimes AtTimes, location *time.Location) ([]time.Time, error) {

vendor/github.com/jonboulle/clockwork/README.md

@@ -36,6 +36,7 @@ Now you can easily test `myFunc` with a `FakeClock`:
 
 ```go
 func TestMyFunc(t *testing.T) {
+	ctx := context.Background()
 	c := clockwork.NewFakeClock()
 
 	// Start our sleepy function
@@ -46,8 +47,12 @@ func TestMyFunc(t *testing.T) {
 		wg.Done()
 	}()
 
-	// Ensure we wait until myFunc is sleeping
-	c.BlockUntil(1)
+	// Ensure we wait until myFunc is waiting on the clock.
+	// Use a context to avoid blocking forever if something
+	// goes wrong.
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	c.BlockUntilContext(ctx, 1)
 
 	assertState()
 

vendor/github.com/jonboulle/clockwork/SECURITY.md

@@ -0,0 +1,19 @@
+# Security Policy
+
+If you have discovered a security vulnerability in this project, please report it
+privately. **Do not disclose it as a public issue.** This gives me time to work with you
+to fix the issue before public exposure, reducing the chance that the exploit will be
+used before a patch is released.
+
+You may submit the report in the following ways:
+
+- send an email to ???@???; and/or
+- send a [private vulnerability report](https://github.com/jonboulle/clockwork/security/advisories/new)
+
+Please provide the following information in your report:
+
+- A description of the vulnerability and its impact
+- How to reproduce the issue
+
+This project is maintained by a single maintainer on a reasonable-effort basis. As such,
+please give me 90 days to work on a fix before public exposure.

vendor/github.com/jonboulle/clockwork/clockwork.go

@@ -1,8 +1,10 @@
+// Package clockwork contains a simple fake clock for Go.
 package clockwork
 
 import (
 	"context"
-	"sort"
+	"errors"
+	"slices"
 	"sync"
 	"time"
 )
@@ -14,49 +16,18 @@ type Clock interface {
 	Sleep(d time.Duration)
 	Now() time.Time
 	Since(t time.Time) time.Duration
+	Until(t time.Time) time.Duration
 	NewTicker(d time.Duration) Ticker
 	NewTimer(d time.Duration) Timer
 	AfterFunc(d time.Duration, f func()) Timer
 }
 
-// FakeClock provides an interface for a clock which can be manually advanced
-// through time.
-//
-// FakeClock maintains a list of "waiters," which consists of all callers
-// waiting on the underlying clock (i.e. Tickers and Timers including callers of
-// Sleep or After). Users can call BlockUntil to block until the clock has an
-// expected number of waiters.
-type FakeClock interface {
-	Clock
-	// Advance advances the FakeClock to a new point in time, ensuring any existing
-	// waiters are notified appropriately before returning.
-	Advance(d time.Duration)
-	// BlockUntil blocks until the FakeClock has the given number of waiters.
-	BlockUntil(waiters int)
-}
-
 // NewRealClock returns a Clock which simply delegates calls to the actual time
 // package; it should be used by packages in production.
 func NewRealClock() Clock {
 	return &realClock{}
 }
 
-// NewFakeClock returns a FakeClock implementation which can be
-// manually advanced through time for testing. The initial time of the
-// FakeClock will be the current system time.
-//
-// Tests that require a deterministic time must use NewFakeClockAt.
-func NewFakeClock() FakeClock {
-	return NewFakeClockAt(time.Now())
-}
-
-// NewFakeClockAt returns a FakeClock initialised at the given time.Time.
-func NewFakeClockAt(t time.Time) FakeClock {
-	return &fakeClock{
-		time: t,
-	}
-}
-
 type realClock struct{}
 
 func (rc *realClock) After(d time.Duration) <-chan time.Time {
@@ -75,6 +46,10 @@ func (rc *realClock) Since(t time.Time) time.Duration {
 	return rc.Now().Sub(t)
 }
 
+func (rc *realClock) Until(t time.Time) time.Duration {
+	return t.Sub(rc.Now())
+}
+
 func (rc *realClock) NewTicker(d time.Duration) Ticker {
 	return realTicker{time.NewTicker(d)}
 }
@@ -87,7 +62,14 @@ func (rc *realClock) AfterFunc(d time.Duration, f func()) Timer {
 	return realTimer{time.AfterFunc(d, f)}
 }
 
-type fakeClock struct {
+// FakeClock provides an interface for a clock which can be manually advanced
+// through time.
+//
+// FakeClock maintains a list of "waiters," which consists of all callers
+// waiting on the underlying clock (i.e. Tickers and Timers including callers of
+// Sleep or After). Users can call BlockUntil to block until the clock has an
+// expected number of waiters.
+type FakeClock struct {
 	// l protects all attributes of the clock, including all attributes of all
 	// waiters and blockers.
 	l        sync.RWMutex
@@ -96,11 +78,27 @@ type fakeClock struct {
 	time     time.Time
 }
 
+// NewFakeClock returns a FakeClock implementation which can be
+// manually advanced through time for testing. The initial time of the
+// FakeClock will be the current system time.
+//
+// Tests that require a deterministic time must use NewFakeClockAt.
+func NewFakeClock() *FakeClock {
+	return NewFakeClockAt(time.Now())
+}
+
+// NewFakeClockAt returns a FakeClock initialised at the given time.Time.
+func NewFakeClockAt(t time.Time) *FakeClock {
+	return &FakeClock{
+		time: t,
+	}
+}
+
 // blocker is a caller of BlockUntil.
 type blocker struct {
 	count int
 
-	// ch is closed when the underlying clock has the specificed number of blockers.
+	// ch is closed when the underlying clock has the specified number of blockers.
 	ch chan struct{}
 }
 
@@ -111,23 +109,23 @@ type expirer interface {
 	expire(now time.Time) (next *time.Duration)
 
 	// Get and set the expiration time.
-	expiry() time.Time
-	setExpiry(time.Time)
+	expiration() time.Time
+	setExpiration(time.Time)
 }
 
 // After mimics [time.After]; it waits for the given duration to elapse on the
 // fakeClock, then sends the current time on the returned channel.
-func (fc *fakeClock) After(d time.Duration) <-chan time.Time {
+func (fc *FakeClock) After(d time.Duration) <-chan time.Time {
 	return fc.NewTimer(d).Chan()
 }
 
 // Sleep blocks until the given duration has passed on the fakeClock.
-func (fc *fakeClock) Sleep(d time.Duration) {
+func (fc *FakeClock) Sleep(d time.Duration) {
 	<-fc.After(d)
 }
 
 // Now returns the current time of the fakeClock
-func (fc *fakeClock) Now() time.Time {
+func (fc *FakeClock) Now() time.Time {
 	fc.l.RLock()
 	defer fc.l.RUnlock()
 	return fc.time
@@ -135,61 +133,73 @@ func (fc *fakeClock) Now() time.Time {
 
 // Since returns the duration that has passed since the given time on the
 // fakeClock.
-func (fc *fakeClock) Since(t time.Time) time.Duration {
+func (fc *FakeClock) Since(t time.Time) time.Duration {
 	return fc.Now().Sub(t)
 }
 
-// NewTicker returns a Ticker that will expire only after calls to
-// fakeClock.Advance() have moved the clock past the given duration.
-func (fc *fakeClock) NewTicker(d time.Duration) Ticker {
-	var ft *fakeTicker
-	ft = &fakeTicker{
-		firer: newFirer(),
-		d:     d,
-		reset: func(d time.Duration) { fc.set(ft, d) },
-		stop:  func() { fc.stop(ft) },
+// Until returns the duration that has to pass from the given time on the fakeClock
+// to reach the given time.
+func (fc *FakeClock) Until(t time.Time) time.Duration {
+	return t.Sub(fc.Now())
 }
-	fc.set(ft, d)
+
+// NewTicker returns a Ticker that will expire only after calls to
+// FakeClock.Advance() have moved the clock past the given duration.
+//
+// The duration d must be greater than zero; if not, NewTicker will panic.
+func (fc *FakeClock) NewTicker(d time.Duration) Ticker {
+	// Maintain parity with
+	// https://cs.opensource.google/go/go/+/refs/tags/go1.20.3:src/time/tick.go;l=23-25
+	if d <= 0 {
+		panic(errors.New("non-positive interval for NewTicker"))
+	}
+	ft := newFakeTicker(fc, d)
+	fc.l.Lock()
+	defer fc.l.Unlock()
+	fc.setExpirer(ft, d)
 	return ft
 }
 
 // NewTimer returns a Timer that will fire only after calls to
 // fakeClock.Advance() have moved the clock past the given duration.
-func (fc *fakeClock) NewTimer(d time.Duration) Timer {
-	return fc.newTimer(d, nil)
+func (fc *FakeClock) NewTimer(d time.Duration) Timer {
+	t, _ := fc.newTimer(d, nil)
+	return t
 }
 
 // AfterFunc mimics [time.AfterFunc]; it returns a Timer that will invoke the
 // given function only after calls to fakeClock.Advance() have moved the clock
 // past the given duration.
-func (fc *fakeClock) AfterFunc(d time.Duration, f func()) Timer {
-	return fc.newTimer(d, f)
+func (fc *FakeClock) AfterFunc(d time.Duration, f func()) Timer {
+	t, _ := fc.newTimer(d, f)
+	return t
 }
 
-// newTimer returns a new timer, using an optional afterFunc.
-func (fc *fakeClock) newTimer(d time.Duration, afterfunc func()) *fakeTimer {
-	var ft *fakeTimer
-	ft = &fakeTimer{
-		firer: newFirer(),
-		reset: func(d time.Duration) bool {
+// newTimer returns a new timer using an optional afterFunc and the time that
+// timer expires.
+func (fc *FakeClock) newTimer(d time.Duration, afterfunc func()) (*fakeTimer, time.Time) {
+	ft := newFakeTimer(fc, afterfunc)
 	fc.l.Lock()
 	defer fc.l.Unlock()
-			// fc.l must be held across the calls to stopExpirer & setExpirer.
-			stopped := fc.stopExpirer(ft)
 	fc.setExpirer(ft, d)
-			return stopped
-		},
-		stop: func() bool { return fc.stop(ft) },
-
-		afterFunc: afterfunc,
+	return ft, ft.expiration()
 }
-	fc.set(ft, d)
+
+// newTimerAtTime is like newTimer, but uses a time instead of a duration.
+//
+// It is used to ensure FakeClock's lock is held constant through calling
+// fc.After(t.Sub(fc.Now())). It should not be exposed externally.
+func (fc *FakeClock) newTimerAtTime(t time.Time, afterfunc func()) *fakeTimer {
+	ft := newFakeTimer(fc, afterfunc)
+	fc.l.Lock()
+	defer fc.l.Unlock()
+	fc.setExpirer(ft, t.Sub(fc.time))
 	return ft
 }
 
 // Advance advances fakeClock to a new point in time, ensuring waiters and
 // blockers are notified appropriately before returning.
-func (fc *fakeClock) Advance(d time.Duration) {
+func (fc *FakeClock) Advance(d time.Duration) {
 	fc.l.Lock()
 	defer fc.l.Unlock()
 	end := fc.time.Add(d)
@@ -198,38 +208,34 @@ func (fc *fakeClock) Advance(d time.Duration) {
 	//
 	// We don't iterate because the callback of the waiter might register a new
 	// waiter, so the list of waiters might change as we execute this.
-	for len(fc.waiters) > 0 && !end.Before(fc.waiters[0].expiry()) {
+	for len(fc.waiters) > 0 && !end.Before(fc.waiters[0].expiration()) {
 		w := fc.waiters[0]
 		fc.waiters = fc.waiters[1:]
 
-		// Use the waiter's expriation as the current time for this expiration.
-		now := w.expiry()
+		// Use the waiter's expiration as the current time for this expiration.
+		now := w.expiration()
 		fc.time = now
 		if d := w.expire(now); d != nil {
-			// Set the new exipration if needed.
+			// Set the new expiration if needed.
 			fc.setExpirer(w, *d)
 		}
 	}
 	fc.time = end
 }
 
-// BlockUntil blocks until the fakeClock has the given number of waiters.
+// BlockUntil blocks until the FakeClock has the given number of waiters.
 //
-// Prefer BlockUntilContext, which offers context cancellation to prevent
-// deadlock.
+// Prefer BlockUntilContext in new code, which offers context cancellation to
+// prevent deadlock.
 //
-// Deprecation warning: This function might be deprecated in later versions.
-func (fc *fakeClock) BlockUntil(n int) {
-	b := fc.newBlocker(n)
-	if b == nil {
-		return
-	}
-	<-b.ch
+// Deprecated: New code should prefer BlockUntilContext.
+func (fc *FakeClock) BlockUntil(n int) {
+	fc.BlockUntilContext(context.TODO(), n)
 }
 
 // BlockUntilContext blocks until the fakeClock has the given number of waiters
 // or the context is cancelled.
-func (fc *fakeClock) BlockUntilContext(ctx context.Context, n int) error {
+func (fc *FakeClock) BlockUntilContext(ctx context.Context, n int) error {
 	b := fc.newBlocker(n)
 	if b == nil {
 		return nil
@@ -243,7 +249,7 @@ func (fc *fakeClock) BlockUntilContext(ctx context.Context, n int) error {
 	}
 }
 
-func (fc *fakeClock) newBlocker(n int) *blocker {
+func (fc *FakeClock) newBlocker(n int) *blocker {
 	fc.l.Lock()
 	defer fc.l.Unlock()
 	// Fast path: we already have >= n waiters.
@@ -260,7 +266,7 @@ func (fc *fakeClock) newBlocker(n int) *blocker {
 }
 
 // stop stops an expirer, returning true if the expirer was stopped.
-func (fc *fakeClock) stop(e expirer) bool {
+func (fc *FakeClock) stop(e expirer) bool {
 	fc.l.Lock()
 	defer fc.l.Unlock()
 	return fc.stopExpirer(e)
@@ -269,81 +275,45 @@ func (fc *fakeClock) stop(e expirer) bool {
 // stopExpirer stops an expirer, returning true if the expirer was stopped.
 //
 // The caller must hold fc.l.
-func (fc *fakeClock) stopExpirer(e expirer) bool {
-	for i, t := range fc.waiters {
-		if t == e {
-			// Remove element, maintaining order.
-			copy(fc.waiters[i:], fc.waiters[i+1:])
+func (fc *FakeClock) stopExpirer(e expirer) bool {
+	idx := slices.Index(fc.waiters, e)
+	if idx == -1 {
+		return false
+	}
+	// Remove element, maintaining order, setting inaccessible elements to nil so
+	// they can be garbage collected.
+	copy(fc.waiters[idx:], fc.waiters[idx+1:])
 	fc.waiters[len(fc.waiters)-1] = nil
 	fc.waiters = fc.waiters[:len(fc.waiters)-1]
 	return true
 }
-	}
-	return false
-}
-
-// set sets an expirer to expire at a future point in time.
-func (fc *fakeClock) set(e expirer, d time.Duration) {
-	fc.l.Lock()
-	defer fc.l.Unlock()
-	fc.setExpirer(e, d)
-}
 
 // setExpirer sets an expirer to expire at a future point in time.
 //
 // The caller must hold fc.l.
-func (fc *fakeClock) setExpirer(e expirer, d time.Duration) {
+func (fc *FakeClock) setExpirer(e expirer, d time.Duration) {
 	if d.Nanoseconds() <= 0 {
-		// special case - trigger immediately, never reset.
+		// Special case for timers with duration <= 0: trigger immediately, never
+		// reset.
 		//
-		// TODO: Explain what cases this covers.
+		// Tickers never get here, they panic if d is < 0.
 		e.expire(fc.time)
 		return
 	}
 	// Add the expirer to the set of waiters and notify any blockers.
-	e.setExpiry(fc.time.Add(d))
+	e.setExpiration(fc.time.Add(d))
 	fc.waiters = append(fc.waiters, e)
-	sort.Slice(fc.waiters, func(i int, j int) bool {
-		return fc.waiters[i].expiry().Before(fc.waiters[j].expiry())
+	slices.SortFunc(fc.waiters, func(a, b expirer) int {
+		return a.expiration().Compare(b.expiration())
 	})
 
 	// Notify blockers of our new waiter.
-	var blocked []*blocker
 	count := len(fc.waiters)
-	for _, b := range fc.blockers {
+	fc.blockers = slices.DeleteFunc(fc.blockers, func(b *blocker) bool {
 		if b.count <= count {
 			close(b.ch)
-			continue
+			return true
 		}
-		blocked = append(blocked, b)
-	}
-	fc.blockers = blocked
-}
-
-// firer is used by fakeTimer and fakeTicker used to help implement expirer.
-type firer struct {
-	// The channel associated with the firer, used to send expriation times.
-	c chan time.Time
-
-	// The time when the firer expires. Only meaningful if the firer is currently
-	// one of a fakeClock's waiters.
-	exp time.Time
-}
-
-func newFirer() firer {
-	return firer{c: make(chan time.Time, 1)}
-}
-
-func (f *firer) Chan() <-chan time.Time {
-	return f.c
-}
-
-// expiry implements expirer.
-func (f *firer) expiry() time.Time {
-	return f.exp
-}
-
-// setExpiry implements expirer.
-func (f *firer) setExpiry(t time.Time) {
-	f.exp = t
+		return false
+	})
 }

vendor/github.com/jonboulle/clockwork/context.go

@@ -2,24 +2,168 @@ package clockwork
 
 import (
 	"context"
+	"fmt"
+	"sync"
+	"time"
 )
 
 // contextKey is private to this package so we can ensure uniqueness here. This
 // type identifies context values provided by this package.
 type contextKey string
 
-// keyClock provides a clock for injecting during tests. If absent, a real clock should be used.
+// keyClock provides a clock for injecting during tests. If absent, a real clock
+// should be used.
 var keyClock = contextKey("clock") // clockwork.Clock
 
 // AddToContext creates a derived context that references the specified clock.
+//
+// Be aware this doesn't change the behavior of standard library functions, such
+// as [context.WithTimeout] or [context.WithDeadline]. For this reason, users
+// should prefer passing explicit [clockwork.Clock] variables rather can passing
+// the clock via the context.
 func AddToContext(ctx context.Context, clock Clock) context.Context {
 	return context.WithValue(ctx, keyClock, clock)
 }
 
-// FromContext extracts a clock from the context. If not present, a real clock is returned.
+// FromContext extracts a clock from the context. If not present, a real clock
+// is returned.
 func FromContext(ctx context.Context) Clock {
 	if clock, ok := ctx.Value(keyClock).(Clock); ok {
 		return clock
 	}
 	return NewRealClock()
 }
+
+// ErrFakeClockDeadlineExceeded is the error returned by [context.Context] when
+// the deadline passes on a context which uses a [FakeClock].
+//
+// It wraps a [context.DeadlineExceeded] error, i.e.:
+//
+//	// The following is true for any Context whose deadline has been exceeded,
+//	// including contexts made with clockwork.WithDeadline or clockwork.WithTimeout.
+//
+//	errors.Is(ctx.Err(), context.DeadlineExceeded)
+//
+//	// The following can only be true for contexts made
+//	// with clockwork.WithDeadline or clockwork.WithTimeout.
+//
+//	errors.Is(ctx.Err(), clockwork.ErrFakeClockDeadlineExceeded)
+var ErrFakeClockDeadlineExceeded error = fmt.Errorf("clockwork.FakeClock: %w", context.DeadlineExceeded)
+
+// WithDeadline returns a context with a deadline based on a [FakeClock].
+//
+// The returned context ignores parent cancelation if the parent was cancelled
+// with a [context.DeadlineExceeded] error. Any other error returned by the
+// parent is treated normally, cancelling the returned context.
+//
+// If the parent is cancelled with a [context.DeadlineExceeded] error, the only
+// way to then cancel the returned context is by calling the returned
+// context.CancelFunc.
+func WithDeadline(parent context.Context, clock Clock, t time.Time) (context.Context, context.CancelFunc) {
+	if fc, ok := clock.(*FakeClock); ok {
+		return newFakeClockContext(parent, t, fc.newTimerAtTime(t, nil).Chan())
+	}
+	return context.WithDeadline(parent, t)
+}
+
+// WithTimeout returns a context with a timeout based on a [FakeClock].
+//
+// The returned context follows the same behaviors as [WithDeadline].
+func WithTimeout(parent context.Context, clock Clock, d time.Duration) (context.Context, context.CancelFunc) {
+	if fc, ok := clock.(*FakeClock); ok {
+		t, deadline := fc.newTimer(d, nil)
+		return newFakeClockContext(parent, deadline, t.Chan())
+	}
+	return context.WithTimeout(parent, d)
+}
+
+// fakeClockContext implements context.Context, using a fake clock for its
+// deadline.
+//
+// It ignores parent cancellation if the parent is cancelled with
+// context.DeadlineExceeded.
+type fakeClockContext struct {
+	parent   context.Context
+	deadline time.Time // The user-facing deadline based on the fake clock's time.
+
+	// Tracks timeout/deadline cancellation.
+	timerDone <-chan time.Time
+
+	// Tracks manual calls to the cancel function.
+	cancel       func() // Closes cancelCalled wrapped in a sync.Once.
+	cancelCalled chan struct{}
+
+	// The user-facing data from the context.Context interface.
+	ctxDone chan struct{} // Returned by Done().
+	err     error         // nil until ctxDone is ready to be closed.
+}
+
+func newFakeClockContext(parent context.Context, deadline time.Time, timer <-chan time.Time) (context.Context, context.CancelFunc) {
+	cancelCalled := make(chan struct{})
+	ctx := &fakeClockContext{
+		parent:       parent,
+		deadline:     deadline,
+		timerDone:    timer,
+		cancelCalled: cancelCalled,
+		ctxDone:      make(chan struct{}),
+		cancel: sync.OnceFunc(func() {
+			close(cancelCalled)
+		}),
+	}
+	ready := make(chan struct{}, 1)
+	go ctx.runCancel(ready)
+	<-ready // Wait until the cancellation goroutine is running.
+	return ctx, ctx.cancel
+}
+
+func (c *fakeClockContext) Deadline() (time.Time, bool) {
+	return c.deadline, true
+}
+
+func (c *fakeClockContext) Done() <-chan struct{} {
+	return c.ctxDone
+}
+
+func (c *fakeClockContext) Err() error {
+	<-c.Done() // Don't return the error before it is ready.
+	return c.err
+}
+
+func (c *fakeClockContext) Value(key any) any {
+	return c.parent.Value(key)
+}
+
+// runCancel runs the fakeClockContext's cancel goroutine and returns the
+// fakeClockContext's cancel function.
+//
+// fakeClockContext is then cancelled when any of the following occur:
+//
+//   - The fakeClockContext.done channel is closed by its timer.
+//   - The returned CancelFunc is executed.
+//   - The fakeClockContext's parent context is cancelled with an error other
+//     than context.DeadlineExceeded.
+func (c *fakeClockContext) runCancel(ready chan struct{}) {
+	parentDone := c.parent.Done()
+
+	// Close ready when done, just in case the ready signal races with other
+	// branches of our select statement below.
+	defer close(ready)
+
+	for c.err == nil {
+		select {
+		case <-c.timerDone:
+			c.err = ErrFakeClockDeadlineExceeded
+		case <-c.cancelCalled:
+			c.err = context.Canceled
+		case <-parentDone:
+			c.err = c.parent.Err()
+
+		case ready <- struct{}{}:
+			// Signals the cancellation goroutine has begun, in an attempt to minimize
+			// race conditions related to goroutine startup time.
+			ready = nil // This case statement can only fire once.
+		}
+	}
+	close(c.ctxDone)
+	return
+}

vendor/github.com/jonboulle/clockwork/ticker.go

@@ -19,7 +19,12 @@ func (r realTicker) Chan() <-chan time.Time {
 }
 
 type fakeTicker struct {
-	firer
+	// The channel associated with the firer, used to send expiration times.
+	c chan time.Time
+
+	// The time when the ticker expires. Only meaningful if the ticker is currently
+	// one of a FakeClock's waiters.
+	exp time.Time
 
 	// reset and stop provide the implementation of the respective exported
 	// functions.
@@ -30,13 +35,27 @@ type fakeTicker struct {
 	d time.Duration
 }
 
-func (f *fakeTicker) Reset(d time.Duration) {
-	f.reset(d)
+func newFakeTicker(fc *FakeClock, d time.Duration) *fakeTicker {
+	var ft *fakeTicker
+	ft = &fakeTicker{
+		c: make(chan time.Time, 1),
+		d: d,
+		reset: func(d time.Duration) {
+			fc.l.Lock()
+			defer fc.l.Unlock()
+			ft.d = d
+			fc.setExpirer(ft, d)
+		},
+		stop: func() { fc.stop(ft) },
+	}
+	return ft
 }
 
-func (f *fakeTicker) Stop() {
-	f.stop()
-}
+func (f *fakeTicker) Chan() <-chan time.Time { return f.c }
+
+func (f *fakeTicker) Reset(d time.Duration) { f.reset(d) }
+
+func (f *fakeTicker) Stop() { f.stop() }
 
 func (f *fakeTicker) expire(now time.Time) *time.Duration {
 	// Never block on expiration.
@@ -46,3 +65,7 @@ func (f *fakeTicker) expire(now time.Time) *time.Duration {
 	}
 	return &f.d
 }
+
+func (f *fakeTicker) expiration() time.Time { return f.exp }
+
+func (f *fakeTicker) setExpiration(t time.Time) { f.exp = t }

vendor/github.com/jonboulle/clockwork/timer.go

@@ -18,9 +18,14 @@ func (r realTimer) Chan() <-chan time.Time {
 }
 
 type fakeTimer struct {
-	firer
+	// The channel associated with the firer, used to send expiration times.
+	c chan time.Time
 
-	// reset and stop provide the implmenetation of the respective exported
+	// The time when the firer expires. Only meaningful if the firer is currently
+	// one of a FakeClock's waiters.
+	exp time.Time
+
+	// reset and stop provide the implementation of the respective exported
 	// functions.
 	reset func(d time.Duration) bool
 	stop  func() bool
@@ -30,13 +35,30 @@ type fakeTimer struct {
 	afterFunc func()
 }
 
-func (f *fakeTimer) Reset(d time.Duration) bool {
-	return f.reset(d)
+func newFakeTimer(fc *FakeClock, afterfunc func()) *fakeTimer {
+	var ft *fakeTimer
+	ft = &fakeTimer{
+		c: make(chan time.Time, 1),
+		reset: func(d time.Duration) bool {
+			fc.l.Lock()
+			defer fc.l.Unlock()
+			// fc.l must be held across the calls to stopExpirer & setExpirer.
+			stopped := fc.stopExpirer(ft)
+			fc.setExpirer(ft, d)
+			return stopped
+		},
+		stop: func() bool { return fc.stop(ft) },
+
+		afterFunc: afterfunc,
+	}
+	return ft
 }
 
-func (f *fakeTimer) Stop() bool {
-	return f.stop()
-}
+func (f *fakeTimer) Chan() <-chan time.Time { return f.c }
+
+func (f *fakeTimer) Reset(d time.Duration) bool { return f.reset(d) }
+
+func (f *fakeTimer) Stop() bool { return f.stop() }
 
 func (f *fakeTimer) expire(now time.Time) *time.Duration {
 	if f.afterFunc != nil {
@@ -51,3 +73,7 @@ func (f *fakeTimer) expire(now time.Time) *time.Duration {
 	}
 	return nil
 }
+
+func (f *fakeTimer) expiration() time.Time { return f.exp }
+
+func (f *fakeTimer) setExpiration(t time.Time) { f.exp = t }

vendor/golang.org/x/exp/LICENSE

@@ -1,27 +0,0 @@
-Copyright 2009 The Go Authors.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google LLC nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/golang.org/x/exp/PATENTS

@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.

vendor/golang.org/x/exp/constraints/constraints.go

@@ -1,50 +0,0 @@
-// Copyright 2021 The Go 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 constraints defines a set of useful constraints to be used
-// with type parameters.
-package constraints
-
-// Signed is a constraint that permits any signed integer type.
-// If future releases of Go add new predeclared signed integer types,
-// this constraint will be modified to include them.
-type Signed interface {
-	~int | ~int8 | ~int16 | ~int32 | ~int64
-}
-
-// Unsigned is a constraint that permits any unsigned integer type.
-// If future releases of Go add new predeclared unsigned integer types,
-// this constraint will be modified to include them.
-type Unsigned interface {
-	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
-}
-
-// Integer is a constraint that permits any integer type.
-// If future releases of Go add new predeclared integer types,
-// this constraint will be modified to include them.
-type Integer interface {
-	Signed | Unsigned
-}
-
-// Float is a constraint that permits any floating-point type.
-// If future releases of Go add new predeclared floating-point types,
-// this constraint will be modified to include them.
-type Float interface {
-	~float32 | ~float64
-}
-
-// Complex is a constraint that permits any complex numeric type.
-// If future releases of Go add new predeclared complex numeric types,
-// this constraint will be modified to include them.
-type Complex interface {
-	~complex64 | ~complex128
-}
-
-// Ordered is a constraint that permits any ordered type: any type
-// that supports the operators < <= >= >.
-// If future releases of Go add new ordered types,
-// this constraint will be modified to include them.
-type Ordered interface {
-	Integer | Float | ~string
-}

vendor/golang.org/x/exp/maps/maps.go

@@ -1,94 +0,0 @@
-// Copyright 2021 The Go 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 maps defines various functions useful with maps of any type.
-package maps
-
-// Keys returns the keys of the map m.
-// The keys will be in an indeterminate order.
-func Keys[M ~map[K]V, K comparable, V any](m M) []K {
-	r := make([]K, 0, len(m))
-	for k := range m {
-		r = append(r, k)
-	}
-	return r
-}
-
-// Values returns the values of the map m.
-// The values will be in an indeterminate order.
-func Values[M ~map[K]V, K comparable, V any](m M) []V {
-	r := make([]V, 0, len(m))
-	for _, v := range m {
-		r = append(r, v)
-	}
-	return r
-}
-
-// Equal reports whether two maps contain the same key/value pairs.
-// Values are compared using ==.
-func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
-	if len(m1) != len(m2) {
-		return false
-	}
-	for k, v1 := range m1 {
-		if v2, ok := m2[k]; !ok || v1 != v2 {
-			return false
-		}
-	}
-	return true
-}
-
-// EqualFunc is like Equal, but compares values using eq.
-// Keys are still compared with ==.
-func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
-	if len(m1) != len(m2) {
-		return false
-	}
-	for k, v1 := range m1 {
-		if v2, ok := m2[k]; !ok || !eq(v1, v2) {
-			return false
-		}
-	}
-	return true
-}
-
-// Clear removes all entries from m, leaving it empty.
-func Clear[M ~map[K]V, K comparable, V any](m M) {
-	for k := range m {
-		delete(m, k)
-	}
-}
-
-// Clone returns a copy of m.  This is a shallow clone:
-// the new keys and values are set using ordinary assignment.
-func Clone[M ~map[K]V, K comparable, V any](m M) M {
-	// Preserve nil in case it matters.
-	if m == nil {
-		return nil
-	}
-	r := make(M, len(m))
-	for k, v := range m {
-		r[k] = v
-	}
-	return r
-}
-
-// Copy copies all key/value pairs in src adding them to dst.
-// When a key in src is already present in dst,
-// the value in dst will be overwritten by the value associated
-// with the key in src.
-func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
-	for k, v := range src {
-		dst[k] = v
-	}
-}
-
-// DeleteFunc deletes any key/value pairs from m for which del returns true.
-func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
-	for k, v := range m {
-		if del(k, v) {
-			delete(m, k)
-		}
-	}
-}

vendor/golang.org/x/exp/slices/cmp.go

@@ -1,44 +0,0 @@
-// Copyright 2023 The Go 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 slices
-
-import "golang.org/x/exp/constraints"
-
-// min is a version of the predeclared function from the Go 1.21 release.
-func min[T constraints.Ordered](a, b T) T {
-	if a < b || isNaN(a) {
-		return a
-	}
-	return b
-}
-
-// max is a version of the predeclared function from the Go 1.21 release.
-func max[T constraints.Ordered](a, b T) T {
-	if a > b || isNaN(a) {
-		return a
-	}
-	return b
-}
-
-// cmpLess is a copy of cmp.Less from the Go 1.21 release.
-func cmpLess[T constraints.Ordered](x, y T) bool {
-	return (isNaN(x) && !isNaN(y)) || x < y
-}
-
-// cmpCompare is a copy of cmp.Compare from the Go 1.21 release.
-func cmpCompare[T constraints.Ordered](x, y T) int {
-	xNaN := isNaN(x)
-	yNaN := isNaN(y)
-	if xNaN && yNaN {
-		return 0
-	}
-	if xNaN || x < y {
-		return -1
-	}
-	if yNaN || x > y {
-		return +1
-	}
-	return 0
-}

vendor/golang.org/x/exp/slices/slices.go

@@ -1,515 +0,0 @@
-// Copyright 2021 The Go 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 slices defines various functions useful with slices of any type.
-package slices
-
-import (
-	"unsafe"
-
-	"golang.org/x/exp/constraints"
-)
-
-// Equal reports whether two slices are equal: the same length and all
-// elements equal. If the lengths are different, Equal returns false.
-// Otherwise, the elements are compared in increasing index order, and the
-// comparison stops at the first unequal pair.
-// Floating point NaNs are not considered equal.
-func Equal[S ~[]E, E comparable](s1, s2 S) bool {
-	if len(s1) != len(s2) {
-		return false
-	}
-	for i := range s1 {
-		if s1[i] != s2[i] {
-			return false
-		}
-	}
-	return true
-}
-
-// EqualFunc reports whether two slices are equal using an equality
-// function on each pair of elements. If the lengths are different,
-// EqualFunc returns false. Otherwise, the elements are compared in
-// increasing index order, and the comparison stops at the first index
-// for which eq returns false.
-func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool {
-	if len(s1) != len(s2) {
-		return false
-	}
-	for i, v1 := range s1 {
-		v2 := s2[i]
-		if !eq(v1, v2) {
-			return false
-		}
-	}
-	return true
-}
-
-// Compare compares the elements of s1 and s2, using [cmp.Compare] on each pair
-// of elements. The elements are compared sequentially, starting at index 0,
-// until one element is not equal to the other.
-// The result of comparing the first non-matching elements is returned.
-// If both slices are equal until one of them ends, the shorter slice is
-// considered less than the longer one.
-// The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.
-func Compare[S ~[]E, E constraints.Ordered](s1, s2 S) int {
-	for i, v1 := range s1 {
-		if i >= len(s2) {
-			return +1
-		}
-		v2 := s2[i]
-		if c := cmpCompare(v1, v2); c != 0 {
-			return c
-		}
-	}
-	if len(s1) < len(s2) {
-		return -1
-	}
-	return 0
-}
-
-// CompareFunc is like [Compare] but uses a custom comparison function on each
-// pair of elements.
-// The result is the first non-zero result of cmp; if cmp always
-// returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
-// and +1 if len(s1) > len(s2).
-func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int {
-	for i, v1 := range s1 {
-		if i >= len(s2) {
-			return +1
-		}
-		v2 := s2[i]
-		if c := cmp(v1, v2); c != 0 {
-			return c
-		}
-	}
-	if len(s1) < len(s2) {
-		return -1
-	}
-	return 0
-}
-
-// Index returns the index of the first occurrence of v in s,
-// or -1 if not present.
-func Index[S ~[]E, E comparable](s S, v E) int {
-	for i := range s {
-		if v == s[i] {
-			return i
-		}
-	}
-	return -1
-}
-
-// IndexFunc returns the first index i satisfying f(s[i]),
-// or -1 if none do.
-func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int {
-	for i := range s {
-		if f(s[i]) {
-			return i
-		}
-	}
-	return -1
-}
-
-// Contains reports whether v is present in s.
-func Contains[S ~[]E, E comparable](s S, v E) bool {
-	return Index(s, v) >= 0
-}
-
-// ContainsFunc reports whether at least one
-// element e of s satisfies f(e).
-func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool {
-	return IndexFunc(s, f) >= 0
-}
-
-// Insert inserts the values v... into s at index i,
-// returning the modified slice.
-// The elements at s[i:] are shifted up to make room.
-// In the returned slice r, r[i] == v[0],
-// and r[i+len(v)] == value originally at r[i].
-// Insert panics if i is out of range.
-// This function is O(len(s) + len(v)).
-func Insert[S ~[]E, E any](s S, i int, v ...E) S {
-	m := len(v)
-	if m == 0 {
-		return s
-	}
-	n := len(s)
-	if i == n {
-		return append(s, v...)
-	}
-	if n+m > cap(s) {
-		// Use append rather than make so that we bump the size of
-		// the slice up to the next storage class.
-		// This is what Grow does but we don't call Grow because
-		// that might copy the values twice.
-		s2 := append(s[:i], make(S, n+m-i)...)
-		copy(s2[i:], v)
-		copy(s2[i+m:], s[i:])
-		return s2
-	}
-	s = s[:n+m]
-
-	// before:
-	// s: aaaaaaaabbbbccccccccdddd
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-	// after:
-	// s: aaaaaaaavvvvbbbbcccccccc
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-	//
-	// a are the values that don't move in s.
-	// v are the values copied in from v.
-	// b and c are the values from s that are shifted up in index.
-	// d are the values that get overwritten, never to be seen again.
-
-	if !overlaps(v, s[i+m:]) {
-		// Easy case - v does not overlap either the c or d regions.
-		// (It might be in some of a or b, or elsewhere entirely.)
-		// The data we copy up doesn't write to v at all, so just do it.
-
-		copy(s[i+m:], s[i:])
-
-		// Now we have
-		// s: aaaaaaaabbbbbbbbcccccccc
-		//            ^   ^       ^   ^
-		//            i  i+m      n  n+m
-		// Note the b values are duplicated.
-
-		copy(s[i:], v)
-
-		// Now we have
-		// s: aaaaaaaavvvvbbbbcccccccc
-		//            ^   ^       ^   ^
-		//            i  i+m      n  n+m
-		// That's the result we want.
-		return s
-	}
-
-	// The hard case - v overlaps c or d. We can't just shift up
-	// the data because we'd move or clobber the values we're trying
-	// to insert.
-	// So instead, write v on top of d, then rotate.
-	copy(s[n:], v)
-
-	// Now we have
-	// s: aaaaaaaabbbbccccccccvvvv
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-
-	rotateRight(s[i:], m)
-
-	// Now we have
-	// s: aaaaaaaavvvvbbbbcccccccc
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-	// That's the result we want.
-	return s
-}
-
-// clearSlice sets all elements up to the length of s to the zero value of E.
-// We may use the builtin clear func instead, and remove clearSlice, when upgrading
-// to Go 1.21+.
-func clearSlice[S ~[]E, E any](s S) {
-	var zero E
-	for i := range s {
-		s[i] = zero
-	}
-}
-
-// Delete removes the elements s[i:j] from s, returning the modified slice.
-// Delete panics if j > len(s) or s[i:j] is not a valid slice of s.
-// Delete is O(len(s)-i), so if many items must be deleted, it is better to
-// make a single call deleting them all together than to delete one at a time.
-// Delete zeroes the elements s[len(s)-(j-i):len(s)].
-func Delete[S ~[]E, E any](s S, i, j int) S {
-	_ = s[i:j:len(s)] // bounds check
-
-	if i == j {
-		return s
-	}
-
-	oldlen := len(s)
-	s = append(s[:i], s[j:]...)
-	clearSlice(s[len(s):oldlen]) // zero/nil out the obsolete elements, for GC
-	return s
-}
-
-// DeleteFunc removes any elements from s for which del returns true,
-// returning the modified slice.
-// DeleteFunc zeroes the elements between the new length and the original length.
-func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
-	i := IndexFunc(s, del)
-	if i == -1 {
-		return s
-	}
-	// Don't start copying elements until we find one to delete.
-	for j := i + 1; j < len(s); j++ {
-		if v := s[j]; !del(v) {
-			s[i] = v
-			i++
-		}
-	}
-	clearSlice(s[i:]) // zero/nil out the obsolete elements, for GC
-	return s[:i]
-}
-
-// Replace replaces the elements s[i:j] by the given v, and returns the
-// modified slice. Replace panics if s[i:j] is not a valid slice of s.
-// When len(v) < (j-i), Replace zeroes the elements between the new length and the original length.
-func Replace[S ~[]E, E any](s S, i, j int, v ...E) S {
-	_ = s[i:j] // verify that i:j is a valid subslice
-
-	if i == j {
-		return Insert(s, i, v...)
-	}
-	if j == len(s) {
-		return append(s[:i], v...)
-	}
-
-	tot := len(s[:i]) + len(v) + len(s[j:])
-	if tot > cap(s) {
-		// Too big to fit, allocate and copy over.
-		s2 := append(s[:i], make(S, tot-i)...) // See Insert
-		copy(s2[i:], v)
-		copy(s2[i+len(v):], s[j:])
-		return s2
-	}
-
-	r := s[:tot]
-
-	if i+len(v) <= j {
-		// Easy, as v fits in the deleted portion.
-		copy(r[i:], v)
-		if i+len(v) != j {
-			copy(r[i+len(v):], s[j:])
-		}
-		clearSlice(s[tot:]) // zero/nil out the obsolete elements, for GC
-		return r
-	}
-
-	// We are expanding (v is bigger than j-i).
-	// The situation is something like this:
-	// (example has i=4,j=8,len(s)=16,len(v)=6)
-	// s: aaaaxxxxbbbbbbbbyy
-	//        ^   ^       ^ ^
-	//        i   j  len(s) tot
-	// a: prefix of s
-	// x: deleted range
-	// b: more of s
-	// y: area to expand into
-
-	if !overlaps(r[i+len(v):], v) {
-		// Easy, as v is not clobbered by the first copy.
-		copy(r[i+len(v):], s[j:])
-		copy(r[i:], v)
-		return r
-	}
-
-	// This is a situation where we don't have a single place to which
-	// we can copy v. Parts of it need to go to two different places.
-	// We want to copy the prefix of v into y and the suffix into x, then
-	// rotate |y| spots to the right.
-	//
-	//        v[2:]      v[:2]
-	//         |           |
-	// s: aaaavvvvbbbbbbbbvv
-	//        ^   ^       ^ ^
-	//        i   j  len(s) tot
-	//
-	// If either of those two destinations don't alias v, then we're good.
-	y := len(v) - (j - i) // length of y portion
-
-	if !overlaps(r[i:j], v) {
-		copy(r[i:j], v[y:])
-		copy(r[len(s):], v[:y])
-		rotateRight(r[i:], y)
-		return r
-	}
-	if !overlaps(r[len(s):], v) {
-		copy(r[len(s):], v[:y])
-		copy(r[i:j], v[y:])
-		rotateRight(r[i:], y)
-		return r
-	}
-
-	// Now we know that v overlaps both x and y.
-	// That means that the entirety of b is *inside* v.
-	// So we don't need to preserve b at all; instead we
-	// can copy v first, then copy the b part of v out of
-	// v to the right destination.
-	k := startIdx(v, s[j:])
-	copy(r[i:], v)
-	copy(r[i+len(v):], r[i+k:])
-	return r
-}
-
-// Clone returns a copy of the slice.
-// The elements are copied using assignment, so this is a shallow clone.
-func Clone[S ~[]E, E any](s S) S {
-	// Preserve nil in case it matters.
-	if s == nil {
-		return nil
-	}
-	return append(S([]E{}), s...)
-}
-
-// Compact replaces consecutive runs of equal elements with a single copy.
-// This is like the uniq command found on Unix.
-// Compact modifies the contents of the slice s and returns the modified slice,
-// which may have a smaller length.
-// Compact zeroes the elements between the new length and the original length.
-func Compact[S ~[]E, E comparable](s S) S {
-	if len(s) < 2 {
-		return s
-	}
-	i := 1
-	for k := 1; k < len(s); k++ {
-		if s[k] != s[k-1] {
-			if i != k {
-				s[i] = s[k]
-			}
-			i++
-		}
-	}
-	clearSlice(s[i:]) // zero/nil out the obsolete elements, for GC
-	return s[:i]
-}
-
-// CompactFunc is like [Compact] but uses an equality function to compare elements.
-// For runs of elements that compare equal, CompactFunc keeps the first one.
-// CompactFunc zeroes the elements between the new length and the original length.
-func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S {
-	if len(s) < 2 {
-		return s
-	}
-	i := 1
-	for k := 1; k < len(s); k++ {
-		if !eq(s[k], s[k-1]) {
-			if i != k {
-				s[i] = s[k]
-			}
-			i++
-		}
-	}
-	clearSlice(s[i:]) // zero/nil out the obsolete elements, for GC
-	return s[:i]
-}
-
-// Grow increases the slice's capacity, if necessary, to guarantee space for
-// another n elements. After Grow(n), at least n elements can be appended
-// to the slice without another allocation. If n is negative or too large to
-// allocate the memory, Grow panics.
-func Grow[S ~[]E, E any](s S, n int) S {
-	if n < 0 {
-		panic("cannot be negative")
-	}
-	if n -= cap(s) - len(s); n > 0 {
-		// TODO(https://go.dev/issue/53888): Make using []E instead of S
-		// to workaround a compiler bug where the runtime.growslice optimization
-		// does not take effect. Revert when the compiler is fixed.
-		s = append([]E(s)[:cap(s)], make([]E, n)...)[:len(s)]
-	}
-	return s
-}
-
-// Clip removes unused capacity from the slice, returning s[:len(s):len(s)].
-func Clip[S ~[]E, E any](s S) S {
-	return s[:len(s):len(s)]
-}
-
-// Rotation algorithm explanation:
-//
-// rotate left by 2
-// start with
-//   0123456789
-// split up like this
-//   01 234567 89
-// swap first 2 and last 2
-//   89 234567 01
-// join first parts
-//   89234567 01
-// recursively rotate first left part by 2
-//   23456789 01
-// join at the end
-//   2345678901
-//
-// rotate left by 8
-// start with
-//   0123456789
-// split up like this
-//   01 234567 89
-// swap first 2 and last 2
-//   89 234567 01
-// join last parts
-//   89 23456701
-// recursively rotate second part left by 6
-//   89 01234567
-// join at the end
-//   8901234567
-
-// TODO: There are other rotate algorithms.
-// This algorithm has the desirable property that it moves each element exactly twice.
-// The triple-reverse algorithm is simpler and more cache friendly, but takes more writes.
-// The follow-cycles algorithm can be 1-write but it is not very cache friendly.
-
-// rotateLeft rotates b left by n spaces.
-// s_final[i] = s_orig[i+r], wrapping around.
-func rotateLeft[E any](s []E, r int) {
-	for r != 0 && r != len(s) {
-		if r*2 <= len(s) {
-			swap(s[:r], s[len(s)-r:])
-			s = s[:len(s)-r]
-		} else {
-			swap(s[:len(s)-r], s[r:])
-			s, r = s[len(s)-r:], r*2-len(s)
-		}
-	}
-}
-func rotateRight[E any](s []E, r int) {
-	rotateLeft(s, len(s)-r)
-}
-
-// swap swaps the contents of x and y. x and y must be equal length and disjoint.
-func swap[E any](x, y []E) {
-	for i := 0; i < len(x); i++ {
-		x[i], y[i] = y[i], x[i]
-	}
-}
-
-// overlaps reports whether the memory ranges a[0:len(a)] and b[0:len(b)] overlap.
-func overlaps[E any](a, b []E) bool {
-	if len(a) == 0 || len(b) == 0 {
-		return false
-	}
-	elemSize := unsafe.Sizeof(a[0])
-	if elemSize == 0 {
-		return false
-	}
-	// TODO: use a runtime/unsafe facility once one becomes available. See issue 12445.
-	// Also see crypto/internal/alias/alias.go:AnyOverlap
-	return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
-		uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
-}
-
-// startIdx returns the index in haystack where the needle starts.
-// prerequisite: the needle must be aliased entirely inside the haystack.
-func startIdx[E any](haystack, needle []E) int {
-	p := &needle[0]
-	for i := range haystack {
-		if p == &haystack[i] {
-			return i
-		}
-	}
-	// TODO: what if the overlap is by a non-integral number of Es?
-	panic("needle not found")
-}
-
-// Reverse reverses the elements of the slice in place.
-func Reverse[S ~[]E, E any](s S) {
-	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
-		s[i], s[j] = s[j], s[i]
-	}
-}

vendor/golang.org/x/exp/slices/sort.go

@@ -1,197 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run $GOROOT/src/sort/gen_sort_variants.go -exp
-
-package slices
-
-import (
-	"math/bits"
-
-	"golang.org/x/exp/constraints"
-)
-
-// Sort sorts a slice of any ordered type in ascending order.
-// When sorting floating-point numbers, NaNs are ordered before other values.
-func Sort[S ~[]E, E constraints.Ordered](x S) {
-	n := len(x)
-	pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
-}
-
-// SortFunc sorts the slice x in ascending order as determined by the cmp
-// function. This sort is not guaranteed to be stable.
-// cmp(a, b) should return a negative number when a < b, a positive number when
-// a > b and zero when a == b or when a is not comparable to b in the sense
-// of the formal definition of Strict Weak Ordering.
-//
-// SortFunc requires that cmp is a strict weak ordering.
-// See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
-// To indicate 'uncomparable', return 0 from the function.
-func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
-	n := len(x)
-	pdqsortCmpFunc(x, 0, n, bits.Len(uint(n)), cmp)
-}
-
-// SortStableFunc sorts the slice x while keeping the original order of equal
-// elements, using cmp to compare elements in the same way as [SortFunc].
-func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
-	stableCmpFunc(x, len(x), cmp)
-}
-
-// IsSorted reports whether x is sorted in ascending order.
-func IsSorted[S ~[]E, E constraints.Ordered](x S) bool {
-	for i := len(x) - 1; i > 0; i-- {
-		if cmpLess(x[i], x[i-1]) {
-			return false
-		}
-	}
-	return true
-}
-
-// IsSortedFunc reports whether x is sorted in ascending order, with cmp as the
-// comparison function as defined by [SortFunc].
-func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool {
-	for i := len(x) - 1; i > 0; i-- {
-		if cmp(x[i], x[i-1]) < 0 {
-			return false
-		}
-	}
-	return true
-}
-
-// Min returns the minimal value in x. It panics if x is empty.
-// For floating-point numbers, Min propagates NaNs (any NaN value in x
-// forces the output to be NaN).
-func Min[S ~[]E, E constraints.Ordered](x S) E {
-	if len(x) < 1 {
-		panic("slices.Min: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		m = min(m, x[i])
-	}
-	return m
-}
-
-// MinFunc returns the minimal value in x, using cmp to compare elements.
-// It panics if x is empty. If there is more than one minimal element
-// according to the cmp function, MinFunc returns the first one.
-func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
-	if len(x) < 1 {
-		panic("slices.MinFunc: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		if cmp(x[i], m) < 0 {
-			m = x[i]
-		}
-	}
-	return m
-}
-
-// Max returns the maximal value in x. It panics if x is empty.
-// For floating-point E, Max propagates NaNs (any NaN value in x
-// forces the output to be NaN).
-func Max[S ~[]E, E constraints.Ordered](x S) E {
-	if len(x) < 1 {
-		panic("slices.Max: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		m = max(m, x[i])
-	}
-	return m
-}
-
-// MaxFunc returns the maximal value in x, using cmp to compare elements.
-// It panics if x is empty. If there is more than one maximal element
-// according to the cmp function, MaxFunc returns the first one.
-func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
-	if len(x) < 1 {
-		panic("slices.MaxFunc: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		if cmp(x[i], m) > 0 {
-			m = x[i]
-		}
-	}
-	return m
-}
-
-// BinarySearch searches for target in a sorted slice and returns the position
-// where target is found, or the position where target would appear in the
-// sort order; it also returns a bool saying whether the target is really found
-// in the slice. The slice must be sorted in increasing order.
-func BinarySearch[S ~[]E, E constraints.Ordered](x S, target E) (int, bool) {
-	// Inlining is faster than calling BinarySearchFunc with a lambda.
-	n := len(x)
-	// Define x[-1] < target and x[n] >= target.
-	// Invariant: x[i-1] < target, x[j] >= target.
-	i, j := 0, n
-	for i < j {
-		h := int(uint(i+j) >> 1) // avoid overflow when computing h
-		// i ≤ h < j
-		if cmpLess(x[h], target) {
-			i = h + 1 // preserves x[i-1] < target
-		} else {
-			j = h // preserves x[j] >= target
-		}
-	}
-	// i == j, x[i-1] < target, and x[j] (= x[i]) >= target  =>  answer is i.
-	return i, i < n && (x[i] == target || (isNaN(x[i]) && isNaN(target)))
-}
-
-// BinarySearchFunc works like [BinarySearch], but uses a custom comparison
-// function. The slice must be sorted in increasing order, where "increasing"
-// is defined by cmp. cmp should return 0 if the slice element matches
-// the target, a negative number if the slice element precedes the target,
-// or a positive number if the slice element follows the target.
-// cmp must implement the same ordering as the slice, such that if
-// cmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.
-func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool) {
-	n := len(x)
-	// Define cmp(x[-1], target) < 0 and cmp(x[n], target) >= 0 .
-	// Invariant: cmp(x[i - 1], target) < 0, cmp(x[j], target) >= 0.
-	i, j := 0, n
-	for i < j {
-		h := int(uint(i+j) >> 1) // avoid overflow when computing h
-		// i ≤ h < j
-		if cmp(x[h], target) < 0 {
-			i = h + 1 // preserves cmp(x[i - 1], target) < 0
-		} else {
-			j = h // preserves cmp(x[j], target) >= 0
-		}
-	}
-	// i == j, cmp(x[i-1], target) < 0, and cmp(x[j], target) (= cmp(x[i], target)) >= 0  =>  answer is i.
-	return i, i < n && cmp(x[i], target) == 0
-}
-
-type sortedHint int // hint for pdqsort when choosing the pivot
-
-const (
-	unknownHint sortedHint = iota
-	increasingHint
-	decreasingHint
-)
-
-// xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
-type xorshift uint64
-
-func (r *xorshift) Next() uint64 {
-	*r ^= *r << 13
-	*r ^= *r >> 17
-	*r ^= *r << 5
-	return uint64(*r)
-}
-
-func nextPowerOfTwo(length int) uint {
-	return 1 << bits.Len(uint(length))
-}
-
-// isNaN reports whether x is a NaN without requiring the math package.
-// This will always return false if T is not floating-point.
-func isNaN[T constraints.Ordered](x T) bool {
-	return x != x
-}

vendor/golang.org/x/exp/slices/zsortanyfunc.go

@@ -1,479 +0,0 @@
-// Code generated by gen_sort_variants.go; DO NOT EDIT.
-
-// Copyright 2022 The Go 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 slices
-
-// insertionSortCmpFunc sorts data[a:b] using insertion sort.
-func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	for i := a + 1; i < b; i++ {
-		for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
-			data[j], data[j-1] = data[j-1], data[j]
-		}
-	}
-}
-
-// siftDownCmpFunc implements the heap property on data[lo:hi].
-// first is an offset into the array where the root of the heap lies.
-func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
-	root := lo
-	for {
-		child := 2*root + 1
-		if child >= hi {
-			break
-		}
-		if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
-			child++
-		}
-		if !(cmp(data[first+root], data[first+child]) < 0) {
-			return
-		}
-		data[first+root], data[first+child] = data[first+child], data[first+root]
-		root = child
-	}
-}
-
-func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	first := a
-	lo := 0
-	hi := b - a
-
-	// Build heap with greatest element at top.
-	for i := (hi - 1) / 2; i >= 0; i-- {
-		siftDownCmpFunc(data, i, hi, first, cmp)
-	}
-
-	// Pop elements, largest first, into end of data.
-	for i := hi - 1; i >= 0; i-- {
-		data[first], data[first+i] = data[first+i], data[first]
-		siftDownCmpFunc(data, lo, i, first, cmp)
-	}
-}
-
-// pdqsortCmpFunc sorts data[a:b].
-// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
-// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
-// C++ implementation: https://github.com/orlp/pdqsort
-// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
-// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
-func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
-	const maxInsertion = 12
-
-	var (
-		wasBalanced    = true // whether the last partitioning was reasonably balanced
-		wasPartitioned = true // whether the slice was already partitioned
-	)
-
-	for {
-		length := b - a
-
-		if length <= maxInsertion {
-			insertionSortCmpFunc(data, a, b, cmp)
-			return
-		}
-
-		// Fall back to heapsort if too many bad choices were made.
-		if limit == 0 {
-			heapSortCmpFunc(data, a, b, cmp)
-			return
-		}
-
-		// If the last partitioning was imbalanced, we need to breaking patterns.
-		if !wasBalanced {
-			breakPatternsCmpFunc(data, a, b, cmp)
-			limit--
-		}
-
-		pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
-		if hint == decreasingHint {
-			reverseRangeCmpFunc(data, a, b, cmp)
-			// The chosen pivot was pivot-a elements after the start of the array.
-			// After reversing it is pivot-a elements before the end of the array.
-			// The idea came from Rust's implementation.
-			pivot = (b - 1) - (pivot - a)
-			hint = increasingHint
-		}
-
-		// The slice is likely already sorted.
-		if wasBalanced && wasPartitioned && hint == increasingHint {
-			if partialInsertionSortCmpFunc(data, a, b, cmp) {
-				return
-			}
-		}
-
-		// Probably the slice contains many duplicate elements, partition the slice into
-		// elements equal to and elements greater than the pivot.
-		if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
-			mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
-			a = mid
-			continue
-		}
-
-		mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
-		wasPartitioned = alreadyPartitioned
-
-		leftLen, rightLen := mid-a, b-mid
-		balanceThreshold := length / 8
-		if leftLen < rightLen {
-			wasBalanced = leftLen >= balanceThreshold
-			pdqsortCmpFunc(data, a, mid, limit, cmp)
-			a = mid + 1
-		} else {
-			wasBalanced = rightLen >= balanceThreshold
-			pdqsortCmpFunc(data, mid+1, b, limit, cmp)
-			b = mid
-		}
-	}
-}
-
-// partitionCmpFunc does one quicksort partition.
-// Let p = data[pivot]
-// Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
-// On return, data[newpivot] = p
-func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for i <= j && (cmp(data[i], data[a]) < 0) {
-		i++
-	}
-	for i <= j && !(cmp(data[j], data[a]) < 0) {
-		j--
-	}
-	if i > j {
-		data[j], data[a] = data[a], data[j]
-		return j, true
-	}
-	data[i], data[j] = data[j], data[i]
-	i++
-	j--
-
-	for {
-		for i <= j && (cmp(data[i], data[a]) < 0) {
-			i++
-		}
-		for i <= j && !(cmp(data[j], data[a]) < 0) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	data[j], data[a] = data[a], data[j]
-	return j, false
-}
-
-// partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
-// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
-func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for {
-		for i <= j && !(cmp(data[a], data[i]) < 0) {
-			i++
-		}
-		for i <= j && (cmp(data[a], data[j]) < 0) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	return i
-}
-
-// partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
-func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
-	const (
-		maxSteps         = 5  // maximum number of adjacent out-of-order pairs that will get shifted
-		shortestShifting = 50 // don't shift any elements on short arrays
-	)
-	i := a + 1
-	for j := 0; j < maxSteps; j++ {
-		for i < b && !(cmp(data[i], data[i-1]) < 0) {
-			i++
-		}
-
-		if i == b {
-			return true
-		}
-
-		if b-a < shortestShifting {
-			return false
-		}
-
-		data[i], data[i-1] = data[i-1], data[i]
-
-		// Shift the smaller one to the left.
-		if i-a >= 2 {
-			for j := i - 1; j >= 1; j-- {
-				if !(cmp(data[j], data[j-1]) < 0) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-		// Shift the greater one to the right.
-		if b-i >= 2 {
-			for j := i + 1; j < b; j++ {
-				if !(cmp(data[j], data[j-1]) < 0) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-	}
-	return false
-}
-
-// breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
-// that might cause imbalanced partitions in quicksort.
-func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	length := b - a
-	if length >= 8 {
-		random := xorshift(length)
-		modulus := nextPowerOfTwo(length)
-
-		for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
-			other := int(uint(random.Next()) & (modulus - 1))
-			if other >= length {
-				other -= length
-			}
-			data[idx], data[a+other] = data[a+other], data[idx]
-		}
-	}
-}
-
-// choosePivotCmpFunc chooses a pivot in data[a:b].
-//
-// [0,8): chooses a static pivot.
-// [8,shortestNinther): uses the simple median-of-three method.
-// [shortestNinther,∞): uses the Tukey ninther method.
-func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
-	const (
-		shortestNinther = 50
-		maxSwaps        = 4 * 3
-	)
-
-	l := b - a
-
-	var (
-		swaps int
-		i     = a + l/4*1
-		j     = a + l/4*2
-		k     = a + l/4*3
-	)
-
-	if l >= 8 {
-		if l >= shortestNinther {
-			// Tukey ninther method, the idea came from Rust's implementation.
-			i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
-			j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
-			k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
-		}
-		// Find the median among i, j, k and stores it into j.
-		j = medianCmpFunc(data, i, j, k, &swaps, cmp)
-	}
-
-	switch swaps {
-	case 0:
-		return j, increasingHint
-	case maxSwaps:
-		return j, decreasingHint
-	default:
-		return j, unknownHint
-	}
-}
-
-// order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
-func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
-	if cmp(data[b], data[a]) < 0 {
-		*swaps++
-		return b, a
-	}
-	return a, b
-}
-
-// medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
-func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
-	a, b = order2CmpFunc(data, a, b, swaps, cmp)
-	b, c = order2CmpFunc(data, b, c, swaps, cmp)
-	a, b = order2CmpFunc(data, a, b, swaps, cmp)
-	return b
-}
-
-// medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
-func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
-	return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
-}
-
-func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	i := a
-	j := b - 1
-	for i < j {
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-}
-
-func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
-	for i := 0; i < n; i++ {
-		data[a+i], data[b+i] = data[b+i], data[a+i]
-	}
-}
-
-func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
-	blockSize := 20 // must be > 0
-	a, b := 0, blockSize
-	for b <= n {
-		insertionSortCmpFunc(data, a, b, cmp)
-		a = b
-		b += blockSize
-	}
-	insertionSortCmpFunc(data, a, n, cmp)
-
-	for blockSize < n {
-		a, b = 0, 2*blockSize
-		for b <= n {
-			symMergeCmpFunc(data, a, a+blockSize, b, cmp)
-			a = b
-			b += 2 * blockSize
-		}
-		if m := a + blockSize; m < n {
-			symMergeCmpFunc(data, a, m, n, cmp)
-		}
-		blockSize *= 2
-	}
-}
-
-// symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
-// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
-// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
-// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
-// Computer Science, pages 714-723. Springer, 2004.
-//
-// Let M = m-a and N = b-n. Wolog M < N.
-// The recursion depth is bound by ceil(log(N+M)).
-// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
-// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
-//
-// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
-// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
-// in the paper carries through for Swap operations, especially as the block
-// swapping rotate uses only O(M+N) Swaps.
-//
-// symMerge assumes non-degenerate arguments: a < m && m < b.
-// Having the caller check this condition eliminates many leaf recursion calls,
-// which improves performance.
-func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[a] into data[m:b]
-	// if data[a:m] only contains one element.
-	if m-a == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] >= data[a] for m <= i < b.
-		// Exit the search loop with i == b in case no such index exists.
-		i := m
-		j := b
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if cmp(data[h], data[a]) < 0 {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[a] reaches the position before i.
-		for k := a; k < i-1; k++ {
-			data[k], data[k+1] = data[k+1], data[k]
-		}
-		return
-	}
-
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[m] into data[a:m]
-	// if data[m:b] only contains one element.
-	if b-m == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] > data[m] for a <= i < m.
-		// Exit the search loop with i == m in case no such index exists.
-		i := a
-		j := m
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if !(cmp(data[m], data[h]) < 0) {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[m] reaches the position i.
-		for k := m; k > i; k-- {
-			data[k], data[k-1] = data[k-1], data[k]
-		}
-		return
-	}
-
-	mid := int(uint(a+b) >> 1)
-	n := mid + m
-	var start, r int
-	if m > mid {
-		start = n - b
-		r = mid
-	} else {
-		start = a
-		r = m
-	}
-	p := n - 1
-
-	for start < r {
-		c := int(uint(start+r) >> 1)
-		if !(cmp(data[p-c], data[c]) < 0) {
-			start = c + 1
-		} else {
-			r = c
-		}
-	}
-
-	end := n - start
-	if start < m && m < end {
-		rotateCmpFunc(data, start, m, end, cmp)
-	}
-	if a < start && start < mid {
-		symMergeCmpFunc(data, a, start, mid, cmp)
-	}
-	if mid < end && end < b {
-		symMergeCmpFunc(data, mid, end, b, cmp)
-	}
-}
-
-// rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
-// Data of the form 'x u v y' is changed to 'x v u y'.
-// rotate performs at most b-a many calls to data.Swap,
-// and it assumes non-degenerate arguments: a < m && m < b.
-func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
-	i := m - a
-	j := b - m
-
-	for i != j {
-		if i > j {
-			swapRangeCmpFunc(data, m-i, m, j, cmp)
-			i -= j
-		} else {
-			swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
-			j -= i
-		}
-	}
-	// i == j
-	swapRangeCmpFunc(data, m-i, m, i, cmp)
-}

vendor/golang.org/x/exp/slices/zsortordered.go

@@ -1,481 +0,0 @@
-// Code generated by gen_sort_variants.go; DO NOT EDIT.
-
-// Copyright 2022 The Go 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 slices
-
-import "golang.org/x/exp/constraints"
-
-// insertionSortOrdered sorts data[a:b] using insertion sort.
-func insertionSortOrdered[E constraints.Ordered](data []E, a, b int) {
-	for i := a + 1; i < b; i++ {
-		for j := i; j > a && cmpLess(data[j], data[j-1]); j-- {
-			data[j], data[j-1] = data[j-1], data[j]
-		}
-	}
-}
-
-// siftDownOrdered implements the heap property on data[lo:hi].
-// first is an offset into the array where the root of the heap lies.
-func siftDownOrdered[E constraints.Ordered](data []E, lo, hi, first int) {
-	root := lo
-	for {
-		child := 2*root + 1
-		if child >= hi {
-			break
-		}
-		if child+1 < hi && cmpLess(data[first+child], data[first+child+1]) {
-			child++
-		}
-		if !cmpLess(data[first+root], data[first+child]) {
-			return
-		}
-		data[first+root], data[first+child] = data[first+child], data[first+root]
-		root = child
-	}
-}
-
-func heapSortOrdered[E constraints.Ordered](data []E, a, b int) {
-	first := a
-	lo := 0
-	hi := b - a
-
-	// Build heap with greatest element at top.
-	for i := (hi - 1) / 2; i >= 0; i-- {
-		siftDownOrdered(data, i, hi, first)
-	}
-
-	// Pop elements, largest first, into end of data.
-	for i := hi - 1; i >= 0; i-- {
-		data[first], data[first+i] = data[first+i], data[first]
-		siftDownOrdered(data, lo, i, first)
-	}
-}
-
-// pdqsortOrdered sorts data[a:b].
-// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
-// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
-// C++ implementation: https://github.com/orlp/pdqsort
-// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
-// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
-func pdqsortOrdered[E constraints.Ordered](data []E, a, b, limit int) {
-	const maxInsertion = 12
-
-	var (
-		wasBalanced    = true // whether the last partitioning was reasonably balanced
-		wasPartitioned = true // whether the slice was already partitioned
-	)
-
-	for {
-		length := b - a
-
-		if length <= maxInsertion {
-			insertionSortOrdered(data, a, b)
-			return
-		}
-
-		// Fall back to heapsort if too many bad choices were made.
-		if limit == 0 {
-			heapSortOrdered(data, a, b)
-			return
-		}
-
-		// If the last partitioning was imbalanced, we need to breaking patterns.
-		if !wasBalanced {
-			breakPatternsOrdered(data, a, b)
-			limit--
-		}
-
-		pivot, hint := choosePivotOrdered(data, a, b)
-		if hint == decreasingHint {
-			reverseRangeOrdered(data, a, b)
-			// The chosen pivot was pivot-a elements after the start of the array.
-			// After reversing it is pivot-a elements before the end of the array.
-			// The idea came from Rust's implementation.
-			pivot = (b - 1) - (pivot - a)
-			hint = increasingHint
-		}
-
-		// The slice is likely already sorted.
-		if wasBalanced && wasPartitioned && hint == increasingHint {
-			if partialInsertionSortOrdered(data, a, b) {
-				return
-			}
-		}
-
-		// Probably the slice contains many duplicate elements, partition the slice into
-		// elements equal to and elements greater than the pivot.
-		if a > 0 && !cmpLess(data[a-1], data[pivot]) {
-			mid := partitionEqualOrdered(data, a, b, pivot)
-			a = mid
-			continue
-		}
-
-		mid, alreadyPartitioned := partitionOrdered(data, a, b, pivot)
-		wasPartitioned = alreadyPartitioned
-
-		leftLen, rightLen := mid-a, b-mid
-		balanceThreshold := length / 8
-		if leftLen < rightLen {
-			wasBalanced = leftLen >= balanceThreshold
-			pdqsortOrdered(data, a, mid, limit)
-			a = mid + 1
-		} else {
-			wasBalanced = rightLen >= balanceThreshold
-			pdqsortOrdered(data, mid+1, b, limit)
-			b = mid
-		}
-	}
-}
-
-// partitionOrdered does one quicksort partition.
-// Let p = data[pivot]
-// Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
-// On return, data[newpivot] = p
-func partitionOrdered[E constraints.Ordered](data []E, a, b, pivot int) (newpivot int, alreadyPartitioned bool) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for i <= j && cmpLess(data[i], data[a]) {
-		i++
-	}
-	for i <= j && !cmpLess(data[j], data[a]) {
-		j--
-	}
-	if i > j {
-		data[j], data[a] = data[a], data[j]
-		return j, true
-	}
-	data[i], data[j] = data[j], data[i]
-	i++
-	j--
-
-	for {
-		for i <= j && cmpLess(data[i], data[a]) {
-			i++
-		}
-		for i <= j && !cmpLess(data[j], data[a]) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	data[j], data[a] = data[a], data[j]
-	return j, false
-}
-
-// partitionEqualOrdered partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
-// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
-func partitionEqualOrdered[E constraints.Ordered](data []E, a, b, pivot int) (newpivot int) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for {
-		for i <= j && !cmpLess(data[a], data[i]) {
-			i++
-		}
-		for i <= j && cmpLess(data[a], data[j]) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	return i
-}
-
-// partialInsertionSortOrdered partially sorts a slice, returns true if the slice is sorted at the end.
-func partialInsertionSortOrdered[E constraints.Ordered](data []E, a, b int) bool {
-	const (
-		maxSteps         = 5  // maximum number of adjacent out-of-order pairs that will get shifted
-		shortestShifting = 50 // don't shift any elements on short arrays
-	)
-	i := a + 1
-	for j := 0; j < maxSteps; j++ {
-		for i < b && !cmpLess(data[i], data[i-1]) {
-			i++
-		}
-
-		if i == b {
-			return true
-		}
-
-		if b-a < shortestShifting {
-			return false
-		}
-
-		data[i], data[i-1] = data[i-1], data[i]
-
-		// Shift the smaller one to the left.
-		if i-a >= 2 {
-			for j := i - 1; j >= 1; j-- {
-				if !cmpLess(data[j], data[j-1]) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-		// Shift the greater one to the right.
-		if b-i >= 2 {
-			for j := i + 1; j < b; j++ {
-				if !cmpLess(data[j], data[j-1]) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-	}
-	return false
-}
-
-// breakPatternsOrdered scatters some elements around in an attempt to break some patterns
-// that might cause imbalanced partitions in quicksort.
-func breakPatternsOrdered[E constraints.Ordered](data []E, a, b int) {
-	length := b - a
-	if length >= 8 {
-		random := xorshift(length)
-		modulus := nextPowerOfTwo(length)
-
-		for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
-			other := int(uint(random.Next()) & (modulus - 1))
-			if other >= length {
-				other -= length
-			}
-			data[idx], data[a+other] = data[a+other], data[idx]
-		}
-	}
-}
-
-// choosePivotOrdered chooses a pivot in data[a:b].
-//
-// [0,8): chooses a static pivot.
-// [8,shortestNinther): uses the simple median-of-three method.
-// [shortestNinther,∞): uses the Tukey ninther method.
-func choosePivotOrdered[E constraints.Ordered](data []E, a, b int) (pivot int, hint sortedHint) {
-	const (
-		shortestNinther = 50
-		maxSwaps        = 4 * 3
-	)
-
-	l := b - a
-
-	var (
-		swaps int
-		i     = a + l/4*1
-		j     = a + l/4*2
-		k     = a + l/4*3
-	)
-
-	if l >= 8 {
-		if l >= shortestNinther {
-			// Tukey ninther method, the idea came from Rust's implementation.
-			i = medianAdjacentOrdered(data, i, &swaps)
-			j = medianAdjacentOrdered(data, j, &swaps)
-			k = medianAdjacentOrdered(data, k, &swaps)
-		}
-		// Find the median among i, j, k and stores it into j.
-		j = medianOrdered(data, i, j, k, &swaps)
-	}
-
-	switch swaps {
-	case 0:
-		return j, increasingHint
-	case maxSwaps:
-		return j, decreasingHint
-	default:
-		return j, unknownHint
-	}
-}
-
-// order2Ordered returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
-func order2Ordered[E constraints.Ordered](data []E, a, b int, swaps *int) (int, int) {
-	if cmpLess(data[b], data[a]) {
-		*swaps++
-		return b, a
-	}
-	return a, b
-}
-
-// medianOrdered returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
-func medianOrdered[E constraints.Ordered](data []E, a, b, c int, swaps *int) int {
-	a, b = order2Ordered(data, a, b, swaps)
-	b, c = order2Ordered(data, b, c, swaps)
-	a, b = order2Ordered(data, a, b, swaps)
-	return b
-}
-
-// medianAdjacentOrdered finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
-func medianAdjacentOrdered[E constraints.Ordered](data []E, a int, swaps *int) int {
-	return medianOrdered(data, a-1, a, a+1, swaps)
-}
-
-func reverseRangeOrdered[E constraints.Ordered](data []E, a, b int) {
-	i := a
-	j := b - 1
-	for i < j {
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-}
-
-func swapRangeOrdered[E constraints.Ordered](data []E, a, b, n int) {
-	for i := 0; i < n; i++ {
-		data[a+i], data[b+i] = data[b+i], data[a+i]
-	}
-}
-
-func stableOrdered[E constraints.Ordered](data []E, n int) {
-	blockSize := 20 // must be > 0
-	a, b := 0, blockSize
-	for b <= n {
-		insertionSortOrdered(data, a, b)
-		a = b
-		b += blockSize
-	}
-	insertionSortOrdered(data, a, n)
-
-	for blockSize < n {
-		a, b = 0, 2*blockSize
-		for b <= n {
-			symMergeOrdered(data, a, a+blockSize, b)
-			a = b
-			b += 2 * blockSize
-		}
-		if m := a + blockSize; m < n {
-			symMergeOrdered(data, a, m, n)
-		}
-		blockSize *= 2
-	}
-}
-
-// symMergeOrdered merges the two sorted subsequences data[a:m] and data[m:b] using
-// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
-// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
-// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
-// Computer Science, pages 714-723. Springer, 2004.
-//
-// Let M = m-a and N = b-n. Wolog M < N.
-// The recursion depth is bound by ceil(log(N+M)).
-// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
-// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
-//
-// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
-// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
-// in the paper carries through for Swap operations, especially as the block
-// swapping rotate uses only O(M+N) Swaps.
-//
-// symMerge assumes non-degenerate arguments: a < m && m < b.
-// Having the caller check this condition eliminates many leaf recursion calls,
-// which improves performance.
-func symMergeOrdered[E constraints.Ordered](data []E, a, m, b int) {
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[a] into data[m:b]
-	// if data[a:m] only contains one element.
-	if m-a == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] >= data[a] for m <= i < b.
-		// Exit the search loop with i == b in case no such index exists.
-		i := m
-		j := b
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if cmpLess(data[h], data[a]) {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[a] reaches the position before i.
-		for k := a; k < i-1; k++ {
-			data[k], data[k+1] = data[k+1], data[k]
-		}
-		return
-	}
-
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[m] into data[a:m]
-	// if data[m:b] only contains one element.
-	if b-m == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] > data[m] for a <= i < m.
-		// Exit the search loop with i == m in case no such index exists.
-		i := a
-		j := m
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if !cmpLess(data[m], data[h]) {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[m] reaches the position i.
-		for k := m; k > i; k-- {
-			data[k], data[k-1] = data[k-1], data[k]
-		}
-		return
-	}
-
-	mid := int(uint(a+b) >> 1)
-	n := mid + m
-	var start, r int
-	if m > mid {
-		start = n - b
-		r = mid
-	} else {
-		start = a
-		r = m
-	}
-	p := n - 1
-
-	for start < r {
-		c := int(uint(start+r) >> 1)
-		if !cmpLess(data[p-c], data[c]) {
-			start = c + 1
-		} else {
-			r = c
-		}
-	}
-
-	end := n - start
-	if start < m && m < end {
-		rotateOrdered(data, start, m, end)
-	}
-	if a < start && start < mid {
-		symMergeOrdered(data, a, start, mid)
-	}
-	if mid < end && end < b {
-		symMergeOrdered(data, mid, end, b)
-	}
-}
-
-// rotateOrdered rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
-// Data of the form 'x u v y' is changed to 'x v u y'.
-// rotate performs at most b-a many calls to data.Swap,
-// and it assumes non-degenerate arguments: a < m && m < b.
-func rotateOrdered[E constraints.Ordered](data []E, a, m, b int) {
-	i := m - a
-	j := b - m
-
-	for i != j {
-		if i > j {
-			swapRangeOrdered(data, m-i, m, j)
-			i -= j
-		} else {
-			swapRangeOrdered(data, m-i, m+j-i, i)
-			j -= i
-		}
-	}
-	// i == j
-	swapRangeOrdered(data, m-i, m, i)
-}

vendor/golang.org/x/sys/unix/README.md

@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these
 into a common file for each OS.
 
 The merge is performed in the following steps:
-1. Construct the set of common code that is idential in all architecture-specific files.
+1. Construct the set of common code that is identical in all architecture-specific files.
 2. Write this common code to the merged file.
 3. Remove the common code from all architecture-specific files.
 

vendor/golang.org/x/sys/unix/auxv.go

@@ -0,0 +1,36 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+//go:linkname runtime_getAuxv runtime.getAuxv
+func runtime_getAuxv() []uintptr
+
+// Auxv returns the ELF auxiliary vector as a sequence of key/value pairs.
+// The returned slice is always a fresh copy, owned by the caller.
+// It returns an error on non-ELF platforms, or if the auxiliary vector cannot be accessed,
+// which happens in some locked-down environments and build modes.
+func Auxv() ([][2]uintptr, error) {
+	vec := runtime_getAuxv()
+	vecLen := len(vec)
+
+	if vecLen == 0 {
+		return nil, syscall.ENOENT
+	}
+
+	if vecLen%2 != 0 {
+		return nil, syscall.EINVAL
+	}
+
+	result := make([]uintptr, vecLen)
+	copy(result, vec)
+	return unsafe.Slice((*[2]uintptr)(unsafe.Pointer(&result[0])), vecLen/2), nil
+}

vendor/golang.org/x/sys/unix/auxv_unsupported.go

@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import "syscall"
+
+func Auxv() ([][2]uintptr, error) {
+	return nil, syscall.ENOTSUP
+}

vendor/golang.org/x/sys/unix/ioctl_linux.go

@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
 	return &value, err
 }
 
+// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC
+// association for the network device specified by ifname.
+func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return nil, err
+	}
+
+	value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO}
+	ifrd := ifr.withData(unsafe.Pointer(&value))
+
+	err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
+	return &value, err
+}
+
+// IoctlGetHwTstamp retrieves the hardware timestamping configuration
+// for the network device specified by ifname.
+func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return nil, err
+	}
+
+	value := HwTstampConfig{}
+	ifrd := ifr.withData(unsafe.Pointer(&value))
+
+	err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd)
+	return &value, err
+}
+
+// IoctlSetHwTstamp updates the hardware timestamping configuration for
+// the network device specified by ifname.
+func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return err
+	}
+	ifrd := ifr.withData(unsafe.Pointer(cfg))
+	return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd)
+}
+
+// FdToClockID derives the clock ID from the file descriptor number
+// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is
+// suitable for system calls like ClockGettime.
+func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) }
+
+// IoctlPtpClockGetcaps returns the description of a given PTP device.
+func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) {
+	var value PtpClockCaps
+	err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpSysOffsetPrecise returns a description of the clock
+// offset compared to the system clock.
+func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) {
+	var value PtpSysOffsetPrecise
+	err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpSysOffsetExtended returns an extended description of the
+// clock offset compared to the system clock. The samples parameter
+// specifies the desired number of measurements.
+func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) {
+	value := PtpSysOffsetExtended{Samples: uint32(samples)}
+	err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpPinGetfunc returns the configuration of the specified
+// I/O pin on given PTP device.
+func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) {
+	value := PtpPinDesc{Index: uint32(index)}
+	err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpPinSetfunc updates configuration of the specified PTP
+// I/O pin.
+func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error {
+	return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
+}
+
+// IoctlPtpPeroutRequest configures the periodic output mode of the
+// PTP I/O pins.
+func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error {
+	return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
+}
+
+// IoctlPtpExttsRequest configures the external timestamping mode
+// of the PTP I/O pins.
+func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error {
+	return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
+}
+
 // IoctlGetWatchdogInfo fetches information about a watchdog device from the
 // Linux watchdog API. For more information, see:
 // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.

vendor/golang.org/x/sys/unix/mkerrors.sh

@@ -158,6 +158,16 @@ includes_Linux='
 #endif
 #define _GNU_SOURCE
 
+// See the description in unix/linux/types.go
+#if defined(__ARM_EABI__) || \
+	(defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \
+	(defined(__powerpc__) && (!defined(__powerpc64__)))
+# ifdef   _TIME_BITS
+#  undef  _TIME_BITS
+# endif
+# define  _TIME_BITS 32
+#endif
+
 // <sys/ioctl.h> is broken on powerpc64, as it fails to include definitions of
 // these structures. We just include them copied from <bits/termios.h>.
 #if defined(__powerpc__)
@@ -256,6 +266,7 @@ struct ltchars {
 #include <linux/nsfs.h>
 #include <linux/perf_event.h>
 #include <linux/pps.h>
+#include <linux/ptp_clock.h>
 #include <linux/ptrace.h>
 #include <linux/random.h>
 #include <linux/reboot.h>
@@ -527,6 +538,7 @@ ccflags="$@"
 		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ ||
 		$2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ ||
 		$2 ~ /^NFC_.*_(MAX)?SIZE$/ ||
+		$2 ~ /^PTP_/ ||
 		$2 ~ /^RAW_PAYLOAD_/ ||
 		$2 ~ /^[US]F_/ ||
 		$2 ~ /^TP_STATUS_/ ||
@@ -656,7 +668,7 @@ errors=$(
 signals=$(
 	echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
-	grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
+	grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
 	sort
 )
 
@@ -666,7 +678,7 @@ echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
 	sort >_error.grep
 echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
-	grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' |
+	grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' |
 	sort >_signal.grep
 
 echo '// mkerrors.sh' "$@"

vendor/golang.org/x/sys/unix/syscall_aix.go

@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int,
 	var status _C_int
 	var r Pid_t
 	err = ERESTART
-	// AIX wait4 may return with ERESTART errno, while the processus is still
+	// AIX wait4 may return with ERESTART errno, while the process is still
 	// active.
 	for err == ERESTART {
 		r, err = wait4(Pid_t(pid), &status, options, rusage)

vendor/golang.org/x/sys/unix/syscall_darwin.go

@@ -603,6 +603,149 @@ func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocI
 }
 
 // sys	connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
+const minIovec = 8
+
+func Readv(fd int, iovs [][]byte) (n int, err error) {
+	if !darwinKernelVersionMin(11, 0, 0) {
+		return 0, ENOSYS
+	}
+
+	iovecs := make([]Iovec, 0, minIovec)
+	iovecs = appendBytes(iovecs, iovs)
+	n, err = readv(fd, iovecs)
+	readvRacedetect(iovecs, n, err)
+	return n, err
+}
+
+func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
+	if !darwinKernelVersionMin(11, 0, 0) {
+		return 0, ENOSYS
+	}
+	iovecs := make([]Iovec, 0, minIovec)
+	iovecs = appendBytes(iovecs, iovs)
+	n, err = preadv(fd, iovecs, offset)
+	readvRacedetect(iovecs, n, err)
+	return n, err
+}
+
+func Writev(fd int, iovs [][]byte) (n int, err error) {
+	if !darwinKernelVersionMin(11, 0, 0) {
+		return 0, ENOSYS
+	}
+
+	iovecs := make([]Iovec, 0, minIovec)
+	iovecs = appendBytes(iovecs, iovs)
+	if raceenabled {
+		raceReleaseMerge(unsafe.Pointer(&ioSync))
+	}
+	n, err = writev(fd, iovecs)
+	writevRacedetect(iovecs, n)
+	return n, err
+}
+
+func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) {
+	if !darwinKernelVersionMin(11, 0, 0) {
+		return 0, ENOSYS
+	}
+
+	iovecs := make([]Iovec, 0, minIovec)
+	iovecs = appendBytes(iovecs, iovs)
+	if raceenabled {
+		raceReleaseMerge(unsafe.Pointer(&ioSync))
+	}
+	n, err = pwritev(fd, iovecs, offset)
+	writevRacedetect(iovecs, n)
+	return n, err
+}
+
+func appendBytes(vecs []Iovec, bs [][]byte) []Iovec {
+	for _, b := range bs {
+		var v Iovec
+		v.SetLen(len(b))
+		if len(b) > 0 {
+			v.Base = &b[0]
+		} else {
+			v.Base = (*byte)(unsafe.Pointer(&_zero))
+		}
+		vecs = append(vecs, v)
+	}
+	return vecs
+}
+
+func writevRacedetect(iovecs []Iovec, n int) {
+	if !raceenabled {
+		return
+	}
+	for i := 0; n > 0 && i < len(iovecs); i++ {
+		m := int(iovecs[i].Len)
+		if m > n {
+			m = n
+		}
+		n -= m
+		if m > 0 {
+			raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
+		}
+	}
+}
+
+func readvRacedetect(iovecs []Iovec, n int, err error) {
+	if !raceenabled {
+		return
+	}
+	for i := 0; n > 0 && i < len(iovecs); i++ {
+		m := int(iovecs[i].Len)
+		if m > n {
+			m = n
+		}
+		n -= m
+		if m > 0 {
+			raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
+		}
+	}
+	if err == nil {
+		raceAcquire(unsafe.Pointer(&ioSync))
+	}
+}
+
+func darwinMajorMinPatch() (maj, min, patch int, err error) {
+	var un Utsname
+	err = Uname(&un)
+	if err != nil {
+		return
+	}
+
+	var mmp [3]int
+	c := 0
+Loop:
+	for _, b := range un.Release[:] {
+		switch {
+		case b >= '0' && b <= '9':
+			mmp[c] = 10*mmp[c] + int(b-'0')
+		case b == '.':
+			c++
+			if c > 2 {
+				return 0, 0, 0, ENOTSUP
+			}
+		case b == 0:
+			break Loop
+		default:
+			return 0, 0, 0, ENOTSUP
+		}
+	}
+	if c != 2 {
+		return 0, 0, 0, ENOTSUP
+	}
+	return mmp[0], mmp[1], mmp[2], nil
+}
+
+func darwinKernelVersionMin(maj, min, patch int) bool {
+	actualMaj, actualMin, actualPatch, err := darwinMajorMinPatch()
+	if err != nil {
+		return false
+	}
+	return actualMaj > maj || actualMaj == maj && (actualMin > min || actualMin == min && actualPatch >= patch)
+}
+
 //sys	sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
 
 //sys	shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
@@ -705,3 +848,7 @@ func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocI
 //sys	write(fd int, p []byte) (n int, err error)
 //sys	mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
 //sys	munmap(addr uintptr, length uintptr) (err error)
+//sys	readv(fd int, iovecs []Iovec) (n int, err error)
+//sys	preadv(fd int, iovecs []Iovec, offset int64) (n int, err error)
+//sys	writev(fd int, iovecs []Iovec) (n int, err error)
+//sys	pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error)

vendor/golang.org/x/sys/unix/syscall_dragonfly.go

@@ -246,6 +246,18 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 	return sendfile(outfd, infd, offset, count)
 }
 
+func Dup3(oldfd, newfd, flags int) error {
+	if oldfd == newfd || flags&^O_CLOEXEC != 0 {
+		return EINVAL
+	}
+	how := F_DUP2FD
+	if flags&O_CLOEXEC != 0 {
+		how = F_DUP2FD_CLOEXEC
+	}
+	_, err := fcntl(oldfd, how, newfd)
+	return err
+}
+
 /*
  * Exposed directly
  */

vendor/golang.org/x/sys/unix/syscall_linux.go

@@ -13,6 +13,7 @@ package unix
 
 import (
 	"encoding/binary"
+	"slices"
 	"strconv"
 	"syscall"
 	"time"
@@ -417,7 +418,7 @@ func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
 		return nil, 0, EINVAL
 	}
 	sa.raw.Family = AF_UNIX
-	for i := 0; i < n; i++ {
+	for i := range n {
 		sa.raw.Path[i] = int8(name[i])
 	}
 	// length is family (uint16), name, NUL.
@@ -507,7 +508,7 @@ func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm))
 	psm[0] = byte(sa.PSM)
 	psm[1] = byte(sa.PSM >> 8)
-	for i := 0; i < len(sa.Addr); i++ {
+	for i := range len(sa.Addr) {
 		sa.raw.Bdaddr[i] = sa.Addr[len(sa.Addr)-1-i]
 	}
 	cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid))
@@ -589,11 +590,11 @@ func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	sa.raw.Family = AF_CAN
 	sa.raw.Ifindex = int32(sa.Ifindex)
 	rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
-	for i := 0; i < 4; i++ {
+	for i := range 4 {
 		sa.raw.Addr[i] = rx[i]
 	}
 	tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
-	for i := 0; i < 4; i++ {
+	for i := range 4 {
 		sa.raw.Addr[i+4] = tx[i]
 	}
 	return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
@@ -618,11 +619,11 @@ func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	sa.raw.Family = AF_CAN
 	sa.raw.Ifindex = int32(sa.Ifindex)
 	n := (*[8]byte)(unsafe.Pointer(&sa.Name))
-	for i := 0; i < 8; i++ {
+	for i := range 8 {
 		sa.raw.Addr[i] = n[i]
 	}
 	p := (*[4]byte)(unsafe.Pointer(&sa.PGN))
-	for i := 0; i < 4; i++ {
+	for i := range 4 {
 		sa.raw.Addr[i+8] = p[i]
 	}
 	sa.raw.Addr[12] = sa.Addr
@@ -911,7 +912,7 @@ func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	// These are EBCDIC encoded by the kernel, but we still need to pad them
 	// with blanks. Initializing with blanks allows the caller to feed in either
 	// a padded or an unpadded string.
-	for i := 0; i < 8; i++ {
+	for i := range 8 {
 		sa.raw.Nodeid[i] = ' '
 		sa.raw.User_id[i] = ' '
 		sa.raw.Name[i] = ' '
@@ -1148,7 +1149,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 		var user [8]byte
 		var name [8]byte
 
-		for i := 0; i < 8; i++ {
+		for i := range 8 {
 			user[i] = byte(pp.User_id[i])
 			name[i] = byte(pp.Name[i])
 		}
@@ -1173,11 +1174,11 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 				Ifindex: int(pp.Ifindex),
 			}
 			name := (*[8]byte)(unsafe.Pointer(&sa.Name))
-			for i := 0; i < 8; i++ {
+			for i := range 8 {
 				name[i] = pp.Addr[i]
 			}
 			pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN))
-			for i := 0; i < 4; i++ {
+			for i := range 4 {
 				pgn[i] = pp.Addr[i+8]
 			}
 			addr := (*[1]byte)(unsafe.Pointer(&sa.Addr))
@@ -1188,11 +1189,11 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 				Ifindex: int(pp.Ifindex),
 			}
 			rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
-			for i := 0; i < 4; i++ {
+			for i := range 4 {
 				rx[i] = pp.Addr[i]
 			}
 			tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
-			for i := 0; i < 4; i++ {
+			for i := range 4 {
 				tx[i] = pp.Addr[i+4]
 			}
 			return sa, nil
@@ -1295,6 +1296,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
 	return &value, err
 }
 
+// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) {
+	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+	vallen := _Socklen(SizeofTCPCCInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	out := (*TCPVegasInfo)(unsafe.Pointer(&value[0]))
+	return out, err
+}
+
+// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) {
+	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+	vallen := _Socklen(SizeofTCPCCInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0]))
+	return out, err
+}
+
+// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr"
+// algorithm.
+//
+// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option:
+//
+//	algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION)
+func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) {
+	var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment
+	vallen := _Socklen(SizeofTCPCCInfo)
+	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
+	out := (*TCPBBRInfo)(unsafe.Pointer(&value[0]))
+	return out, err
+}
+
 // GetsockoptString returns the string value of the socket option opt for the
 // socket associated with fd at the given socket level.
 func GetsockoptString(fd, level, opt int) (string, error) {
@@ -1818,6 +1861,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 //sys	ClockAdjtime(clockid int32, buf *Timex) (state int, err error)
 //sys	ClockGetres(clockid int32, res *Timespec) (err error)
 //sys	ClockGettime(clockid int32, time *Timespec) (err error)
+//sys	ClockSettime(clockid int32, time *Timespec) (err error)
 //sys	ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
 //sys	Close(fd int) (err error)
 //sys	CloseRange(first uint, last uint, flags uint) (err error)
@@ -1959,7 +2003,26 @@ func Getpgrp() (pid int) {
 //sysnb	Getpid() (pid int)
 //sysnb	Getppid() (ppid int)
 //sys	Getpriority(which int, who int) (prio int, err error)
-//sys	Getrandom(buf []byte, flags int) (n int, err error)
+
+func Getrandom(buf []byte, flags int) (n int, err error) {
+	vdsoRet, supported := vgetrandom(buf, uint32(flags))
+	if supported {
+		if vdsoRet < 0 {
+			return 0, errnoErr(syscall.Errno(-vdsoRet))
+		}
+		return vdsoRet, nil
+	}
+	var p *byte
+	if len(buf) > 0 {
+		p = &buf[0]
+	}
+	r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags))
+	if e != 0 {
+		return 0, errnoErr(e)
+	}
+	return int(r), nil
+}
+
 //sysnb	Getrusage(who int, rusage *Rusage) (err error)
 //sysnb	Getsid(pid int) (sid int, err error)
 //sysnb	Gettid() (tid int)
@@ -2154,10 +2217,7 @@ func readvRacedetect(iovecs []Iovec, n int, err error) {
 		return
 	}
 	for i := 0; n > 0 && i < len(iovecs); i++ {
-		m := int(iovecs[i].Len)
-		if m > n {
-			m = n
-		}
+		m := min(int(iovecs[i].Len), n)
 		n -= m
 		if m > 0 {
 			raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
@@ -2208,10 +2268,7 @@ func writevRacedetect(iovecs []Iovec, n int) {
 		return
 	}
 	for i := 0; n > 0 && i < len(iovecs); i++ {
-		m := int(iovecs[i].Len)
-		if m > n {
-			m = n
-		}
+		m := min(int(iovecs[i].Len), n)
 		n -= m
 		if m > 0 {
 			raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
@@ -2258,12 +2315,7 @@ func isGroupMember(gid int) bool {
 		return false
 	}
 
-	for _, g := range groups {
-		if g == gid {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(groups, gid)
 }
 
 func isCapDacOverrideSet() bool {

vendor/golang.org/x/sys/unix/syscall_linux_arm64.go

@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
 	}
 	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
 }
+
+const SYS_FSTATAT = SYS_NEWFSTATAT

vendor/golang.org/x/sys/unix/syscall_linux_loong64.go

@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error
 	}
 	return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags)
 }
+
+const SYS_FSTATAT = SYS_NEWFSTATAT

vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go

@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error
 	}
 	return riscvHWProbe(pairs, setSize, set, flags)
 }
+
+const SYS_FSTATAT = SYS_NEWFSTATAT

vendor/golang.org/x/sys/unix/syscall_solaris.go

@@ -1102,3 +1102,90 @@ func (s *Strioctl) SetInt(i int) {
 func IoctlSetStrioctlRetInt(fd int, req int, s *Strioctl) (int, error) {
 	return ioctlPtrRet(fd, req, unsafe.Pointer(s))
 }
+
+// Ucred Helpers
+// See ucred(3c) and getpeerucred(3c)
+
+//sys	getpeerucred(fd uintptr, ucred *uintptr) (err error)
+//sys	ucredFree(ucred uintptr) = ucred_free
+//sys	ucredGet(pid int) (ucred uintptr, err error) = ucred_get
+//sys	ucredGeteuid(ucred uintptr) (uid int) = ucred_geteuid
+//sys	ucredGetegid(ucred uintptr) (gid int) = ucred_getegid
+//sys	ucredGetruid(ucred uintptr) (uid int) = ucred_getruid
+//sys	ucredGetrgid(ucred uintptr) (gid int) = ucred_getrgid
+//sys	ucredGetsuid(ucred uintptr) (uid int) = ucred_getsuid
+//sys	ucredGetsgid(ucred uintptr) (gid int) = ucred_getsgid
+//sys	ucredGetpid(ucred uintptr) (pid int) = ucred_getpid
+
+// Ucred is an opaque struct that holds user credentials.
+type Ucred struct {
+	ucred uintptr
+}
+
+// We need to ensure that ucredFree is called on the underlying ucred
+// when the Ucred is garbage collected.
+func ucredFinalizer(u *Ucred) {
+	ucredFree(u.ucred)
+}
+
+func GetPeerUcred(fd uintptr) (*Ucred, error) {
+	var ucred uintptr
+	err := getpeerucred(fd, &ucred)
+	if err != nil {
+		return nil, err
+	}
+	result := &Ucred{
+		ucred: ucred,
+	}
+	// set the finalizer on the result so that the ucred will be freed
+	runtime.SetFinalizer(result, ucredFinalizer)
+	return result, nil
+}
+
+func UcredGet(pid int) (*Ucred, error) {
+	ucred, err := ucredGet(pid)
+	if err != nil {
+		return nil, err
+	}
+	result := &Ucred{
+		ucred: ucred,
+	}
+	// set the finalizer on the result so that the ucred will be freed
+	runtime.SetFinalizer(result, ucredFinalizer)
+	return result, nil
+}
+
+func (u *Ucred) Geteuid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGeteuid(u.ucred)
+}
+
+func (u *Ucred) Getruid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetruid(u.ucred)
+}
+
+func (u *Ucred) Getsuid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetsuid(u.ucred)
+}
+
+func (u *Ucred) Getegid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetegid(u.ucred)
+}
+
+func (u *Ucred) Getrgid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetrgid(u.ucred)
+}
+
+func (u *Ucred) Getsgid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetsgid(u.ucred)
+}
+
+func (u *Ucred) Getpid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetpid(u.ucred)
+}

vendor/golang.org/x/sys/unix/syscall_zos_s390x.go

@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) {
 	return mapper.Munmap(b)
 }
 
+func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
+	xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset)
+	return unsafe.Pointer(xaddr), err
+}
+
+func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
+	return mapper.munmap(uintptr(addr), length)
+}
+
 //sys   Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A
 //sysnb	Getgid() (gid int)
 //sysnb	Getpid() (pid int)
@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) {
 // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/
 func isSpecialPath(path []byte) (v bool) {
 	var special = [4][8]byte{
-		[8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
-		[8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
-		[8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
-		[8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
+		{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
+		{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
+		{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
+		{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
 
 	var i, j int
 	for i = 0; i < len(special); i++ {
@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
 //sys	Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT
 //sys	Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT
 //sys	Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT
+
+func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) {
+	runtime.EnterSyscall()
+	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg)
+	runtime.ExitSyscall()
+	val = int(r0)
+	if int64(r0) == -1 {
+		err = errnoErr2(e1, e2)
+	}
+	return
+}
+
+func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) {
+	switch op.(type) {
+	case *Flock_t:
+		err = FcntlFlock(fd, cmd, op.(*Flock_t))
+		if err != nil {
+			ret = -1
+		}
+		return
+	case int:
+		return FcntlInt(fd, cmd, op.(int))
+	case *F_cnvrt:
+		return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt))))
+	case unsafe.Pointer:
+		return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer)))
+	default:
+		return -1, EINVAL
+	}
+	return
+}
+
+func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+	if raceenabled {
+		raceReleaseMerge(unsafe.Pointer(&ioSync))
+	}
+	return sendfile(outfd, infd, offset, count)
+}
+
+func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+	// TODO: use LE call instead if the call is implemented
+	originalOffset, err := Seek(infd, 0, SEEK_CUR)
+	if err != nil {
+		return -1, err
+	}
+	//start reading data from in_fd
+	if offset != nil {
+		_, err := Seek(infd, *offset, SEEK_SET)
+		if err != nil {
+			return -1, err
+		}
+	}
+
+	buf := make([]byte, count)
+	readBuf := make([]byte, 0)
+	var n int = 0
+	for i := 0; i < count; i += n {
+		n, err := Read(infd, buf)
+		if n == 0 {
+			if err != nil {
+				return -1, err
+			} else { // EOF
+				break
+			}
+		}
+		readBuf = append(readBuf, buf...)
+		buf = buf[0:0]
+	}
+
+	n2, err := Write(outfd, readBuf)
+	if err != nil {
+		return -1, err
+	}
+
+	//When sendfile() returns, this variable will be set to the
+	// offset of the byte following the last byte that was read.
+	if offset != nil {
+		*offset = *offset + int64(n)
+		// If offset is not NULL, then sendfile() does not modify the file
+		// offset of in_fd
+		_, err := Seek(infd, originalOffset, SEEK_SET)
+		if err != nil {
+			return -1, err
+		}
+	}
+	return n2, nil
+}

vendor/golang.org/x/sys/unix/vgetrandom_linux.go

@@ -0,0 +1,13 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux && go1.24
+
+package unix
+
+import _ "unsafe"
+
+//go:linkname vgetrandom runtime.vgetrandom
+//go:noescape
+func vgetrandom(p []byte, flags uint32) (ret int, supported bool)

vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go

@@ -0,0 +1,11 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !linux || !go1.24
+
+package unix
+
+func vgetrandom(p []byte, flags uint32) (ret int, supported bool) {
+	return -1, false
+}

vendor/golang.org/x/sys/unix/zerrors_linux.go

@@ -321,6 +321,9 @@ const (
 	AUDIT_INTEGRITY_STATUS                      = 0x70a
 	AUDIT_IPC                                   = 0x517
 	AUDIT_IPC_SET_PERM                          = 0x51f
+	AUDIT_IPE_ACCESS                            = 0x58c
+	AUDIT_IPE_CONFIG_CHANGE                     = 0x58d
+	AUDIT_IPE_POLICY_LOAD                       = 0x58e
 	AUDIT_KERNEL                                = 0x7d0
 	AUDIT_KERNEL_OTHER                          = 0x524
 	AUDIT_KERN_MODULE                           = 0x532
@@ -489,12 +492,14 @@ const (
 	BPF_F_ID                                    = 0x20
 	BPF_F_NETFILTER_IP_DEFRAG                   = 0x1
 	BPF_F_QUERY_EFFECTIVE                       = 0x1
+	BPF_F_REDIRECT_FLAGS                        = 0x19
 	BPF_F_REPLACE                               = 0x4
 	BPF_F_SLEEPABLE                             = 0x10
 	BPF_F_STRICT_ALIGNMENT                      = 0x1
 	BPF_F_TEST_REG_INVARIANTS                   = 0x80
 	BPF_F_TEST_RND_HI32                         = 0x4
 	BPF_F_TEST_RUN_ON_CPU                       = 0x1
+	BPF_F_TEST_SKB_CHECKSUM_COMPLETE            = 0x4
 	BPF_F_TEST_STATE_FREQ                       = 0x8
 	BPF_F_TEST_XDP_LIVE_FRAMES                  = 0x2
 	BPF_F_XDP_DEV_BOUND_ONLY                    = 0x40
@@ -1165,6 +1170,7 @@ const (
 	EXTA                                        = 0xe
 	EXTB                                        = 0xf
 	F2FS_SUPER_MAGIC                            = 0xf2f52010
+	FALLOC_FL_ALLOCATE_RANGE                    = 0x0
 	FALLOC_FL_COLLAPSE_RANGE                    = 0x8
 	FALLOC_FL_INSERT_RANGE                      = 0x20
 	FALLOC_FL_KEEP_SIZE                         = 0x1
@@ -1239,6 +1245,7 @@ const (
 	FAN_REPORT_DFID_NAME                        = 0xc00
 	FAN_REPORT_DFID_NAME_TARGET                 = 0x1e00
 	FAN_REPORT_DIR_FID                          = 0x400
+	FAN_REPORT_FD_ERROR                         = 0x2000
 	FAN_REPORT_FID                              = 0x200
 	FAN_REPORT_NAME                             = 0x800
 	FAN_REPORT_PIDFD                            = 0x80
@@ -1324,8 +1331,10 @@ const (
 	FUSE_SUPER_MAGIC                            = 0x65735546
 	FUTEXFS_SUPER_MAGIC                         = 0xbad1dea
 	F_ADD_SEALS                                 = 0x409
+	F_CREATED_QUERY                             = 0x404
 	F_DUPFD                                     = 0x0
 	F_DUPFD_CLOEXEC                             = 0x406
+	F_DUPFD_QUERY                               = 0x403
 	F_EXLCK                                     = 0x4
 	F_GETFD                                     = 0x1
 	F_GETFL                                     = 0x3
@@ -1545,6 +1554,7 @@ const (
 	IPPROTO_ROUTING                             = 0x2b
 	IPPROTO_RSVP                                = 0x2e
 	IPPROTO_SCTP                                = 0x84
+	IPPROTO_SMC                                 = 0x100
 	IPPROTO_TCP                                 = 0x6
 	IPPROTO_TP                                  = 0x1d
 	IPPROTO_UDP                                 = 0x11
@@ -1617,6 +1627,8 @@ const (
 	IPV6_UNICAST_IF                             = 0x4c
 	IPV6_USER_FLOW                              = 0xe
 	IPV6_V6ONLY                                 = 0x1a
+	IPV6_VERSION                                = 0x60
+	IPV6_VERSION_MASK                           = 0xf0
 	IPV6_XFRM_POLICY                            = 0x23
 	IP_ADD_MEMBERSHIP                           = 0x23
 	IP_ADD_SOURCE_MEMBERSHIP                    = 0x27
@@ -1798,6 +1810,8 @@ const (
 	LANDLOCK_ACCESS_NET_BIND_TCP                = 0x1
 	LANDLOCK_ACCESS_NET_CONNECT_TCP             = 0x2
 	LANDLOCK_CREATE_RULESET_VERSION             = 0x1
+	LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET         = 0x1
+	LANDLOCK_SCOPE_SIGNAL                       = 0x2
 	LINUX_REBOOT_CMD_CAD_OFF                    = 0x0
 	LINUX_REBOOT_CMD_CAD_ON                     = 0x89abcdef
 	LINUX_REBOOT_CMD_HALT                       = 0xcdef0123
@@ -1859,6 +1873,7 @@ const (
 	MADV_UNMERGEABLE                            = 0xd
 	MADV_WILLNEED                               = 0x3
 	MADV_WIPEONFORK                             = 0x12
+	MAP_DROPPABLE                               = 0x8
 	MAP_FILE                                    = 0x0
 	MAP_FIXED                                   = 0x10
 	MAP_FIXED_NOREPLACE                         = 0x100000
@@ -1922,6 +1937,8 @@ const (
 	MNT_EXPIRE                                  = 0x4
 	MNT_FORCE                                   = 0x1
 	MNT_ID_REQ_SIZE_VER0                        = 0x18
+	MNT_ID_REQ_SIZE_VER1                        = 0x20
+	MNT_NS_INFO_SIZE_VER0                       = 0x10
 	MODULE_INIT_COMPRESSED_FILE                 = 0x4
 	MODULE_INIT_IGNORE_MODVERSIONS              = 0x1
 	MODULE_INIT_IGNORE_VERMAGIC                 = 0x2
@@ -1957,6 +1974,7 @@ const (
 	MSG_PEEK                                    = 0x2
 	MSG_PROXY                                   = 0x10
 	MSG_RST                                     = 0x1000
+	MSG_SOCK_DEVMEM                             = 0x2000000
 	MSG_SYN                                     = 0x400
 	MSG_TRUNC                                   = 0x20
 	MSG_TRYHARD                                 = 0x4
@@ -2073,6 +2091,7 @@ const (
 	NFC_ATR_REQ_MAXSIZE                         = 0x40
 	NFC_ATR_RES_GB_MAXSIZE                      = 0x2f
 	NFC_ATR_RES_MAXSIZE                         = 0x40
+	NFC_ATS_MAXSIZE                             = 0x14
 	NFC_COMM_ACTIVE                             = 0x0
 	NFC_COMM_PASSIVE                            = 0x1
 	NFC_DEVICE_NAME_MAXSIZE                     = 0x8
@@ -2153,6 +2172,7 @@ const (
 	NFNL_SUBSYS_QUEUE                           = 0x3
 	NFNL_SUBSYS_ULOG                            = 0x4
 	NFS_SUPER_MAGIC                             = 0x6969
+	NFT_BITWISE_BOOL                            = 0x0
 	NFT_CHAIN_FLAGS                             = 0x7
 	NFT_CHAIN_MAXNAMELEN                        = 0x100
 	NFT_CT_MAX                                  = 0x17
@@ -2187,7 +2207,7 @@ const (
 	NFT_REG_SIZE                                = 0x10
 	NFT_REJECT_ICMPX_MAX                        = 0x3
 	NFT_RT_MAX                                  = 0x4
-	NFT_SECMARK_CTX_MAXLEN                      = 0x100
+	NFT_SECMARK_CTX_MAXLEN                      = 0x1000
 	NFT_SET_MAXNAMELEN                          = 0x100
 	NFT_SOCKET_MAX                              = 0x3
 	NFT_TABLE_F_MASK                            = 0x7
@@ -2356,9 +2376,11 @@ const (
 	PERF_MEM_LVLNUM_IO                          = 0xa
 	PERF_MEM_LVLNUM_L1                          = 0x1
 	PERF_MEM_LVLNUM_L2                          = 0x2
+	PERF_MEM_LVLNUM_L2_MHB                      = 0x5
 	PERF_MEM_LVLNUM_L3                          = 0x3
 	PERF_MEM_LVLNUM_L4                          = 0x4
 	PERF_MEM_LVLNUM_LFB                         = 0xc
+	PERF_MEM_LVLNUM_MSC                         = 0x6
 	PERF_MEM_LVLNUM_NA                          = 0xf
 	PERF_MEM_LVLNUM_PMEM                        = 0xe
 	PERF_MEM_LVLNUM_RAM                         = 0xd
@@ -2431,6 +2453,7 @@ const (
 	PRIO_PGRP                                   = 0x1
 	PRIO_PROCESS                                = 0x0
 	PRIO_USER                                   = 0x2
+	PROCFS_IOCTL_MAGIC                          = 'f'
 	PROC_SUPER_MAGIC                            = 0x9fa0
 	PROT_EXEC                                   = 0x4
 	PROT_GROWSDOWN                              = 0x1000000
@@ -2478,6 +2501,7 @@ const (
 	PR_GET_PDEATHSIG                            = 0x2
 	PR_GET_SECCOMP                              = 0x15
 	PR_GET_SECUREBITS                           = 0x1b
+	PR_GET_SHADOW_STACK_STATUS                  = 0x4a
 	PR_GET_SPECULATION_CTRL                     = 0x34
 	PR_GET_TAGGED_ADDR_CTRL                     = 0x38
 	PR_GET_THP_DISABLE                          = 0x2a
@@ -2486,6 +2510,7 @@ const (
 	PR_GET_TIMING                               = 0xd
 	PR_GET_TSC                                  = 0x19
 	PR_GET_UNALIGN                              = 0x5
+	PR_LOCK_SHADOW_STACK_STATUS                 = 0x4c
 	PR_MCE_KILL                                 = 0x21
 	PR_MCE_KILL_CLEAR                           = 0x0
 	PR_MCE_KILL_DEFAULT                         = 0x2
@@ -2512,6 +2537,8 @@ const (
 	PR_PAC_GET_ENABLED_KEYS                     = 0x3d
 	PR_PAC_RESET_KEYS                           = 0x36
 	PR_PAC_SET_ENABLED_KEYS                     = 0x3c
+	PR_PMLEN_MASK                               = 0x7f000000
+	PR_PMLEN_SHIFT                              = 0x18
 	PR_PPC_DEXCR_CTRL_CLEAR                     = 0x4
 	PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC              = 0x10
 	PR_PPC_DEXCR_CTRL_EDITABLE                  = 0x1
@@ -2579,6 +2606,7 @@ const (
 	PR_SET_PTRACER                              = 0x59616d61
 	PR_SET_SECCOMP                              = 0x16
 	PR_SET_SECUREBITS                           = 0x1c
+	PR_SET_SHADOW_STACK_STATUS                  = 0x4b
 	PR_SET_SPECULATION_CTRL                     = 0x35
 	PR_SET_SYSCALL_USER_DISPATCH                = 0x3b
 	PR_SET_TAGGED_ADDR_CTRL                     = 0x37
@@ -2589,6 +2617,9 @@ const (
 	PR_SET_UNALIGN                              = 0x6
 	PR_SET_VMA                                  = 0x53564d41
 	PR_SET_VMA_ANON_NAME                        = 0x0
+	PR_SHADOW_STACK_ENABLE                      = 0x1
+	PR_SHADOW_STACK_PUSH                        = 0x4
+	PR_SHADOW_STACK_WRITE                       = 0x2
 	PR_SME_GET_VL                               = 0x40
 	PR_SME_SET_VL                               = 0x3f
 	PR_SME_SET_VL_ONEXEC                        = 0x40000
@@ -2620,6 +2651,28 @@ const (
 	PR_UNALIGN_NOPRINT                          = 0x1
 	PR_UNALIGN_SIGBUS                           = 0x2
 	PSTOREFS_MAGIC                              = 0x6165676c
+	PTP_CLK_MAGIC                               = '='
+	PTP_ENABLE_FEATURE                          = 0x1
+	PTP_EXTTS_EDGES                             = 0x6
+	PTP_EXTTS_EVENT_VALID                       = 0x1
+	PTP_EXTTS_V1_VALID_FLAGS                    = 0x7
+	PTP_EXTTS_VALID_FLAGS                       = 0x1f
+	PTP_EXT_OFFSET                              = 0x10
+	PTP_FALLING_EDGE                            = 0x4
+	PTP_MAX_SAMPLES                             = 0x19
+	PTP_PEROUT_DUTY_CYCLE                       = 0x2
+	PTP_PEROUT_ONE_SHOT                         = 0x1
+	PTP_PEROUT_PHASE                            = 0x4
+	PTP_PEROUT_V1_VALID_FLAGS                   = 0x0
+	PTP_PEROUT_VALID_FLAGS                      = 0x7
+	PTP_PIN_GETFUNC                             = 0xc0603d06
+	PTP_PIN_GETFUNC2                            = 0xc0603d0f
+	PTP_RISING_EDGE                             = 0x2
+	PTP_STRICT_FLAGS                            = 0x8
+	PTP_SYS_OFFSET_EXTENDED                     = 0xc4c03d09
+	PTP_SYS_OFFSET_EXTENDED2                    = 0xc4c03d12
+	PTP_SYS_OFFSET_PRECISE                      = 0xc0403d08
+	PTP_SYS_OFFSET_PRECISE2                     = 0xc0403d11
 	PTRACE_ATTACH                               = 0x10
 	PTRACE_CONT                                 = 0x7
 	PTRACE_DETACH                               = 0x11
@@ -2876,7 +2929,6 @@ const (
 	RTM_NEWNEXTHOP                              = 0x68
 	RTM_NEWNEXTHOPBUCKET                        = 0x74
 	RTM_NEWNSID                                 = 0x58
-	RTM_NEWNVLAN                                = 0x70
 	RTM_NEWPREFIX                               = 0x34
 	RTM_NEWQDISC                                = 0x24
 	RTM_NEWROUTE                                = 0x18
@@ -2885,6 +2937,7 @@ const (
 	RTM_NEWTCLASS                               = 0x28
 	RTM_NEWTFILTER                              = 0x2c
 	RTM_NEWTUNNEL                               = 0x78
+	RTM_NEWVLAN                                 = 0x70
 	RTM_NR_FAMILIES                             = 0x1b
 	RTM_NR_MSGTYPES                             = 0x6c
 	RTM_SETDCB                                  = 0x4f
@@ -2933,15 +2986,17 @@ const (
 	RUSAGE_SELF                                 = 0x0
 	RUSAGE_THREAD                               = 0x1
 	RWF_APPEND                                  = 0x10
+	RWF_ATOMIC                                  = 0x40
 	RWF_DSYNC                                   = 0x2
 	RWF_HIPRI                                   = 0x1
 	RWF_NOAPPEND                                = 0x20
 	RWF_NOWAIT                                  = 0x8
-	RWF_SUPPORTED                               = 0x3f
+	RWF_SUPPORTED                               = 0x7f
 	RWF_SYNC                                    = 0x4
 	RWF_WRITE_LIFE_NOT_SET                      = 0x0
 	SCHED_BATCH                                 = 0x3
 	SCHED_DEADLINE                              = 0x6
+	SCHED_EXT                                   = 0x7
 	SCHED_FIFO                                  = 0x1
 	SCHED_FLAG_ALL                              = 0x7f
 	SCHED_FLAG_DL_OVERRUN                       = 0x4
@@ -3210,6 +3265,7 @@ const (
 	STATX_ATTR_MOUNT_ROOT                       = 0x2000
 	STATX_ATTR_NODUMP                           = 0x40
 	STATX_ATTR_VERITY                           = 0x100000
+	STATX_ATTR_WRITE_ATOMIC                     = 0x400000
 	STATX_BASIC_STATS                           = 0x7ff
 	STATX_BLOCKS                                = 0x400
 	STATX_BTIME                                 = 0x800
@@ -3226,6 +3282,7 @@ const (
 	STATX_SUBVOL                                = 0x8000
 	STATX_TYPE                                  = 0x1
 	STATX_UID                                   = 0x8
+	STATX_WRITE_ATOMIC                          = 0x10000
 	STATX__RESERVED                             = 0x80000000
 	SYNC_FILE_RANGE_WAIT_AFTER                  = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE                 = 0x1
@@ -3624,6 +3681,7 @@ const (
 	XDP_UMEM_PGOFF_COMPLETION_RING              = 0x180000000
 	XDP_UMEM_PGOFF_FILL_RING                    = 0x100000000
 	XDP_UMEM_REG                                = 0x4
+	XDP_UMEM_TX_METADATA_LEN                    = 0x4
 	XDP_UMEM_TX_SW_CSUM                         = 0x2
 	XDP_UMEM_UNALIGNED_CHUNK_FLAG               = 0x1
 	XDP_USE_NEED_WAKEUP                         = 0x8

vendor/golang.org/x/sys/unix/zerrors_linux_386.go

@@ -109,12 +109,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,9 +156,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -232,6 +240,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPXREGS                = 0x12
 	PTRACE_GET_THREAD_AREA           = 0x19
@@ -278,10 +300,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -316,6 +341,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4

vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go

@@ -109,12 +109,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -153,9 +156,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -232,6 +240,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_ARCH_PRCTL                = 0x1e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GETFPXREGS                = 0x12
@@ -279,10 +301,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -317,6 +342,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4

vendor/golang.org/x/sys/unix/zerrors_linux_arm.go

@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_GETCRUNCHREGS             = 0x19
 	PTRACE_GETFDPIC                  = 0x1f
 	PTRACE_GETFDPIC_EXEC             = 0x0
@@ -284,10 +306,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -322,6 +347,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4

vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go

@@ -109,15 +109,19 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	GCS_MAGIC                        = 0x47435300
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -154,9 +158,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -200,6 +209,7 @@ const (
 	PERF_EVENT_IOC_SET_BPF           = 0x40042408
 	PERF_EVENT_IOC_SET_FILTER        = 0x40082406
 	PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
+	POE_MAGIC                        = 0x504f4530
 	PPPIOCATTACH                     = 0x4004743d
 	PPPIOCATTCHAN                    = 0x40047438
 	PPPIOCBRIDGECHAN                 = 0x40047435
@@ -235,6 +245,20 @@ const (
 	PROT_BTI                         = 0x10
 	PROT_MTE                         = 0x20
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_PEEKMTETAGS               = 0x21
 	PTRACE_POKEMTETAGS               = 0x22
 	PTRACE_SYSEMU                    = 0x1f
@@ -275,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -313,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4

vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go

@@ -109,12 +109,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
+	HIDIOCREVOKE                     = 0x4004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x8000
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -154,9 +157,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x8008b705
 	NS_GET_NSTYPE                    = 0xb703
 	NS_GET_OWNER_UID                 = 0xb704
 	NS_GET_PARENT                    = 0xb702
+	NS_GET_PID_FROM_PIDNS            = 0x8004b706
+	NS_GET_PID_IN_PIDNS              = 0x8004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x8004b707
+	NS_GET_TGID_IN_PIDNS             = 0x8004b709
 	NS_GET_USERNS                    = 0xb701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -233,6 +241,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x7434
 	PPPIOCXFERUNIT                   = 0x744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x80503d01
+	PTP_CLOCK_GETCAPS2               = 0x80503d0a
+	PTP_ENABLE_PPS                   = 0x40043d04
+	PTP_ENABLE_PPS2                  = 0x40043d0d
+	PTP_EXTTS_REQUEST                = 0x40103d02
+	PTP_EXTTS_REQUEST2               = 0x40103d0b
+	PTP_MASK_CLEAR_ALL               = 0x3d13
+	PTP_MASK_EN_SINGLE               = 0x40043d14
+	PTP_PEROUT_REQUEST               = 0x40383d03
+	PTP_PEROUT_REQUEST2              = 0x40383d0c
+	PTP_PIN_SETFUNC                  = 0x40603d07
+	PTP_PIN_SETFUNC2                 = 0x40603d10
+	PTP_SYS_OFFSET                   = 0x43403d05
+	PTP_SYS_OFFSET2                  = 0x43403d0e
 	PTRACE_SYSEMU                    = 0x1f
 	PTRACE_SYSEMU_SINGLESTEP         = 0x20
 	RLIMIT_AS                        = 0x9
@@ -271,10 +293,13 @@ const (
 	RTC_WIE_ON                       = 0x700f
 	RTC_WKALM_RD                     = 0x80287010
 	RTC_WKALM_SET                    = 0x4028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
@@ -309,6 +334,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x27
 	SO_DONTROUTE                     = 0x5
 	SO_ERROR                         = 0x4

vendor/golang.org/x/sys/unix/zerrors_linux_mips.go

@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x20
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -277,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -315,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007

vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go

@@ -108,12 +108,15 @@ const (
 	HIDIOCGRAWINFO                   = 0x40084803
 	HIDIOCGRDESC                     = 0x50044802
 	HIDIOCGRDESCSIZE                 = 0x40044801
+	HIDIOCREVOKE                     = 0x8004480d
 	HUPCL                            = 0x400
 	ICANON                           = 0x2
 	IEXTEN                           = 0x100
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -150,9 +153,14 @@ const (
 	NFDBITS                          = 0x40
 	NLDLY                            = 0x100
 	NOFLSH                           = 0x80
+	NS_GET_MNTNS_ID                  = 0x4008b705
 	NS_GET_NSTYPE                    = 0x2000b703
 	NS_GET_OWNER_UID                 = 0x2000b704
 	NS_GET_PARENT                    = 0x2000b702
+	NS_GET_PID_FROM_PIDNS            = 0x4004b706
+	NS_GET_PID_IN_PIDNS              = 0x4004b708
+	NS_GET_TGID_FROM_PIDNS           = 0x4004b707
+	NS_GET_TGID_IN_PIDNS             = 0x4004b709
 	NS_GET_USERNS                    = 0x2000b701
 	OLCUC                            = 0x2
 	ONLCR                            = 0x4
@@ -229,6 +237,20 @@ const (
 	PPPIOCUNBRIDGECHAN               = 0x20007434
 	PPPIOCXFERUNIT                   = 0x2000744e
 	PR_SET_PTRACER_ANY               = 0xffffffffffffffff
+	PTP_CLOCK_GETCAPS                = 0x40503d01
+	PTP_CLOCK_GETCAPS2               = 0x40503d0a
+	PTP_ENABLE_PPS                   = 0x80043d04
+	PTP_ENABLE_PPS2                  = 0x80043d0d
+	PTP_EXTTS_REQUEST                = 0x80103d02
+	PTP_EXTTS_REQUEST2               = 0x80103d0b
+	PTP_MASK_CLEAR_ALL               = 0x20003d13
+	PTP_MASK_EN_SINGLE               = 0x80043d14
+	PTP_PEROUT_REQUEST               = 0x80383d03
+	PTP_PEROUT_REQUEST2              = 0x80383d0c
+	PTP_PIN_SETFUNC                  = 0x80603d07
+	PTP_PIN_SETFUNC2                 = 0x80603d10
+	PTP_SYS_OFFSET                   = 0x83403d05
+	PTP_SYS_OFFSET2                  = 0x83403d0e
 	PTRACE_GETFPREGS                 = 0xe
 	PTRACE_GET_THREAD_AREA           = 0x19
 	PTRACE_GET_THREAD_AREA_3264      = 0xc4
@@ -277,10 +299,13 @@ const (
 	RTC_WIE_ON                       = 0x2000700f
 	RTC_WKALM_RD                     = 0x40287010
 	RTC_WKALM_SET                    = 0x8028700f
+	SCM_DEVMEM_DMABUF                = 0x4f
+	SCM_DEVMEM_LINEAR                = 0x4e
 	SCM_TIMESTAMPING                 = 0x25
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
@@ -315,6 +340,9 @@ const (
 	SO_CNX_ADVICE                    = 0x35
 	SO_COOKIE                        = 0x39
 	SO_DETACH_REUSEPORT_BPF          = 0x44
+	SO_DEVMEM_DMABUF                 = 0x4f
+	SO_DEVMEM_DONTNEED               = 0x50
+	SO_DEVMEM_LINEAR                 = 0x4e
 	SO_DOMAIN                        = 0x1029
 	SO_DONTROUTE                     = 0x10
 	SO_ERROR                         = 0x1007