No examples tell me how to use LookupPartitionStrategy&PredicatePartitionStrategy

[xiaofeige]

any examples?
why partitions cann't not be group by grpc method?

[platinummonkey]

You might look at the tests for current examples:

https://github.com/platinummonkey/go-concurrency-limits/blob/master/strategy/lookup_partition_test.go https://github.com/platinummonkey/go-concurrency-limits/blob/master/strategy/predicate_partition_test.go

The per method is interesting. Currently this https://github.com/platinummonkey/go-concurrency-limits/blob/master/grpc/grpc_unary.go#L11 applies to all methods but could easily obtain the method name (and context args for something even more custom) with your own interceptor. The per method name seems like a relatively good FR that can be generalized

[xiaofeige]

` func (i *InterceptorManager) GetAutoRateLimiter() lwp.ServerInterceptor {

emptyLimitFunc := func(ctx context.Context, req *msgpack.ArgsCodec, info *lwp.ServerInfo, handler lwp.UnaryHandler) (resp interface{}, err error) {
    return handler(ctx, req)
}

if !fileConf.Config.FileServerSettting.StartAutoRateLimit {
    return emptyLimitFunc
}

partitions := make(map[string]*strategy.LookupPartition)
partitions["default"] = strategy.NewLookupPartitionWithMetricRegistry("default", 0.5, 100, limitCore.EmptyMetricRegistryInstance)
partitions["/r/Icon/genAutomaticIcon"] = strategy.NewLookupPartitionWithMetricRegistry("/r/Icon/genAutomaticIcon", 0.2, 10, limitCore.EmptyMetricRegistryInstance)

fileLimitStrategy, err := strategy.NewLookupPartitionStrategyWithMetricRegistry(
    partitions,
    func(ctx context.Context) string {
        rpcCtx, ok := lwputil.RpcContextFromContext(ctx)
        if !ok {
            return "default"
        }

        if _, ok = partitions[rpcCtx.Url]; !ok {
            return "default"
        }

        return rpcCtx.Url
    },
    1000,
    limitCore.EmptyMetricRegistryInstance,
)

tags := make([]string, 0)
autoLimiter, err := limiter.NewDefaultLimiterWithDefaults(
    "file",
    fileLimitStrategy,
    &log.RateLimitLogger{},
    limitCore.EmptyMetricRegistryInstance,
    tags...,
)

if err != nil || autoLimiter == nil {
    log.Logger.Errorf("create auto limiter err:%v", err)
    return emptyLimitFunc
}

go func() {
    for {
        time.Sleep(1 * time.Second)
        log.Logger.Infof("[rate_limit_state]: %s estimate:%d", autoLimiter.String(), autoLimiter.EstimatedLimit())
    }
}()

classifyRspCode := func(url string, err error) string {
    if err == nil {
        return "success"
    }

    lwpStat, ok := err.(*status.LwpStatus)
    if !ok {
        log.Logger.Infof("convert lwp error failed, err:%T", err)
        return "ignore"
    }

    if lwpStat.LwpCode() == 408 || lwpStat.LwpCode() >= 500 {
        return "drop"
    }

    return "ignore"
}

return func(ctx context.Context, args *msgpack.ArgsCodec, info *lwp.ServerInfo, handler lwp.UnaryHandler) (resp interface{}, err error) {

    rpcCtx, ok := lwputil.RpcContextFromContext(ctx)
    if !ok {
        return nil, status.NewLwpBadRequestErrorWithScope(status.LwpDefaultLang, lwputil.BizCodeRpcContextMissing,
            "RpcContext_empty", "", lwputil.GetBizScope("AuthInterceptor"))
    }

    token, ok := autoLimiter.Acquire(ctx)
    if !ok {
        log.LogFmt.CommonErrorLog(ctx, "rate_limit", fmt.Errorf("auto_rate_limit"), map[string]interface{}{
            "uid": rpcCtx.Uid,
            "did": rpcCtx.Did,
        })
        return nil, status.NewLwpBadRequestErrorWithScope(status.LwpDefaultLang, fmt.Sprint(types.ErrTooManyRequest),
            "服务繁忙，请稍后重试", "", lwputil.GetBizScope("AuthInterceptor"))
    }
    defer func() {
        rspType := classifyRspCode(rpcCtx.Url, err)

        switch rspType {
        case "success":
            token.OnSuccess()
        case "ignore":
            token.OnIgnore()
        case "drop":
            token.OnDropped()
        default:
            token.OnIgnore()
        }
    }()

    return handler(ctx, args)
}

} `

this is how I code, but it seems like the token wasn't released correctly. In my presure test, all the request will be forbinden finally, and it won't recover unless I restart the server, even if I stop the presure test for a long time.