tajniak81andClaude Opus 5
d187ad0d17
CI / Test (ubuntu-latest) (push) Canceled after 0s
CI / Test (windows-latest) (push) Canceled after 0s
CI / Storage tests on PostgreSQL (push) Canceled after 0s
CI / Complement (federation off) (push) Canceled after 0s
CI / golangci-lint (push) Canceled after 0s
CI / Smoke test the binary (push) Canceled after 0s
Implements PLAN.md Phase 4: the read model. /sync, /messages and /context, the filters that narrow them, and the streams a response carries that are not room events — typing, receipts, presence and to-device messages. With this a client can be used against Warp, which is milestone M1. The one architectural choice is that the syncapi has no copy of the rooms: it reads them through the roomserver. Dendrite gives its syncapi its own tables and feeds them from the output stream, which is right for a design where the two can be separate processes, and Dendrite's could be. Warp is one process by decision, and there the copy buys nothing and costs the hardest class of bug a homeserver has — a read model that disagrees with the room, where a client is shown a message that was rejected and the only way to find out is to compare two tables. So the roomserver grew a read model (stream.go, roomsync.go, visibility.go) rather than exporting its store: reading an event means parsing it under its room's version, and a second copy of the version registry, the parser and the client projection would be a second place for them to disagree. syncapi: stream tokens naming a position in each of five independent streams, so a client that has seen receipt 7 but only event 4 can say so in one opaque string. A token with fewer positions than this build writes is accepted and the rest read as zero, which is what lets a token stored before a stream existed go on working. The PDU position comes from MAX(stream_ordering) and not from the counter row the other four use: the counter is advanced inside the writing transaction, so a token taken from it would name a position whose event no reader can see yet, and the event would be skipped for good once that transaction committed. Long polling goes through a notifier that wakes by room and by user rather than globally — an event wakes the listeners of its room, a membership event also wakes the user it names, so an invite reaches a client that is not in the room yet. A wake-up is only ever a hint: the listener re-reads the streams and decides for itself what changed, which is what makes it safe for the notifier to hold no state about what each client has seen. The listener registers before the read, so an event landing in between leaves the channel signalled and the sync reads again rather than blocking on a change it just missed. EventPersisted must not block, because it is called with the room's write lock still held. "Something happened" is not "a token moved". A stream can move without this user being concerned by it, and returning on every such move would turn a long poll back into a busy loop. The same trap caught presence twice over: a client says it is still online by syncing, so ?set_presence= makes every sync a presence write, and a stream that moved each time would wake every peer, which would sync, which would move it again. SetPresence therefore reports whether anything a peer would notice actually changed, and a write that only refreshes the last-active timestamp leaves the stream alone. Timeline windows are named by their two ends and a direction, Low exclusive and High inclusive in both directions, rather than by "from" and "to" as the wire format spells them. Each of those would otherwise be the low bound in one direction and the high bound in the other, which is exactly the off-by-one every pagination bug is made of; the handlers translate once and nothing below them thinks about it again. A sync's timeline is read backwards and reported forwards, because a client wants the newest events of the window it missed — a forward read with a limit hands it the oldest and then calls the rest a gap. visibility: history visibility is now a span rather than a yes or no, which is what Phase 3 deferred here. A user who has left a room is served the room as it was when they left — their state reads, their members and their timeline — instead of being refused, and is bounded above at their own membership event so a kicked client cannot go on streaming. Their span is found from their own member events, so a user who joined, left and rejoined sees their latest span. ?at= on /members is honoured for the same reason. What is left is that the span is computed from the room's current history_visibility where the spec judges each event by the one in force when it was sent; that is a state read per event and belongs with open question 1. Typing is held in memory and nowhere else: notifications expire in seconds, are worthless across a restart, and arrive one per keystroke-burst per room, so persisting them would be the busiest table in the database holding the least valuable data in it. Receipts only ever advance, compared on the position of the event acknowledged rather than on arrival, because two of a user's clients read at different speeds and the slower one must not drag the marker backwards. To-device queues are per device and drained by the next sync rather than by the one that delivered them, so a client that crashes in between gets the batch again — the right way round, since a lost key share leaves a message permanently undecryptable and a duplicate is ignored. A wildcard addressee is expanded when sent, not stored, because "every device" means the ones that existed then. Presence is off by default, which answers PLAN.md open question 3. It is the noisiest thing in Matrix and the one genuinely fan-out notification here; a private homeserver gains little from it. With it off the endpoints refuse rather than disappearing, because a client that gets a 404 from /presence concludes the server is too old to have it and stops asking. storage: one migration per driver adding the receipt, to-device, presence and filter tables with a counter row each, and a stream position on the existing account data table rather than a parallel one — there is exactly one current value per (user, room, type), and a second table would be a second thing to keep in step. Account data is reported in an event list but is not an event, so it gets its own response type: a room event with an empty sender and no timestamp would make a client decide what that meant. Deliberately missing, each named in docs/sync.md: notification counts (they need push rules, Phase 8), device lists (the keyserver, Phase 7), anything remote (Phase 5), threads (Phase 10). device_lists is sent as two empty lists because a client reads a missing one as malformed; the notification counts are left out entirely, because a zero there is a claim and an absent field is not. Tested through HTTP rather than against the builder, because what is worth pinning down is the response a client sees — which section a room lands in, whether a token handed back can be handed in again, whether paging terminates and loses nothing. The storage tests run against both SQL drivers; the notifier has its own tests for the concurrent case. A live server was driven end to end, which is what caught the two bugs the unit tests had missed: a backwards /messages page must be in reverse chronological order, and `start` must name where the page began rather than position zero when ?from= was omitted. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
344 lines
14 KiB
Go
344 lines
14 KiB
Go
// Package clientapi implements the Client-Server API: the HTTP surface
|
|
// clients talk to.
|
|
//
|
|
// Phase 1 covers everything about identity — registration, login, sessions,
|
|
// devices, profiles, account data and capabilities. Rooms, messages and
|
|
// /sync arrive in Phases 3 and 4; the route table here is the place they
|
|
// will be added.
|
|
//
|
|
// Handlers are thin. They decode a request, map it onto a userapi call and
|
|
// shape the response; the rules live in userapi, and the storage in
|
|
// internal/storage. A handler that needs more than that is a sign something
|
|
// belongs further down.
|
|
package clientapi
|
|
|
|
import (
|
|
"errors"
|
|
"log/slog"
|
|
"time"
|
|
|
|
"github.com/dariuszjaniak/warp/server/internal/config"
|
|
"github.com/dariuszjaniak/warp/server/internal/federation"
|
|
"github.com/dariuszjaniak/warp/server/internal/httputil"
|
|
"github.com/dariuszjaniak/warp/server/internal/ratelimit"
|
|
"github.com/dariuszjaniak/warp/server/internal/roomserver"
|
|
"github.com/dariuszjaniak/warp/server/internal/settings"
|
|
"github.com/dariuszjaniak/warp/server/internal/syncapi"
|
|
"github.com/dariuszjaniak/warp/server/internal/userapi"
|
|
)
|
|
|
|
// ClientAPI serves the Client-Server API.
|
|
type ClientAPI struct {
|
|
serverName string
|
|
clientBaseURL string
|
|
users *userapi.API
|
|
rooms *roomserver.API
|
|
sync *syncapi.API
|
|
settings *settings.Service
|
|
federation *federation.Gate
|
|
registration config.Registration
|
|
log *slog.Logger
|
|
now func() time.Time
|
|
|
|
uia *uiaStore
|
|
clientIP ratelimit.KeyFunc
|
|
|
|
// One limiter per endpoint class, so a client hammering /login cannot
|
|
// spend the budget of /profile.
|
|
limitDefault *ratelimit.Limiter
|
|
limitLogin *ratelimit.Limiter
|
|
limitRegister *ratelimit.Limiter
|
|
limitRoomCreate *ratelimit.Limiter
|
|
limitJoin *ratelimit.Limiter
|
|
|
|
// limitSync is deliberately generous. A client is in /sync all the
|
|
// time, and a long poll that is refused leaves it reconnecting in a
|
|
// loop — the one place where rate limiting makes the load worse rather
|
|
// than better.
|
|
limitSync *ratelimit.Limiter
|
|
}
|
|
|
|
// Options configure the component.
|
|
type Options struct {
|
|
// ServerName is the Matrix server name.
|
|
ServerName string
|
|
|
|
// ClientBaseURL is the URL advertised to clients, the same value
|
|
// /.well-known/matrix/client carries. A successful login repeats it so
|
|
// that a client which only knew the server name does not have to fetch
|
|
// the discovery document separately.
|
|
ClientBaseURL string
|
|
|
|
// Users is the userapi component.
|
|
Users *userapi.API
|
|
|
|
// Rooms is the roomserver component. Without it the room endpoints are
|
|
// not registered at all, which is what the Phase 1 and Phase 2 tests
|
|
// relied on and what keeps a half-wired server from offering a
|
|
// createRoom it cannot honour.
|
|
Rooms *roomserver.API
|
|
|
|
// Sync is the syncapi component. Like the roomserver it is optional,
|
|
// and for the same reason: without it /sync, /messages, /context and
|
|
// the ephemeral endpoints answer M_UNRECOGNIZED rather than
|
|
// pretending there is a stream to read.
|
|
Sync *syncapi.API
|
|
|
|
// Settings is the runtime-settings service; the registration switch is
|
|
// read from it on every registration attempt.
|
|
Settings *settings.Service
|
|
|
|
// Federation gates the endpoints that would need a remote server.
|
|
Federation *federation.Gate
|
|
|
|
// Registration is the file configuration of the registration flow.
|
|
Registration config.Registration
|
|
|
|
// RateLimit configures the per-endpoint buckets.
|
|
RateLimit config.RateLimit
|
|
|
|
// TrustXForwardedFor takes the client address from the proxy header.
|
|
TrustXForwardedFor bool
|
|
|
|
Logger *slog.Logger
|
|
|
|
// Now is the clock, so tests can expire sessions without waiting.
|
|
Now func() time.Time
|
|
}
|
|
|
|
// New builds the component.
|
|
func New(opts Options) (*ClientAPI, error) {
|
|
if opts.ServerName == "" {
|
|
return nil, errors.New("clientapi: ServerName must not be empty")
|
|
}
|
|
if opts.Users == nil {
|
|
return nil, errors.New("clientapi: Users must not be nil")
|
|
}
|
|
if opts.Settings == nil {
|
|
return nil, errors.New("clientapi: Settings must not be nil")
|
|
}
|
|
if opts.Federation == nil {
|
|
opts.Federation = federation.NewGate(nil, nil)
|
|
}
|
|
if opts.Logger == nil {
|
|
opts.Logger = slog.Default()
|
|
}
|
|
if opts.Now == nil {
|
|
opts.Now = time.Now
|
|
}
|
|
|
|
c := &ClientAPI{
|
|
serverName: opts.ServerName,
|
|
clientBaseURL: opts.ClientBaseURL,
|
|
users: opts.Users,
|
|
rooms: opts.Rooms,
|
|
sync: opts.Sync,
|
|
settings: opts.Settings,
|
|
federation: opts.Federation,
|
|
registration: opts.Registration,
|
|
log: opts.Logger,
|
|
now: opts.Now,
|
|
uia: newUIAStore(uiaSessionTTL, opts.Now),
|
|
clientIP: ratelimit.ClientIP(opts.TrustXForwardedFor),
|
|
}
|
|
|
|
if opts.RateLimit.Enabled {
|
|
c.limitDefault = ratelimit.New(bucket(opts.RateLimit.Default))
|
|
c.limitLogin = ratelimit.New(bucket(opts.RateLimit.Login))
|
|
c.limitRegister = ratelimit.New(bucket(opts.RateLimit.Register))
|
|
// Creating a room writes a dozen events and joining one writes a
|
|
// membership event into a room everybody in it then sees, so both
|
|
// get their own, tighter bucket: the default one is sized for
|
|
// reads.
|
|
c.limitRoomCreate = ratelimit.New(bucket(opts.RateLimit.RoomCreate))
|
|
c.limitJoin = ratelimit.New(bucket(opts.RateLimit.Join))
|
|
c.limitSync = ratelimit.New(bucket(opts.RateLimit.Sync))
|
|
} else {
|
|
c.limitDefault, c.limitLogin, c.limitRegister =
|
|
ratelimit.Disabled(), ratelimit.Disabled(), ratelimit.Disabled()
|
|
c.limitRoomCreate, c.limitJoin = ratelimit.Disabled(), ratelimit.Disabled()
|
|
c.limitSync = ratelimit.Disabled()
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
func bucket(b config.RateLimitBucket) ratelimit.Policy {
|
|
return ratelimit.Policy{Burst: b.Burst, Interval: b.Interval}
|
|
}
|
|
|
|
// Client-Server API path prefixes. Warp serves the versioned paths only:
|
|
// the r0 prefix was deprecated in Matrix 1.4, and every client that still
|
|
// sends it also understands a 404 and falls back to version negotiation
|
|
// through /_matrix/client/versions.
|
|
const (
|
|
v3 = "/_matrix/client/v3"
|
|
v1 = "/_matrix/client/v1"
|
|
)
|
|
|
|
// RegisterRoutes adds the Client-Server endpoints to the router.
|
|
func (c *ClientAPI) RegisterRoutes(r *httputil.Router) {
|
|
// Registration. The token-validity endpoint is v1 because that is the
|
|
// version the spec introduced it at.
|
|
c.public(r, "POST "+v3+"/register", c.limitRegister, c.handleRegister)
|
|
c.public(r, "GET "+v3+"/register/available", c.limitRegister, c.handleRegisterAvailable)
|
|
c.public(r, "GET "+v1+"/register/m.login.registration_token/validity",
|
|
c.limitRegister, c.handleRegistrationTokenValidity)
|
|
|
|
// Sessions.
|
|
c.public(r, "GET "+v3+"/login", c.limitDefault, c.handleLoginFlows)
|
|
c.public(r, "POST "+v3+"/login", c.limitLogin, c.handleLogin)
|
|
c.public(r, "POST "+v3+"/refresh", c.limitLogin, c.handleRefresh)
|
|
c.authed(r, "POST "+v3+"/logout", c.limitDefault, c.handleLogout)
|
|
c.authed(r, "POST "+v3+"/logout/all", c.limitDefault, c.handleLogoutAll)
|
|
|
|
// Account.
|
|
c.authed(r, "GET "+v3+"/account/whoami", c.limitDefault, c.handleWhoami)
|
|
c.authed(r, "GET "+v3+"/capabilities", c.limitDefault, c.handleCapabilities)
|
|
|
|
// Devices.
|
|
c.authed(r, "GET "+v3+"/devices", c.limitDefault, c.handleGetDevices)
|
|
c.authed(r, "GET "+v3+"/devices/{deviceID}", c.limitDefault, c.handleGetDevice)
|
|
c.authed(r, "PUT "+v3+"/devices/{deviceID}", c.limitDefault, c.handlePutDevice)
|
|
c.authed(r, "DELETE "+v3+"/devices/{deviceID}", c.limitDefault, c.handleDeleteDevice)
|
|
c.authed(r, "POST "+v3+"/delete_devices", c.limitDefault, c.handleDeleteDevices)
|
|
|
|
// Profiles are world-readable: a client showing a room member's name
|
|
// has no token for that member's server, and the spec makes the GETs
|
|
// unauthenticated for exactly that reason.
|
|
c.public(r, "GET "+v3+"/profile/{userID}", c.limitDefault, c.handleGetProfile)
|
|
c.public(r, "GET "+v3+"/profile/{userID}/displayname", c.limitDefault, c.handleGetDisplayName)
|
|
c.public(r, "GET "+v3+"/profile/{userID}/avatar_url", c.limitDefault, c.handleGetAvatarURL)
|
|
c.authed(r, "PUT "+v3+"/profile/{userID}/displayname", c.limitDefault, c.handlePutDisplayName)
|
|
c.authed(r, "PUT "+v3+"/profile/{userID}/avatar_url", c.limitDefault, c.handlePutAvatarURL)
|
|
|
|
// Account data.
|
|
c.authed(r, "GET "+v3+"/user/{userID}/account_data/{dataType}",
|
|
c.limitDefault, c.handleGetAccountData)
|
|
c.authed(r, "PUT "+v3+"/user/{userID}/account_data/{dataType}",
|
|
c.limitDefault, c.handlePutAccountData)
|
|
c.authed(r, "GET "+v3+"/user/{userID}/rooms/{roomID}/account_data/{dataType}",
|
|
c.limitDefault, c.handleGetRoomAccountData)
|
|
c.authed(r, "PUT "+v3+"/user/{userID}/rooms/{roomID}/account_data/{dataType}",
|
|
c.limitDefault, c.handlePutRoomAccountData)
|
|
|
|
c.registerRoomRoutes(r)
|
|
c.registerSyncRoutes(r)
|
|
}
|
|
|
|
// registerSyncRoutes adds the endpoints the syncapi serves, if there is
|
|
// one.
|
|
//
|
|
// Like the room routes they are left unregistered rather than stubbed in a
|
|
// build without the component: a client that gets M_UNRECOGNIZED from
|
|
// /sync knows the server does not have it, where an empty success would
|
|
// have it believe nothing was happening.
|
|
func (c *ClientAPI) registerSyncRoutes(r *httputil.Router) {
|
|
if c.sync == nil {
|
|
return
|
|
}
|
|
|
|
c.authed(r, "GET "+v3+"/sync", c.limitSync, c.handleSync)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/messages", c.limitDefault, c.handleMessages)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/context/{eventID}", c.limitDefault, c.handleContext)
|
|
|
|
// Filters.
|
|
c.authed(r, "POST "+v3+"/user/{userID}/filter", c.limitDefault, c.handlePostFilter)
|
|
c.authed(r, "GET "+v3+"/user/{userID}/filter/{filterID}", c.limitDefault, c.handleGetFilter)
|
|
|
|
// The ephemeral streams. Typing goes in the sync limiter's class
|
|
// rather than the default one: a client sends one per keystroke-burst,
|
|
// and it is the chattiest write in the API.
|
|
c.authed(r, "PUT "+v3+"/rooms/{roomID}/typing/{userID}", c.limitSync, c.handlePutTyping)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/receipt/{receiptType}/{eventID}",
|
|
c.limitSync, c.handlePostReceipt)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/read_markers", c.limitDefault, c.handlePostReadMarkers)
|
|
|
|
// To-device messaging. A client encrypting for a busy room sends one
|
|
// of these per device, so it shares the sync budget too.
|
|
c.authed(r, "PUT "+v3+"/sendToDevice/{eventType}/{txnID}", c.limitSync, c.handleSendToDevice)
|
|
|
|
// Presence.
|
|
c.authed(r, "GET "+v3+"/presence/{userID}/status", c.limitDefault, c.handleGetPresence)
|
|
c.authed(r, "PUT "+v3+"/presence/{userID}/status", c.limitSync, c.handlePutPresence)
|
|
}
|
|
|
|
// registerRoomRoutes adds the room endpoints, if there is a roomserver.
|
|
//
|
|
// A build without one answers them with M_UNRECOGNIZED, which is the right
|
|
// answer: a server that cannot store a room should say it has no createRoom
|
|
// rather than fail every call to it.
|
|
func (c *ClientAPI) registerRoomRoutes(r *httputil.Router) {
|
|
if c.rooms == nil {
|
|
return
|
|
}
|
|
|
|
c.authed(r, "POST "+v3+"/createRoom", c.limitRoomCreate, c.handleCreateRoom)
|
|
|
|
// Membership. The two join endpoints differ only in what they are
|
|
// addressed by: /join/{roomIdOrAlias} resolves an alias first.
|
|
c.authed(r, "POST "+v3+"/join/{roomIDOrAlias}", c.limitJoin, c.handleJoinRoom)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/join", c.limitJoin, c.handleJoinRoomByID)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/leave", c.limitDefault, c.handleLeaveRoom)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/invite", c.limitDefault, c.handleInvite)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/kick", c.limitDefault, c.handleKick)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/ban", c.limitDefault, c.handleBan)
|
|
c.authed(r, "POST "+v3+"/rooms/{roomID}/unban", c.limitDefault, c.handleUnban)
|
|
|
|
// Sending. The state endpoint is registered twice, because the empty
|
|
// state key is both valid and the common case and arrives in two
|
|
// spellings: ".../state/m.room.name" and ".../state/m.room.name/".
|
|
// The trailing-slash form uses a multi-segment wildcard, which is the
|
|
// only kind Go's router matches against an empty segment — and which
|
|
// also means a state key a client did not escape arrives whole rather
|
|
// than as a 404.
|
|
c.authed(r, "PUT "+v3+"/rooms/{roomID}/send/{eventType}/{txnID}",
|
|
c.limitDefault, c.handleSendEvent)
|
|
c.authed(r, "PUT "+v3+"/rooms/{roomID}/state/{eventType}",
|
|
c.limitDefault, c.handlePutState)
|
|
c.authed(r, "PUT "+v3+"/rooms/{roomID}/state/{eventType}/{stateKey...}",
|
|
c.limitDefault, c.handlePutState)
|
|
c.authed(r, "PUT "+v3+"/rooms/{roomID}/redact/{eventID}/{txnID}",
|
|
c.limitDefault, c.handleRedact)
|
|
|
|
// Reading.
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/event/{eventID}", c.limitDefault, c.handleGetEvent)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/state", c.limitDefault, c.handleGetState)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/state/{eventType}",
|
|
c.limitDefault, c.handleGetStateEvent)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/state/{eventType}/{stateKey...}",
|
|
c.limitDefault, c.handleGetStateEvent)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/members", c.limitDefault, c.handleGetMembers)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/joined_members",
|
|
c.limitDefault, c.handleGetJoinedMembers)
|
|
c.authed(r, "GET "+v3+"/joined_rooms", c.limitDefault, c.handleGetJoinedRooms)
|
|
|
|
// The directory. Resolving an alias and reading the public room list
|
|
// need no token: a client handed a link has to be able to follow it
|
|
// before it decides whether to log in.
|
|
c.public(r, "GET "+v3+"/directory/room/{roomAlias}", c.limitDefault, c.handleGetAlias)
|
|
c.authed(r, "PUT "+v3+"/directory/room/{roomAlias}", c.limitDefault, c.handlePutAlias)
|
|
c.authed(r, "DELETE "+v3+"/directory/room/{roomAlias}", c.limitDefault, c.handleDeleteAlias)
|
|
c.authed(r, "GET "+v3+"/rooms/{roomID}/aliases", c.limitDefault, c.handleGetRoomAliases)
|
|
|
|
c.public(r, "GET "+v3+"/publicRooms", c.limitDefault, c.handleGetPublicRooms)
|
|
c.authed(r, "POST "+v3+"/publicRooms", c.limitDefault, c.handlePostPublicRooms)
|
|
c.public(r, "GET "+v3+"/directory/list/room/{roomID}",
|
|
c.limitDefault, c.handleGetRoomVisibility)
|
|
c.authed(r, "PUT "+v3+"/directory/list/room/{roomID}",
|
|
c.limitDefault, c.handlePutRoomVisibility)
|
|
}
|
|
|
|
// public registers an endpoint that needs no access token.
|
|
func (c *ClientAPI) public(r *httputil.Router, pattern string, limiter *ratelimit.Limiter, h httputil.Handler) {
|
|
r.Handle(pattern, limiter.Middleware(c.clientIP)(httputil.Wrap(h)))
|
|
}
|
|
|
|
// authed registers an endpoint that needs one.
|
|
//
|
|
// The rate limiter still keys on the client address rather than the user:
|
|
// it runs before the token is resolved, and a limiter that had to hit the
|
|
// database to find its own key would be a denial of service of its own.
|
|
func (c *ClientAPI) authed(r *httputil.Router, pattern string, limiter *ratelimit.Limiter, h AuthedHandler) {
|
|
r.Handle(pattern, limiter.Middleware(c.clientIP)(httputil.Wrap(c.withAuth(h))))
|
|
}
|