function61 / gokit

Frequently needed, stupid simple, packages in Go

⬆️ For table of contents, click the above icon

Frequently needed, stupid simple, packages in Go.

Directory structure

Low-level packages

Directory structure follows Go's stdlib where there are equivalents. E.g. httputils is found in net/http/httputils/.

Higher-level, "app", packages

Go's stdlib (wisely) doesn't implement higher level/app-level concepts.

Higher-level concepts are in app/ like backoff/retry algorithms or external service related things like AWS wrappers or Prometheus helpers.

Deprecations

• csrf/ - just use SameSite cookies
• crypto/pkencryptedstream/ - provides confidentiality, but is malleable (ciphertext is not authenticated). Use Age instead.

gokit's Issues

Inline most useful primitives from `samber/lo`

Most used ones:

• Contains()
• Map()
• Filter()

Others:

• Some()?

Ternary operator

Prototype:

// 'ternary operator'
func IfElseAssign[T any](val bool, ifTrue T, ifFalse T) T {
	if val {
		return ifTrue
	} else {
		return ifFalse
	}
}

// 'ternary operator' (lazy production of value)
func IfElseAssignFn[T any](val bool, ifTrue func() T, ifFalse func() T) T {
	if val {
		return ifTrue()
	} else {
		return ifFalse()
	}
}

// "adapter" for making values for `IfElseAssignFn` without having to type the full `func () string { return "foo" }`
func fn[T any](val T) func() T {
	return func() T { return val }
}

func main() {
	name := "Joonas"
	powerEstimate := IfElseAssignFn(name == "Joonas", fn(9001), fn(3))
	powerEstimate = IfElseAssign(name == "Joonas", 9001, 3)
	fmt.Printf("Power of %s = %d\n", name, powerEstimate)
}

ezhttp: reject http.Get() with non-nil RequestBody

Logging: migrate to slog

https://pkg.go.dev/golang.org/x/exp/slog

https://go.googlesource.com/proposal/+/master/design/56345-structured-logging.md

Move dynversion/

Shouldn't be in root, but moving requires change to https://github.com/function61/buildkit-golang

Also, investigate if https://golang.org/cmd/buildid/ has overlap?

ossignal: WaitForInterruptOrTerminate to return channel

This makes it more versatile

Implement version module

Bug in "systemd file already exists?" logic

https://github.com/function61/gokit/blob/master/systemdinstaller/systemdinstaller.go#L42

`ezhttp`: support for not following redirects

var (
        // can't patch existing HTTP client because we could end up modifying `http.DefaultClient`
        // https://stackoverflow.com/a/38150816
	noFollowRedirects = ezhttp.Client(&http.Client{
		CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
			// no error - just don't follow redirects
			return http.ErrUseLastResponse
		},
	})
)

ossignal: subsequent signal termination

https://github.com/distr1/distri/blob/cec04b5ac63fbe5d401244859c7076b7f7e98b10/context.go#L18

bidipipe: use sync.Once() instead of firstErrorCh?

Support for opendoas in privileges_linux.go

There is no support for the doas command, which is a secure alternative to sudo.

opendoas sets the DOAS_USER environment variables (e.g. DOAS_USER="humaid").

An alternate check should be added somewhere here, but the UID has to be fetched.

gokit/os/user/userutil/privileges_linux.go

Line 226 in 27b5c49

if os.Getenv("SUDO_UID") == "" { // not running under sudo

jsonfile.Read* should document to promise returning fs.ErrNotFound when file is not found

JSON errors: line numbers

Playground code:

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"strings"
)

// (ab)using the fact that the JSON decoder has accumulated over all it's read plus it's working on the new buffer
// it's about to receive now.
type lineCounter struct {
	committedLines int
	committedBytes int64

	uncommitted      []byte
	uncommittedLines int
}

func (l *lineCounter) LineNumberFromOffset(offset int64) int {
	if offset < l.committedBytes {
		panic("offset < l.committedBytes")
	}

	intoUncommitted := offset - l.committedBytes

	linesIntoUncommitted := countNewlines(l.uncommitted[:intoUncommitted])

	return l.committedLines + linesIntoUncommitted
}

var _ io.Writer = (*lineCounter)(nil)

func (l *lineCounter) Write(buf []byte) (int, error) {
	// the fact that `Write()` was called means that the previous uncommitted buffer was consumed fully. "commit" now.
	l.committedBytes += int64(len(l.uncommitted))
	l.committedLines += l.uncommittedLines

	l.uncommittedLines = countNewlines(buf)
	l.uncommitted = buf

	return len(buf), nil
}

func main() {
	lc := &lineCounter{}

	jd := json.NewDecoder(io.TeeReader(strings.NewReader(`{


	"Foo": "bar"}`), lc))
	err := jd.Decode(&struct{ Foo struct{} }{})
	if err != nil {
		fmt.Printf("err=%v pos=%d\n", err, lc.LineNumberFromOffset(jd.InputOffset()))
	}

	fmt.Println("Hello, 世界")
}

func countNewlines(buf []byte) int {
	newlines := 0

	for _, ch := range buf {
		if ch == '\n' {
			newlines++
		}
	}

	return newlines
}

Atomic file partial filename, should the filename be hidden?

Atomic file partial filename should be random (or use locking somehow)

If two processes are racing to make the same final file:

rename /run/notifydedup/counter.json.part /run/notifydedup/counter.json: no such file or directory; also failed removing temp file: remove /run/notifydedup/counter.json.part: no such file or directory

Think timeline:

• Process 1 starts producing counter.json.part
• Process 2 starts producing counter.json.part, overriding first one
• Process 1 renames the part file to target (thinking it is its own part file), effectively replacing the target file with an incomplete file

Is it possible to use locking with the part file in a way that two competing processes are not racing to produce the target file?

Nevermind..

Wrong repo :D

`assert`: deprecate `Assert()`

Implement it with assert.Equal(t, expr, true)?

Result type

Some sketching:

type Result[T any] struct {
	item *T
	err  error
}

func Ok[T any](value T) Result[T] {
	return Result[T]{
		item: &value,
		err:  nil,
	}
}

func Err[T any](err error) Result[T] {
	return Result[T]{
		item: nil,
		err:  err,
	}
}

func getTemp(succeed bool) Result[string] {
	if succeed {
		return Ok("warm")
	} else {
		return Err[string](errors.New("could not succeed"))
	}
}

func main() {
	temp := getTemp(true)
	fmt.Printf("temp=%s\n", *temp.item)
}