dist_locked_worker.hpp

#pragma once
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
#include <userver/dist_lock/dist_lock_settings.hpp>
#include <userver/dist_lock/dist_lock_strategy.hpp>
#include <userver/dist_lock/statistics.hpp>
#include <userver/engine/mutex.hpp>
#include <userver/engine/task/task_with_result.hpp>
#include <userver/formats/json/value.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace dist_lock {
namespace impl {
 
class Locker;
 
}  // namespace impl
 
class DistLockedWorker final {
 public:
  using WorkerFunc = std::function<void()>;
 
  DistLockedWorker(std::string name, WorkerFunc worker_func,
                   std::shared_ptr<DistLockStrategyBase> strategy,
                   const DistLockSettings& settings = {},
                   engine::TaskProcessor* task_processor = nullptr);
 
  ~DistLockedWorker();
 
  const std::string& Name() const;
 
  DistLockSettings GetSettings() const;
 
  void UpdateSettings(const DistLockSettings&);
 
  void Start();
 
  void Stop();
 
  void RunOnce();
 
  bool IsRunning() const;
 
  std::optional<std::chrono::steady_clock::duration> GetLockedDuration() const;
 
  const Statistics& GetStatistics() const;
 
  formats::json::Value GetStatisticsJson() const;
 
 private:
  engine::TaskProcessor& GetTaskProcessor() const noexcept;
 
  std::shared_ptr<impl::Locker> locker_ptr_;
 
  mutable engine::Mutex locker_task_mutex_;
  engine::TaskWithResult<void> locker_task_;
 
  engine::TaskProcessor* const task_processor_;
};
 
}  // namespace dist_lock
 
USERVER_NAMESPACE_END