go.mod: Include "gobang" dependency

1 files changed, 47 insertions, 642 deletions

diff --git a/src/lib.go b/src/lib.go
index d537b34..b06829a 100644
--- a/src/lib.go
+++ b/src/lib.go
@@ -3,21 +3,13 @@ package papod
 import (
 	"bufio"
 	"bytes"
-	"crypto/hmac"
-	"crypto/rand"
-	"crypto/sha256"
 	"database/sql"
-	"encoding/binary"
-	"encoding/hex"
 	"errors"
 	"flag"
 	"fmt"
-	"hash"
 	"io"
 	"io/ioutil"
 	"log/slog"
-	"math/big"
-	"math/bits"
 	"net"
 	"os"
 	"regexp"
@@ -25,613 +17,46 @@ import (
 	"sort"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
-	_ "github.com/mattn/go-sqlite3"
-)
-
+	g "euandre.org/gobang/src"
 
-/* Global variables */
-var (
-	Hostname string
-	Version  string
-	Colour   string
+	_ "github.com/mattn/go-sqlite3"
 )
 
-// FIXME: reorder
-var EmitActiveConnection   = MakeGauge("active-connections")
-var EmitNicksInChannel     = MakeGauge("nicks-in-channel")
-var EmitReceivedMessage    = MakeCounter("received-message")
-var EmitWriteToClientError = MakeCounter("write-to-client")
 
-const pingFrequency  = time.Duration(30) * time.Second
-const pongMaxLatency = time.Duration(5)  * time.Second
 
 
 
-// FIXME: finish rewriting
-//
-// lastV7time is the last time we returned stored as:
-//
-//   52 bits of time in milliseconds since epoch
-//   12 bits of (fractional nanoseconds) >> 8
-var lastV7Time int64
-var timeMu sync.Mutex
-// getV7Time returns the time in milliseconds and nanoseconds / 256.
-// The returned (milli << (12 + seq)) is guaranteed to be greater than
-// (milli << (12 + seq)) returned by any previous call to getV7Time.
-// `seq` Sequence number is between 0 and 3906 (nanoPerMilli >> 8)
-func getV7Time(nano int64) (int64, int64) {
-	const nanoPerMilli = 1000 * 1000
-
-	milli := nano / nanoPerMilli
-	seq := (nano - (milli * nanoPerMilli)) >> 8
-	now := milli << (12 + seq)
-
-	timeMu.Lock()
-	defer timeMu.Unlock()
-	if now <= lastV7Time {
-		now = lastV7Time + 1
-		milli = now >> 12
-		seq = now & 0xfff
-	}
-	lastV7Time = now
-	return milli, seq
-}
-
-const lengthUUID = 16
-
-type UUID struct {
-	bytes [lengthUUID]byte
-}
-
-func NewUUID() UUID {
-	var buf [lengthUUID]byte
-	_, err := io.ReadFull(rand.Reader, buf[7:])
-	if err != nil {
-		panic(err)
-	}
-
-	buf[6] = (buf[6] & 0x0f) | 0x40 // Version 4
-	buf[8] = (buf[8] & 0x3f) | 0x80 // Variant is 10
-
-	t, s := getV7Time(time.Now().UnixNano())
-
-	buf[0] = byte(t >> 40)
-	buf[1] = byte(t >> 32)
-	buf[2] = byte(t >> 24)
-	buf[3] = byte(t >> 16)
-	buf[4] = byte(t >> 8)
-	buf[5] = byte(t >> 0)
-
-	buf[6] = 0x70 | (0x0f & byte(s >> 8))
-	buf[7] = byte(s)
-	return UUID { bytes: buf }
-}
-
-func (uuid UUID) ToString() string {
-	const dashCount = 4
-	const encodedLength = (lengthUUID * 2) + dashCount
-	dst := [encodedLength]byte {
-		0, 0, 0, 0,
-		0, 0, 0, 0,
-		'-',
-		0, 0, 0, 0,
-		'-',
-		0, 0, 0, 0,
-		'-',
-		0, 0, 0, 0,
-		'-',
-		0, 0, 0, 0,
-		0, 0, 0, 0,
-		0, 0, 0, 0,
-	}
-
-	hex.Encode(dst[ 0:8],  uuid.bytes[0:4])
-	hex.Encode(dst[ 9:13], uuid.bytes[4:6])
-	hex.Encode(dst[14:18], uuid.bytes[6:8])
-	hex.Encode(dst[19:23], uuid.bytes[8:10])
-	hex.Encode(dst[24:36], uuid.bytes[10:])
-
-	return string(dst[:])
-}
-
-type LogLevel int8
-
-const (
-	 LevelNone    LogLevel = 0
-	 LevelError   LogLevel = 1
-	 LevelWarning LogLevel = 2
-	 LevelInfo    LogLevel = 3
-	 LevelDebug   LogLevel = 4
+// Global variables
+var (
+	Version  string
+	Colour   string
 )
 
-var Level LogLevel = LevelInfo
-
-var EmitMetric bool = true
-
-
-func Debug(message string, type_ string, args ...any) {
-	if (Level < LevelDebug) {
-		return
-	}
-
-	slog.Debug(
-		message,
-		append(
-			[]any {
-				"id",    NewUUID().ToString(),
-				"kind",  "log",
-				"type",  type_,
-			},
-			args...,
-		)...,
-	)
-}
-
-func Info(message string, type_ string, args ...any) {
-	if (Level < LevelInfo) {
-		return
-	}
-
-	slog.Info(
-		message,
-		append(
-			[]any {
-				"id",    NewUUID().ToString(),
-				"kind",  "log",
-				"type",  type_,
-			},
-			args...,
-		)...,
-	)
-}
-
-func Warning(message string, type_ string, args ...any) {
-	if (Level < LevelWarning) {
-		return
-	}
-
-	slog.Warn(
-		message,
-		append(
-			[]any {
-				"id",    NewUUID().ToString(),
-				"kind",  "log",
-				"type",  type_,
-			},
-			args...,
-		)...,
-	)
-}
-
-func Error(message string, type_ string, args ...any) {
-	if (Level < LevelError) {
-		return
-	}
-
-	slog.Error(
-		message,
-		append(
-			[]any {
-				"id",    NewUUID().ToString(),
-				"kind",  "log",
-				"type",  type_,
-			},
-			args...,
-		)...,
-	)
-}
-
-func Metric(type_ string, label string, args ...any) {
-	if (!EmitMetric) {
-		return
-	}
-
-	slog.Info(
-		"_",
-		append(
-			[]any {
-				"id",    NewUUID().ToString(),
-				"kind",  "metric",
-				"type",  type_,
-				"label", label,
-			},
-			args...,
-		)...,
-	)
-}
-
-type Gauge struct {
-	Inc func(...any)
-	Dec func(...any)
-}
-
-var zero = big.NewInt(0)
-var one  = big.NewInt(1)
-func MakeGauge(label string, staticArgs ...any) Gauge {
-	count := big.NewInt(0)
-	emitGauge := func(dynamicArgs ...any) {
-		if count.Cmp(zero) == -1 {
-			Error(
-				"Gauge went negative",
-				"process-metric",
-				append(
-					[]any { "value", count },
-					append(
-						staticArgs,
-						dynamicArgs...,
-					)...,
-				)...,
-			)
-			return  // avoid wrong metrics being emitted
-		}
-		Metric(
-			"gauge", label,
-			// TODO: we'll have slices.Concat on Go 1.22
-			append(
-				[]any { "value", count },
-				append(
-					staticArgs,
-					dynamicArgs...,
-				)...,
-			)...,
-		)
-	}
-	return Gauge {
-		Inc: func(dynamicArgs ...any) {
-			count.Add(count, one)
-			emitGauge(dynamicArgs...)
-		},
-		Dec: func(dynamicArgs ...any) {
-			count.Sub(count, one)
-			emitGauge(dynamicArgs...)
-		},
-	}
-}
-
-func MakeCounter(label string) func(...any) {
-	return func(args ...any) {
-		Metric(
-			"counter", label,
-			append([]any { "value", 1 }, args...)...,
-		)
-	}
-}
-
-func SetLoggerOutput(w io.Writer) {
-	slog.SetDefault(slog.New(slog.NewJSONHandler(w, &slog.HandlerOptions {
-		AddSource: true,
-	})).With(
-		slog.Group(
-			"info",
-			"pid",   os.Getpid(),
-			"ppid",  os.Getppid(),
-			"puuid", NewUUID().ToString(),
-		),
-	))
-}
-
-func SetTraceback() {
-	if os.Getenv("GOTRACEBACK") == "" {
-		debug.SetTraceback("crash")
-	}
-}
-
-func Fatal(err error) {
-	Error(
-		"Fatal error", "fatal-error",
-		"error", err,
-		"stack", string(debug.Stack()),
-	)
-	syscall.Kill(os.Getpid(), syscall.SIGABRT)
-	os.Exit(3)
-}
-
-func FatalIf(err error) {
-	if err != nil {
-		Fatal(err)
-	}
-}
-
-
-/*
-Package pbkdf2 implements the key derivation function PBKDF2 as defined in RFC
-2898 / PKCS #5 v2.0.
-
-A key derivation function is useful when encrypting data based on a password
-or any other not-fully-random data. It uses a pseudorandom function to derive
-a secure encryption key based on the password.
-
-While v2.0 of the standard defines only one pseudorandom function to use,
-HMAC-SHA1, the drafted v2.1 specification allows use of all five FIPS Approved
-Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for HMAC. To
-choose, you can pass the `New` functions from the different SHA packages to
-pbkdf2.Key.
-*/
-
-// Key derives a key from the password, salt and iteration count, returning a
-// []byte of length keylen that can be used as cryptographic key. The key is
-// derived based on the method described as PBKDF2 with the HMAC variant using
-// the supplied hash function.
-//
-// For example, to use a HMAC-SHA-1 based PBKDF2 key derivation function, you
-// can get a derived key for e.g. AES-256 (which needs a 32-byte key) by
-// doing:
-//
-//	dk := pbkdf2.Key([]byte("some password"), salt, 4096, 32, sha1.New)
-//
-// Remember to get a good random salt. At least 8 bytes is recommended by the
-// RFC.
-//
-// Using a higher iteration count will increase the cost of an exhaustive
-// search but will also make derivation proportionally slower.
-func PBKDF2Key(
-	password []byte,
-	salt []byte,
-	iter int,
-	keyLen int,
-	h func() hash.Hash,
-) []byte {
-	prf := hmac.New(h, password)
-	hashLen := prf.Size()
-	numBlocks := (keyLen + hashLen - 1) / hashLen
-
-	var buf [4]byte
-	dk := make([]byte, 0, numBlocks*hashLen)
-	U := make([]byte, hashLen)
-	for block := 1; block <= numBlocks; block++ {
-		// N.B.: || means concatenation, ^ means XOR
-		// for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
-		// U_1 = PRF(password, salt || uint(i))
-		prf.Reset()
-		prf.Write(salt)
-		buf[0] = byte(block >> 24)
-		buf[1] = byte(block >> 16)
-		buf[2] = byte(block >> 8)
-		buf[3] = byte(block)
-		prf.Write(buf[:4])
-		dk = prf.Sum(dk)
-		T := dk[len(dk)-hashLen:]
-		copy(U, T)
-
-		// U_n = PRF(password, U_(n-1))
-		for n := 2; n <= iter; n++ {
-			prf.Reset()
-			prf.Write(U)
-			U = U[:0]
-			U = prf.Sum(U)
-			for x := range U {
-				T[x] ^= U[x]
-			}
-		}
-	}
-	return dk[:keyLen]
-}
-
-// Package scrypt implements the scrypt key derivation function as defined in
-// Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard
-// Functions" (https://www.tarsnap.com/scrypt/scrypt.pdf).
-
-const maxInt = int(^uint(0) >> 1)
-
-// blockCopy copies n numbers from src into dst.
-func blockCopy(dst []uint32, src []uint32, n int) {
-	copy(dst, src[:n])
-}
-
-// blockXOR XORs numbers from dst with n numbers from src.
-func blockXOR(dst []uint32, src []uint32, n int) {
-	for i, v := range src[:n] {
-		dst[i] ^= v
-	}
-}
-
-// salsaXOR applies Salsa20/8 to the XOR of 16 numbers from tmp and in,
-// and puts the result into both tmp and out.
-func salsaXOR(tmp *[16]uint32, in []uint32, out []uint32) {
-	w0  := tmp[0]  ^ in[0]
-	w1  := tmp[1]  ^ in[1]
-	w2  := tmp[2]  ^ in[2]
-	w3  := tmp[3]  ^ in[3]
-	w4  := tmp[4]  ^ in[4]
-	w5  := tmp[5]  ^ in[5]
-	w6  := tmp[6]  ^ in[6]
-	w7  := tmp[7]  ^ in[7]
-	w8  := tmp[8]  ^ in[8]
-	w9  := tmp[9]  ^ in[9]
-	w10 := tmp[10] ^ in[10]
-	w11 := tmp[11] ^ in[11]
-	w12 := tmp[12] ^ in[12]
-	w13 := tmp[13] ^ in[13]
-	w14 := tmp[14] ^ in[14]
-	w15 := tmp[15] ^ in[15]
-
-	x0  := w0
-	x1  := w1
-	x2  := w2
-	x3  := w3
-	x4  := w4
-	x5  := w5
-	x6  := w6
-	x7  := w7
-	x8  := w8
-	x9  := w9
-	x10 := w10
-	x11 := w11
-	x12 := w12
-	x13 := w13
-	x14 := w14
-	x15 := w15
-
-	for i := 0; i < 8; i += 2 {
-		x4  ^= bits.RotateLeft32(x0  + x12, 7)
-		x8  ^= bits.RotateLeft32(x4  + x0,  9)
-		x12 ^= bits.RotateLeft32(x8  + x4,  13)
-		x0  ^= bits.RotateLeft32(x12 + x8,  18)
-
-		x9  ^= bits.RotateLeft32(x5  + x1,  7)
-		x13 ^= bits.RotateLeft32(x9  + x5,  9)
-		x1  ^= bits.RotateLeft32(x13 + x9,  13)
-		x5  ^= bits.RotateLeft32(x1  + x13, 18)
-
-		x14 ^= bits.RotateLeft32(x10 + x6,  7)
-		x2  ^= bits.RotateLeft32(x14 + x10, 9)
-		x6  ^= bits.RotateLeft32(x2  + x14, 13)
-		x10 ^= bits.RotateLeft32(x6  + x2,  18)
-
-		x3  ^= bits.RotateLeft32(x15 + x11, 7)
-		x7  ^= bits.RotateLeft32(x3  + x15, 9)
-		x11 ^= bits.RotateLeft32(x7  + x3,  13)
-		x15 ^= bits.RotateLeft32(x11 + x7,  18)
-
-		x1  ^= bits.RotateLeft32(x0  + x3,  7)
-		x2  ^= bits.RotateLeft32(x1  + x0,  9)
-		x3  ^= bits.RotateLeft32(x2  + x1,  13)
-		x0  ^= bits.RotateLeft32(x3  + x2,  18)
-
-		x6  ^= bits.RotateLeft32(x5  + x4,  7)
-		x7  ^= bits.RotateLeft32(x6  + x5,  9)
-		x4  ^= bits.RotateLeft32(x7  + x6,  13)
-		x5  ^= bits.RotateLeft32(x4  + x7,  18)
-
-		x11 ^= bits.RotateLeft32(x10 + x9,  7)
-		x8  ^= bits.RotateLeft32(x11 + x10, 9)
-		x9  ^= bits.RotateLeft32(x8  + x11, 13)
-		x10 ^= bits.RotateLeft32(x9  + x8,  18)
-
-		x12 ^= bits.RotateLeft32(x15 + x14, 7)
-		x13 ^= bits.RotateLeft32(x12 + x15, 9)
-		x14 ^= bits.RotateLeft32(x13 + x12, 13)
-		x15 ^= bits.RotateLeft32(x14 + x13, 18)
-	}
-
-	x0  += w0
-	x1  += w1
-	x2  += w2
-	x3  += w3
-	x4  += w4
-	x5  += w5
-	x6  += w6
-	x7  += w7
-	x8  += w8
-	x9  += w9
-	x10 += w10
-	x11 += w11
-	x12 += w12
-	x13 += w13
-	x14 += w14
-	x15 += w15
-
-	out[0],  tmp[0]  = x0,  x0
-	out[1],  tmp[1]  = x1,  x1
-	out[2],  tmp[2]  = x2,  x2
-	out[3],  tmp[3]  = x3,  x3
-	out[4],  tmp[4]  = x4,  x4
-	out[5],  tmp[5]  = x5,  x5
-	out[6],  tmp[6]  = x6,  x6
-	out[7],  tmp[7]  = x7,  x7
-	out[8],  tmp[8]  = x8,  x8
-	out[9],  tmp[9]  = x9,  x9
-	out[10], tmp[10] = x10, x10
-	out[11], tmp[11] = x11, x11
-	out[12], tmp[12] = x12, x12
-	out[13], tmp[13] = x13, x13
-	out[14], tmp[14] = x14, x14
-	out[15], tmp[15] = x15, x15
-}
-
-func blockMix(tmp *[16]uint32, in []uint32, out []uint32, r int) {
-	blockCopy(tmp[:], in[(2*r-1)*16:], 16)
-	for i := 0; i < 2*r; i += 2 {
-		salsaXOR(tmp, in[i*16:], out[i*8:])
-		salsaXOR(tmp, in[i*16+16:], out[i*8+r*16:])
-	}
-}
-
-func integer(b []uint32, r int) uint64 {
-	j := (2*r - 1) * 16
-	return uint64(b[j]) | uint64(b[j+1])<<32
-}
 
-func smix(b []byte, r int, N int, v []uint32, xy []uint32) {
-	var tmp [16]uint32
-	R := 32 * r
-	x := xy
-	y := xy[R:]
 
-	j := 0
-	for i := 0; i < R; i++ {
-		x[i] = binary.LittleEndian.Uint32(b[j:])
-		j += 4
+func SetEnvironmentVariables() {
+	Version = os.Getenv("PAPOD_VERSION")
+	if Version == "" {
+		Version = "PAPOD-VERSION-UNKNOWN"
 	}
-	for i := 0; i < N; i += 2 {
-		blockCopy(v[i*R:], x, R)
-		blockMix(&tmp, x, y, r)
 
-		blockCopy(v[(i+1)*R:], y, R)
-		blockMix(&tmp, y, x, r)
-	}
-	for i := 0; i < N; i += 2 {
-		j := int(integer(x, r) & uint64(N-1))
-		blockXOR(x, v[j*R:], R)
-		blockMix(&tmp, x, y, r)
-
-		j = int(integer(y, r) & uint64(N-1))
-		blockXOR(y, v[j*R:], R)
-		blockMix(&tmp, y, x, r)
-	}
-	j = 0
-	for _, v := range x[:R] {
-		binary.LittleEndian.PutUint32(b[j:], v)
-		j += 4
+	Colour = os.Getenv("PAPOD_COLOUR")
+	if Colour == "" {
+		Colour = "PAPOD-COLOUR-UNKNOWN"
 	}
 }
 
-// Key derives a key from the password, salt, and cost parameters, returning
-// a byte slice of length keyLen that can be used as cryptographic key.
-//
-// N is a CPU/memory cost parameter, which must be a power of 2 greater than 1.
-// r and p must satisfy r * p < 2³⁰. If the parameters do not satisfy the
-// limits, the function returns a nil byte slice and an error.
-//
-// For example, you can get a derived key for e.g. AES-256 (which needs a
-// 32-byte key) by doing:
-//
-//	dk, err := scrypt.Key([]byte("some password"), salt, 32768, 8, 1, 32)
-//
-// The recommended parameters for interactive logins as of 2017 are N=32768, r=8
-// and p=1. The parameters N, r, and p should be increased as memory latency and
-// CPU parallelism increases; consider setting N to the highest power of 2 you
-// can derive within 100 milliseconds. Remember to get a good random salt.
-func Scrypt(
-	password []byte,
-	salt []byte,
-	N int,
-	r int,
-	p int,
-	keyLen int,
-) ([]byte, error) {
-	if N <= 1 || N&(N-1) != 0 {
-		return nil, errors.New("scrypt: N must be > 1 and a power of 2")
-	}
-	if uint64(r)*uint64(p) >= 1<<30 ||
-			r > maxInt/128/p || r > maxInt/256 || N > maxInt/128/r {
-		return nil, errors.New("scrypt: parameters are too large")
-	}
-
-	xy := make([]uint32, 64*r)
-	v := make([]uint32, 32*N*r)
-	b := PBKDF2Key(password, salt, 1, p*128*r, sha256.New)
-
-	for i := 0; i < p; i++ {
-		smix(b[i*128*r:], r, N, v, xy)
-	}
 
-	return PBKDF2Key(password, b, 1, keyLen, sha256.New), nil
-}
+// FIXME: reorder
+var EmitActiveConnection   = g.MakeGauge("active-connections")
+var EmitNicksInChannel     = g.MakeGauge("nicks-in-channel")
+var EmitReceivedMessage    = g.MakeCounter("received-message")
+var EmitWriteToClientError = g.MakeCounter("write-to-client")
 
+const pingFrequency  = time.Duration(30) * time.Second
+const pongMaxLatency = time.Duration(5)  * time.Second
 
 // type UUID string
 	
@@ -747,7 +172,7 @@ func ParseMessage(rawMessage string) (Message, error) {
 }
 
 func HandleUnknown(ctx *Context, msg Message) {
-	Warning(
+	g.Warning(
 		"Unsupported command", "unsupported-command",
 		"command", msg.Command,
 	)
@@ -781,7 +206,7 @@ func HandlePRIVMSG(ctx *Context, msg Message) {
 	defer stmt.Close()
 
 	ret, err := stmt.Exec(
-		NewUUID().ToString(),
+		g.NewUUID().ToString(),
 		"FIXME",
 		"FIXME",
 		time.Now(),
@@ -860,7 +285,7 @@ func ProcessMessage(ctx *Context, connection *Connection, rawMessage string) {
 
 	msg, err := ParseMessage(rawMessage)
 	if err != nil {
-		Info(
+		g.Info(
 			"Error processing message",
 			"process-message",
 			"err", err,
@@ -898,7 +323,7 @@ func WriteLoop(ctx *Context, connection *Connection) {
 	for message := range connection.replyChan {
 		_, err := io.WriteString(connection.conn, message)
 		if err != nil {
-			Error(
+			g.Error(
 				"Failed to send data to user",
 				"user-reply-error",
 				"err", err,
@@ -957,13 +382,13 @@ func HandleConnection(ctx *Context, conn net.Conn) {
 
 func IRCdLoop(ctx *Context, publicSocketPath string) {
 	listener, err := net.Listen("unix", publicSocketPath)
-	FatalIf(err)
-	Info("IRCd started", "component-up", "component", "ircd")
+	g.FatalIf(err)
+	g.Info("IRCd started", "component-up", "component", "ircd")
 
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
-			Warning(
+			g.Warning(
 				"Error accepting a public IRCd connection",
 				"accept-connection",
 				"err", err,
@@ -978,8 +403,8 @@ func IRCdLoop(ctx *Context, publicSocketPath string) {
 
 func CommandListenerLoop(ctx *Context, commandSocketPath string) {
 	listener, err := net.Listen("unix", commandSocketPath)
-	FatalIf(err)
-	Info(
+	g.FatalIf(err)
+	g.Info(
 		"command listener started",
 		"component-up",
 		"component", "command-listener",
@@ -988,7 +413,7 @@ func CommandListenerLoop(ctx *Context, commandSocketPath string) {
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
-			Warning(
+			g.Warning(
 				"Error accepting a command connection",
 				"accept-command",
 				"err", err,
@@ -1002,7 +427,7 @@ func CommandListenerLoop(ctx *Context, commandSocketPath string) {
 }
 
 func TransactorLoop(ctx *Context) {
-	Info("transactor started", "component-up", "component", "transactor")
+	g.Info("transactor started", "component-up", "component", "transactor")
 	EmitActiveConnection.Inc()
 
 	for tx := range ctx.tx {
@@ -1010,37 +435,19 @@ func TransactorLoop(ctx *Context) {
 	}
 }
 
-func SetHostname() {
-	var err error
-	Hostname, err = os.Hostname()
-	FatalIf(err)
-}
-
-func SetEnvironmentVariables() {
-	Version = os.Getenv("PAPOD_VERSION")
-	if Version == "" {
-		Version = "PAPOD-VERSION-UNKNOWN"
-	}
-
-	Colour = os.Getenv("PAPOD_COLOUR")
-	if Colour == "" {
-		Colour = "PAPOD-COLOUR-UNKNOWN"
-	}
-}
-
 func InitMigrations(db *sql.DB) {
 	_, err := db.Exec(`
 		CREATE TABLE IF NOT EXISTS migrations (
 			filename TEXT PRIMARY KEY
 		);
 	`)
-	FatalIf(err)
+	g.FatalIf(err)
 }
 
 const MIGRATIONS_DIR = "src/sql/migrations/"
 func PendingMigrations(db *sql.DB) []string {
 	files, err := ioutil.ReadDir(MIGRATIONS_DIR)
-	FatalIf(err)
+	g.FatalIf(err)
 
 	set := make(map[string]bool)
 	for _, file := range files {
@@ -1048,16 +455,16 @@ func PendingMigrations(db *sql.DB) []string {
 	}
 
 	rows, err := db.Query(`SELECT filename FROM migrations;`)
-	FatalIf(err)
+	g.FatalIf(err)
 	defer rows.Close()
 
 	for rows.Next() {
 		var filename string
 		err := rows.Scan(&filename)
-		FatalIf(err)
+		g.FatalIf(err)
 		delete(set, filename)
 	}
-	FatalIf(rows.Err())
+	g.FatalIf(rows.Err())
 
 	difference := make([]string, 0)
 	for filename := range set {
@@ -1072,52 +479,50 @@ func RunMigrations(db *sql.DB) {
 	InitMigrations(db)
 
 	stmt, err := db.Prepare(`INSERT INTO migrations (filename) VALUES (?);`)
-	FatalIf(err)
+	g.FatalIf(err)
 	defer stmt.Close()
 
 	for _, filename := range PendingMigrations(db) {
-		Info("Running migration file", "exec-migration-file",
+		g.Info("Running migration file", "exec-migration-file",
 			"filename", filename,
 		)
 
 		tx, err := db.Begin()
-		FatalIf(err)
+		g.FatalIf(err)
 
 		sql, err := os.ReadFile(MIGRATIONS_DIR + filename)
-		FatalIf(err)
+		g.FatalIf(err)
 
 		_, err = tx.Exec(string(sql))
-		FatalIf(err)
+		g.FatalIf(err)
 
 		_, err = tx.Stmt(stmt).Exec(filename)
-		FatalIf(err)
+		g.FatalIf(err)
 
 		err = tx.Commit()
-		FatalIf(err)
+		g.FatalIf(err)
 	}
 }
 
 func InitDB(databasePath string) *sql.DB {
 	db, err := sql.Open("sqlite3", databasePath)
-	FatalIf(err)
+	g.FatalIf(err)
 	RunMigrations(db)
 	return db
 }
 
 func Init() {
-	SetLoggerOutput(os.Stdout)
-	SetTraceback()
-	SetHostname()
+	g.Init()
 	SetEnvironmentVariables()
 }
 
 func Start(ctx *Context, publicSocketPath string, commandSocketPath string) {
 	buildInfo, ok := debug.ReadBuildInfo()
 	if !ok {
-		Fatal(errors.New("error on debug.ReadBuildInfo()"))
+		g.Fatal(errors.New("error on debug.ReadBuildInfo()"))
 	}
 
-	Info("-", "lifecycle-event",
+	g.Info("-", "lifecycle-event",
 		"event", "starting-server",
 		slog.Group(
 			"go",