util

Documentation

Overview

Package util provides common utility functions used across the Packhorse codebase.

Index

• func DeferClose(logger *slog.Logger, closer io.Closer, msg string) func()
• func RepoFromPath(path string) string
• func WrapHandler(handler http.Handler) http.Handler
• func WrapTransport(transport http.RoundTripper) http.RoundTripper
• type OrderedMap
  • func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V]
  • func NewOrderedMapFromPairs[K comparable, V any](pairs ...Pair[K, V]) *OrderedMap[K, V]
  • func (om *OrderedMap[K, V]) All() iter.Seq2[K, V]
  • func (om *OrderedMap[K, V]) Delete(key K)
  • func (om *OrderedMap[K, V]) Get(key K) (V, bool)
  • func (om *OrderedMap[K, V]) Has(key K) bool
  • func (om *OrderedMap[K, V]) Keys() []K
  • func (om *OrderedMap[K, V]) Len() int
  • func (om *OrderedMap[K, V]) Range(fn func(key K, value V) bool)
  • func (om *OrderedMap[K, V]) Set(key K, value V)
  • func (om *OrderedMap[K, V]) ToMap() map[K]V
• type Pair
  • func P[K comparable, V any](key K, value V) Pair[K, V]

Functions

func DeferClose

func DeferClose(logger *slog.Logger, closer io.Closer, msg string) func()

DeferClose returns a function that closes the given io.Closer and logs any errors. This is useful for defer statements where you want to ensure close errors are logged but don't want to handle them explicitly.

Example usage:

file, err := os.Open("file.txt")
if err != nil {
    return err
}
defer DeferClose(logger, file, "failed to close file")()

func RepoFromPath

func RepoFromPath(path string) string

RepoFromPath extracts a repository name like "gitlab-org/gitlab" from a Git Smart HTTP request path like "/gitlab-org/gitlab.git/git-upload-pack" or "/gitlab-org/gitlab.git/info/refs".

func WrapHandler

func WrapHandler(handler http.Handler) http.Handler

WrapHandler wraps an HTTP server handler with debug logging when PACKHORSE_DEBUG_HTTP=1. If debug logging is not enabled, returns the original handler unchanged.

func WrapTransport

func WrapTransport(transport http.RoundTripper) http.RoundTripper

WrapTransport wraps an HTTP client transport with debug logging when PACKHORSE_DEBUG_HTTP=1. If debug logging is not enabled, returns the original transport unchanged.

Types

type OrderedMap

type OrderedMap[K comparable, V any] struct {
	// contains filtered or unexported fields
}

OrderedMap is a map that preserves insertion order. It stores key-value pairs and maintains the order in which keys were first inserted.

func NewOrderedMap

func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V]

NewOrderedMap creates a new OrderedMap.

func NewOrderedMapFromPairs

func NewOrderedMapFromPairs[K comparable, V any](pairs ...Pair[K, V]) *OrderedMap[K, V]

NewOrderedMapFromPairs creates a new OrderedMap with initial key-value pairs. The pairs are inserted in the order provided.

func (*OrderedMap[K, V]) All

func (om *OrderedMap[K, V]) All() iter.Seq2[K, V]

All returns an iterator over key-value pairs in insertion order. This enables using OrderedMap with Go's range over function syntax:

for key, value := range om.All() {
    // process key and value
}

func (*OrderedMap[K, V]) Delete

func (om *OrderedMap[K, V]) Delete(key K)

Delete removes a key-value pair from the map.

func (*OrderedMap[K, V]) Get

func (om *OrderedMap[K, V]) Get(key K) (V, bool)

Get retrieves the value for a key and whether it exists.

func (*OrderedMap[K, V]) Has

func (om *OrderedMap[K, V]) Has(key K) bool

Has checks if a key exists in the map.

func (*OrderedMap[K, V]) Keys

func (om *OrderedMap[K, V]) Keys() []K

Keys returns a slice of all keys in insertion order.

func (*OrderedMap[K, V]) Len

func (om *OrderedMap[K, V]) Len() int

Len returns the number of key-value pairs in the map.

func (*OrderedMap[K, V]) Range

func (om *OrderedMap[K, V]) Range(fn func(key K, value V) bool)

Range iterates over the map in insertion order, calling the function for each key-value pair. If the function returns false, iteration stops.

func (*OrderedMap[K, V]) Set

func (om *OrderedMap[K, V]) Set(key K, value V)

Set sets a key-value pair. If the key already exists, the value is updated but the key position in the order is not changed.

func (*OrderedMap[K, V]) ToMap

func (om *OrderedMap[K, V]) ToMap() map[K]V

ToMap returns a regular map with all key-value pairs (order information is lost).

type Pair

type Pair[K comparable, V any] struct {
	Key   K
	Value V
}

Pair represents a key-value pair for OrderedMap construction.

func P

func P[K comparable, V any](key K, value V) Pair[K, V]

P creates a Pair with type inference from the provided key and value. This is a convenience function to avoid explicitly specifying type parameters.