func (c *lockRESTClient) Unlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCUnlock, &args)
}

// ForceUnlock calls force unlock handler to forcibly unlock an active lock.
func (c *lockRESTClient) ForceUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCForceUnlock, &args)
}

func newLockAPI(endpoint Endpoint) dsync.NetLocker {

}

// ForceUnlockHandler - query expired lock status.
func (l *lockRESTServer) ForceUnlockHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {
	resp := lockRPCForceUnlock.NewResponse()

	_, err := l.ll.ForceUnlock(context.Background(), *args)
	return l.makeResp(resp, err)
}

var (
	// Static lock handlers.
	// All have the same signature.
	lockRPCForceUnlock = newLockHandler(grid.HandlerLockForceUnlock)

func (l *localLocker) IsOnline() bool {
	return true
}

// IsLocal - local locker returns true.
func (l *localLocker) IsLocal() bool {
	return true
}

func (l *localLocker) ForceUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	if ctx.Err() != nil {
		return false, ctx.Err()
	}

	defer l.getMutex()()
	if ctx.Err() != nil {
		return false, ctx.Err()
	}

								toUnLock = append(toUnLock, dsync.LockArgs{Resources: []string{k}, UID: lock.UID})
							}
						}
					}
					start := time.Now()
					for _, lock := range toUnLock {
						ok, err := l.ForceUnlock(t.Context(), lock)
						if err != nil || !ok {
							t.Fatal(err)
						}
					}
					t.Logf("Expire 50%% took: %v. Left: %d/%d", time.Since(start).Round(time.Millisecond), len(l.lockUID), len(l.lockMap))

		}
		args.Resources = append(args.Resources, path)
	}

	for _, lks := range z.serverPools[0].erasureLockers {
		lockers = append(lockers, lks...)
	}

	for _, locker := range lockers {
		locker.ForceUnlock(ctx, args)
	}
}

// TopLocksHandler Get list of locks in use
func (a adminAPIHandlers) TopLocksHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()