examples: Update and fix outdated (#420)
Update examples/server/rate-limiting to use the same replace directive strategy as the auth-middleware example, and fix the breakages. Also remove the unneeded type parameters in examples/client/middleware.
This commit is contained in:
parent
9d34aff732
commit
b774809086
1 changed files with 32 additions and 25 deletions
|
|
@ -18,13 +18,13 @@ import (
|
|||
// GlobalRateLimiterMiddleware creates a middleware that applies a global rate limit.
|
||||
// Every request attempting to pass through will try to acquire a token.
|
||||
// If a token cannot be acquired immediately, the request will be rejected.
|
||||
func GlobalRateLimiterMiddleware[S mcp.Session](limiter *rate.Limiter) mcp.Middleware[S] {
|
||||
return func(next mcp.MethodHandler[S]) mcp.MethodHandler[S] {
|
||||
return func(ctx context.Context, session S, method string, params mcp.Params) (mcp.Result, error) {
|
||||
func GlobalRateLimiterMiddleware(limiter *rate.Limiter) mcp.Middleware {
|
||||
return func(next mcp.MethodHandler) mcp.MethodHandler {
|
||||
return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
|
||||
if !limiter.Allow() {
|
||||
return nil, errors.New("JSON RPC overloaded")
|
||||
}
|
||||
return next(ctx, session, method, params)
|
||||
return next(ctx, method, req)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -32,40 +32,40 @@ func GlobalRateLimiterMiddleware[S mcp.Session](limiter *rate.Limiter) mcp.Middl
|
|||
// PerMethodRateLimiterMiddleware creates a middleware that applies rate limiting
|
||||
// on a per-method basis.
|
||||
// Methods not specified in limiters will not be rate limited by this middleware.
|
||||
func PerMethodRateLimiterMiddleware[S mcp.Session](limiters map[string]*rate.Limiter) mcp.Middleware[S] {
|
||||
return func(next mcp.MethodHandler[S]) mcp.MethodHandler[S] {
|
||||
return func(ctx context.Context, session S, method string, params mcp.Params) (mcp.Result, error) {
|
||||
func PerMethodRateLimiterMiddleware(limiters map[string]*rate.Limiter) mcp.Middleware {
|
||||
return func(next mcp.MethodHandler) mcp.MethodHandler {
|
||||
return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
|
||||
if limiter, ok := limiters[method]; ok {
|
||||
if !limiter.Allow() {
|
||||
return nil, errors.New("JSON RPC overloaded")
|
||||
}
|
||||
}
|
||||
return next(ctx, session, method, params)
|
||||
return next(ctx, method, req)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// PerSessionRateLimiterMiddleware creates a middleware that applies rate limiting
|
||||
// on a per-session basis for receiving requests.
|
||||
func PerSessionRateLimiterMiddleware[S mcp.Session](limit rate.Limit, burst int) mcp.Middleware[S] {
|
||||
func PerSessionRateLimiterMiddleware(limit rate.Limit, burst int) mcp.Middleware {
|
||||
// A map to store limiters, keyed by the session ID.
|
||||
var (
|
||||
sessionLimiters = make(map[string]*rate.Limiter)
|
||||
mu sync.Mutex
|
||||
)
|
||||
|
||||
return func(next mcp.MethodHandler[S]) mcp.MethodHandler[S] {
|
||||
return func(ctx context.Context, session S, method string, params mcp.Params) (mcp.Result, error) {
|
||||
return func(next mcp.MethodHandler) mcp.MethodHandler {
|
||||
return func(ctx context.Context, method string, req mcp.Request) (mcp.Result, error) {
|
||||
// It's possible that session.ID() may be empty at this point in time
|
||||
// for some transports (e.g., stdio) or until the MCP initialize handshake
|
||||
// has completed.
|
||||
sessionID := session.ID()
|
||||
sessionID := req.GetSession().ID()
|
||||
if sessionID == "" {
|
||||
// In this situation, you could apply a single global identifier
|
||||
// if session ID is empty or bypass the rate limiter.
|
||||
// In this example, we bypass the rate limiter.
|
||||
log.Printf("Warning: Session ID is empty for method %q. Skipping per-session rate limiting.", method)
|
||||
return next(ctx, session, method, params) // Skip limiting if ID is unavailable
|
||||
return next(ctx, method, req) // Skip limiting if ID is unavailable
|
||||
}
|
||||
mu.Lock()
|
||||
limiter, ok := sessionLimiters[sessionID]
|
||||
|
|
@ -77,19 +77,19 @@ func PerSessionRateLimiterMiddleware[S mcp.Session](limit rate.Limit, burst int)
|
|||
if !limiter.Allow() {
|
||||
return nil, errors.New("JSON RPC overloaded")
|
||||
}
|
||||
return next(ctx, session, method, params)
|
||||
return next(ctx, method, req)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
server := mcp.NewServer("greeter1", "v0.0.1", nil)
|
||||
server.AddReceivingMiddleware(GlobalRateLimiterMiddleware[*mcp.ServerSession](rate.NewLimiter(rate.Every(time.Second/5), 10)))
|
||||
server.AddReceivingMiddleware(PerMethodRateLimiterMiddleware[*mcp.ServerSession](map[string]*rate.Limiter{
|
||||
server := mcp.NewServer(&mcp.Implementation{Name: "greeter1", Version: "v0.0.1"}, nil)
|
||||
server.AddReceivingMiddleware(GlobalRateLimiterMiddleware(rate.NewLimiter(rate.Every(time.Second/5), 10)))
|
||||
server.AddReceivingMiddleware(PerMethodRateLimiterMiddleware(map[string]*rate.Limiter{
|
||||
"callTool": rate.NewLimiter(rate.Every(time.Second), 5), // once a second with a burst up to 5
|
||||
"listTools": rate.NewLimiter(rate.Every(time.Minute), 20), // once a minute with a burst up to 20
|
||||
}))
|
||||
server.AddReceivingMiddleware(PerSessionRateLimiterMiddleware[*mcp.ServerSession](rate.Every(time.Second/5), 10))
|
||||
server.AddReceivingMiddleware(PerSessionRateLimiterMiddleware(rate.Every(time.Second/5), 10))
|
||||
// Run Server logic.
|
||||
log.Println("MCP Server instance created with Middleware (but not running).")
|
||||
log.Println("This example demonstrates configuration, not live interaction.")
|
||||
|
|
|
|||
Loading…
Reference in a new issue