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

MVP 1.0: IRC-over-HTTP chat server #10

Merged
sneak merged 18 commits from feature/mvp-1.0 into main 2026-02-27 07:21:35 +01:00
Conversation 21 Commits 18 Files Changed 39 +7264 -3658
39 changed files with 7264 additions and 3658 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
.dockerignore
View File

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

40
.golangci.yml
View File

@@ -7,24 +7,28 @@ run:
linters: linters:
default: all default: all
disable: disable:
# Genuinely incompatible with project patterns - wsl # Deprecated in v2, replaced by wsl_v5
- exhaustruct # Requires all struct fields settings:
- depguard # Dependency allow/block lists lll:
- godot # Requires comments to end with periods line-length: 88
- wsl # Deprecated, replaced by wsl_v5 funlen:
- wrapcheck # Too verbose for internal packages lines: 80
- varnamelen # Short names like db, id are idiomatic Go statements: 50
cyclop:
linters-settings: max-complexity: 15
lll: dupl:
line-length: 88 threshold: 100
funlen: gosec:
lines: 80 excludes:
statements: 50 - G704
cyclop: depguard:
max-complexity: 15 rules:
dupl: all:
threshold: 100 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

22
Dockerfile
View File

@@ -1,28 +1,32 @@
# 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
RUN go install github.com/golangci/golangci-lint/cmd/golangci-lint@v2.1.6
RUN make check RUN make check
# Build binaries
ARG VERSION=dev ARG VERSION=dev
RUN go build -ldflags "-X main.Version=${VERSION}" -o /chatd ./cmd/chatd RUN CGO_ENABLED=1 go build -trimpath -ldflags="-s -w -X main.Version=${VERSION}" -o /chatd ./cmd/chatd/
RUN CGO_ENABLED=1 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 \
RUN apk add --no-cache ca-certificates && addgroup -S chat && adduser -S chat -G chat
COPY --from=builder /chatd /usr/local/bin/chatd COPY --from=builder /chatd /usr/local/bin/chatd
WORKDIR /data USER chat
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"]

2293
README.md
View File

File diff suppressed because it is too large Load Diff

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

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

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

@@ -7,20 +7,18 @@ type SessionRequest struct {
Nick string `json:"nick"` Nick string `json:"nick"`
} }
// SessionResponse is the response from POST /api/v1/session. // SessionResponse is the response from session creation.
type SessionResponse struct { type SessionResponse struct {
SessionID string `json:"sessionId"` ID int64 `json:"id"`
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 {
SessionID string `json:"sessionId"` ID int64 `json:"id"`
ClientID string `json:"clientId"` Nick string `json:"nick"`
Nick string `json:"nick"` Channels []string `json:"channels"`
Channels []string `json:"channels"`
} }
// Message represents a chat message envelope. // Message represents a chat message envelope.
@@ -35,22 +33,21 @@ type Message struct {
Meta any `json:"meta,omitempty"` Meta any `json:"meta,omitempty"`
} }
// BodyLines returns the body as a slice of strings (for text // BodyLines returns the body as a string slice.
// messages).
func (m *Message) BodyLines() []string { func (m *Message) BodyLines() []string {
switch v := m.Body.(type) { switch bodyVal := m.Body.(type) {
case []any: case []any:
lines := make([]string, 0, len(v)) lines := make([]string, 0, len(bodyVal))
for _, item := range v { for _, item := range bodyVal {
if s, ok := item.(string); ok { if str, ok := item.(string); ok {
lines = append(lines, s) lines = append(lines, str)
} }
} }
return lines return lines
case []string: case []string:
return v return bodyVal
default: default:
return nil return nil
} }
@@ -74,6 +71,13 @@ 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.

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

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

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

@@ -31,85 +31,89 @@ 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{ ui := &UI{ //nolint:exhaustruct,varnamelen // fields set below; ui is idiomatic
app: tview.NewApplication(), app: tview.NewApplication(),
buffers: []*Buffer{ buffers: []*Buffer{
{Name: "(status)", Lines: nil}, {Name: "(status)", Lines: nil, Unread: 0},
}, },
} }
ui.setupMessages() ui.initMessages()
ui.setupStatusBar() ui.initStatusBar()
ui.setupInput() ui.initInput()
ui.setupKeybindings() ui.initKeyCapture()
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 {
return ui.app.Run() err := ui.app.Run()
if err != nil {
return fmt.Errorf("run ui: %w", err)
}
return nil
} }
// Stop stops the UI. // Stop stops the UI.
func (ui *UI) Stop() { func (ui *UI) Stop() {
ui.app.Stop() ui.app.Stop()
} }
// OnInput sets the callback for user input. // OnInput sets the callback for user input.
func (ui *UI) OnInput(fn func(string)) { func (ui *UI) OnInput(fn func(string)) {
ui.onInput = fn ui.onInput = fn
} }
// 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)
// Mark unread if not currently viewing this buffer. cur := ui.buffers[ui.currentBuffer]
if ui.buffers[ui.currentBuffer] != buf { if cur != buf {
buf.Unread++ buf.Unread++
ui.refreshStatus() ui.refreshStatusBar()
} }
// If viewing this buffer, append to display. if cur == buf {
if ui.buffers[ui.currentBuffer] == buf {
_, _ = fmt.Fprintln(ui.messages, line) _, _ = fmt.Fprintln(ui.messages, line)
} }
}) })
} }
// AddStatus adds a line to the status buffer (buffer 0). // AddStatus adds a line to the status buffer.
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)",
fmt.Sprintf("[gray]%s[white] %s", ts, line), "[gray]"+ts+"[white] "+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 n < 0 || n >= len(ui.buffers) { if bufIndex < 0 || bufIndex >= len(ui.buffers) {
return return
} }
ui.currentBuffer = n ui.currentBuffer = bufIndex
buf := ui.buffers[n] buf := ui.buffers[bufIndex]
buf.Unread = 0 buf.Unread = 0
ui.messages.Clear() ui.messages.Clear()
@@ -119,12 +123,12 @@ func (ui *UI) SwitchBuffer(n int) {
} }
ui.messages.ScrollToEnd() ui.messages.ScrollToEnd()
ui.refreshStatus() ui.refreshStatusBar()
}) })
} }
// SwitchToBuffer switches to the named buffer, creating it // SwitchToBuffer switches to named buffer, creating if
// 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)
@@ -146,28 +150,25 @@ func (ui *UI) SwitchToBuffer(name string) {
} }
ui.messages.ScrollToEnd() ui.messages.ScrollToEnd()
ui.refreshStatus() ui.refreshStatusBar()
}) })
} }
// SetStatus updates the status bar text. // SetStatus updates the status bar text.
func (ui *UI) SetStatus( func (ui *UI) SetStatus(
nick, target, connStatus string, nick, target, connStatus string,
) { ) {
ui.app.QueueUpdateDraw(func() { ui.app.QueueUpdateDraw(func() {
ui.refreshStatusWith(nick, target, connStatus) ui.renderStatusBar(nick, target, connStatus)
}) })
} }
// BufferCount returns the number of buffers. // BufferCount returns the number of buffers.
func (ui *UI) BufferCount() int { func (ui *UI) BufferCount() int {
return len(ui.buffers) return len(ui.buffers)
} }
// BufferIndex returns the index of a named buffer, or -1. // BufferIndex returns the index of a named buffer.
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 {
@@ -178,7 +179,7 @@ func (ui *UI) BufferIndex(name string) int {
return -1 return -1
} }
func (ui *UI) setupMessages() { func (ui *UI) initMessages() {
ui.messages = tview.NewTextView(). ui.messages = tview.NewTextView().
SetDynamicColors(true). SetDynamicColors(true).
SetScrollable(true). SetScrollable(true).
@@ -189,14 +190,14 @@ func (ui *UI) setupMessages() {
ui.messages.SetBorder(false) ui.messages.SetBorder(false)
} }
func (ui *UI) setupStatusBar() { func (ui *UI) initStatusBar() {
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) setupInput() { func (ui *UI) initInput() {
ui.input = tview.NewInputField(). ui.input = tview.NewInputField().
SetFieldBackgroundColor(tcell.ColorBlack). SetFieldBackgroundColor(tcell.ColorBlack).
SetFieldTextColor(tcell.ColorWhite) SetFieldTextColor(tcell.ColorWhite)
@@ -219,7 +220,7 @@ func (ui *UI) setupInput() {
}) })
} }
func (ui *UI) setupKeybindings() { func (ui *UI) initKeyCapture() {
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 {
@@ -239,34 +240,21 @@ func (ui *UI) setupKeybindings() {
) )
} }
func (ui *UI) setupLayout() { func (ui *UI) refreshStatusBar() {
ui.layout = tview.NewFlex(). // Placeholder; full refresh needs nick/target context.
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)
} }
// if needed. func (ui *UI) renderStatusBar(
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 = append(unreadParts,
unreadParts,
fmt.Sprintf( fmt.Sprintf(
"%d:%s(%d)", i, buf.Name, buf.Unread, "%d:%s(%d)",
i, buf.Name, buf.Unread,
), ),
) )
} }
@@ -286,8 +274,8 @@ func (ui *UI) refreshStatusWith(
ui.statusBar.Clear() ui.statusBar.Clear()
_, _ = fmt.Fprintf( _, _ = fmt.Fprintf(ui.statusBar,
ui.statusBar, " [%s] %s %s %s%s", " [%s] %s %s %s%s",
connStatus, nick, bufInfo, target, unread, connStatus, nick, bufInfo, target, unread,
) )
} }
@@ -299,7 +287,7 @@ func (ui *UI) getOrCreateBuffer(name string) *Buffer {
} }
} }
buf := &Buffer{Name: name} buf := &Buffer{Name: name, Lines: nil, Unread: 0}
ui.buffers = append(ui.buffers, buf) ui.buffers = append(ui.buffers, buf)
return buf return buf

73
internal/broker/broker.go Normal file
View File

@@ -0,0 +1,73 @@
// 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 Normal file
View File

@@ -0,0 +1,121 @@
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,7 +41,9 @@ 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(_ fx.Lifecycle, params Params) (*Config, error) { func New(
_ fx.Lifecycle, params Params,
) (*Config, error) {
log := params.Logger.Get() log := params.Logger.Get()
name := params.Globals.Appname name := params.Globals.Appname
@@ -74,7 +76,7 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
} }
} }
s := &Config{ cfg := &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"),
@@ -92,10 +94,10 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
params: &params, params: &params,
} }
if s.Debug { if cfg.Debug {
params.Logger.EnableDebugLogging() params.Logger.EnableDebugLogging()
s.log = params.Logger.Get() cfg.log = params.Logger.Get()
} }
return s, nil return cfg, nil
} }

750
internal/db/db.go
View File

@@ -11,20 +11,16 @@ 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" // loads .env file _ "github.com/joho/godotenv/autoload" // .env
_ "modernc.org/sqlite" // SQLite driver _ "modernc.org/sqlite" // driver
) )
const ( const minMigrationParts = 2
minMigrationParts = 2
)
// SchemaFiles contains embedded SQL migration files. // SchemaFiles contains embedded SQL migration files.
// //
@@ -39,527 +35,95 @@ type Params struct {
Config *config.Config Config *config.Config
} }
// Database manages the SQLite database connection and migrations. // Database manages the SQLite connection and migrations.
type Database struct { type Database struct {
db *sql.DB conn *sql.DB
log *slog.Logger log *slog.Logger
params *Params params *Params
} }
// New creates a new Database instance and registers lifecycle hooks. // New creates a new Database and registers lifecycle hooks.
func New(lc fx.Lifecycle, params Params) (*Database, error) { func New(
s := new(Database) lifecycle fx.Lifecycle,
s.params = &params params Params,
s.log = params.Logger.Get() ) (*Database, error) {
database := &Database{ //nolint:exhaustruct // conn set in OnStart
params: &params,
log: params.Logger.Get(),
}
s.log.Info("Database instantiated") database.log.Info("Database instantiated")
lc.Append(fx.Hook{ lifecycle.Append(fx.Hook{
OnStart: func(ctx context.Context) error { OnStart: func(ctx context.Context) error {
s.log.Info("Database OnStart Hook") database.log.Info("Database OnStart Hook")
return s.connect(ctx) return database.connect(ctx)
}, },
OnStop: func(_ context.Context) error { OnStop: func(_ context.Context) error {
s.log.Info("Database OnStop Hook") database.log.Info("Database OnStop Hook")
if s.db != nil { if database.conn != nil {
return s.db.Close() closeErr := database.conn.Close()
if closeErr != nil {
return fmt.Errorf(
"close db: %w", closeErr,
)
}
} }
return nil return nil
}, },
}) })
return s, nil return database, 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 // 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 (s *Database) GetDB() *sql.DB { func (database *Database) GetDB() *sql.DB {
return s.db return database.conn
} }
// Hydrate injects the database reference into any model that func (database *Database) connect(ctx context.Context) error {
// embeds Base. dbURL := database.params.Config.DBURL
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" dbURL = "file:./data.db?_journal_mode=WAL&_busy_timeout=5000"
} }
s.log.Info("connecting to database", "url", dbURL) database.log.Info(
"connecting to database", "url", dbURL,
)
d, err := sql.Open("sqlite", dbURL) conn, err := sql.Open("sqlite", dbURL)
if err != nil { if err != nil {
s.log.Error("failed to open database", "error", err) return fmt.Errorf("open database: %w", err)
return err
} }
err = d.PingContext(ctx) err = conn.PingContext(ctx)
if err != nil { if err != nil {
s.log.Error("failed to ping database", "error", err) return fmt.Errorf("ping database: %w", err)
return err
} }
s.db = d conn.SetMaxOpenConns(1)
s.log.Info("database connected")
// Item 9: Enable foreign keys on every connection database.conn = conn
_, err = s.db.ExecContext(ctx, "PRAGMA foreign_keys = ON") database.log.Info("database connected")
_, 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)
} }
return s.runMigrations(ctx) _, err = database.conn.ExecContext(
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 {
@@ -568,51 +132,125 @@ type migration struct {
sql string sql string
} }
func (s *Database) runMigrations(ctx context.Context) error { func (database *Database) runMigrations(
err := s.bootstrapMigrationsTable(ctx) ctx context.Context,
) error {
_, err := database.conn.ExecContext(ctx,
`CREATE TABLE IF NOT EXISTS schema_migrations (
version INTEGER PRIMARY KEY,
applied_at DATETIME DEFAULT CURRENT_TIMESTAMP)`)
if err != nil {
return fmt.Errorf(
"create schema_migrations: %w", err,
)
}
migrations, err := database.loadMigrations()
if err != nil { if err != nil {
return err return err
} }
migrations, err := s.loadMigrations() for _, mig := range migrations {
if err != nil { err = database.applyMigration(ctx, mig)
return err if err != nil {
return err
}
} }
err = s.applyMigrations(ctx, migrations) database.log.Info("database migrations complete")
if err != nil {
return err
}
s.log.Info("database migrations complete")
return nil return nil
} }
func (s *Database) bootstrapMigrationsTable( func (database *Database) applyMigration(
ctx context.Context, ctx context.Context,
mig migration,
) error { ) error {
_, err := s.db.ExecContext(ctx, var exists int
`CREATE TABLE IF NOT EXISTS schema_migrations (
version INTEGER PRIMARY KEY, err := database.conn.QueryRowContext(ctx,
applied_at DATETIME DEFAULT CURRENT_TIMESTAMP `SELECT COUNT(*) FROM schema_migrations
)`) WHERE version = ?`,
mig.version,
).Scan(&exists)
if err != nil { if err != nil {
return fmt.Errorf( return fmt.Errorf(
"create schema_migrations table: %w", err, "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 (s *Database) loadMigrations() ([]migration, error) { func (database *Database) loadMigrations() (
[]migration,
error,
) {
entries, err := fs.ReadDir(SchemaFiles, "schema") entries, err := fs.ReadDir(SchemaFiles, "schema")
if err != nil { if err != nil {
return nil, fmt.Errorf("read schema dir: %w", err) return nil, fmt.Errorf(
"read schema dir: %w", err,
)
} }
var migrations []migration migrations := make([]migration, 0, len(entries))
for _, entry := range entries { for _, entry := range entries {
if entry.IsDir() || if entry.IsDir() ||
@@ -627,17 +265,18 @@ func (s *Database) loadMigrations() ([]migration, error) {
continue continue
} }
version, err := strconv.Atoi(parts[0]) version, parseErr := strconv.Atoi(parts[0])
if err != nil { if parseErr != nil {
continue continue
} }
content, err := SchemaFiles.ReadFile( content, readErr := SchemaFiles.ReadFile(
"schema/" + entry.Name(), "schema/" + entry.Name(),
) )
if err != nil { if readErr != nil {
return nil, fmt.Errorf( return nil, fmt.Errorf(
"read migration %s: %w", entry.Name(), err, "read migration %s: %w",
entry.Name(), readErr,
) )
} }
@@ -654,82 +293,3 @@ func (s *Database) loadMigrations() ([]migration, error) {
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
}

425
internal/db/db_test.go
View File

@@ -1,425 +0,0 @@
package db_test
import (
"context"
"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 := context.Background()
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 := context.Background()
_, 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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
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 := context.Background()
_, 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 := context.Background()
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 := context.Background()
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 := context.Background()
_, _ = 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 Normal file
View File

@@ -0,0 +1,60 @@
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
}

1133
internal/db/queries.go
View File

File diff suppressed because it is too large Load Diff

569
internal/db/queries_test.go Normal file
View File

@@ -0,0 +1,569 @@
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,4 +1,54 @@
CREATE TABLE IF NOT EXISTS schema_migrations ( -- Chat server schema (pre-1.0 consolidated)
version INTEGER PRIMARY KEY, PRAGMA foreign_keys = ON;
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
View File

@@ -1,89 +0,0 @@
-- 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
View File

@@ -1,53 +0,0 @@
-- 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;

1415
internal/handlers/api.go
View File

File diff suppressed because it is too large Load Diff

1498
internal/handlers/api_test.go Normal file
View File

File diff suppressed because it is too large Load Diff

60
internal/handlers/handlers.go
View File

@@ -4,9 +4,11 @@ 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"
@@ -15,6 +17,8 @@ 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
@@ -31,32 +35,64 @@ 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(lc fx.Lifecycle, params Params) (*Handlers, error) { func New(
s := new(Handlers) lifecycle fx.Lifecycle,
s.params = &params params Params,
s.log = params.Logger.Get() ) (*Handlers, error) {
s.hc = params.Healthcheck hdlr := &Handlers{
params: &params,
log: params.Logger.Get(),
hc: params.Healthcheck,
broker: broker.New(),
}
lc.Append(fx.Hook{ lifecycle.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 s, nil return hdlr, nil
} }
func (s *Handlers) respondJSON(w http.ResponseWriter, _ *http.Request, data any, status int) { func (hdlr *Handlers) respondJSON(
w.WriteHeader(status) writer http.ResponseWriter,
w.Header().Set("Content-Type", "application/json") _ *http.Request,
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(w).Encode(data) err := json.NewEncoder(writer).Encode(data)
if err != nil { if err != nil {
s.log.Error("json encode error", "error", err) hdlr.log.Error(
"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,9 +7,12 @@ 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 (s *Handlers) HandleHealthCheck() http.HandlerFunc { func (hdlr *Handlers) HandleHealthCheck() http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) { return func(
resp := s.hc.Healthcheck() writer http.ResponseWriter,
s.respondJSON(w, req, resp, httpStatusOK) request *http.Request,
) {
resp := hdlr.hc.Healthcheck()
hdlr.respondJSON(writer, request, resp, httpStatusOK)
} }
} }

36
internal/healthcheck/healthcheck.go
View File

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

61
internal/logger/logger.go
View File

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

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

@@ -1,26 +0,0 @@
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
View File

@@ -1,96 +0,0 @@
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
View File

@@ -1,35 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,15 +0,0 @@
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
View File

@@ -1,65 +0,0 @@
// 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
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
if cl, ok := b.db.(ChannelLookup); ok {
return cl
}
return nil
}

18
internal/models/server_link.go
View File

@@ -1,18 +0,0 @@
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
View File

@@ -1,26 +0,0 @@
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
View File

@@ -1,92 +0,0 @@
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 = 10 * time.Second httpWriteTimeout = 60 * time.Second
maxHeaderBytes = 1 << 20 maxHeaderBytes = 1 << 20
) )

174
internal/server/routes.go
View File

@@ -16,92 +16,138 @@ import (
const routeTimeout = 60 * time.Second const routeTimeout = 60 * time.Second
// SetupRoutes configures the HTTP routes and middleware chain. // SetupRoutes configures the HTTP routes and middleware.
func (s *Server) SetupRoutes() { func (srv *Server) SetupRoutes() {
s.router = chi.NewRouter() srv.router = chi.NewRouter()
s.router.Use(middleware.Recoverer) srv.router.Use(middleware.Recoverer)
s.router.Use(middleware.RequestID) srv.router.Use(middleware.RequestID)
s.router.Use(s.mw.Logging()) srv.router.Use(srv.mw.Logging())
if viper.GetString("METRICS_USERNAME") != "" { if viper.GetString("METRICS_USERNAME") != "" {
s.router.Use(s.mw.Metrics()) srv.router.Use(srv.mw.Metrics())
} }
s.router.Use(s.mw.CORS()) srv.router.Use(srv.mw.CORS())
s.router.Use(middleware.Timeout(routeTimeout)) srv.router.Use(middleware.Timeout(routeTimeout))
if s.sentryEnabled { if srv.sentryEnabled {
sentryHandler := sentryhttp.New(sentryhttp.Options{ sentryHandler := sentryhttp.New(
Repanic: true, sentryhttp.Options{ //nolint:exhaustruct // optional fields
}) Repanic: true,
s.router.Use(sentryHandler.Handle) },
)
srv.router.Use(sentryHandler.Handle)
} }
// Health check // Health check.
s.router.Get("/.well-known/healthcheck.json", s.h.HandleHealthCheck()) srv.router.Get(
"/.well-known/healthcheck.json",
srv.handlers.HandleHealthCheck(),
)
// Protected metrics endpoint // Protected metrics endpoint.
if viper.GetString("METRICS_USERNAME") != "" { if viper.GetString("METRICS_USERNAME") != "" {
s.router.Group(func(r chi.Router) { srv.router.Group(func(router chi.Router) {
r.Use(s.mw.MetricsAuth()) router.Use(srv.mw.MetricsAuth())
r.Get("/metrics", http.HandlerFunc(promhttp.Handler().ServeHTTP)) router.Get("/metrics",
http.HandlerFunc(
promhttp.Handler().ServeHTTP,
))
}) })
} }
// API v1 // API v1.
s.router.Route("/api/v1", func(r chi.Router) { srv.router.Route(
r.Get("/server", s.h.HandleServerInfo()) "/api/v1",
r.Post("/session", s.h.HandleCreateSession()) func(router chi.Router) {
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(),
)
},
)
// Unified state and message endpoints // Serve embedded SPA.
r.Get("/state", s.h.HandleState()) srv.setupSPA()
r.Get("/messages", s.h.HandleGetMessages()) }
r.Post("/messages", s.h.HandleSendCommand())
r.Get("/history", s.h.HandleGetHistory())
// Channels func (srv *Server) setupSPA() {
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 {
s.log.Error("failed to get web dist filesystem", "error", err) srv.log.Error(
} else { "failed to get web dist filesystem",
fileServer := http.FileServer(http.FS(distFS)) "error", err,
)
s.router.Get("/*", func(w http.ResponseWriter, r *http.Request) {
s.serveSPA(distFS, fileServer, w, r)
})
}
}
func (s *Server) serveSPA(
distFS fs.FS,
fileServer http.Handler,
w http.ResponseWriter,
r *http.Request,
) {
readFS, ok := distFS.(fs.ReadFileFS)
if !ok {
http.Error(w, "filesystem error", http.StatusInternalServerError)
return return
} }
// Try to serve the file; fall back to index.html for SPA routing. fileServer := http.FileServer(http.FS(distFS))
f, err := readFS.ReadFile(r.URL.Path[1:])
if err != nil || len(f) == 0 {
indexHTML, _ := readFS.ReadFile("index.html")
w.Header().Set("Content-Type", "text/html; charset=utf-8") srv.router.Get("/*", func(
w.WriteHeader(http.StatusOK) writer http.ResponseWriter,
_, _ = w.Write(indexHTML) request *http.Request,
) {
readFS, ok := distFS.(fs.ReadFileFS)
if !ok {
fileServer.ServeHTTP(writer, request)
return return
} }
fileServer.ServeHTTP(w, r) fileData, readErr := readFS.ReadFile(
request.URL.Path[1:],
)
if readErr != nil || len(fileData) == 0 {
indexHTML, indexErr := readFS.ReadFile(
"index.html",
)
if indexErr != nil {
http.NotFound(writer, request)
return
}
writer.Header().Set(
"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,7 +41,8 @@ type Params struct {
Handlers *handlers.Handlers Handlers *handlers.Handlers
} }
// Server is the main HTTP server. It manages routing, middleware, and lifecycle. // Server is the main HTTP server.
// It manages routing, middleware, and lifecycle.
type Server struct { type Server struct {
startupTime time.Time startupTime time.Time
exitCode int exitCode int
@@ -53,21 +54,24 @@ type Server struct {
router *chi.Mux router *chi.Mux
params Params params Params
mw *middleware.Middleware mw *middleware.Middleware
h *handlers.Handlers handlers *handlers.Handlers
} }
// New creates a new Server and registers its lifecycle hooks. // New creates a new Server and registers its lifecycle hooks.
func New(lc fx.Lifecycle, params Params) (*Server, error) { func New(
s := new(Server) lifecycle fx.Lifecycle, params Params,
s.params = params ) (*Server, error) {
s.mw = params.Middleware srv := &Server{ //nolint:exhaustruct // fields set during lifecycle
s.h = params.Handlers params: params,
s.log = params.Logger.Get() mw: params.Middleware,
handlers: params.Handlers,
log: params.Logger.Get(),
}
lc.Append(fx.Hook{ lifecycle.Append(fx.Hook{
OnStart: func(_ context.Context) error { OnStart: func(_ context.Context) error {
s.startupTime = time.Now() srv.startupTime = time.Now()
go s.Run() //nolint:contextcheck go srv.Run() //nolint:contextcheck
return nil return nil
}, },
@@ -76,120 +80,140 @@ func New(lc fx.Lifecycle, params Params) (*Server, error) {
}, },
}) })
return s, nil return srv, nil
} }
// Run starts the server configuration, Sentry, and begins serving. // Run starts the server configuration, Sentry, and begins serving.
func (s *Server) Run() { func (srv *Server) Run() {
s.configure() srv.configure()
s.enableSentry() srv.enableSentry()
s.serve() srv.serve()
} }
// ServeHTTP delegates to the chi router. // ServeHTTP delegates to the chi router.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { func (srv *Server) ServeHTTP(
s.router.ServeHTTP(w, r) writer http.ResponseWriter,
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 (s *Server) MaintenanceMode() bool { func (srv *Server) MaintenanceMode() bool {
return s.params.Config.MaintenanceMode return srv.params.Config.MaintenanceMode
} }
func (s *Server) enableSentry() { func (srv *Server) enableSentry() {
s.sentryEnabled = false srv.sentryEnabled = false
if s.params.Config.SentryDSN == "" { if srv.params.Config.SentryDSN == "" {
return return
} }
err := sentry.Init(sentry.ClientOptions{ err := sentry.Init(sentry.ClientOptions{ //nolint:exhaustruct // only essential fields
Dsn: s.params.Config.SentryDSN, Dsn: srv.params.Config.SentryDSN,
Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.Globals.Version), Release: fmt.Sprintf(
"%s-%s",
srv.params.Globals.Appname,
srv.params.Globals.Version,
),
}) })
if err != nil { if err != nil {
s.log.Error("sentry init failure", "error", err) srv.log.Error("sentry init failure", "error", err)
os.Exit(1) os.Exit(1)
} }
s.log.Info("sentry error reporting activated") srv.log.Info("sentry error reporting activated")
s.sentryEnabled = true srv.sentryEnabled = true
} }
func (s *Server) serve() int { func (srv *Server) serve() int {
s.ctx, s.cancelFunc = context.WithCancel(context.Background()) srv.ctx, srv.cancelFunc = context.WithCancel(
context.Background(),
)
go func() { go func() {
c := make(chan os.Signal, 1) sigCh := make(chan os.Signal, 1)
signal.Ignore(syscall.SIGPIPE) signal.Ignore(syscall.SIGPIPE)
signal.Notify(c, os.Interrupt, syscall.SIGTERM) signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
sig := <-c
s.log.Info("signal received", "signal", sig)
if s.cancelFunc != nil { sig := <-sigCh
s.cancelFunc()
srv.log.Info("signal received", "signal", sig)
if srv.cancelFunc != nil {
srv.cancelFunc()
} }
}() }()
go s.serveUntilShutdown() go srv.serveUntilShutdown()
<-s.ctx.Done() <-srv.ctx.Done()
s.cleanShutdown() srv.cleanShutdown()
return s.exitCode return srv.exitCode
} }
func (s *Server) cleanupForExit() { func (srv *Server) cleanupForExit() {
s.log.Info("cleaning up") srv.log.Info("cleaning up")
} }
func (s *Server) cleanShutdown() { func (srv *Server) cleanShutdown() {
s.exitCode = 0 srv.exitCode = 0
ctxShutdown, shutdownCancel := context.WithTimeout(context.Background(), shutdownTimeout) ctxShutdown, shutdownCancel := context.WithTimeout(
context.Background(), shutdownTimeout,
)
err := s.httpServer.Shutdown(ctxShutdown) err := srv.httpServer.Shutdown(ctxShutdown)
if err != nil { if err != nil {
s.log.Error("server clean shutdown failed", "error", err) srv.log.Error(
"server clean shutdown failed", "error", err,
)
} }
if shutdownCancel != nil { if shutdownCancel != nil {
shutdownCancel() shutdownCancel()
} }
s.cleanupForExit() srv.cleanupForExit()
if s.sentryEnabled { if srv.sentryEnabled {
sentry.Flush(sentryFlushTime) sentry.Flush(sentryFlushTime)
} }
} }
func (s *Server) configure() { func (srv *Server) configure() {
// server configuration placeholder // Server configuration placeholder.
} }
func (s *Server) serveUntilShutdown() { func (srv *Server) serveUntilShutdown() {
listenAddr := fmt.Sprintf(":%d", s.params.Config.Port) listenAddr := fmt.Sprintf(
s.httpServer = &http.Server{ ":%d", srv.params.Config.Port,
)
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: s, Handler: srv,
} }
s.SetupRoutes() srv.SetupRoutes()
s.log.Info("http begin listen", "listenaddr", listenAddr) srv.log.Info(
"http begin listen", "listenaddr", listenAddr,
)
err := s.httpServer.ListenAndServe() err := srv.httpServer.ListenAndServe()
if err != nil && !errors.Is(err, http.ErrServerClosed) { if err != nil && !errors.Is(err, http.ErrServerClosed) {
s.log.Error("listen error", "error", err) srv.log.Error("listen error", "error", err)
if s.cancelFunc != nil { if srv.cancelFunc != nil {
s.cancelFunc() srv.cancelFunc()
} }
} }
} }

465
web/dist/app.js vendored
View File

File diff suppressed because one or more lines are too long