[#4] limiting: Add limiter

Signed-off-by: Aleksey Savchuk <a.savchuk@yadro.com>

limiting/limiter.go

@@ -0,0 +1,75 @@
+package limiting
+
+import (
+	"fmt"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/limiting/semaphore"
+)
+
+type ReleaseFunc func()
+
+type Limiter interface {
+	// Acquire attempts to reserve a slot without blocking.
+	//
+	// Returns a release function and true if successful. The function must be
+	// called to release the limiter. The function must be called exactly once.
+	// Calling the function more that once will cause incorrect behavior of the
+	// limiter.
+	//
+	// Returns nil and false if fails.
+	//
+	// If the key was not defined in the limiter, no limit is applied.
+	Acquire(key string) (ReleaseFunc, bool)
+}
+
+type SemaphoreLimiter struct {
+	m map[string]*semaphore.Semaphore
+}
+
+// KeyLimit defines a concurrency limit for a set of keys.
+//
+// All keys of one set share the same limit.
+// Keys of different sets have separate limits.
+//
+// Sets must not overlap.
+type KeyLimit struct {
+	Keys  []string
+	Limit int64
+}
+
+func NewSemaphoreLimiter(limits []KeyLimit) (*SemaphoreLimiter, error) {
+	lr := SemaphoreLimiter{make(map[string]*semaphore.Semaphore)}
+	for _, limit := range limits {
+		if limit.Limit < 0 {
+			return nil, fmt.Errorf("invalid limit %d", limit.Limit)
+		}
+		sem := semaphore.NewSemaphore(limit.Limit)
+
+		if err := lr.addLimit(&limit, sem); err != nil {
+			return nil, err
+		}
+	}
+	return &lr, nil
+}
+
+func (lr *SemaphoreLimiter) addLimit(limit *KeyLimit, sem *semaphore.Semaphore) error {
+	for _, key := range limit.Keys {
+		if _, exists := lr.m[key]; exists {
+			return fmt.Errorf("duplicate key %q", key)
+		}
+		lr.m[key] = sem
+	}
+	return nil
+}
+
+func (lr *SemaphoreLimiter) Acquire(key string) (ReleaseFunc, bool) {
+	sem, ok := lr.m[key]
+	if !ok {
+		return func() {}, true
+	}
+
+	if ok := sem.Acquire(); ok {
+		return func() { sem.Release() }, true
+	}
+	return nil, false
+}