sneak/chat
1
0
Fork 0
Code Issues 15 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: sneak:feature/mvp-1.0
Branches Tags
sneak:main sneak:fix/29-split-dockerfile sneak:feature/mvp-1.0 sneak:fix/dockerfile-golangci-lint-v2-module-path sneak:fix/golangci-lint-sha-13 sneak:ci/make-check sneak:fix/main-lint-issues sneak:feature/web-client sneak:feature/database-schema sneak:fix/review-feedback sneak:fix/agents-md-workflow
..
compare: sneak:fix/golangci-lint-sha-13
Branches Tags
sneak:main sneak:fix/29-split-dockerfile sneak:feature/mvp-1.0 sneak:fix/dockerfile-golangci-lint-v2-module-path sneak:fix/golangci-lint-sha-13 sneak:ci/make-check sneak:fix/main-lint-issues sneak:feature/web-client sneak:feature/database-schema sneak:fix/review-feedback sneak:fix/agents-md-workflow

1 Commits
feature/mv ... fix/golang

Author SHA1 Message Date
clawbot
c7bcedd8d4 fix: pin golangci-lint install to commit SHA (fixes #13)
All checks were successful
check / check (push) Successful in 1m31s
Details 
- Fix Dockerfile: use correct v2 module path with commit SHA
  (github.com/golangci/golangci-lint/v2/cmd/golangci-lint@eabc2638...)
- Add CGO_ENABLED=0 for alpine compatibility
- Fix 35 lint issues found by golangci-lint v2.1.6:
  - Remove unused nolint directives, add nolintlint where needed
  - Pre-allocate migrations slice
  - Use t.Context() instead of context.Background() in tests
  - Fix blank lines between comments and exported functions in ui.go
 2026-02-26 20:20:31 -08:00
39 changed files with 3714 additions and 7331 deletions
Expand all files Collapse all files

12
.dockerignore
View File

@@ -1,9 +1,9 @@
.git .git
*.md node_modules
!README.md .DS_Store
chatd bin/
chat-cli
data.db data.db
data.db-wal
data.db-shm
.env .env
*.test
*.out
debug.log

22
.golangci.yml
View File

@@ -7,8 +7,15 @@ run:
linters: linters:
default: all default: all
disable: disable:
- wsl # Deprecated in v2, replaced by wsl_v5 # Genuinely incompatible with project patterns
settings: - exhaustruct # Requires all struct fields
- depguard # Dependency allow/block lists
- godot # Requires comments to end with periods
- wsl # Deprecated, replaced by wsl_v5
- wrapcheck # Too verbose for internal packages
- varnamelen # Short names like db, id are idiomatic Go
linters-settings:
lll: lll:
line-length: 88 line-length: 88
funlen: funlen:
@@ -18,17 +25,6 @@ linters:
max-complexity: 15 max-complexity: 15
dupl: dupl:
threshold: 100 threshold: 100
gosec:
excludes:
- G704
depguard:
rules:
all:
deny:
- pkg: "io/ioutil"
desc: "Deprecated; use io and os packages."
- pkg: "math/rand$"
desc: "Use crypto/rand for security-sensitive code."
issues: issues:
exclude-use-default: false exclude-use-default: false

23
Dockerfile
View File

@@ -1,32 +1,29 @@
# golang:1.24-alpine, 2026-02-26 # golang:1.24-alpine, 2026-02-26
FROM golang@sha256:8bee1901f1e530bfb4a7850aa7a479d17ae3a18beb6e09064ed54cfd245b7191 AS builder FROM golang@sha256:8bee1901f1e530bfb4a7850aa7a479d17ae3a18beb6e09064ed54cfd245b7191 AS builder
RUN apk add --no-cache git build-base
WORKDIR /src WORKDIR /src
RUN apk add --no-cache git build-base make
# golangci-lint v2.1.6 (eabc2638a66d), 2026-02-26
RUN CGO_ENABLED=0 go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@eabc2638a66daf5bb6c6fb052a32fa3ef7b6600d
COPY go.mod go.sum ./ COPY go.mod go.sum ./
RUN go mod download RUN go mod download
COPY . . COPY . .
# Run all checks — build fails if branch is not green # Run all checks — build fails if branch is not green
# golangci-lint v2.1.6
RUN CGO_ENABLED=0 go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@eabc2638a66daf5bb6c6fb052a32fa3ef7b6600d
RUN make check RUN make check
# Build static binaries (no cgo needed at runtime — modernc.org/sqlite is pure Go)
ARG VERSION=dev ARG VERSION=dev
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.Version=${VERSION}" -o /chatd ./cmd/chatd/ RUN go build -ldflags "-X main.Version=${VERSION}" -o /chatd ./cmd/chatd
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /chat-cli ./cmd/chat-cli/
# alpine:3.21, 2026-02-26 # alpine:3.21, 2026-02-26
FROM alpine@sha256:c3f8e73fdb79deaebaa2037150150191b9dcbfba68b4a46d70103204c53f4709 FROM alpine@sha256:c3f8e73fdb79deaebaa2037150150191b9dcbfba68b4a46d70103204c53f4709
RUN apk add --no-cache ca-certificates \
&& addgroup -S chat && adduser -S chat -G chat RUN apk add --no-cache ca-certificates
COPY --from=builder /chatd /usr/local/bin/chatd COPY --from=builder /chatd /usr/local/bin/chatd
USER chat WORKDIR /data
EXPOSE 8080 EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD wget -qO- http://localhost:8080/.well-known/healthcheck.json || exit 1
ENTRYPOINT ["chatd"] ENTRYPOINT ["chatd"]

2269
README.md
View File

File diff suppressed because it is too large Load Diff

204
cmd/chat-cli/api/client.go
View File

@@ -1,9 +1,8 @@
// Package chatapi provides a client for the chat server API. // Package chatapi provides a client for the chat server HTTP API.
package chatapi package chatapi
import ( import (
"bytes" "bytes"
"context"
"encoding/json" "encoding/json"
"errors" "errors"
"fmt" "fmt"
@@ -11,17 +10,21 @@ import (
"net/http" "net/http"
"net/url" "net/url"
"strconv" "strconv"
"strings"
"time" "time"
) )
const ( const (
httpTimeout = 30 * time.Second httpTimeout = 30 * time.Second
pollExtraTime = 5 pollExtraDelay = 5
httpErrThreshold = 400 httpErrThreshold = 400
) )
var errHTTP = errors.New("HTTP error") // ErrHTTP is returned for non-2xx responses.
var ErrHTTP = errors.New("http error")
// ErrUnexpectedFormat is returned when the response format is
// not recognised.
var ErrUnexpectedFormat = errors.New("unexpected format")
// Client wraps HTTP calls to the chat server API. // Client wraps HTTP calls to the chat server API.
type Client struct { type Client struct {
@@ -32,21 +35,20 @@ type Client struct {
// NewClient creates a new API client. // NewClient creates a new API client.
func NewClient(baseURL string) *Client { func NewClient(baseURL string) *Client {
return &Client{ //nolint:exhaustruct // Token set after CreateSession return &Client{
BaseURL: baseURL, BaseURL: baseURL,
HTTPClient: &http.Client{ //nolint:exhaustruct // defaults fine HTTPClient: &http.Client{
Timeout: httpTimeout, Timeout: httpTimeout,
}, },
} }
} }
// CreateSession creates a new session on the server. // CreateSession creates a new session on the server.
func (client *Client) CreateSession( func (c *Client) CreateSession(
nick string, nick string,
) (*SessionResponse, error) { ) (*SessionResponse, error) {
data, err := client.do( data, err := c.do(
http.MethodPost, "POST", "/api/v1/session",
"/api/v1/session",
&SessionRequest{Nick: nick}, &SessionRequest{Nick: nick},
) )
if err != nil { if err != nil {
@@ -60,16 +62,14 @@ func (client *Client) CreateSession(
return nil, fmt.Errorf("decode session: %w", err) return nil, fmt.Errorf("decode session: %w", err)
} }
client.Token = resp.Token c.Token = resp.Token
return &resp, nil return &resp, nil
} }
// GetState returns the current user state. // GetState returns the current user state.
func (client *Client) GetState() (*StateResponse, error) { func (c *Client) GetState() (*StateResponse, error) {
data, err := client.do( data, err := c.do("GET", "/api/v1/state", nil)
http.MethodGet, "/api/v1/state", nil,
)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -85,110 +85,106 @@ func (client *Client) GetState() (*StateResponse, error) {
} }
// SendMessage sends a message (any IRC command). // SendMessage sends a message (any IRC command).
func (client *Client) SendMessage(msg *Message) error { func (c *Client) SendMessage(msg *Message) error {
_, err := client.do( _, err := c.do("POST", "/api/v1/messages", msg)
http.MethodPost, "/api/v1/messages", msg,
)
return err return err
} }
// PollMessages long-polls for new messages. // PollMessages long-polls for new messages.
func (client *Client) PollMessages( func (c *Client) PollMessages(
afterID int64, afterID string,
timeout int, timeout int,
) (*PollResult, error) { ) ([]Message, error) {
pollClient := &http.Client{ //nolint:exhaustruct // defaults fine pollTimeout := time.Duration(
Timeout: time.Duration( timeout+pollExtraDelay,
timeout+pollExtraTime, ) * time.Second
) * time.Second,
} client := &http.Client{Timeout: pollTimeout}
params := url.Values{} params := url.Values{}
if afterID > 0 { if afterID != "" {
params.Set( params.Set("after", afterID)
"after",
strconv.FormatInt(afterID, 10),
)
} }
params.Set("timeout", strconv.Itoa(timeout)) params.Set("timeout", strconv.Itoa(timeout))
path := "/api/v1/messages?" + params.Encode() path := "/api/v1/messages"
if len(params) > 0 {
request, err := http.NewRequestWithContext( path += "?" + params.Encode()
context.Background(),
http.MethodGet,
client.BaseURL+path,
nil,
)
if err != nil {
return nil, fmt.Errorf("new request: %w", err)
} }
request.Header.Set( req, err := http.NewRequest( //nolint:noctx // CLI tool
"Authorization", "Bearer "+client.Token, http.MethodGet, c.BaseURL+path, nil,
) )
resp, err := pollClient.Do(request)
if err != nil { if err != nil {
return nil, fmt.Errorf("poll request: %w", err) return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.Token)
resp, err := client.Do(req) //nolint:gosec,nolintlint // URL from user config
if err != nil {
return nil, err
} }
defer func() { _ = resp.Body.Close() }() defer func() { _ = resp.Body.Close() }()
data, err := io.ReadAll(resp.Body) data, err := io.ReadAll(resp.Body)
if err != nil { if err != nil {
return nil, fmt.Errorf("read poll body: %w", err) return nil, err
} }
if resp.StatusCode >= httpErrThreshold { if resp.StatusCode >= httpErrThreshold {
return nil, fmt.Errorf( return nil, fmt.Errorf(
"%w %d: %s", "%w: %d: %s",
errHTTP, resp.StatusCode, string(data), ErrHTTP, resp.StatusCode, string(data),
) )
} }
return decodeMessages(data)
}
func decodeMessages(data []byte) ([]Message, error) {
var msgs []Message
err := json.Unmarshal(data, &msgs)
if err == nil {
return msgs, nil
}
var wrapped MessagesResponse var wrapped MessagesResponse
err = json.Unmarshal(data, &wrapped) err2 := json.Unmarshal(data, &wrapped)
if err != nil { if err2 != nil {
return nil, fmt.Errorf( return nil, fmt.Errorf(
"decode messages: %w", err, "decode messages: %w (raw: %s)",
err, string(data),
) )
} }
return &PollResult{ return wrapped.Messages, nil
Messages: wrapped.Messages,
LastID: wrapped.LastID,
}, nil
} }
// JoinChannel joins a channel. // JoinChannel joins a channel via the unified command
func (client *Client) JoinChannel(channel string) error { // endpoint.
return client.SendMessage( func (c *Client) JoinChannel(channel string) error {
&Message{ //nolint:exhaustruct // only command+to needed return c.SendMessage(
Command: "JOIN", To: channel, &Message{Command: "JOIN", To: channel},
},
) )
} }
// PartChannel leaves a channel. // PartChannel leaves a channel via the unified command
func (client *Client) PartChannel(channel string) error { // endpoint.
return client.SendMessage( func (c *Client) PartChannel(channel string) error {
&Message{ //nolint:exhaustruct // only command+to needed return c.SendMessage(
Command: "PART", To: channel, &Message{Command: "PART", To: channel},
},
) )
} }
// ListChannels returns all channels on the server. // ListChannels returns all channels on the server.
func (client *Client) ListChannels() ( func (c *Client) ListChannels() ([]Channel, error) {
[]Channel, error, data, err := c.do("GET", "/api/v1/channels", nil)
) {
data, err := client.do(
http.MethodGet, "/api/v1/channels", nil,
)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -197,26 +193,20 @@ func (client *Client) ListChannels() (
err = json.Unmarshal(data, &channels) err = json.Unmarshal(data, &channels)
if err != nil { if err != nil {
return nil, fmt.Errorf( return nil, err
"decode channels: %w", err,
)
} }
return channels, nil return channels, nil
} }
// GetMembers returns members of a channel. // GetMembers returns members of a channel.
func (client *Client) GetMembers( func (c *Client) GetMembers(
channel string, channel string,
) ([]string, error) { ) ([]string, error) {
name := strings.TrimPrefix(channel, "#") path := "/api/v1/channels/" +
url.PathEscape(channel) + "/members"
data, err := client.do( data, err := c.do("GET", path, nil)
http.MethodGet,
"/api/v1/channels/"+url.PathEscape(name)+
"/members",
nil,
)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -226,7 +216,8 @@ func (client *Client) GetMembers(
err = json.Unmarshal(data, &members) err = json.Unmarshal(data, &members)
if err != nil { if err != nil {
return nil, fmt.Errorf( return nil, fmt.Errorf(
"unexpected members format: %w", err, "%w: members: %s",
ErrUnexpectedFormat, string(data),
) )
} }
@@ -234,12 +225,8 @@ func (client *Client) GetMembers(
} }
// GetServerInfo returns server info. // GetServerInfo returns server info.
func (client *Client) GetServerInfo() ( func (c *Client) GetServerInfo() (*ServerInfo, error) {
*ServerInfo, error, data, err := c.do("GET", "/api/v1/server", nil)
) {
data, err := client.do(
http.MethodGet, "/api/v1/server", nil,
)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -248,15 +235,13 @@ func (client *Client) GetServerInfo() (
err = json.Unmarshal(data, &info) err = json.Unmarshal(data, &info)
if err != nil { if err != nil {
return nil, fmt.Errorf( return nil, err
"decode server info: %w", err,
)
} }
return &info, nil return &info, nil
} }
func (client *Client) do( func (c *Client) do(
method, path string, method, path string,
body any, body any,
) ([]byte, error) { ) ([]byte, error) {
@@ -271,27 +256,20 @@ func (client *Client) do(
bodyReader = bytes.NewReader(data) bodyReader = bytes.NewReader(data)
} }
request, err := http.NewRequestWithContext( req, err := http.NewRequest( //nolint:noctx // CLI tool
context.Background(), method, c.BaseURL+path, bodyReader,
method,
client.BaseURL+path,
bodyReader,
) )
if err != nil { if err != nil {
return nil, fmt.Errorf("request: %w", err) return nil, fmt.Errorf("request: %w", err)
} }
request.Header.Set( req.Header.Set("Content-Type", "application/json")
"Content-Type", "application/json",
)
if client.Token != "" { if c.Token != "" {
request.Header.Set( req.Header.Set("Authorization", "Bearer "+c.Token)
"Authorization", "Bearer "+client.Token,
)
} }
resp, err := client.HTTPClient.Do(request) resp, err := c.HTTPClient.Do(req) //nolint:gosec,nolintlint // URL from user config
if err != nil { if err != nil {
return nil, fmt.Errorf("http: %w", err) return nil, fmt.Errorf("http: %w", err)
} }
@@ -305,8 +283,8 @@ func (client *Client) do(
if resp.StatusCode >= httpErrThreshold { if resp.StatusCode >= httpErrThreshold {
return data, fmt.Errorf( return data, fmt.Errorf(
"%w %d: %s", "%w: %d: %s",
errHTTP, resp.StatusCode, string(data), ErrHTTP, resp.StatusCode, string(data),
) )
} }

30
cmd/chat-cli/api/types.go
View File

@@ -7,16 +7,18 @@ type SessionRequest struct {
Nick string `json:"nick"` Nick string `json:"nick"`
} }
// SessionResponse is the response from session creation. // SessionResponse is the response from POST /api/v1/session.
type SessionResponse struct { type SessionResponse struct {
ID int64 `json:"id"` SessionID string `json:"sessionId"`
ClientID string `json:"clientId"`
Nick string `json:"nick"` Nick string `json:"nick"`
Token string `json:"token"` Token string `json:"token"`
} }
// StateResponse is the response from GET /api/v1/state. // StateResponse is the response from GET /api/v1/state.
type StateResponse struct { type StateResponse struct {
ID int64 `json:"id"` SessionID string `json:"sessionId"`
ClientID string `json:"clientId"`
Nick string `json:"nick"` Nick string `json:"nick"`
Channels []string `json:"channels"` Channels []string `json:"channels"`
} }
@@ -33,21 +35,22 @@ type Message struct {
Meta any `json:"meta,omitempty"` Meta any `json:"meta,omitempty"`
} }
// BodyLines returns the body as a string slice. // BodyLines returns the body as a slice of strings (for text
// messages).
func (m *Message) BodyLines() []string { func (m *Message) BodyLines() []string {
switch bodyVal := m.Body.(type) { switch v := m.Body.(type) {
case []any: case []any:
lines := make([]string, 0, len(bodyVal)) lines := make([]string, 0, len(v))
for _, item := range bodyVal { for _, item := range v {
if str, ok := item.(string); ok { if s, ok := item.(string); ok {
lines = append(lines, str) lines = append(lines, s)
} }
} }
return lines return lines
case []string: case []string:
return bodyVal return v
default: default:
return nil return nil
} }
@@ -71,13 +74,6 @@ type ServerInfo struct {
// MessagesResponse wraps polling results. // MessagesResponse wraps polling results.
type MessagesResponse struct { type MessagesResponse struct {
Messages []Message `json:"messages"` Messages []Message `json:"messages"`
LastID int64 `json:"lastId"`
}
// PollResult wraps the poll response including the cursor.
type PollResult struct {
Messages []Message
LastID int64
} }
// ParseTS parses the message timestamp. // ParseTS parses the message timestamp.

426
cmd/chat-cli/main.go
View File

@@ -1,9 +1,10 @@
// Package main is the entry point for the chat-cli client. // Package main implements chat-cli, an IRC-style terminal client.
package main package main
import ( import (
"fmt" "fmt"
"os" "os"
"strconv"
"strings" "strings"
"sync" "sync"
"time" "time"
@@ -12,10 +13,9 @@ import (
) )
const ( const (
splitParts = 2 pollTimeoutSec = 15
pollTimeout = 15 retryDelay = 2 * time.Second
pollRetry = 2 * time.Second maxNickLength = 32
timeFormat = "15:04"
) )
// App holds the application state. // App holds the application state.
@@ -25,14 +25,14 @@ type App struct {
mu sync.Mutex mu sync.Mutex
nick string nick string
target string target string // current target (#channel or nick for DM)
connected bool connected bool
lastQID int64 lastMsgID string
stopPoll chan struct{} stopPoll chan struct{}
} }
func main() { func main() {
app := &App{ //nolint:exhaustruct app := &App{
ui: NewUI(), ui: NewUI(),
nick: "guest", nick: "guest",
} }
@@ -41,17 +41,17 @@ func main() {
app.ui.SetStatus(app.nick, "", "disconnected") app.ui.SetStatus(app.nick, "", "disconnected")
app.ui.AddStatus( app.ui.AddStatus(
"Welcome to chat-cli — an IRC-style client", "Welcome to chat-cli \u2014 an IRC-style client",
) )
app.ui.AddStatus( app.ui.AddStatus(
"Type [yellow]/connect <server-url>" + "Type [yellow]/connect <server-url>[white] " +
"[white] to begin, " + "to begin, or [yellow]/help[white] for commands",
"or [yellow]/help[white] for commands",
) )
err := app.ui.Run() err := app.ui.Run()
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Error: %v\n", err) _, _ = fmt.Fprintf(os.Stderr, "Error: %v\n", err)
os.Exit(1) os.Exit(1)
} }
} }
@@ -63,9 +63,14 @@ func (a *App) handleInput(text string) {
return return
} }
a.sendPlainText(text)
}
func (a *App) sendPlainText(text string) {
a.mu.Lock() a.mu.Lock()
target := a.target target := a.target
connected := a.connected connected := a.connected
nick := a.nick
a.mu.Unlock() a.mu.Unlock()
if !connected { if !connected {
@@ -85,33 +90,32 @@ func (a *App) handleInput(text string) {
return return
} }
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct err := a.client.SendMessage(&api.Message{
Command: "PRIVMSG", Command: "PRIVMSG",
To: target, To: target,
Body: []string{text}, Body: []string{text},
}) })
if err != nil { if err != nil {
a.ui.AddStatus( a.ui.AddStatus(
"[red]Send error: " + err.Error(), fmt.Sprintf("[red]Send error: %v", err),
) )
return return
} }
timestamp := time.Now().Format(timeFormat) ts := time.Now().Format("15:04")
a.mu.Lock() a.ui.AddLine(
nick := a.nick target,
a.mu.Unlock() fmt.Sprintf(
a.ui.AddLine(target, fmt.Sprintf(
"[gray]%s [green]<%s>[white] %s", "[gray]%s [green]<%s>[white] %s",
timestamp, nick, text, ts, nick, text,
)) ),
)
} }
func (a *App) handleCommand(text string) { func (a *App) handleCommand(text string) { //nolint:cyclop // command dispatch
parts := strings.SplitN(text, " ", splitParts) parts := strings.SplitN(text, " ", 2) //nolint:mnd // split into cmd+args
cmd := strings.ToLower(parts[0]) cmd := strings.ToLower(parts[0])
args := "" args := ""
@@ -119,10 +123,6 @@ func (a *App) handleCommand(text string) {
args = parts[1] args = parts[1]
} }
a.dispatchCommand(cmd, args)
}
func (a *App) dispatchCommand(cmd, args string) {
switch cmd { switch cmd {
case "/connect": case "/connect":
a.cmdConnect(args) a.cmdConnect(args)
@@ -166,7 +166,9 @@ func (a *App) cmdConnect(serverURL string) {
serverURL = strings.TrimRight(serverURL, "/") serverURL = strings.TrimRight(serverURL, "/")
a.ui.AddStatus("Connecting to " + serverURL + "...") a.ui.AddStatus(
fmt.Sprintf("Connecting to %s...", serverURL),
)
a.mu.Lock() a.mu.Lock()
nick := a.nick nick := a.nick
@@ -176,9 +178,11 @@ func (a *App) cmdConnect(serverURL string) {
resp, err := client.CreateSession(nick) resp, err := client.CreateSession(nick)
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[red]Connection failed: %v", err, "[red]Connection failed: %v", err,
)) ),
)
return return
} }
@@ -187,13 +191,15 @@ func (a *App) cmdConnect(serverURL string) {
a.client = client a.client = client
a.nick = resp.Nick a.nick = resp.Nick
a.connected = true a.connected = true
a.lastQID = 0 a.lastMsgID = ""
a.mu.Unlock() a.mu.Unlock()
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
"[green]Connected! Nick: %s, Session: %d", fmt.Sprintf(
resp.Nick, resp.ID, "[green]Connected! Nick: %s, Session: %s",
)) resp.Nick, resp.SessionID,
),
)
a.ui.SetStatus(resp.Nick, "", "connected") a.ui.SetStatus(resp.Nick, "", "connected")
a.stopPoll = make(chan struct{}) a.stopPoll = make(chan struct{})
@@ -203,9 +209,7 @@ func (a *App) cmdConnect(serverURL string) {
func (a *App) cmdNick(nick string) { func (a *App) cmdNick(nick string) {
if nick == "" { if nick == "" {
a.ui.AddStatus( a.ui.AddStatus("[red]Usage: /nick <name>")
"[red]Usage: /nick <name>",
)
return return
} }
@@ -220,21 +224,25 @@ func (a *App) cmdNick(nick string) {
a.mu.Unlock() a.mu.Unlock()
a.ui.AddStatus( a.ui.AddStatus(
"Nick set to " + nick + fmt.Sprintf(
" (will be used on connect)", "Nick set to %s (will be used on connect)",
nick,
),
) )
return return
} }
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct err := a.client.SendMessage(&api.Message{
Command: "NICK", Command: "NICK",
Body: []string{nick}, Body: []string{nick},
}) })
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[red]Nick change failed: %v", err, "[red]Nick change failed: %v", err,
)) ),
)
return return
} }
@@ -245,14 +253,14 @@ func (a *App) cmdNick(nick string) {
a.mu.Unlock() a.mu.Unlock()
a.ui.SetStatus(nick, target, "connected") a.ui.SetStatus(nick, target, "connected")
a.ui.AddStatus("Nick changed to " + nick) a.ui.AddStatus(
"Nick changed to " + nick,
)
} }
func (a *App) cmdJoin(channel string) { func (a *App) cmdJoin(channel string) {
if channel == "" { if channel == "" {
a.ui.AddStatus( a.ui.AddStatus("[red]Usage: /join #channel")
"[red]Usage: /join #channel",
)
return return
} }
@@ -273,9 +281,9 @@ func (a *App) cmdJoin(channel string) {
err := a.client.JoinChannel(channel) err := a.client.JoinChannel(channel)
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
"[red]Join failed: %v", err, fmt.Sprintf("[red]Join failed: %v", err),
)) )
return return
} }
@@ -286,7 +294,8 @@ func (a *App) cmdJoin(channel string) {
a.mu.Unlock() a.mu.Unlock()
a.ui.SwitchToBuffer(channel) a.ui.SwitchToBuffer(channel)
a.ui.AddLine(channel, a.ui.AddLine(
channel,
"[yellow]*** Joined "+channel, "[yellow]*** Joined "+channel,
) )
a.ui.SetStatus(nick, channel, "connected") a.ui.SetStatus(nick, channel, "connected")
@@ -294,6 +303,7 @@ func (a *App) cmdJoin(channel string) {
func (a *App) cmdPart(channel string) { func (a *App) cmdPart(channel string) {
a.mu.Lock() a.mu.Lock()
if channel == "" { if channel == "" {
channel = a.target channel = a.target
} }
@@ -301,8 +311,7 @@ func (a *App) cmdPart(channel string) {
connected := a.connected connected := a.connected
a.mu.Unlock() a.mu.Unlock()
if channel == "" || if channel == "" || !strings.HasPrefix(channel, "#") {
!strings.HasPrefix(channel, "#") {
a.ui.AddStatus("[red]No channel to part") a.ui.AddStatus("[red]No channel to part")
return return
@@ -316,18 +325,20 @@ func (a *App) cmdPart(channel string) {
err := a.client.PartChannel(channel) err := a.client.PartChannel(channel)
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
"[red]Part failed: %v", err, fmt.Sprintf("[red]Part failed: %v", err),
)) )
return return
} }
a.ui.AddLine(channel, a.ui.AddLine(
channel,
"[yellow]*** Left "+channel, "[yellow]*** Left "+channel,
) )
a.mu.Lock() a.mu.Lock()
if a.target == channel { if a.target == channel {
a.target = "" a.target = ""
} }
@@ -340,11 +351,9 @@ func (a *App) cmdPart(channel string) {
} }
func (a *App) cmdMsg(args string) { func (a *App) cmdMsg(args string) {
parts := strings.SplitN(args, " ", splitParts) parts := strings.SplitN(args, " ", 2) //nolint:mnd // split into target+text
if len(parts) < splitParts { if len(parts) < 2 { //nolint:mnd // min args
a.ui.AddStatus( a.ui.AddStatus("[red]Usage: /msg <nick> <text>")
"[red]Usage: /msg <nick> <text>",
)
return return
} }
@@ -362,32 +371,33 @@ func (a *App) cmdMsg(args string) {
return return
} }
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct err := a.client.SendMessage(&api.Message{
Command: "PRIVMSG", Command: "PRIVMSG",
To: target, To: target,
Body: []string{text}, Body: []string{text},
}) })
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
"[red]Send failed: %v", err, fmt.Sprintf("[red]Send failed: %v", err),
)) )
return return
} }
timestamp := time.Now().Format(timeFormat) ts := time.Now().Format("15:04")
a.ui.AddLine(target, fmt.Sprintf( a.ui.AddLine(
target,
fmt.Sprintf(
"[gray]%s [green]<%s>[white] %s", "[gray]%s [green]<%s>[white] %s",
timestamp, nick, text, ts, nick, text,
)) ),
)
} }
func (a *App) cmdQuery(nick string) { func (a *App) cmdQuery(nick string) {
if nick == "" { if nick == "" {
a.ui.AddStatus( a.ui.AddStatus("[red]Usage: /query <nick>")
"[red]Usage: /query <nick>",
)
return return
} }
@@ -420,28 +430,32 @@ func (a *App) cmdTopic(args string) {
} }
if args == "" { if args == "" {
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct err := a.client.SendMessage(&api.Message{
Command: "TOPIC", Command: "TOPIC",
To: target, To: target,
}) })
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[red]Topic query failed: %v", err, "[red]Topic query failed: %v", err,
)) ),
)
} }
return return
} }
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct err := a.client.SendMessage(&api.Message{
Command: "TOPIC", Command: "TOPIC",
To: target, To: target,
Body: []string{args}, Body: []string{args},
}) })
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[red]Topic set failed: %v", err, "[red]Topic set failed: %v", err,
)) ),
)
} }
} }
@@ -465,17 +479,20 @@ func (a *App) cmdNames() {
members, err := a.client.GetMembers(target) members, err := a.client.GetMembers(target)
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
"[red]Names failed: %v", err, fmt.Sprintf("[red]Names failed: %v", err),
)) )
return return
} }
a.ui.AddLine(target, fmt.Sprintf( a.ui.AddLine(
target,
fmt.Sprintf(
"[cyan]*** Members of %s: %s", "[cyan]*** Members of %s: %s",
target, strings.Join(members, " "), target, strings.Join(members, " "),
)) ),
)
} }
func (a *App) cmdList() { func (a *App) cmdList() {
@@ -491,9 +508,9 @@ func (a *App) cmdList() {
channels, err := a.client.ListChannels() channels, err := a.client.ListChannels()
if err != nil { if err != nil {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
"[red]List failed: %v", err, fmt.Sprintf("[red]List failed: %v", err),
)) )
return return
} }
@@ -501,10 +518,12 @@ func (a *App) cmdList() {
a.ui.AddStatus("[cyan]*** Channel list:") a.ui.AddStatus("[cyan]*** Channel list:")
for _, ch := range channels { for _, ch := range channels {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
" %s (%d members) %s", " %s (%d members) %s",
ch.Name, ch.Members, ch.Topic, ch.Name, ch.Members, ch.Topic,
)) ),
)
} }
a.ui.AddStatus("[cyan]*** End of channel list") a.ui.AddStatus("[cyan]*** End of channel list")
@@ -512,33 +531,27 @@ func (a *App) cmdList() {
func (a *App) cmdWindow(args string) { func (a *App) cmdWindow(args string) {
if args == "" { if args == "" {
a.ui.AddStatus( a.ui.AddStatus("[red]Usage: /window <number>")
"[red]Usage: /window <number>",
)
return return
} }
var bufIndex int n, _ := strconv.Atoi(args)
a.ui.SwitchBuffer(n)
_, _ = fmt.Sscanf(args, "%d", &bufIndex)
a.ui.SwitchBuffer(bufIndex)
a.mu.Lock() a.mu.Lock()
nick := a.nick nick := a.nick
a.mu.Unlock() a.mu.Unlock()
if bufIndex >= 0 && bufIndex < a.ui.BufferCount() { if n >= 0 && n < a.ui.BufferCount() {
buf := a.ui.buffers[bufIndex] buf := a.ui.buffers[n]
if buf.Name != "(status)" { if buf.Name != "(status)" {
a.mu.Lock() a.mu.Lock()
a.target = buf.Name a.target = buf.Name
a.mu.Unlock() a.mu.Unlock()
a.ui.SetStatus( a.ui.SetStatus(nick, buf.Name, "connected")
nick, buf.Name, "connected",
)
} else { } else {
a.ui.SetStatus(nick, "", "connected") a.ui.SetStatus(nick, "", "connected")
} }
@@ -550,7 +563,7 @@ func (a *App) cmdQuit() {
if a.connected && a.client != nil { if a.connected && a.client != nil {
_ = a.client.SendMessage( _ = a.client.SendMessage(
&api.Message{Command: "QUIT"}, //nolint:exhaustruct &api.Message{Command: "QUIT"},
) )
} }
@@ -565,18 +578,18 @@ func (a *App) cmdQuit() {
func (a *App) cmdHelp() { func (a *App) cmdHelp() {
help := []string{ help := []string{
"[cyan]*** chat-cli commands:", "[cyan]*** chat-cli commands:",
" /connect <url> — Connect to server", " /connect <url> \u2014 Connect to server",
" /nick <name> — Change nickname", " /nick <name> \u2014 Change nickname",
" /join #channel — Join channel", " /join #channel \u2014 Join channel",
" /part [#chan] — Leave channel", " /part [#chan] \u2014 Leave channel",
" /msg <nick> <text> — Send DM", " /msg <nick> <text> \u2014 Send DM",
" /query <nick> — Open DM window", " /query <nick> \u2014 Open DM window",
" /topic [text] — View/set topic", " /topic [text] \u2014 View/set topic",
" /names — List channel members", " /names \u2014 List channel members",
" /list — List channels", " /list \u2014 List channels",
" /window <n> — Switch buffer", " /window <n> \u2014 Switch buffer (Alt+0-9)",
" /quit — Disconnect and exit", " /quit \u2014 Disconnect and exit",
" /help — This help", " /help \u2014 This help",
" Plain text sends to current target.", " Plain text sends to current target.",
} }
@@ -596,36 +609,38 @@ func (a *App) pollLoop() {
a.mu.Lock() a.mu.Lock()
client := a.client client := a.client
lastQID := a.lastQID lastID := a.lastMsgID
a.mu.Unlock() a.mu.Unlock()
if client == nil { if client == nil {
return return
} }
result, err := client.PollMessages( msgs, err := client.PollMessages(
lastQID, pollTimeout, lastID, pollTimeoutSec,
) )
if err != nil { if err != nil {
time.Sleep(pollRetry) time.Sleep(retryDelay)
continue continue
} }
if result.LastID > 0 { for i := range msgs {
a.handleServerMessage(&msgs[i])
if msgs[i].ID != "" {
a.mu.Lock() a.mu.Lock()
a.lastQID = result.LastID a.lastMsgID = msgs[i].ID
a.mu.Unlock() a.mu.Unlock()
} }
for i := range result.Messages {
a.handleServerMessage(&result.Messages[i])
} }
} }
} }
func (a *App) handleServerMessage(msg *api.Message) { func (a *App) handleServerMessage(
timestamp := a.formatTS(msg) msg *api.Message,
) {
ts := a.parseMessageTS(msg)
a.mu.Lock() a.mu.Lock()
myNick := a.nick myNick := a.nick
@@ -633,34 +648,37 @@ func (a *App) handleServerMessage(msg *api.Message) {
switch msg.Command { switch msg.Command {
case "PRIVMSG": case "PRIVMSG":
a.handlePrivmsgEvent(msg, timestamp, myNick) a.handlePrivmsgMsg(msg, ts, myNick)
case "JOIN": case "JOIN":
a.handleJoinEvent(msg, timestamp) a.handleJoinMsg(msg, ts)
case "PART": case "PART":
a.handlePartEvent(msg, timestamp) a.handlePartMsg(msg, ts)
case "QUIT": case "QUIT":
a.handleQuitEvent(msg, timestamp) a.handleQuitMsg(msg, ts)
case "NICK": case "NICK":
a.handleNickEvent(msg, timestamp, myNick) a.handleNickMsg(msg, ts, myNick)
case "NOTICE": case "NOTICE":
a.handleNoticeEvent(msg, timestamp) a.handleNoticeMsg(msg, ts)
case "TOPIC": case "TOPIC":
a.handleTopicEvent(msg, timestamp) a.handleTopicMsg(msg, ts)
default: default:
a.handleDefaultEvent(msg, timestamp) a.handleDefaultMsg(msg, ts)
} }
} }
func (a *App) formatTS(msg *api.Message) string { func (a *App) parseMessageTS(msg *api.Message) string {
if msg.TS != "" { if msg.TS != "" {
return msg.ParseTS().UTC().Format(timeFormat) t := msg.ParseTS()
return t.In(time.Local).Format("15:04") //nolint:gosmopolitan // CLI uses local time
} }
return time.Now().Format(timeFormat) return time.Now().Format("15:04")
} }
func (a *App) handlePrivmsgEvent( func (a *App) handlePrivmsgMsg(
msg *api.Message, timestamp, myNick string, msg *api.Message,
ts, myNick string,
) { ) {
lines := msg.BodyLines() lines := msg.BodyLines()
text := strings.Join(lines, " ") text := strings.Join(lines, " ")
@@ -674,29 +692,37 @@ func (a *App) handlePrivmsgEvent(
target = msg.From target = msg.From
} }
a.ui.AddLine(target, fmt.Sprintf( a.ui.AddLine(
target,
fmt.Sprintf(
"[gray]%s [green]<%s>[white] %s", "[gray]%s [green]<%s>[white] %s",
timestamp, msg.From, text, ts, msg.From, text,
)) ),
)
} }
func (a *App) handleJoinEvent( func (a *App) handleJoinMsg(
msg *api.Message, timestamp string, msg *api.Message, ts string,
) { ) {
if msg.To == "" { target := msg.To
if target == "" {
return return
} }
a.ui.AddLine(msg.To, fmt.Sprintf( a.ui.AddLine(
target,
fmt.Sprintf(
"[gray]%s [yellow]*** %s has joined %s", "[gray]%s [yellow]*** %s has joined %s",
timestamp, msg.From, msg.To, ts, msg.From, target,
)) ),
)
} }
func (a *App) handlePartEvent( func (a *App) handlePartMsg(
msg *api.Message, timestamp string, msg *api.Message, ts string,
) { ) {
if msg.To == "" { target := msg.To
if target == "" {
return return
} }
@@ -704,39 +730,49 @@ func (a *App) handlePartEvent(
reason := strings.Join(lines, " ") reason := strings.Join(lines, " ")
if reason != "" { if reason != "" {
a.ui.AddLine(msg.To, fmt.Sprintf( a.ui.AddLine(
target,
fmt.Sprintf(
"[gray]%s [yellow]*** %s has left %s (%s)", "[gray]%s [yellow]*** %s has left %s (%s)",
timestamp, msg.From, msg.To, reason, ts, msg.From, target, reason,
)) ),
)
} else { } else {
a.ui.AddLine(msg.To, fmt.Sprintf( a.ui.AddLine(
target,
fmt.Sprintf(
"[gray]%s [yellow]*** %s has left %s", "[gray]%s [yellow]*** %s has left %s",
timestamp, msg.From, msg.To, ts, msg.From, target,
)) ),
)
} }
} }
func (a *App) handleQuitEvent( func (a *App) handleQuitMsg(
msg *api.Message, timestamp string, msg *api.Message, ts string,
) { ) {
lines := msg.BodyLines() lines := msg.BodyLines()
reason := strings.Join(lines, " ") reason := strings.Join(lines, " ")
if reason != "" { if reason != "" {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[gray]%s [yellow]*** %s has quit (%s)", "[gray]%s [yellow]*** %s has quit (%s)",
timestamp, msg.From, reason, ts, msg.From, reason,
)) ),
)
} else { } else {
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[gray]%s [yellow]*** %s has quit", "[gray]%s [yellow]*** %s has quit",
timestamp, msg.From, ts, msg.From,
)) ),
)
} }
} }
func (a *App) handleNickEvent( func (a *App) handleNickMsg(
msg *api.Message, timestamp, myNick string, msg *api.Message, ts, myNick string,
) { ) {
lines := msg.BodyLines() lines := msg.BodyLines()
@@ -748,33 +784,36 @@ func (a *App) handleNickEvent(
if msg.From == myNick && newNick != "" { if msg.From == myNick && newNick != "" {
a.mu.Lock() a.mu.Lock()
a.nick = newNick a.nick = newNick
target := a.target target := a.target
a.mu.Unlock() a.mu.Unlock()
a.ui.SetStatus(newNick, target, "connected") a.ui.SetStatus(newNick, target, "connected")
} }
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[gray]%s [yellow]*** %s is now known as %s", "[gray]%s [yellow]*** %s is now known as %s",
timestamp, msg.From, newNick, ts, msg.From, newNick,
)) ),
)
} }
func (a *App) handleNoticeEvent( func (a *App) handleNoticeMsg(
msg *api.Message, timestamp string, msg *api.Message, ts string,
) { ) {
lines := msg.BodyLines() lines := msg.BodyLines()
text := strings.Join(lines, " ") text := strings.Join(lines, " ")
a.ui.AddStatus(fmt.Sprintf( a.ui.AddStatus(
fmt.Sprintf(
"[gray]%s [magenta]--%s-- %s", "[gray]%s [magenta]--%s-- %s",
timestamp, msg.From, text, ts, msg.From, text,
)) ),
)
} }
func (a *App) handleTopicEvent( func (a *App) handleTopicMsg(
msg *api.Message, timestamp string, msg *api.Message, ts string,
) { ) {
if msg.To == "" { if msg.To == "" {
return return
@@ -783,22 +822,29 @@ func (a *App) handleTopicEvent(
lines := msg.BodyLines() lines := msg.BodyLines()
text := strings.Join(lines, " ") text := strings.Join(lines, " ")
a.ui.AddLine(msg.To, fmt.Sprintf( a.ui.AddLine(
msg.To,
fmt.Sprintf(
"[gray]%s [cyan]*** %s set topic: %s", "[gray]%s [cyan]*** %s set topic: %s",
timestamp, msg.From, text, ts, msg.From, text,
)) ),
)
} }
func (a *App) handleDefaultEvent( func (a *App) handleDefaultMsg(
msg *api.Message, timestamp string, msg *api.Message, ts string,
) { ) {
lines := msg.BodyLines() lines := msg.BodyLines()
text := strings.Join(lines, " ") text := strings.Join(lines, " ")
if text != "" { if text == "" {
a.ui.AddStatus(fmt.Sprintf( return
}
a.ui.AddStatus(
fmt.Sprintf(
"[gray]%s [white][%s] %s", "[gray]%s [white][%s] %s",
timestamp, msg.Command, text, ts, msg.Command, text,
)) ),
} )
} }

103
cmd/chat-cli/ui.go
View File

@@ -32,38 +32,25 @@ type UI struct {
// NewUI creates the tview-based IRC-like UI. // NewUI creates the tview-based IRC-like UI.
func NewUI() *UI { func NewUI() *UI {
ui := &UI{ //nolint:exhaustruct,varnamelen // fields set below; ui is idiomatic ui := &UI{
app: tview.NewApplication(), app: tview.NewApplication(),
buffers: []*Buffer{ buffers: []*Buffer{
{Name: "(status)", Lines: nil, Unread: 0}, {Name: "(status)", Lines: nil},
}, },
} }
ui.initMessages() ui.setupMessages()
ui.initStatusBar() ui.setupStatusBar()
ui.initInput() ui.setupInput()
ui.initKeyCapture() ui.setupKeybindings()
ui.setupLayout()
ui.layout = tview.NewFlex().
SetDirection(tview.FlexRow).
AddItem(ui.messages, 0, 1, false).
AddItem(ui.statusBar, 1, 0, false).
AddItem(ui.input, 1, 0, true)
ui.app.SetRoot(ui.layout, true)
ui.app.SetFocus(ui.input)
return ui return ui
} }
// Run starts the UI event loop (blocks). // Run starts the UI event loop (blocks).
func (ui *UI) Run() error { func (ui *UI) Run() error {
err := ui.app.Run() return ui.app.Run()
if err != nil {
return fmt.Errorf("run ui: %w", err)
}
return nil
} }
// Stop stops the UI. // Stop stops the UI.
@@ -77,43 +64,45 @@ func (ui *UI) OnInput(fn func(string)) {
} }
// AddLine adds a line to the specified buffer. // AddLine adds a line to the specified buffer.
func (ui *UI) AddLine(bufferName, line string) { func (ui *UI) AddLine(bufferName string, line string) {
ui.app.QueueUpdateDraw(func() { ui.app.QueueUpdateDraw(func() {
buf := ui.getOrCreateBuffer(bufferName) buf := ui.getOrCreateBuffer(bufferName)
buf.Lines = append(buf.Lines, line) buf.Lines = append(buf.Lines, line)
cur := ui.buffers[ui.currentBuffer] // Mark unread if not currently viewing this buffer.
if cur != buf { if ui.buffers[ui.currentBuffer] != buf {
buf.Unread++ buf.Unread++
ui.refreshStatusBar() ui.refreshStatus()
} }
if cur == buf { // If viewing this buffer, append to display.
if ui.buffers[ui.currentBuffer] == buf {
_, _ = fmt.Fprintln(ui.messages, line) _, _ = fmt.Fprintln(ui.messages, line)
} }
}) })
} }
// AddStatus adds a line to the status buffer. // AddStatus adds a line to the status buffer (buffer 0).
func (ui *UI) AddStatus(line string) { func (ui *UI) AddStatus(line string) {
ts := time.Now().Format("15:04") ts := time.Now().Format("15:04")
ui.AddLine( ui.AddLine(
"(status)", "(status)",
"[gray]"+ts+"[white] "+line, fmt.Sprintf("[gray]%s[white] %s", ts, line),
) )
} }
// SwitchBuffer switches to the buffer at index n. // SwitchBuffer switches to the buffer at index n.
func (ui *UI) SwitchBuffer(bufIndex int) { func (ui *UI) SwitchBuffer(n int) {
ui.app.QueueUpdateDraw(func() { ui.app.QueueUpdateDraw(func() {
if bufIndex < 0 || bufIndex >= len(ui.buffers) { if n < 0 || n >= len(ui.buffers) {
return return
} }
ui.currentBuffer = bufIndex ui.currentBuffer = n
buf := ui.buffers[bufIndex] buf := ui.buffers[n]
buf.Unread = 0 buf.Unread = 0
ui.messages.Clear() ui.messages.Clear()
@@ -123,12 +112,11 @@ func (ui *UI) SwitchBuffer(bufIndex int) {
} }
ui.messages.ScrollToEnd() ui.messages.ScrollToEnd()
ui.refreshStatusBar() ui.refreshStatus()
}) })
} }
// SwitchToBuffer switches to named buffer, creating if // SwitchToBuffer switches to the named buffer, creating it
// needed.
func (ui *UI) SwitchToBuffer(name string) { func (ui *UI) SwitchToBuffer(name string) {
ui.app.QueueUpdateDraw(func() { ui.app.QueueUpdateDraw(func() {
buf := ui.getOrCreateBuffer(name) buf := ui.getOrCreateBuffer(name)
@@ -150,7 +138,7 @@ func (ui *UI) SwitchToBuffer(name string) {
} }
ui.messages.ScrollToEnd() ui.messages.ScrollToEnd()
ui.refreshStatusBar() ui.refreshStatus()
}) })
} }
@@ -159,7 +147,7 @@ func (ui *UI) SetStatus(
nick, target, connStatus string, nick, target, connStatus string,
) { ) {
ui.app.QueueUpdateDraw(func() { ui.app.QueueUpdateDraw(func() {
ui.renderStatusBar(nick, target, connStatus) ui.refreshStatusWith(nick, target, connStatus)
}) })
} }
@@ -168,7 +156,7 @@ func (ui *UI) BufferCount() int {
return len(ui.buffers) return len(ui.buffers)
} }
// BufferIndex returns the index of a named buffer. // BufferIndex returns the index of a named buffer, or -1.
func (ui *UI) BufferIndex(name string) int { func (ui *UI) BufferIndex(name string) int {
for i, buf := range ui.buffers { for i, buf := range ui.buffers {
if buf.Name == name { if buf.Name == name {
@@ -179,7 +167,7 @@ func (ui *UI) BufferIndex(name string) int {
return -1 return -1
} }
func (ui *UI) initMessages() { func (ui *UI) setupMessages() {
ui.messages = tview.NewTextView(). ui.messages = tview.NewTextView().
SetDynamicColors(true). SetDynamicColors(true).
SetScrollable(true). SetScrollable(true).
@@ -190,14 +178,14 @@ func (ui *UI) initMessages() {
ui.messages.SetBorder(false) ui.messages.SetBorder(false)
} }
func (ui *UI) initStatusBar() { func (ui *UI) setupStatusBar() {
ui.statusBar = tview.NewTextView(). ui.statusBar = tview.NewTextView().
SetDynamicColors(true) SetDynamicColors(true)
ui.statusBar.SetBackgroundColor(tcell.ColorNavy) ui.statusBar.SetBackgroundColor(tcell.ColorNavy)
ui.statusBar.SetTextColor(tcell.ColorWhite) ui.statusBar.SetTextColor(tcell.ColorWhite)
} }
func (ui *UI) initInput() { func (ui *UI) setupInput() {
ui.input = tview.NewInputField(). ui.input = tview.NewInputField().
SetFieldBackgroundColor(tcell.ColorBlack). SetFieldBackgroundColor(tcell.ColorBlack).
SetFieldTextColor(tcell.ColorWhite) SetFieldTextColor(tcell.ColorWhite)
@@ -220,7 +208,7 @@ func (ui *UI) initInput() {
}) })
} }
func (ui *UI) initKeyCapture() { func (ui *UI) setupKeybindings() {
ui.app.SetInputCapture( ui.app.SetInputCapture(
func(event *tcell.EventKey) *tcell.EventKey { func(event *tcell.EventKey) *tcell.EventKey {
if event.Modifiers()&tcell.ModAlt == 0 { if event.Modifiers()&tcell.ModAlt == 0 {
@@ -240,21 +228,34 @@ func (ui *UI) initKeyCapture() {
) )
} }
func (ui *UI) refreshStatusBar() { func (ui *UI) setupLayout() {
// Placeholder; full refresh needs nick/target context. ui.layout = tview.NewFlex().
SetDirection(tview.FlexRow).
AddItem(ui.messages, 0, 1, false).
AddItem(ui.statusBar, 1, 0, false).
AddItem(ui.input, 1, 0, true)
ui.app.SetRoot(ui.layout, true)
ui.app.SetFocus(ui.input)
} }
func (ui *UI) renderStatusBar( // if needed.
func (ui *UI) refreshStatus() {
// Rebuilt from app state by parent QueueUpdateDraw.
}
func (ui *UI) refreshStatusWith(
nick, target, connStatus string, nick, target, connStatus string,
) { ) {
var unreadParts []string var unreadParts []string
for i, buf := range ui.buffers { for i, buf := range ui.buffers {
if buf.Unread > 0 { if buf.Unread > 0 {
unreadParts = append(unreadParts, unreadParts = append(
unreadParts,
fmt.Sprintf( fmt.Sprintf(
"%d:%s(%d)", "%d:%s(%d)", i, buf.Name, buf.Unread,
i, buf.Name, buf.Unread,
), ),
) )
} }
@@ -274,8 +275,8 @@ func (ui *UI) renderStatusBar(
ui.statusBar.Clear() ui.statusBar.Clear()
_, _ = fmt.Fprintf(ui.statusBar, _, _ = fmt.Fprintf(
" [%s] %s %s %s%s", ui.statusBar, " [%s] %s %s %s%s",
connStatus, nick, bufInfo, target, unread, connStatus, nick, bufInfo, target, unread,
) )
} }
@@ -287,7 +288,7 @@ func (ui *UI) getOrCreateBuffer(name string) *Buffer {
} }
} }
buf := &Buffer{Name: name, Lines: nil, Unread: 0} buf := &Buffer{Name: name}
ui.buffers = append(ui.buffers, buf) ui.buffers = append(ui.buffers, buf)
return buf return buf

73
internal/broker/broker.go
View File

@@ -1,73 +0,0 @@
// Package broker provides an in-memory pub/sub for long-poll notifications.
package broker
import (
"sync"
)
// Broker notifies waiting clients when new messages are available.
type Broker struct {
mu sync.Mutex
listeners map[int64][]chan struct{}
}
// New creates a new Broker.
func New() *Broker {
return &Broker{ //nolint:exhaustruct // mu has zero-value default
listeners: make(map[int64][]chan struct{}),
}
}
// Wait returns a channel that will be closed when a message
// is available for the user.
func (b *Broker) Wait(userID int64) chan struct{} {
waitCh := make(chan struct{}, 1)
b.mu.Lock()
b.listeners[userID] = append(
b.listeners[userID], waitCh,
)
b.mu.Unlock()
return waitCh
}
// Notify wakes up all waiting clients for a user.
func (b *Broker) Notify(userID int64) {
b.mu.Lock()
waiters := b.listeners[userID]
delete(b.listeners, userID)
b.mu.Unlock()
for _, waiter := range waiters {
select {
case waiter <- struct{}{}:
default:
}
}
}
// Remove removes a specific wait channel (for cleanup on timeout).
func (b *Broker) Remove(
userID int64,
waitCh chan struct{},
) {
b.mu.Lock()
defer b.mu.Unlock()
waiters := b.listeners[userID]
for i, waiter := range waiters {
if waiter == waitCh {
b.listeners[userID] = append(
waiters[:i], waiters[i+1:]...,
)
break
}
}
if len(b.listeners[userID]) == 0 {
delete(b.listeners, userID)
}
}

121
internal/broker/broker_test.go
View File

@@ -1,121 +0,0 @@
package broker_test
import (
"sync"
"testing"
"time"
"git.eeqj.de/sneak/chat/internal/broker"
)
func TestNewBroker(t *testing.T) {
t.Parallel()
brk := broker.New()
if brk == nil {
t.Fatal("expected non-nil broker")
}
}
func TestWaitAndNotify(t *testing.T) {
t.Parallel()
brk := broker.New()
waitCh := brk.Wait(1)
go func() {
time.Sleep(10 * time.Millisecond)
brk.Notify(1)
}()
select {
case <-waitCh:
case <-time.After(2 * time.Second):
t.Fatal("timeout")
}
}
func TestNotifyWithoutWaiters(t *testing.T) {
t.Parallel()
brk := broker.New()
brk.Notify(42) // should not panic.
}
func TestRemove(t *testing.T) {
t.Parallel()
brk := broker.New()
waitCh := brk.Wait(1)
brk.Remove(1, waitCh)
brk.Notify(1)
select {
case <-waitCh:
t.Fatal("should not receive after remove")
case <-time.After(50 * time.Millisecond):
}
}
func TestMultipleWaiters(t *testing.T) {
t.Parallel()
brk := broker.New()
waitCh1 := brk.Wait(1)
waitCh2 := brk.Wait(1)
brk.Notify(1)
select {
case <-waitCh1:
case <-time.After(time.Second):
t.Fatal("ch1 timeout")
}
select {
case <-waitCh2:
case <-time.After(time.Second):
t.Fatal("ch2 timeout")
}
}
func TestConcurrentWaitNotify(t *testing.T) {
t.Parallel()
brk := broker.New()
var waitGroup sync.WaitGroup
const concurrency = 100
for idx := range concurrency {
waitGroup.Add(1)
go func(uid int64) {
defer waitGroup.Done()
waitCh := brk.Wait(uid)
brk.Notify(uid)
select {
case <-waitCh:
case <-time.After(time.Second):
t.Error("timeout")
}
}(int64(idx % 10))
}
waitGroup.Wait()
}
func TestRemoveNonexistent(t *testing.T) {
t.Parallel()
brk := broker.New()
waitCh := make(chan struct{}, 1)
brk.Remove(999, waitCh) // should not panic.
}

12
internal/config/config.go
View File

@@ -41,9 +41,7 @@ type Config struct {
} }
// New creates a new Config by reading from files and environment variables. // New creates a new Config by reading from files and environment variables.
func New( func New(_ fx.Lifecycle, params Params) (*Config, error) {
_ fx.Lifecycle, params Params,
) (*Config, error) {
log := params.Logger.Get() log := params.Logger.Get()
name := params.Globals.Appname name := params.Globals.Appname
@@ -76,7 +74,7 @@ func New(
} }
} }
cfg := &Config{ s := &Config{
DBURL: viper.GetString("DBURL"), DBURL: viper.GetString("DBURL"),
Debug: viper.GetBool("DEBUG"), Debug: viper.GetBool("DEBUG"),
Port: viper.GetInt("PORT"), Port: viper.GetInt("PORT"),
@@ -94,10 +92,10 @@ func New(
params: &params, params: &params,
} }
if cfg.Debug { if s.Debug {
params.Logger.EnableDebugLogging() params.Logger.EnableDebugLogging()
cfg.log = params.Logger.Get() s.log = params.Logger.Get()
} }
return cfg, nil return s, nil
} }

764
internal/db/db.go
View File

@@ -11,16 +11,20 @@ import (
"sort" "sort"
"strconv" "strconv"
"strings" "strings"
"time"
"git.eeqj.de/sneak/chat/internal/config" "git.eeqj.de/sneak/chat/internal/config"
"git.eeqj.de/sneak/chat/internal/logger" "git.eeqj.de/sneak/chat/internal/logger"
"git.eeqj.de/sneak/chat/internal/models"
"go.uber.org/fx" "go.uber.org/fx"
_ "github.com/joho/godotenv/autoload" // .env _ "github.com/joho/godotenv/autoload" // loads .env file
_ "modernc.org/sqlite" // driver _ "modernc.org/sqlite" // SQLite driver
) )
const minMigrationParts = 2 const (
minMigrationParts = 2
)
// SchemaFiles contains embedded SQL migration files. // SchemaFiles contains embedded SQL migration files.
// //
@@ -35,95 +39,527 @@ type Params struct {
Config *config.Config Config *config.Config
} }
// Database manages the SQLite connection and migrations. // Database manages the SQLite database connection and migrations.
type Database struct { type Database struct {
conn *sql.DB db *sql.DB
log *slog.Logger log *slog.Logger
params *Params params *Params
} }
// New creates a new Database and registers lifecycle hooks. // New creates a new Database instance and registers lifecycle hooks.
func New( func New(lc fx.Lifecycle, params Params) (*Database, error) {
lifecycle fx.Lifecycle, s := new(Database)
params Params, s.params = &params
) (*Database, error) { s.log = params.Logger.Get()
database := &Database{ //nolint:exhaustruct // conn set in OnStart
params: &params,
log: params.Logger.Get(),
}
database.log.Info("Database instantiated") s.log.Info("Database instantiated")
lifecycle.Append(fx.Hook{ lc.Append(fx.Hook{
OnStart: func(ctx context.Context) error { OnStart: func(ctx context.Context) error {
database.log.Info("Database OnStart Hook") s.log.Info("Database OnStart Hook")
return database.connect(ctx) return s.connect(ctx)
}, },
OnStop: func(_ context.Context) error { OnStop: func(_ context.Context) error {
database.log.Info("Database OnStop Hook") s.log.Info("Database OnStop Hook")
if database.conn != nil { if s.db != nil {
closeErr := database.conn.Close() return s.db.Close()
if closeErr != nil {
return fmt.Errorf(
"close db: %w", closeErr,
)
}
} }
return nil return nil
}, },
}) })
return database, nil return s, nil
}
// NewTest creates a Database for testing, bypassing fx lifecycle.
// It connects to the given DSN and runs all migrations.
func NewTest(dsn string) (*Database, error) {
d, err := sql.Open("sqlite", dsn)
if err != nil {
return nil, err
}
s := &Database{
db: d,
log: slog.Default(),
}
// Item 9: Enable foreign keys
_, err = d.Exec("PRAGMA foreign_keys = ON") //nolint:noctx,nolintlint // no context in sql.Open path
if err != nil {
_ = d.Close()
return nil, fmt.Errorf("enable foreign keys: %w", err)
}
ctx := context.Background()
err = s.runMigrations(ctx)
if err != nil {
_ = d.Close()
return nil, err
}
return s, nil
} }
// GetDB returns the underlying sql.DB connection. // GetDB returns the underlying sql.DB connection.
func (database *Database) GetDB() *sql.DB { func (s *Database) GetDB() *sql.DB {
return database.conn return s.db
} }
func (database *Database) connect(ctx context.Context) error { // Hydrate injects the database reference into any model that
dbURL := database.params.Config.DBURL // embeds Base.
func (s *Database) Hydrate(m interface{ SetDB(d models.DB) }) {
m.SetDB(s)
}
// GetUserByID looks up a user by their ID.
func (s *Database) GetUserByID(
ctx context.Context,
id string,
) (*models.User, error) {
u := &models.User{}
s.Hydrate(u)
err := s.db.QueryRowContext(ctx, `
SELECT id, nick, password_hash, created_at, updated_at, last_seen_at
FROM users WHERE id = ?`,
id,
).Scan(
&u.ID, &u.Nick, &u.PasswordHash,
&u.CreatedAt, &u.UpdatedAt, &u.LastSeenAt,
)
if err != nil {
return nil, err
}
return u, nil
}
// GetChannelByID looks up a channel by its ID.
func (s *Database) GetChannelByID(
ctx context.Context,
id string,
) (*models.Channel, error) {
c := &models.Channel{}
s.Hydrate(c)
err := s.db.QueryRowContext(ctx, `
SELECT id, name, topic, modes, created_at, updated_at
FROM channels WHERE id = ?`,
id,
).Scan(
&c.ID, &c.Name, &c.Topic, &c.Modes,
&c.CreatedAt, &c.UpdatedAt,
)
if err != nil {
return nil, err
}
return c, nil
}
// GetUserByNickModel looks up a user by their nick.
func (s *Database) GetUserByNickModel(
ctx context.Context,
nick string,
) (*models.User, error) {
u := &models.User{}
s.Hydrate(u)
err := s.db.QueryRowContext(ctx, `
SELECT id, nick, password_hash, created_at, updated_at, last_seen_at
FROM users WHERE nick = ?`,
nick,
).Scan(
&u.ID, &u.Nick, &u.PasswordHash,
&u.CreatedAt, &u.UpdatedAt, &u.LastSeenAt,
)
if err != nil {
return nil, err
}
return u, nil
}
// GetUserByTokenModel looks up a user by their auth token.
func (s *Database) GetUserByTokenModel(
ctx context.Context,
token string,
) (*models.User, error) {
u := &models.User{}
s.Hydrate(u)
err := s.db.QueryRowContext(ctx, `
SELECT u.id, u.nick, u.password_hash,
u.created_at, u.updated_at, u.last_seen_at
FROM users u
JOIN auth_tokens t ON t.user_id = u.id
WHERE t.token = ?`,
token,
).Scan(
&u.ID, &u.Nick, &u.PasswordHash,
&u.CreatedAt, &u.UpdatedAt, &u.LastSeenAt,
)
if err != nil {
return nil, err
}
return u, nil
}
// DeleteAuthToken removes an auth token from the database.
func (s *Database) DeleteAuthToken(
ctx context.Context,
token string,
) error {
_, err := s.db.ExecContext(ctx,
`DELETE FROM auth_tokens WHERE token = ?`, token,
)
return err
}
// UpdateUserLastSeen updates the last_seen_at timestamp for a user.
func (s *Database) UpdateUserLastSeen(
ctx context.Context,
userID string,
) error {
_, err := s.db.ExecContext(ctx,
`UPDATE users SET last_seen_at = CURRENT_TIMESTAMP WHERE id = ?`,
userID,
)
return err
}
// CreateUserModel inserts a new user into the database.
func (s *Database) CreateUserModel(
ctx context.Context,
id, nick, passwordHash string,
) (*models.User, error) {
now := time.Now()
_, err := s.db.ExecContext(ctx,
`INSERT INTO users (id, nick, password_hash)
VALUES (?, ?, ?)`,
id, nick, passwordHash,
)
if err != nil {
return nil, err
}
u := &models.User{
ID: id, Nick: nick, PasswordHash: passwordHash,
CreatedAt: now, UpdatedAt: now,
}
s.Hydrate(u)
return u, nil
}
// CreateChannel inserts a new channel into the database.
func (s *Database) CreateChannel(
ctx context.Context,
id, name, topic, modes string,
) (*models.Channel, error) {
now := time.Now()
_, err := s.db.ExecContext(ctx,
`INSERT INTO channels (id, name, topic, modes)
VALUES (?, ?, ?, ?)`,
id, name, topic, modes,
)
if err != nil {
return nil, err
}
c := &models.Channel{
ID: id, Name: name, Topic: topic, Modes: modes,
CreatedAt: now, UpdatedAt: now,
}
s.Hydrate(c)
return c, nil
}
// AddChannelMember adds a user to a channel with the given modes.
func (s *Database) AddChannelMember(
ctx context.Context,
channelID, userID, modes string,
) (*models.ChannelMember, error) {
now := time.Now()
_, err := s.db.ExecContext(ctx,
`INSERT INTO channel_members
(channel_id, user_id, modes)
VALUES (?, ?, ?)`,
channelID, userID, modes,
)
if err != nil {
return nil, err
}
cm := &models.ChannelMember{
ChannelID: channelID,
UserID: userID,
Modes: modes,
JoinedAt: now,
}
s.Hydrate(cm)
return cm, nil
}
// CreateMessage inserts a new message into the database.
func (s *Database) CreateMessage(
ctx context.Context,
id, fromUserID, fromNick, target, msgType, body string,
) (*models.Message, error) {
now := time.Now()
_, err := s.db.ExecContext(ctx,
`INSERT INTO messages
(id, from_user_id, from_nick, target, type, body)
VALUES (?, ?, ?, ?, ?, ?)`,
id, fromUserID, fromNick, target, msgType, body,
)
if err != nil {
return nil, err
}
m := &models.Message{
ID: id,
FromUserID: fromUserID,
FromNick: fromNick,
Target: target,
Type: msgType,
Body: body,
Timestamp: now,
CreatedAt: now,
}
s.Hydrate(m)
return m, nil
}
// QueueMessage adds a message to a user's delivery queue.
func (s *Database) QueueMessage(
ctx context.Context,
userID, messageID string,
) (*models.MessageQueueEntry, error) {
now := time.Now()
res, err := s.db.ExecContext(ctx,
`INSERT INTO message_queue (user_id, message_id)
VALUES (?, ?)`,
userID, messageID,
)
if err != nil {
return nil, err
}
entryID, err := res.LastInsertId()
if err != nil {
return nil, fmt.Errorf("get last insert id: %w", err)
}
mq := &models.MessageQueueEntry{
ID: entryID,
UserID: userID,
MessageID: messageID,
QueuedAt: now,
}
s.Hydrate(mq)
return mq, nil
}
// DequeueMessages returns up to limit pending messages for a user,
// ordered by queue time (oldest first).
func (s *Database) DequeueMessages(
ctx context.Context,
userID string,
limit int,
) ([]*models.MessageQueueEntry, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id, user_id, message_id, queued_at
FROM message_queue
WHERE user_id = ?
ORDER BY queued_at ASC
LIMIT ?`,
userID, limit,
)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
entries := []*models.MessageQueueEntry{}
for rows.Next() {
e := &models.MessageQueueEntry{}
s.Hydrate(e)
err = rows.Scan(&e.ID, &e.UserID, &e.MessageID, &e.QueuedAt)
if err != nil {
return nil, err
}
entries = append(entries, e)
}
return entries, rows.Err()
}
// AckMessages removes the given queue entry IDs, marking them as delivered.
func (s *Database) AckMessages(
ctx context.Context,
entryIDs []int64,
) error {
if len(entryIDs) == 0 {
return nil
}
placeholders := make([]string, len(entryIDs))
args := make([]any, len(entryIDs))
for i, id := range entryIDs {
placeholders[i] = "?"
args[i] = id
}
query := fmt.Sprintf( //nolint:gosec // placeholders are ?, not user input
"DELETE FROM message_queue WHERE id IN (%s)",
strings.Join(placeholders, ","),
)
_, err := s.db.ExecContext(ctx, query, args...)
return err
}
// CreateAuthToken inserts a new auth token for a user.
func (s *Database) CreateAuthToken(
ctx context.Context,
token, userID string,
) (*models.AuthToken, error) {
now := time.Now()
_, err := s.db.ExecContext(ctx,
`INSERT INTO auth_tokens (token, user_id)
VALUES (?, ?)`,
token, userID,
)
if err != nil {
return nil, err
}
at := &models.AuthToken{Token: token, UserID: userID, CreatedAt: now}
s.Hydrate(at)
return at, nil
}
// CreateSession inserts a new session for a user.
func (s *Database) CreateSession(
ctx context.Context,
id, userID string,
) (*models.Session, error) {
now := time.Now()
_, err := s.db.ExecContext(ctx,
`INSERT INTO sessions (id, user_id)
VALUES (?, ?)`,
id, userID,
)
if err != nil {
return nil, err
}
sess := &models.Session{
ID: id, UserID: userID,
CreatedAt: now, LastActiveAt: now,
}
s.Hydrate(sess)
return sess, nil
}
// CreateServerLink inserts a new server link.
func (s *Database) CreateServerLink(
ctx context.Context,
id, name, url, sharedKeyHash string,
isActive bool,
) (*models.ServerLink, error) {
now := time.Now()
active := 0
if isActive {
active = 1
}
_, err := s.db.ExecContext(ctx,
`INSERT INTO server_links
(id, name, url, shared_key_hash, is_active)
VALUES (?, ?, ?, ?, ?)`,
id, name, url, sharedKeyHash, active,
)
if err != nil {
return nil, err
}
sl := &models.ServerLink{
ID: id,
Name: name,
URL: url,
SharedKeyHash: sharedKeyHash,
IsActive: isActive,
CreatedAt: now,
}
s.Hydrate(sl)
return sl, nil
}
func (s *Database) connect(ctx context.Context) error {
dbURL := s.params.Config.DBURL
if dbURL == "" { if dbURL == "" {
dbURL = "file:./data.db?_journal_mode=WAL&_busy_timeout=5000" dbURL = "file:./data.db?_journal_mode=WAL"
} }
database.log.Info( s.log.Info("connecting to database", "url", dbURL)
"connecting to database", "url", dbURL,
)
conn, err := sql.Open("sqlite", dbURL) d, err := sql.Open("sqlite", dbURL)
if err != nil { if err != nil {
return fmt.Errorf("open database: %w", err) s.log.Error("failed to open database", "error", err)
return err
} }
err = conn.PingContext(ctx) err = d.PingContext(ctx)
if err != nil { if err != nil {
return fmt.Errorf("ping database: %w", err) s.log.Error("failed to ping database", "error", err)
return err
} }
conn.SetMaxOpenConns(1) s.db = d
s.log.Info("database connected")
database.conn = conn // Item 9: Enable foreign keys on every connection
database.log.Info("database connected") _, err = s.db.ExecContext(ctx, "PRAGMA foreign_keys = ON")
_, err = database.conn.ExecContext(
ctx, "PRAGMA foreign_keys = ON",
)
if err != nil { if err != nil {
return fmt.Errorf("enable foreign keys: %w", err) return fmt.Errorf("enable foreign keys: %w", err)
} }
_, err = database.conn.ExecContext( return s.runMigrations(ctx)
ctx, "PRAGMA busy_timeout = 5000",
)
if err != nil {
return fmt.Errorf("set busy timeout: %w", err)
}
return database.runMigrations(ctx)
} }
type migration struct { type migration struct {
@@ -132,122 +568,48 @@ type migration struct {
sql string sql string
} }
func (database *Database) runMigrations( func (s *Database) runMigrations(ctx context.Context) error {
err := s.bootstrapMigrationsTable(ctx)
if err != nil {
return err
}
migrations, err := s.loadMigrations()
if err != nil {
return err
}
err = s.applyMigrations(ctx, migrations)
if err != nil {
return err
}
s.log.Info("database migrations complete")
return nil
}
func (s *Database) bootstrapMigrationsTable(
ctx context.Context, ctx context.Context,
) error { ) error {
_, err := database.conn.ExecContext(ctx, _, err := s.db.ExecContext(ctx,
`CREATE TABLE IF NOT EXISTS schema_migrations ( `CREATE TABLE IF NOT EXISTS schema_migrations (
version INTEGER PRIMARY KEY, version INTEGER PRIMARY KEY,
applied_at DATETIME DEFAULT CURRENT_TIMESTAMP)`) applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
)`)
if err != nil { if err != nil {
return fmt.Errorf( return fmt.Errorf(
"create schema_migrations: %w", err, "create schema_migrations table: %w", err,
)
}
migrations, err := database.loadMigrations()
if err != nil {
return err
}
for _, mig := range migrations {
err = database.applyMigration(ctx, mig)
if err != nil {
return err
}
}
database.log.Info("database migrations complete")
return nil
}
func (database *Database) applyMigration(
ctx context.Context,
mig migration,
) error {
var exists int
err := database.conn.QueryRowContext(ctx,
`SELECT COUNT(*) FROM schema_migrations
WHERE version = ?`,
mig.version,
).Scan(&exists)
if err != nil {
return fmt.Errorf(
"check migration %d: %w", mig.version, err,
)
}
if exists > 0 {
return nil
}
database.log.Info(
"applying migration",
"version", mig.version,
"name", mig.name,
)
return database.execMigration(ctx, mig)
}
func (database *Database) execMigration(
ctx context.Context,
mig migration,
) error {
transaction, err := database.conn.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf(
"begin tx for migration %d: %w",
mig.version, err,
)
}
_, err = transaction.ExecContext(ctx, mig.sql)
if err != nil {
_ = transaction.Rollback()
return fmt.Errorf(
"apply migration %d (%s): %w",
mig.version, mig.name, err,
)
}
_, err = transaction.ExecContext(ctx,
`INSERT INTO schema_migrations (version)
VALUES (?)`,
mig.version,
)
if err != nil {
_ = transaction.Rollback()
return fmt.Errorf(
"record migration %d: %w",
mig.version, err,
)
}
err = transaction.Commit()
if err != nil {
return fmt.Errorf(
"commit migration %d: %w",
mig.version, err,
) )
} }
return nil return nil
} }
func (database *Database) loadMigrations() ( func (s *Database) loadMigrations() ([]migration, error) {
[]migration,
error,
) {
entries, err := fs.ReadDir(SchemaFiles, "schema") entries, err := fs.ReadDir(SchemaFiles, "schema")
if err != nil { if err != nil {
return nil, fmt.Errorf( return nil, fmt.Errorf("read schema dir: %w", err)
"read schema dir: %w", err,
)
} }
migrations := make([]migration, 0, len(entries)) migrations := make([]migration, 0, len(entries))
@@ -265,18 +627,17 @@ func (database *Database) loadMigrations() (
continue continue
} }
version, parseErr := strconv.Atoi(parts[0]) version, err := strconv.Atoi(parts[0])
if parseErr != nil { if err != nil {
continue continue
} }
content, readErr := SchemaFiles.ReadFile( content, err := SchemaFiles.ReadFile(
"schema/" + entry.Name(), "schema/" + entry.Name(),
) )
if readErr != nil { if err != nil {
return nil, fmt.Errorf( return nil, fmt.Errorf(
"read migration %s: %w", "read migration %s: %w", entry.Name(), err,
entry.Name(), readErr,
) )
} }
@@ -293,3 +654,82 @@ func (database *Database) loadMigrations() (
return migrations, nil return migrations, nil
} }
// Item 4: Wrap each migration in a transaction
func (s *Database) applyMigrations(
ctx context.Context,
migrations []migration,
) error {
for _, m := range migrations {
var exists int
err := s.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM schema_migrations WHERE version = ?",
m.version,
).Scan(&exists)
if err != nil {
return fmt.Errorf(
"check migration %d: %w", m.version, err,
)
}
if exists > 0 {
continue
}
s.log.Info(
"applying migration",
"version", m.version, "name", m.name,
)
err = s.executeMigration(ctx, m)
if err != nil {
return err
}
}
return nil
}
func (s *Database) executeMigration(
ctx context.Context,
m migration,
) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf(
"begin tx for migration %d: %w", m.version, err,
)
}
_, err = tx.ExecContext(ctx, m.sql)
if err != nil {
_ = tx.Rollback()
return fmt.Errorf(
"apply migration %d (%s): %w",
m.version, m.name, err,
)
}
_, err = tx.ExecContext(ctx,
"INSERT INTO schema_migrations (version) VALUES (?)",
m.version,
)
if err != nil {
_ = tx.Rollback()
return fmt.Errorf(
"record migration %d: %w", m.version, err,
)
}
err = tx.Commit()
if err != nil {
return fmt.Errorf(
"commit migration %d: %w", m.version, err,
)
}
return nil
}

424
internal/db/db_test.go Normal file
View File

@@ -0,0 +1,424 @@
package db_test
import (
"fmt"
"path/filepath"
"testing"
"time"
"git.eeqj.de/sneak/chat/internal/db"
)
const (
nickAlice = "alice"
nickBob = "bob"
nickCharlie = "charlie"
)
// setupTestDB creates a fresh database in a temp directory with
// all migrations applied.
func setupTestDB(t *testing.T) *db.Database {
t.Helper()
dir := t.TempDir()
dsn := fmt.Sprintf(
"file:%s?_journal_mode=WAL",
filepath.Join(dir, "test.db"),
)
d, err := db.NewTest(dsn)
if err != nil {
t.Fatalf("failed to create test database: %v", err)
}
t.Cleanup(func() { _ = d.GetDB().Close() })
return d
}
func TestCreateUser(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
id, token, err := d.CreateUser(ctx, nickAlice)
if err != nil {
t.Fatalf("CreateUser: %v", err)
}
if id <= 0 {
t.Errorf("expected positive id, got %d", id)
}
if token == "" {
t.Error("expected non-empty token")
}
}
func TestGetUserByToken(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
_, token, _ := d.CreateUser(ctx, nickAlice)
id, nick, err := d.GetUserByToken(ctx, token)
if err != nil {
t.Fatalf("GetUserByToken: %v", err)
}
if id <= 0 || nick != nickAlice {
t.Errorf(
"got id=%d nick=%s, want nick=%s",
id, nick, nickAlice,
)
}
}
func TestGetUserByNick(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
origID, _, _ := d.CreateUser(ctx, nickAlice)
id, err := d.GetUserByNick(ctx, nickAlice)
if err != nil {
t.Fatalf("GetUserByNick: %v", err)
}
if id != origID {
t.Errorf("got id %d, want %d", id, origID)
}
}
func TestGetOrCreateChannel(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
id1, err := d.GetOrCreateChannel(ctx, "#general")
if err != nil {
t.Fatalf("GetOrCreateChannel: %v", err)
}
if id1 <= 0 {
t.Errorf("expected positive id, got %d", id1)
}
// Same channel returns same ID.
id2, err := d.GetOrCreateChannel(ctx, "#general")
if err != nil {
t.Fatalf("GetOrCreateChannel(2): %v", err)
}
if id1 != id2 {
t.Errorf("got different ids: %d vs %d", id1, id2)
}
}
func TestJoinAndListChannels(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid, _, _ := d.CreateUser(ctx, nickAlice)
ch1, _ := d.GetOrCreateChannel(ctx, "#alpha")
ch2, _ := d.GetOrCreateChannel(ctx, "#beta")
_ = d.JoinChannel(ctx, ch1, uid)
_ = d.JoinChannel(ctx, ch2, uid)
channels, err := d.ListChannels(ctx, uid)
if err != nil {
t.Fatalf("ListChannels: %v", err)
}
if len(channels) != 2 {
t.Fatalf("expected 2 channels, got %d", len(channels))
}
}
func TestListChannelsEmpty(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid, _, _ := d.CreateUser(ctx, nickAlice)
channels, err := d.ListChannels(ctx, uid)
if err != nil {
t.Fatalf("ListChannels: %v", err)
}
if len(channels) != 0 {
t.Errorf("expected 0 channels, got %d", len(channels))
}
}
func TestPartChannel(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid, _, _ := d.CreateUser(ctx, nickAlice)
chID, _ := d.GetOrCreateChannel(ctx, "#general")
_ = d.JoinChannel(ctx, chID, uid)
_ = d.PartChannel(ctx, chID, uid)
channels, err := d.ListChannels(ctx, uid)
if err != nil {
t.Fatalf("ListChannels: %v", err)
}
if len(channels) != 0 {
t.Errorf("expected 0 after part, got %d", len(channels))
}
}
func TestSendAndGetMessages(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid, _, _ := d.CreateUser(ctx, nickAlice)
chID, _ := d.GetOrCreateChannel(ctx, "#general")
_ = d.JoinChannel(ctx, chID, uid)
_, err := d.SendMessage(ctx, chID, uid, "hello world")
if err != nil {
t.Fatalf("SendMessage: %v", err)
}
msgs, err := d.GetMessages(ctx, chID, 0, 0)
if err != nil {
t.Fatalf("GetMessages: %v", err)
}
if len(msgs) != 1 {
t.Fatalf("expected 1 message, got %d", len(msgs))
}
if msgs[0].Content != "hello world" {
t.Errorf(
"got content %q, want %q",
msgs[0].Content, "hello world",
)
}
}
func TestChannelMembers(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid1, _, _ := d.CreateUser(ctx, nickAlice)
uid2, _, _ := d.CreateUser(ctx, nickBob)
uid3, _, _ := d.CreateUser(ctx, nickCharlie)
chID, _ := d.GetOrCreateChannel(ctx, "#general")
_ = d.JoinChannel(ctx, chID, uid1)
_ = d.JoinChannel(ctx, chID, uid2)
_ = d.JoinChannel(ctx, chID, uid3)
members, err := d.ChannelMembers(ctx, chID)
if err != nil {
t.Fatalf("ChannelMembers: %v", err)
}
if len(members) != 3 {
t.Fatalf("expected 3 members, got %d", len(members))
}
}
func TestChannelMembersEmpty(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
chID, _ := d.GetOrCreateChannel(ctx, "#empty")
members, err := d.ChannelMembers(ctx, chID)
if err != nil {
t.Fatalf("ChannelMembers: %v", err)
}
if len(members) != 0 {
t.Errorf("expected 0, got %d", len(members))
}
}
func TestSendDM(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid1, _, _ := d.CreateUser(ctx, nickAlice)
uid2, _, _ := d.CreateUser(ctx, nickBob)
msgID, err := d.SendDM(ctx, uid1, uid2, "hey bob")
if err != nil {
t.Fatalf("SendDM: %v", err)
}
if msgID <= 0 {
t.Errorf("expected positive msgID, got %d", msgID)
}
msgs, err := d.GetDMs(ctx, uid1, uid2, 0, 0)
if err != nil {
t.Fatalf("GetDMs: %v", err)
}
if len(msgs) != 1 {
t.Fatalf("expected 1 DM, got %d", len(msgs))
}
if msgs[0].Content != "hey bob" {
t.Errorf("got %q, want %q", msgs[0].Content, "hey bob")
}
}
func TestPollMessages(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid1, _, _ := d.CreateUser(ctx, nickAlice)
uid2, _, _ := d.CreateUser(ctx, nickBob)
chID, _ := d.GetOrCreateChannel(ctx, "#general")
_ = d.JoinChannel(ctx, chID, uid1)
_ = d.JoinChannel(ctx, chID, uid2)
_, _ = d.SendMessage(ctx, chID, uid2, "hello")
_, _ = d.SendDM(ctx, uid2, uid1, "private")
time.Sleep(10 * time.Millisecond)
msgs, err := d.PollMessages(ctx, uid1, 0, 0)
if err != nil {
t.Fatalf("PollMessages: %v", err)
}
if len(msgs) < 2 {
t.Fatalf("expected >=2 messages, got %d", len(msgs))
}
}
func TestChangeNick(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
_, token, _ := d.CreateUser(ctx, nickAlice)
err := d.ChangeNick(ctx, 1, "alice2")
if err != nil {
t.Fatalf("ChangeNick: %v", err)
}
_, nick, err := d.GetUserByToken(ctx, token)
if err != nil {
t.Fatalf("GetUserByToken: %v", err)
}
if nick != "alice2" {
t.Errorf("got nick %q, want alice2", nick)
}
}
func TestSetTopic(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid, _, _ := d.CreateUser(ctx, nickAlice)
_, _ = d.GetOrCreateChannel(ctx, "#general")
err := d.SetTopic(ctx, "#general", uid, "new topic")
if err != nil {
t.Fatalf("SetTopic: %v", err)
}
channels, err := d.ListAllChannels(ctx)
if err != nil {
t.Fatalf("ListAllChannels: %v", err)
}
found := false
for _, ch := range channels {
if ch.Name == "#general" && ch.Topic == "new topic" {
found = true
}
}
if !found {
t.Error("topic was not updated")
}
}
func TestGetMessagesBefore(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
uid, _, _ := d.CreateUser(ctx, nickAlice)
chID, _ := d.GetOrCreateChannel(ctx, "#general")
_ = d.JoinChannel(ctx, chID, uid)
for i := range 5 {
_, _ = d.SendMessage(
ctx, chID, uid,
fmt.Sprintf("msg%d", i),
)
time.Sleep(10 * time.Millisecond)
}
msgs, err := d.GetMessagesBefore(ctx, chID, 0, 3)
if err != nil {
t.Fatalf("GetMessagesBefore: %v", err)
}
if len(msgs) != 3 {
t.Fatalf("expected 3, got %d", len(msgs))
}
}
func TestListAllChannels(t *testing.T) {
t.Parallel()
d := setupTestDB(t)
ctx := t.Context()
_, _ = d.GetOrCreateChannel(ctx, "#alpha")
_, _ = d.GetOrCreateChannel(ctx, "#beta")
channels, err := d.ListAllChannels(ctx)
if err != nil {
t.Fatalf("ListAllChannels: %v", err)
}
if len(channels) != 2 {
t.Errorf("expected 2, got %d", len(channels))
}
}

60
internal/db/export_test.go
View File

@@ -1,60 +0,0 @@
package db
import (
"context"
"database/sql"
"fmt"
"log/slog"
"sync/atomic"
)
//nolint:gochecknoglobals // test counter
var testDBCounter atomic.Int64
// NewTestDatabase creates an in-memory database for testing.
func NewTestDatabase() (*Database, error) {
counter := testDBCounter.Add(1)
dsn := fmt.Sprintf(
"file:testdb%d?mode=memory"+
"&cache=shared&_pragma=foreign_keys(1)",
counter,
)
conn, err := sql.Open("sqlite", dsn)
if err != nil {
return nil, fmt.Errorf("open test db: %w", err)
}
database := &Database{ //nolint:exhaustruct // test helper, params not needed
conn: conn,
log: slog.Default(),
}
err = database.runMigrations(context.Background())
if err != nil {
closeErr := conn.Close()
if closeErr != nil {
return nil, fmt.Errorf(
"close after migration failure: %w",
closeErr,
)
}
return nil, fmt.Errorf(
"run test migrations: %w", err,
)
}
return database, nil
}
// Close closes the underlying database connection.
func (database *Database) Close() error {
err := database.conn.Close()
if err != nil {
return fmt.Errorf("close database: %w", err)
}
return nil
}

1129
internal/db/queries.go
View File

File diff suppressed because it is too large Load Diff

569
internal/db/queries_test.go
View File

@@ -1,569 +0,0 @@
package db_test
import (
"encoding/json"
"testing"
"git.eeqj.de/sneak/chat/internal/db"
_ "modernc.org/sqlite"
)
func setupTestDB(t *testing.T) *db.Database {
t.Helper()
database, err := db.NewTestDatabase()
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
closeErr := database.Close()
if closeErr != nil {
t.Logf("close db: %v", closeErr)
}
})
return database
}
func TestCreateUser(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
id, token, err := database.CreateUser(ctx, "alice")
if err != nil {
t.Fatal(err)
}
if id == 0 || token == "" {
t.Fatal("expected valid id and token")
}
_, _, err = database.CreateUser(ctx, "alice")
if err == nil {
t.Fatal("expected error for duplicate nick")
}
}
func TestGetUserByToken(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
_, token, err := database.CreateUser(ctx, "bob")
if err != nil {
t.Fatal(err)
}
id, nick, err := database.GetUserByToken(ctx, token)
if err != nil {
t.Fatal(err)
}
if nick != "bob" || id == 0 {
t.Fatalf("expected bob, got %s", nick)
}
_, _, err = database.GetUserByToken(ctx, "badtoken")
if err == nil {
t.Fatal("expected error for bad token")
}
}
func TestGetUserByNick(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
_, _, err := database.CreateUser(ctx, "charlie")
if err != nil {
t.Fatal(err)
}
id, err := database.GetUserByNick(ctx, "charlie")
if err != nil || id == 0 {
t.Fatal("expected to find charlie")
}
_, err = database.GetUserByNick(ctx, "nobody")
if err == nil {
t.Fatal("expected error for unknown nick")
}
}
func TestChannelOperations(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
chID, err := database.GetOrCreateChannel(ctx, "#test")
if err != nil || chID == 0 {
t.Fatal("expected channel id")
}
chID2, err := database.GetOrCreateChannel(ctx, "#test")
if err != nil || chID2 != chID {
t.Fatal("expected same channel id")
}
chID3, err := database.GetChannelByName(ctx, "#test")
if err != nil || chID3 != chID {
t.Fatal("expected same channel id")
}
_, err = database.GetChannelByName(ctx, "#nope")
if err == nil {
t.Fatal("expected error for nonexistent channel")
}
}
func TestJoinAndPart(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
uid, _, err := database.CreateUser(ctx, "user1")
if err != nil {
t.Fatal(err)
}
chID, err := database.GetOrCreateChannel(ctx, "#chan")
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, chID, uid)
if err != nil {
t.Fatal(err)
}
ids, err := database.GetChannelMemberIDs(ctx, chID)
if err != nil || len(ids) != 1 || ids[0] != uid {
t.Fatal("expected user in channel")
}
err = database.JoinChannel(ctx, chID, uid)
if err != nil {
t.Fatal(err)
}
err = database.PartChannel(ctx, chID, uid)
if err != nil {
t.Fatal(err)
}
ids, _ = database.GetChannelMemberIDs(ctx, chID)
if len(ids) != 0 {
t.Fatal("expected empty channel")
}
}
func TestDeleteChannelIfEmpty(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
chID, err := database.GetOrCreateChannel(
ctx, "#empty",
)
if err != nil {
t.Fatal(err)
}
uid, _, err := database.CreateUser(ctx, "temp")
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, chID, uid)
if err != nil {
t.Fatal(err)
}
err = database.PartChannel(ctx, chID, uid)
if err != nil {
t.Fatal(err)
}
err = database.DeleteChannelIfEmpty(ctx, chID)
if err != nil {
t.Fatal(err)
}
_, err = database.GetChannelByName(ctx, "#empty")
if err == nil {
t.Fatal("expected channel to be deleted")
}
}
func createUserWithChannels(
t *testing.T,
database *db.Database,
nick, ch1Name, ch2Name string,
) (int64, int64, int64) {
t.Helper()
ctx := t.Context()
uid, _, err := database.CreateUser(ctx, nick)
if err != nil {
t.Fatal(err)
}
ch1, err := database.GetOrCreateChannel(
ctx, ch1Name,
)
if err != nil {
t.Fatal(err)
}
ch2, err := database.GetOrCreateChannel(
ctx, ch2Name,
)
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, ch1, uid)
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, ch2, uid)
if err != nil {
t.Fatal(err)
}
return uid, ch1, ch2
}
func TestListChannels(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
uid, _, _ := createUserWithChannels(
t, database, "lister", "#a", "#b",
)
channels, err := database.ListChannels(
t.Context(), uid,
)
if err != nil || len(channels) != 2 {
t.Fatalf(
"expected 2 channels, got %d",
len(channels),
)
}
}
func TestListAllChannels(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
_, err := database.GetOrCreateChannel(ctx, "#x")
if err != nil {
t.Fatal(err)
}
_, err = database.GetOrCreateChannel(ctx, "#y")
if err != nil {
t.Fatal(err)
}
channels, err := database.ListAllChannels(ctx)
if err != nil || len(channels) < 2 {
t.Fatalf(
"expected >= 2 channels, got %d",
len(channels),
)
}
}
func TestChangeNick(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
uid, token, err := database.CreateUser(ctx, "old")
if err != nil {
t.Fatal(err)
}
err = database.ChangeNick(ctx, uid, "new")
if err != nil {
t.Fatal(err)
}
_, nick, err := database.GetUserByToken(ctx, token)
if err != nil {
t.Fatal(err)
}
if nick != "new" {
t.Fatalf("expected new, got %s", nick)
}
}
func TestSetTopic(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
_, err := database.GetOrCreateChannel(
ctx, "#topictest",
)
if err != nil {
t.Fatal(err)
}
err = database.SetTopic(ctx, "#topictest", "Hello")
if err != nil {
t.Fatal(err)
}
channels, err := database.ListAllChannels(ctx)
if err != nil {
t.Fatal(err)
}
for _, ch := range channels {
if ch.Name == "#topictest" &&
ch.Topic != "Hello" {
t.Fatalf(
"expected topic Hello, got %s",
ch.Topic,
)
}
}
}
func TestInsertMessage(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
body := json.RawMessage(`["hello"]`)
dbID, msgUUID, err := database.InsertMessage(
ctx, "PRIVMSG", "poller", "#test", body, nil,
)
if err != nil {
t.Fatal(err)
}
if dbID == 0 || msgUUID == "" {
t.Fatal("expected valid id and uuid")
}
}
func TestPollMessages(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
uid, _, err := database.CreateUser(ctx, "poller")
if err != nil {
t.Fatal(err)
}
body := json.RawMessage(`["hello"]`)
dbID, _, err := database.InsertMessage(
ctx, "PRIVMSG", "poller", "#test", body, nil,
)
if err != nil {
t.Fatal(err)
}
err = database.EnqueueMessage(ctx, uid, dbID)
if err != nil {
t.Fatal(err)
}
const batchSize = 10
msgs, lastQID, err := database.PollMessages(
ctx, uid, 0, batchSize,
)
if err != nil {
t.Fatal(err)
}
if len(msgs) != 1 {
t.Fatalf(
"expected 1 message, got %d", len(msgs),
)
}
if msgs[0].Command != "PRIVMSG" {
t.Fatalf(
"expected PRIVMSG, got %s", msgs[0].Command,
)
}
if lastQID == 0 {
t.Fatal("expected nonzero lastQID")
}
msgs, _, _ = database.PollMessages(
ctx, uid, lastQID, batchSize,
)
if len(msgs) != 0 {
t.Fatalf(
"expected 0 messages, got %d", len(msgs),
)
}
}
func TestGetHistory(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
const msgCount = 10
for range msgCount {
_, _, err := database.InsertMessage(
ctx, "PRIVMSG", "user", "#hist",
json.RawMessage(`["msg"]`), nil,
)
if err != nil {
t.Fatal(err)
}
}
const histLimit = 5
msgs, err := database.GetHistory(
ctx, "#hist", 0, histLimit,
)
if err != nil {
t.Fatal(err)
}
if len(msgs) != histLimit {
t.Fatalf("expected %d, got %d",
histLimit, len(msgs))
}
if msgs[0].DBID > msgs[histLimit-1].DBID {
t.Fatal("expected ascending order")
}
}
func TestDeleteUser(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
uid, _, err := database.CreateUser(ctx, "deleteme")
if err != nil {
t.Fatal(err)
}
chID, err := database.GetOrCreateChannel(
ctx, "#delchan",
)
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, chID, uid)
if err != nil {
t.Fatal(err)
}
err = database.DeleteUser(ctx, uid)
if err != nil {
t.Fatal(err)
}
_, err = database.GetUserByNick(ctx, "deleteme")
if err == nil {
t.Fatal("user should be deleted")
}
ids, _ := database.GetChannelMemberIDs(ctx, chID)
if len(ids) != 0 {
t.Fatal("expected no members after deletion")
}
}
func TestChannelMembers(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
uid1, _, err := database.CreateUser(ctx, "m1")
if err != nil {
t.Fatal(err)
}
uid2, _, err := database.CreateUser(ctx, "m2")
if err != nil {
t.Fatal(err)
}
chID, err := database.GetOrCreateChannel(
ctx, "#members",
)
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, chID, uid1)
if err != nil {
t.Fatal(err)
}
err = database.JoinChannel(ctx, chID, uid2)
if err != nil {
t.Fatal(err)
}
members, err := database.ChannelMembers(ctx, chID)
if err != nil || len(members) != 2 {
t.Fatalf(
"expected 2 members, got %d",
len(members),
)
}
}
func TestGetAllChannelMembershipsForUser(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
uid, _, _ := createUserWithChannels(
t, database, "multi", "#m1", "#m2",
)
channels, err :=
database.GetAllChannelMembershipsForUser(
t.Context(), uid,
)
if err != nil || len(channels) != 2 {
t.Fatalf(
"expected 2 channels, got %d",
len(channels),
)
}
}

56
internal/db/schema/001_initial.sql
View File

@@ -1,54 +1,4 @@
-- Chat server schema (pre-1.0 consolidated) CREATE TABLE IF NOT EXISTS schema_migrations (
PRAGMA foreign_keys = ON; version INTEGER PRIMARY KEY,
applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
-- Users: IRC-style sessions (no passwords, just nick + token)
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nick TEXT NOT NULL UNIQUE,
token TEXT NOT NULL UNIQUE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
); );
CREATE INDEX IF NOT EXISTS idx_users_token ON users(token);
-- Channels
CREATE TABLE IF NOT EXISTS channels (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL UNIQUE,
topic TEXT NOT NULL DEFAULT '',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
-- Channel members
CREATE TABLE IF NOT EXISTS channel_members (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id INTEGER NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE(channel_id, user_id)
);
-- Messages: IRC envelope format
CREATE TABLE IF NOT EXISTS messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
uuid TEXT NOT NULL UNIQUE,
command TEXT NOT NULL DEFAULT 'PRIVMSG',
msg_from TEXT NOT NULL DEFAULT '',
msg_to TEXT NOT NULL DEFAULT '',
body TEXT NOT NULL DEFAULT '[]',
meta TEXT NOT NULL DEFAULT '{}',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX IF NOT EXISTS idx_messages_to_id ON messages(msg_to, id);
CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at);
-- Per-client message queues for fan-out delivery
CREATE TABLE IF NOT EXISTS client_queues (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE(user_id, message_id)
);
CREATE INDEX IF NOT EXISTS idx_client_queues_user ON client_queues(user_id, id);

89
internal/db/schema/002_schema.sql Normal file
View File

@@ -0,0 +1,89 @@
-- All schema changes go into this file until 1.0.0 is tagged.
-- There will not be migrations during the early development phase.
-- After 1.0.0, new changes get their own numbered migration files.
-- Users: accounts and authentication
CREATE TABLE IF NOT EXISTS users (
id TEXT PRIMARY KEY, -- UUID
nick TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
last_seen_at DATETIME
);
-- Auth tokens: one user can have multiple active tokens (multiple devices)
CREATE TABLE IF NOT EXISTS auth_tokens (
token TEXT PRIMARY KEY, -- random token string
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
expires_at DATETIME, -- NULL = no expiry
last_used_at DATETIME
);
CREATE INDEX IF NOT EXISTS idx_auth_tokens_user_id ON auth_tokens(user_id);
-- Channels: chat rooms
CREATE TABLE IF NOT EXISTS channels (
id TEXT PRIMARY KEY, -- UUID
name TEXT NOT NULL UNIQUE, -- #general, etc.
topic TEXT NOT NULL DEFAULT '',
modes TEXT NOT NULL DEFAULT '', -- +i, +m, +s, +t, +n
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
);
-- Channel members: who is in which channel, with per-user modes
CREATE TABLE IF NOT EXISTS channel_members (
channel_id TEXT NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
modes TEXT NOT NULL DEFAULT '', -- +o (operator), +v (voice)
joined_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (channel_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_channel_members_user_id ON channel_members(user_id);
-- Messages: channel and DM history (rotated per MAX_HISTORY)
CREATE TABLE IF NOT EXISTS messages (
id TEXT PRIMARY KEY, -- UUID
ts DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
from_user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
from_nick TEXT NOT NULL, -- denormalized for history
target TEXT NOT NULL, -- #channel name or user UUID for DMs
type TEXT NOT NULL DEFAULT 'message', -- message, action, notice, join, part, quit, topic, mode, nick, system
body TEXT NOT NULL DEFAULT '',
meta TEXT NOT NULL DEFAULT '{}', -- JSON extensible metadata
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX IF NOT EXISTS idx_messages_target_ts ON messages(target, ts);
CREATE INDEX IF NOT EXISTS idx_messages_from_user ON messages(from_user_id);
-- Message queue: per-user pending delivery (unread messages)
CREATE TABLE IF NOT EXISTS message_queue (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
queued_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
UNIQUE(user_id, message_id)
);
CREATE INDEX IF NOT EXISTS idx_message_queue_user_id ON message_queue(user_id, queued_at);
-- Sessions: server-held session state
CREATE TABLE IF NOT EXISTS sessions (
id TEXT PRIMARY KEY, -- UUID
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
last_active_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
expires_at DATETIME -- idle timeout
);
CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id);
-- Server links: federation peer configuration
CREATE TABLE IF NOT EXISTS server_links (
id TEXT PRIMARY KEY, -- UUID
name TEXT NOT NULL UNIQUE, -- human-readable peer name
url TEXT NOT NULL, -- base URL of peer server
shared_key_hash TEXT NOT NULL, -- hashed shared secret
is_active INTEGER NOT NULL DEFAULT 1,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
last_seen_at DATETIME
);

53
internal/db/schema/003_users.sql Normal file
View File

@@ -0,0 +1,53 @@
-- Migration 003: Replace UUID-based tables with simple integer-keyed
-- tables for the HTTP API. Drops the 002 tables and recreates them.
PRAGMA foreign_keys = OFF;
DROP TABLE IF EXISTS message_queue;
DROP TABLE IF EXISTS sessions;
DROP TABLE IF EXISTS server_links;
DROP TABLE IF EXISTS messages;
DROP TABLE IF EXISTS channel_members;
DROP TABLE IF EXISTS auth_tokens;
DROP TABLE IF EXISTS channels;
DROP TABLE IF EXISTS users;
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nick TEXT NOT NULL UNIQUE,
token TEXT NOT NULL UNIQUE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE channels (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL UNIQUE,
topic TEXT NOT NULL DEFAULT '',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE channel_members (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id INTEGER NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE(channel_id, user_id)
);
CREATE TABLE messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id INTEGER REFERENCES channels(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
content TEXT NOT NULL,
is_dm INTEGER NOT NULL DEFAULT 0,
dm_target_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX idx_messages_channel ON messages(channel_id, created_at);
CREATE INDEX idx_messages_dm ON messages(user_id, dm_target_id, created_at);
CREATE INDEX idx_users_token ON users(token);
PRAGMA foreign_keys = ON;

1505
internal/handlers/api.go
View File

File diff suppressed because it is too large Load Diff

1498
internal/handlers/api_test.go
View File

File diff suppressed because it is too large Load Diff

60
internal/handlers/handlers.go
View File

@@ -4,11 +4,9 @@ package handlers
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors"
"log/slog" "log/slog"
"net/http" "net/http"
"git.eeqj.de/sneak/chat/internal/broker"
"git.eeqj.de/sneak/chat/internal/config" "git.eeqj.de/sneak/chat/internal/config"
"git.eeqj.de/sneak/chat/internal/db" "git.eeqj.de/sneak/chat/internal/db"
"git.eeqj.de/sneak/chat/internal/globals" "git.eeqj.de/sneak/chat/internal/globals"
@@ -17,8 +15,6 @@ import (
"go.uber.org/fx" "go.uber.org/fx"
) )
var errUnauthorized = errors.New("unauthorized")
// Params defines the dependencies for creating Handlers. // Params defines the dependencies for creating Handlers.
type Params struct { type Params struct {
fx.In fx.In
@@ -35,64 +31,32 @@ type Handlers struct {
params *Params params *Params
log *slog.Logger log *slog.Logger
hc *healthcheck.Healthcheck hc *healthcheck.Healthcheck
broker *broker.Broker
} }
// New creates a new Handlers instance. // New creates a new Handlers instance.
func New( func New(lc fx.Lifecycle, params Params) (*Handlers, error) {
lifecycle fx.Lifecycle, s := new(Handlers)
params Params, s.params = &params
) (*Handlers, error) { s.log = params.Logger.Get()
hdlr := &Handlers{ s.hc = params.Healthcheck
params: &params,
log: params.Logger.Get(),
hc: params.Healthcheck,
broker: broker.New(),
}
lifecycle.Append(fx.Hook{ lc.Append(fx.Hook{
OnStart: func(_ context.Context) error { OnStart: func(_ context.Context) error {
return nil return nil
}, },
OnStop: func(_ context.Context) error {
return nil
},
}) })
return hdlr, nil return s, nil
} }
func (hdlr *Handlers) respondJSON( func (s *Handlers) respondJSON(w http.ResponseWriter, _ *http.Request, data any, status int) {
writer http.ResponseWriter, w.WriteHeader(status)
_ *http.Request, w.Header().Set("Content-Type", "application/json")
data any,
status int,
) {
writer.Header().Set(
"Content-Type",
"application/json; charset=utf-8",
)
writer.WriteHeader(status)
if data != nil { if data != nil {
err := json.NewEncoder(writer).Encode(data) err := json.NewEncoder(w).Encode(data)
if err != nil { if err != nil {
hdlr.log.Error( s.log.Error("json encode error", "error", err)
"json encode error", "error", err,
)
} }
} }
} }
func (hdlr *Handlers) respondError(
writer http.ResponseWriter,
request *http.Request,
msg string,
status int,
) {
hdlr.respondJSON(
writer, request,
map[string]string{"error": msg},
status,
)
}

11
internal/handlers/healthcheck.go
View File

@@ -7,12 +7,9 @@ import (
const httpStatusOK = 200 const httpStatusOK = 200
// HandleHealthCheck returns an HTTP handler for the health check endpoint. // HandleHealthCheck returns an HTTP handler for the health check endpoint.
func (hdlr *Handlers) HandleHealthCheck() http.HandlerFunc { func (s *Handlers) HandleHealthCheck() http.HandlerFunc {
return func( return func(w http.ResponseWriter, req *http.Request) {
writer http.ResponseWriter, resp := s.hc.Healthcheck()
request *http.Request, s.respondJSON(w, req, resp, httpStatusOK)
) {
resp := hdlr.hc.Healthcheck()
hdlr.respondJSON(writer, request, resp, httpStatusOK)
} }
} }

38
internal/healthcheck/healthcheck.go
View File

@@ -33,17 +33,14 @@ type Healthcheck struct {
} }
// New creates a new Healthcheck instance. // New creates a new Healthcheck instance.
func New( func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
lifecycle fx.Lifecycle, params Params, s := new(Healthcheck)
) (*Healthcheck, error) { s.params = &params
hcheck := &Healthcheck{ //nolint:exhaustruct // StartupTime set in OnStart s.log = params.Logger.Get()
params: &params,
log: params.Logger.Get(),
}
lifecycle.Append(fx.Hook{ lc.Append(fx.Hook{
OnStart: func(_ context.Context) error { OnStart: func(_ context.Context) error {
hcheck.StartupTime = time.Now() s.StartupTime = time.Now()
return nil return nil
}, },
@@ -52,7 +49,7 @@ func New(
}, },
}) })
return hcheck, nil return s, nil
} }
// Response is the JSON response returned by the health endpoint. // Response is the JSON response returned by the health endpoint.
@@ -67,18 +64,19 @@ type Response struct {
} }
// Healthcheck returns the current health status of the server. // Healthcheck returns the current health status of the server.
func (hcheck *Healthcheck) Healthcheck() *Response { func (s *Healthcheck) Healthcheck() *Response {
return &Response{ resp := &Response{
Status: "ok", Status: "ok",
Now: time.Now().UTC().Format(time.RFC3339Nano), Now: time.Now().UTC().Format(time.RFC3339Nano),
UptimeSeconds: int64(hcheck.uptime().Seconds()), UptimeSeconds: int64(s.uptime().Seconds()),
UptimeHuman: hcheck.uptime().String(), UptimeHuman: s.uptime().String(),
Appname: hcheck.params.Globals.Appname, Appname: s.params.Globals.Appname,
Version: hcheck.params.Globals.Version, Version: s.params.Globals.Version,
Maintenance: hcheck.params.Config.MaintenanceMode,
}
} }
func (hcheck *Healthcheck) uptime() time.Duration { return resp
return time.Since(hcheck.StartupTime) }
func (s *Healthcheck) uptime() time.Duration {
return time.Since(s.StartupTime)
} }

55
internal/logger/logger.go
View File

@@ -23,56 +23,51 @@ type Logger struct {
params Params params Params
} }
// New creates a new Logger with appropriate handler // New creates a new Logger with appropriate handler based on terminal detection.
// based on terminal detection. func New(_ fx.Lifecycle, params Params) (*Logger, error) {
func New( l := new(Logger)
_ fx.Lifecycle, params Params, l.level = new(slog.LevelVar)
) (*Logger, error) { l.level.Set(slog.LevelInfo)
logger := new(Logger)
logger.level = new(slog.LevelVar)
logger.level.Set(slog.LevelInfo)
tty := false tty := false
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 { if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
tty = true tty = true
} }
opts := &slog.HandlerOptions{ //nolint:exhaustruct // ReplaceAttr optional
Level: logger.level,
AddSource: true,
}
var handler slog.Handler var handler slog.Handler
if tty { if tty {
handler = slog.NewTextHandler(os.Stdout, opts) handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
Level: l.level,
AddSource: true,
})
} else { } else {
handler = slog.NewJSONHandler(os.Stdout, opts) handler = slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
Level: l.level,
AddSource: true,
})
} }
logger.log = slog.New(handler) l.log = slog.New(handler)
logger.params = params l.params = params
return logger, nil return l, nil
} }
// EnableDebugLogging switches the log level to debug. // EnableDebugLogging switches the log level to debug.
func (logger *Logger) EnableDebugLogging() { func (l *Logger) EnableDebugLogging() {
logger.level.Set(slog.LevelDebug) l.level.Set(slog.LevelDebug)
logger.log.Debug( l.log.Debug("debug logging enabled", "debug", true)
"debug logging enabled", "debug", true,
)
} }
// Get returns the underlying slog.Logger. // Get returns the underlying slog.Logger.
func (logger *Logger) Get() *slog.Logger { func (l *Logger) Get() *slog.Logger {
return logger.log return l.log
} }
// Identify logs the application name and version at startup. // Identify logs the application name and version at startup.
func (logger *Logger) Identify() { func (l *Logger) Identify() {
logger.log.Info("starting", l.log.Info("starting",
"appname", logger.params.Globals.Appname, "appname", l.params.Globals.Appname,
"version", logger.params.Globals.Version, "version", l.params.Globals.Version,
) )
} }

113
internal/middleware/middleware.go
View File

@@ -11,7 +11,7 @@ import (
"git.eeqj.de/sneak/chat/internal/globals" "git.eeqj.de/sneak/chat/internal/globals"
"git.eeqj.de/sneak/chat/internal/logger" "git.eeqj.de/sneak/chat/internal/logger"
basicauth "github.com/99designs/basicauth-go" basicauth "github.com/99designs/basicauth-go"
chimw "github.com/go-chi/chi/middleware" "github.com/go-chi/chi/middleware"
"github.com/go-chi/cors" "github.com/go-chi/cors"
metrics "github.com/slok/go-http-metrics/metrics/prometheus" metrics "github.com/slok/go-http-metrics/metrics/prometheus"
ghmm "github.com/slok/go-http-metrics/middleware" ghmm "github.com/slok/go-http-metrics/middleware"
@@ -38,28 +38,25 @@ type Middleware struct {
} }
// New creates a new Middleware instance. // New creates a new Middleware instance.
func New( func New(_ fx.Lifecycle, params Params) (*Middleware, error) {
_ fx.Lifecycle, params Params, s := new(Middleware)
) (*Middleware, error) { s.params = &params
mware := &Middleware{ s.log = params.Logger.Get()
params: &params,
log: params.Logger.Get(), return s, nil
} }
return mware, nil func ipFromHostPort(hp string) string {
} h, _, err := net.SplitHostPort(hp)
func ipFromHostPort(hostPort string) string {
host, _, err := net.SplitHostPort(hostPort)
if err != nil { if err != nil {
return "" return ""
} }
if len(host) > 0 && host[0] == '[' { if len(h) > 0 && h[0] == '[' {
return host[1 : len(host)-1] return h[1 : len(h)-1]
} }
return host return h
} }
type loggingResponseWriter struct { type loggingResponseWriter struct {
@@ -68,15 +65,9 @@ type loggingResponseWriter struct {
statusCode int statusCode int
} }
// newLoggingResponseWriter wraps a ResponseWriter // newLoggingResponseWriter wraps a ResponseWriter to capture the status code.
// to capture the status code. func newLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
func newLoggingResponseWriter( return &loggingResponseWriter{w, http.StatusOK}
writer http.ResponseWriter,
) *loggingResponseWriter {
return &loggingResponseWriter{
ResponseWriter: writer,
statusCode: http.StatusOK,
}
} }
func (lrw *loggingResponseWriter) WriteHeader(code int) { func (lrw *loggingResponseWriter) WriteHeader(code int) {
@@ -85,57 +76,43 @@ func (lrw *loggingResponseWriter) WriteHeader(code int) {
} }
// Logging returns middleware that logs each HTTP request. // Logging returns middleware that logs each HTTP request.
func (mware *Middleware) Logging() func(http.Handler) http.Handler { func (s *Middleware) Logging() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler { return func(next http.Handler) http.Handler {
return http.HandlerFunc( return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
func(
writer http.ResponseWriter,
request *http.Request,
) {
start := time.Now() start := time.Now()
lrw := newLoggingResponseWriter(writer) lrw := newLoggingResponseWriter(w)
ctx := request.Context() ctx := r.Context()
defer func() { defer func() {
latency := time.Since(start) latency := time.Since(start)
reqID, _ := ctx.Value( reqID, _ := ctx.Value(middleware.RequestIDKey).(string)
chimw.RequestIDKey,
).(string)
mware.log.InfoContext( s.log.InfoContext(ctx, "request",
ctx, "request",
"request_start", start, "request_start", start,
"method", request.Method, "method", r.Method,
"url", request.URL.String(), "url", r.URL.String(),
"useragent", request.UserAgent(), "useragent", r.UserAgent(),
"request_id", reqID, "request_id", reqID,
"referer", request.Referer(), "referer", r.Referer(),
"proto", request.Proto, "proto", r.Proto,
"remoteIP", "remoteIP", ipFromHostPort(r.RemoteAddr),
ipFromHostPort(request.RemoteAddr),
"status", lrw.statusCode, "status", lrw.statusCode,
"latency_ms", "latency_ms", latency.Milliseconds(),
latency.Milliseconds(),
) )
}() }()
next.ServeHTTP(lrw, request) next.ServeHTTP(lrw, r)
}) })
} }
} }
// CORS returns middleware that handles Cross-Origin Resource Sharing. // CORS returns middleware that handles Cross-Origin Resource Sharing.
func (mware *Middleware) CORS() func(http.Handler) http.Handler { func (s *Middleware) CORS() func(http.Handler) http.Handler {
return cors.Handler(cors.Options{ //nolint:exhaustruct // optional fields return cors.Handler(cors.Options{
AllowedOrigins: []string{"*"}, AllowedOrigins: []string{"*"},
AllowedMethods: []string{ AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
"GET", "POST", "PUT", "DELETE", "OPTIONS", AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
},
AllowedHeaders: []string{
"Accept", "Authorization",
"Content-Type", "X-CSRF-Token",
},
ExposedHeaders: []string{"Link"}, ExposedHeaders: []string{"Link"},
AllowCredentials: false, AllowCredentials: false,
MaxAge: corsMaxAge, MaxAge: corsMaxAge,
@@ -143,34 +120,28 @@ func (mware *Middleware) CORS() func(http.Handler) http.Handler {
} }
// Auth returns middleware that performs authentication. // Auth returns middleware that performs authentication.
func (mware *Middleware) Auth() func(http.Handler) http.Handler { func (s *Middleware) Auth() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler { return func(next http.Handler) http.Handler {
return http.HandlerFunc( return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
func( s.log.Info("AUTH: before request")
writer http.ResponseWriter, next.ServeHTTP(w, r)
request *http.Request,
) {
mware.log.Info("AUTH: before request")
next.ServeHTTP(writer, request)
}) })
} }
} }
// Metrics returns middleware that records HTTP metrics. // Metrics returns middleware that records HTTP metrics.
func (mware *Middleware) Metrics() func(http.Handler) http.Handler { func (s *Middleware) Metrics() func(http.Handler) http.Handler {
metricsMiddleware := ghmm.New(ghmm.Config{ //nolint:exhaustruct // optional fields mdlw := ghmm.New(ghmm.Config{
Recorder: metrics.NewRecorder( Recorder: metrics.NewRecorder(metrics.Config{}),
metrics.Config{}, //nolint:exhaustruct // defaults
),
}) })
return func(next http.Handler) http.Handler { return func(next http.Handler) http.Handler {
return std.Handler("", metricsMiddleware, next) return std.Handler("", mdlw, next)
} }
} }
// MetricsAuth returns middleware that protects metrics with basic auth. // MetricsAuth returns middleware that protects metrics with basic auth.
func (mware *Middleware) MetricsAuth() func(http.Handler) http.Handler { func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
return basicauth.New( return basicauth.New(
"metrics", "metrics",
map[string][]string{ map[string][]string{

26
internal/models/auth_token.go Normal file
View File

@@ -0,0 +1,26 @@
package models
import (
"context"
"time"
)
// AuthToken represents an authentication token for a user session.
type AuthToken struct {
Base
Token string `json:"-"`
UserID string `json:"userId"`
CreatedAt time.Time `json:"createdAt"`
ExpiresAt *time.Time `json:"expiresAt,omitempty"`
LastUsedAt *time.Time `json:"lastUsedAt,omitempty"`
}
// User returns the user who owns this token.
func (t *AuthToken) User(ctx context.Context) (*User, error) {
if ul := t.GetUserLookup(); ul != nil {
return ul.GetUserByID(ctx, t.UserID)
}
return nil, ErrUserLookupNotAvailable
}

96
internal/models/channel.go Normal file
View File

@@ -0,0 +1,96 @@
package models
import (
"context"
"time"
)
// Channel represents a chat channel.
type Channel struct {
Base
ID string `json:"id"`
Name string `json:"name"`
Topic string `json:"topic"`
Modes string `json:"modes"`
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
}
// Members returns all users who are members of this channel.
func (c *Channel) Members(ctx context.Context) ([]*ChannelMember, error) {
rows, err := c.GetDB().QueryContext(ctx, `
SELECT cm.channel_id, cm.user_id, cm.modes, cm.joined_at,
u.nick
FROM channel_members cm
JOIN users u ON u.id = cm.user_id
WHERE cm.channel_id = ?
ORDER BY cm.joined_at`,
c.ID,
)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
members := []*ChannelMember{}
for rows.Next() {
m := &ChannelMember{}
m.SetDB(c.db)
err = rows.Scan(
&m.ChannelID, &m.UserID, &m.Modes,
&m.JoinedAt, &m.Nick,
)
if err != nil {
return nil, err
}
members = append(members, m)
}
return members, rows.Err()
}
// RecentMessages returns the most recent messages in this channel.
func (c *Channel) RecentMessages(
ctx context.Context,
limit int,
) ([]*Message, error) {
rows, err := c.GetDB().QueryContext(ctx, `
SELECT id, ts, from_user_id, from_nick,
target, type, body, meta, created_at
FROM messages
WHERE target = ?
ORDER BY ts DESC
LIMIT ?`,
c.Name, limit,
)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
messages := []*Message{}
for rows.Next() {
msg := &Message{}
msg.SetDB(c.db)
err = rows.Scan(
&msg.ID, &msg.Timestamp, &msg.FromUserID,
&msg.FromNick, &msg.Target, &msg.Type,
&msg.Body, &msg.Meta, &msg.CreatedAt,
)
if err != nil {
return nil, err
}
messages = append(messages, msg)
}
return messages, rows.Err()
}

35
internal/models/channel_member.go Normal file
View File

@@ -0,0 +1,35 @@
package models
import (
"context"
"time"
)
// ChannelMember represents a user's membership in a channel.
type ChannelMember struct {
Base
ChannelID string `json:"channelId"`
UserID string `json:"userId"`
Modes string `json:"modes"`
JoinedAt time.Time `json:"joinedAt"`
Nick string `json:"nick"` // denormalized from users table
}
// User returns the full User for this membership.
func (cm *ChannelMember) User(ctx context.Context) (*User, error) {
if ul := cm.GetUserLookup(); ul != nil {
return ul.GetUserByID(ctx, cm.UserID)
}
return nil, ErrUserLookupNotAvailable
}
// Channel returns the full Channel for this membership.
func (cm *ChannelMember) Channel(ctx context.Context) (*Channel, error) {
if cl := cm.GetChannelLookup(); cl != nil {
return cl.GetChannelByID(ctx, cm.ChannelID)
}
return nil, ErrChannelLookupNotAvailable
}

20
internal/models/message.go Normal file
View File

@@ -0,0 +1,20 @@
package models
import (
"time"
)
// Message represents a chat message (channel or DM).
type Message struct {
Base
ID string `json:"id"`
Timestamp time.Time `json:"ts"`
FromUserID string `json:"fromUserId"`
FromNick string `json:"from"`
Target string `json:"to"`
Type string `json:"type"`
Body string `json:"body"`
Meta string `json:"meta"`
CreatedAt time.Time `json:"createdAt"`
}

15
internal/models/message_queue.go Normal file
View File

@@ -0,0 +1,15 @@
package models
import (
"time"
)
// MessageQueueEntry represents a pending message delivery for a user.
type MessageQueueEntry struct {
Base
ID int64 `json:"id"`
UserID string `json:"userId"`
MessageID string `json:"messageId"`
QueuedAt time.Time `json:"queuedAt"`
}

65
internal/models/model.go Normal file
View File

@@ -0,0 +1,65 @@
// Package models defines the data models used by the chat application.
// All model structs embed Base, which provides database access for
// relation-fetching methods directly on model instances.
package models
import (
"context"
"database/sql"
"errors"
)
// DB is the interface that models use to query the database.
// This avoids a circular import with the db package.
type DB interface {
GetDB() *sql.DB
}
// UserLookup provides user lookup by ID without circular imports.
type UserLookup interface {
GetUserByID(ctx context.Context, id string) (*User, error)
}
// ChannelLookup provides channel lookup by ID without circular imports.
type ChannelLookup interface {
GetChannelByID(ctx context.Context, id string) (*Channel, error)
}
// Sentinel errors for model lookup methods.
var (
ErrUserLookupNotAvailable = errors.New("user lookup not available")
ErrChannelLookupNotAvailable = errors.New("channel lookup not available")
)
// Base is embedded in all model structs to provide database access.
type Base struct {
db DB
}
// SetDB injects the database reference into a model.
func (b *Base) SetDB(d DB) {
b.db = d
}
// GetDB returns the database interface for use in model methods.
func (b *Base) GetDB() *sql.DB {
return b.db.GetDB()
}
// GetUserLookup returns the DB as a UserLookup if it implements the interface.
func (b *Base) GetUserLookup() UserLookup { //nolint:ireturn,nolintlint // returns interface by design
if ul, ok := b.db.(UserLookup); ok {
return ul
}
return nil
}
// GetChannelLookup returns the DB as a ChannelLookup if it implements the interface.
func (b *Base) GetChannelLookup() ChannelLookup { //nolint:ireturn,nolintlint // returns interface by design
if cl, ok := b.db.(ChannelLookup); ok {
return cl
}
return nil
}

18
internal/models/server_link.go Normal file
View File

@@ -0,0 +1,18 @@
package models
import (
"time"
)
// ServerLink represents a federation peer server configuration.
type ServerLink struct {
Base
ID string `json:"id"`
Name string `json:"name"`
URL string `json:"url"`
SharedKeyHash string `json:"-"`
IsActive bool `json:"isActive"`
CreatedAt time.Time `json:"createdAt"`
LastSeenAt *time.Time `json:"lastSeenAt,omitempty"`
}

26
internal/models/session.go Normal file
View File

@@ -0,0 +1,26 @@
package models
import (
"context"
"time"
)
// Session represents a server-held user session.
type Session struct {
Base
ID string `json:"id"`
UserID string `json:"userId"`
CreatedAt time.Time `json:"createdAt"`
LastActiveAt time.Time `json:"lastActiveAt"`
ExpiresAt *time.Time `json:"expiresAt,omitempty"`
}
// User returns the user who owns this session.
func (s *Session) User(ctx context.Context) (*User, error) {
if ul := s.GetUserLookup(); ul != nil {
return ul.GetUserByID(ctx, s.UserID)
}
return nil, ErrUserLookupNotAvailable
}

92
internal/models/user.go Normal file
View File

@@ -0,0 +1,92 @@
package models
import (
"context"
"time"
)
// User represents a registered user account.
type User struct {
Base
ID string `json:"id"`
Nick string `json:"nick"`
PasswordHash string `json:"-"`
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
LastSeenAt *time.Time `json:"lastSeenAt,omitempty"`
}
// Channels returns all channels the user is a member of.
func (u *User) Channels(ctx context.Context) ([]*Channel, error) {
rows, err := u.GetDB().QueryContext(ctx, `
SELECT c.id, c.name, c.topic, c.modes, c.created_at, c.updated_at
FROM channels c
JOIN channel_members cm ON cm.channel_id = c.id
WHERE cm.user_id = ?
ORDER BY c.name`,
u.ID,
)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
channels := []*Channel{}
for rows.Next() {
c := &Channel{}
c.SetDB(u.db)
err = rows.Scan(
&c.ID, &c.Name, &c.Topic, &c.Modes,
&c.CreatedAt, &c.UpdatedAt,
)
if err != nil {
return nil, err
}
channels = append(channels, c)
}
return channels, rows.Err()
}
// QueuedMessages returns undelivered messages for this user.
func (u *User) QueuedMessages(ctx context.Context) ([]*Message, error) {
rows, err := u.GetDB().QueryContext(ctx, `
SELECT m.id, m.ts, m.from_user_id, m.from_nick,
m.target, m.type, m.body, m.meta, m.created_at
FROM messages m
JOIN message_queue mq ON mq.message_id = m.id
WHERE mq.user_id = ?
ORDER BY mq.queued_at ASC`,
u.ID,
)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
messages := []*Message{}
for rows.Next() {
msg := &Message{}
msg.SetDB(u.db)
err = rows.Scan(
&msg.ID, &msg.Timestamp, &msg.FromUserID,
&msg.FromNick, &msg.Target, &msg.Type,
&msg.Body, &msg.Meta, &msg.CreatedAt,
)
if err != nil {
return nil, err
}
messages = append(messages, msg)
}
return messages, rows.Err()
}

2
internal/server/http.go
View File

@@ -4,6 +4,6 @@ import "time"
const ( const (
httpReadTimeout = 10 * time.Second httpReadTimeout = 10 * time.Second
httpWriteTimeout = 60 * time.Second httpWriteTimeout = 10 * time.Second
maxHeaderBytes = 1 << 20 maxHeaderBytes = 1 << 20
) )

160
internal/server/routes.go
View File

@@ -16,138 +16,92 @@ import (
const routeTimeout = 60 * time.Second const routeTimeout = 60 * time.Second
// SetupRoutes configures the HTTP routes and middleware. // SetupRoutes configures the HTTP routes and middleware chain.
func (srv *Server) SetupRoutes() { func (s *Server) SetupRoutes() {
srv.router = chi.NewRouter() s.router = chi.NewRouter()
srv.router.Use(middleware.Recoverer) s.router.Use(middleware.Recoverer)
srv.router.Use(middleware.RequestID) s.router.Use(middleware.RequestID)
srv.router.Use(srv.mw.Logging()) s.router.Use(s.mw.Logging())
if viper.GetString("METRICS_USERNAME") != "" { if viper.GetString("METRICS_USERNAME") != "" {
srv.router.Use(srv.mw.Metrics()) s.router.Use(s.mw.Metrics())
} }
srv.router.Use(srv.mw.CORS()) s.router.Use(s.mw.CORS())
srv.router.Use(middleware.Timeout(routeTimeout)) s.router.Use(middleware.Timeout(routeTimeout))
if srv.sentryEnabled { if s.sentryEnabled {
sentryHandler := sentryhttp.New( sentryHandler := sentryhttp.New(sentryhttp.Options{
sentryhttp.Options{ //nolint:exhaustruct // optional fields
Repanic: true, Repanic: true,
}, })
) s.router.Use(sentryHandler.Handle)
srv.router.Use(sentryHandler.Handle)
} }
// Health check. // Health check
srv.router.Get( s.router.Get("/.well-known/healthcheck.json", s.h.HandleHealthCheck())
"/.well-known/healthcheck.json",
srv.handlers.HandleHealthCheck(),
)
// Protected metrics endpoint. // Protected metrics endpoint
if viper.GetString("METRICS_USERNAME") != "" { if viper.GetString("METRICS_USERNAME") != "" {
srv.router.Group(func(router chi.Router) { s.router.Group(func(r chi.Router) {
router.Use(srv.mw.MetricsAuth()) r.Use(s.mw.MetricsAuth())
router.Get("/metrics", r.Get("/metrics", http.HandlerFunc(promhttp.Handler().ServeHTTP))
http.HandlerFunc(
promhttp.Handler().ServeHTTP,
))
}) })
} }
// API v1. // API v1
srv.router.Route( s.router.Route("/api/v1", func(r chi.Router) {
"/api/v1", r.Get("/server", s.h.HandleServerInfo())
func(router chi.Router) { r.Post("/session", s.h.HandleCreateSession())
router.Get(
"/server",
srv.handlers.HandleServerInfo(),
)
router.Post(
"/session",
srv.handlers.HandleCreateSession(),
)
router.Get(
"/state",
srv.handlers.HandleState(),
)
router.Get(
"/messages",
srv.handlers.HandleGetMessages(),
)
router.Post(
"/messages",
srv.handlers.HandleSendCommand(),
)
router.Get(
"/history",
srv.handlers.HandleGetHistory(),
)
router.Get(
"/channels",
srv.handlers.HandleListAllChannels(),
)
router.Get(
"/channels/{channel}/members",
srv.handlers.HandleChannelMembers(),
)
},
)
// Serve embedded SPA. // Unified state and message endpoints
srv.setupSPA() r.Get("/state", s.h.HandleState())
} r.Get("/messages", s.h.HandleGetMessages())
r.Post("/messages", s.h.HandleSendCommand())
r.Get("/history", s.h.HandleGetHistory())
func (srv *Server) setupSPA() { // Channels
r.Get("/channels", s.h.HandleListAllChannels())
r.Get("/channels/{channel}/members", s.h.HandleChannelMembers())
})
// Serve embedded SPA
distFS, err := fs.Sub(web.Dist, "dist") distFS, err := fs.Sub(web.Dist, "dist")
if err != nil { if err != nil {
srv.log.Error( s.log.Error("failed to get web dist filesystem", "error", err)
"failed to get web dist filesystem", } else {
"error", err,
)
return
}
fileServer := http.FileServer(http.FS(distFS)) fileServer := http.FileServer(http.FS(distFS))
srv.router.Get("/*", func( s.router.Get("/*", func(w http.ResponseWriter, r *http.Request) {
writer http.ResponseWriter, s.serveSPA(distFS, fileServer, w, r)
request *http.Request, })
}
}
func (s *Server) serveSPA(
distFS fs.FS,
fileServer http.Handler,
w http.ResponseWriter,
r *http.Request,
) { ) {
readFS, ok := distFS.(fs.ReadFileFS) readFS, ok := distFS.(fs.ReadFileFS)
if !ok { if !ok {
fileServer.ServeHTTP(writer, request) http.Error(w, "filesystem error", http.StatusInternalServerError)
return return
} }
fileData, readErr := readFS.ReadFile( // Try to serve the file; fall back to index.html for SPA routing.
request.URL.Path[1:], f, err := readFS.ReadFile(r.URL.Path[1:])
) if err != nil || len(f) == 0 {
if readErr != nil || len(fileData) == 0 { indexHTML, _ := readFS.ReadFile("index.html")
indexHTML, indexErr := readFS.ReadFile(
"index.html", w.Header().Set("Content-Type", "text/html; charset=utf-8")
) w.WriteHeader(http.StatusOK)
if indexErr != nil { _, _ = w.Write(indexHTML)
http.NotFound(writer, request)
return return
} }
writer.Header().Set( fileServer.ServeHTTP(w, r)
"Content-Type",
"text/html; charset=utf-8",
)
writer.WriteHeader(http.StatusOK)
_, _ = writer.Write(indexHTML)
return
}
fileServer.ServeHTTP(writer, request)
})
} }

148
internal/server/server.go
View File

@@ -41,8 +41,7 @@ type Params struct {
Handlers *handlers.Handlers Handlers *handlers.Handlers
} }
// Server is the main HTTP server. // Server is the main HTTP server. It manages routing, middleware, and lifecycle.
// It manages routing, middleware, and lifecycle.
type Server struct { type Server struct {
startupTime time.Time startupTime time.Time
exitCode int exitCode int
@@ -54,24 +53,21 @@ type Server struct {
router *chi.Mux router *chi.Mux
params Params params Params
mw *middleware.Middleware mw *middleware.Middleware
handlers *handlers.Handlers h *handlers.Handlers
} }
// New creates a new Server and registers its lifecycle hooks. // New creates a new Server and registers its lifecycle hooks.
func New( func New(lc fx.Lifecycle, params Params) (*Server, error) {
lifecycle fx.Lifecycle, params Params, s := new(Server)
) (*Server, error) { s.params = params
srv := &Server{ //nolint:exhaustruct // fields set during lifecycle s.mw = params.Middleware
params: params, s.h = params.Handlers
mw: params.Middleware, s.log = params.Logger.Get()
handlers: params.Handlers,
log: params.Logger.Get(),
}
lifecycle.Append(fx.Hook{ lc.Append(fx.Hook{
OnStart: func(_ context.Context) error { OnStart: func(_ context.Context) error {
srv.startupTime = time.Now() s.startupTime = time.Now()
go srv.Run() //nolint:contextcheck go s.Run() //nolint:contextcheck
return nil return nil
}, },
@@ -80,140 +76,120 @@ func New(
}, },
}) })
return srv, nil return s, nil
} }
// Run starts the server configuration, Sentry, and begins serving. // Run starts the server configuration, Sentry, and begins serving.
func (srv *Server) Run() { func (s *Server) Run() {
srv.configure() s.configure()
srv.enableSentry() s.enableSentry()
srv.serve() s.serve()
} }
// ServeHTTP delegates to the chi router. // ServeHTTP delegates to the chi router.
func (srv *Server) ServeHTTP( func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
writer http.ResponseWriter, s.router.ServeHTTP(w, r)
request *http.Request,
) {
srv.router.ServeHTTP(writer, request)
} }
// MaintenanceMode reports whether the server is in maintenance mode. // MaintenanceMode reports whether the server is in maintenance mode.
func (srv *Server) MaintenanceMode() bool { func (s *Server) MaintenanceMode() bool {
return srv.params.Config.MaintenanceMode return s.params.Config.MaintenanceMode
} }
func (srv *Server) enableSentry() { func (s *Server) enableSentry() {
srv.sentryEnabled = false s.sentryEnabled = false
if srv.params.Config.SentryDSN == "" { if s.params.Config.SentryDSN == "" {
return return
} }
err := sentry.Init(sentry.ClientOptions{ //nolint:exhaustruct // only essential fields err := sentry.Init(sentry.ClientOptions{
Dsn: srv.params.Config.SentryDSN, Dsn: s.params.Config.SentryDSN,
Release: fmt.Sprintf( Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.Globals.Version),
"%s-%s",
srv.params.Globals.Appname,
srv.params.Globals.Version,
),
}) })
if err != nil { if err != nil {
srv.log.Error("sentry init failure", "error", err) s.log.Error("sentry init failure", "error", err)
os.Exit(1) os.Exit(1)
} }
srv.log.Info("sentry error reporting activated") s.log.Info("sentry error reporting activated")
srv.sentryEnabled = true s.sentryEnabled = true
} }
func (srv *Server) serve() int { func (s *Server) serve() int {
srv.ctx, srv.cancelFunc = context.WithCancel( s.ctx, s.cancelFunc = context.WithCancel(context.Background())
context.Background(),
)
go func() { go func() {
sigCh := make(chan os.Signal, 1) c := make(chan os.Signal, 1)
signal.Ignore(syscall.SIGPIPE) signal.Ignore(syscall.SIGPIPE)
signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM) signal.Notify(c, os.Interrupt, syscall.SIGTERM)
sig := <-c
s.log.Info("signal received", "signal", sig)
sig := <-sigCh if s.cancelFunc != nil {
s.cancelFunc()
srv.log.Info("signal received", "signal", sig)
if srv.cancelFunc != nil {
srv.cancelFunc()
} }
}() }()
go srv.serveUntilShutdown() go s.serveUntilShutdown()
<-srv.ctx.Done() <-s.ctx.Done()
srv.cleanShutdown() s.cleanShutdown()
return srv.exitCode return s.exitCode
} }
func (srv *Server) cleanupForExit() { func (s *Server) cleanupForExit() {
srv.log.Info("cleaning up") s.log.Info("cleaning up")
} }
func (srv *Server) cleanShutdown() { func (s *Server) cleanShutdown() {
srv.exitCode = 0 s.exitCode = 0
ctxShutdown, shutdownCancel := context.WithTimeout( ctxShutdown, shutdownCancel := context.WithTimeout(context.Background(), shutdownTimeout)
context.Background(), shutdownTimeout,
)
err := srv.httpServer.Shutdown(ctxShutdown) err := s.httpServer.Shutdown(ctxShutdown)
if err != nil { if err != nil {
srv.log.Error( s.log.Error("server clean shutdown failed", "error", err)
"server clean shutdown failed", "error", err,
)
} }
if shutdownCancel != nil { if shutdownCancel != nil {
shutdownCancel() shutdownCancel()
} }
srv.cleanupForExit() s.cleanupForExit()
if srv.sentryEnabled { if s.sentryEnabled {
sentry.Flush(sentryFlushTime) sentry.Flush(sentryFlushTime)
} }
} }
func (srv *Server) configure() { func (s *Server) configure() {
// Server configuration placeholder. // server configuration placeholder
} }
func (srv *Server) serveUntilShutdown() { func (s *Server) serveUntilShutdown() {
listenAddr := fmt.Sprintf( listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
":%d", srv.params.Config.Port, s.httpServer = &http.Server{
)
srv.httpServer = &http.Server{ //nolint:exhaustruct // optional fields
Addr: listenAddr, Addr: listenAddr,
ReadTimeout: httpReadTimeout, ReadTimeout: httpReadTimeout,
WriteTimeout: httpWriteTimeout, WriteTimeout: httpWriteTimeout,
MaxHeaderBytes: maxHeaderBytes, MaxHeaderBytes: maxHeaderBytes,
Handler: srv, Handler: s,
} }
srv.SetupRoutes() s.SetupRoutes()
srv.log.Info( s.log.Info("http begin listen", "listenaddr", listenAddr)
"http begin listen", "listenaddr", listenAddr,
)
err := srv.httpServer.ListenAndServe() err := s.httpServer.ListenAndServe()
if err != nil && !errors.Is(err, http.ErrServerClosed) { if err != nil && !errors.Is(err, http.ErrServerClosed) {
srv.log.Error("listen error", "error", err) s.log.Error("listen error", "error", err)
if srv.cancelFunc != nil { if s.cancelFunc != nil {
srv.cancelFunc() s.cancelFunc()
} }
} }
} }

465
web/dist/app.js vendored
View File

File diff suppressed because one or more lines are too long