2014-04-02 07:59:43 +00:00
|
|
|
#pragma once
|
|
|
|
|
2017-06-19 20:06:35 +00:00
|
|
|
#include <Common/ZooKeeper/ZooKeeper.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Common/Exception.h>
|
|
|
|
#include <IO/ReadHelpers.h>
|
2014-04-02 07:59:43 +00:00
|
|
|
|
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
2016-01-24 05:00:24 +00:00
|
|
|
namespace ErrorCodes
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
extern const int LOGICAL_ERROR;
|
2016-01-24 05:00:24 +00:00
|
|
|
}
|
|
|
|
|
2017-04-16 15:00:33 +00:00
|
|
|
/** The synchronization is primitive. Works as follows:
|
|
|
|
* Creates a non-ephemeral incremental node and marks it as locked (LOCKED).
|
|
|
|
* `unlock()` unlocks it (UNLOCKED).
|
|
|
|
* When the destructor is called or the session ends in ZooKeeper, it goes into the ABANDONED state.
|
|
|
|
* (Including when the program is halted).
|
2014-04-02 07:59:43 +00:00
|
|
|
*/
|
2018-03-13 20:36:22 +00:00
|
|
|
class AbandonableLockInZooKeeper : public boost::noncopyable
|
2014-04-02 07:59:43 +00:00
|
|
|
{
|
|
|
|
public:
|
2017-04-01 07:20:54 +00:00
|
|
|
enum State
|
|
|
|
{
|
|
|
|
UNLOCKED,
|
|
|
|
LOCKED,
|
|
|
|
ABANDONED,
|
|
|
|
};
|
|
|
|
|
|
|
|
AbandonableLockInZooKeeper(
|
2018-04-04 12:39:48 +00:00
|
|
|
const String & path_prefix_, const String & temp_path, zkutil::ZooKeeper & zookeeper_, zkutil::Requests * precheck_ops = nullptr);
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-03-13 20:36:22 +00:00
|
|
|
AbandonableLockInZooKeeper() = default;
|
|
|
|
|
|
|
|
AbandonableLockInZooKeeper(AbandonableLockInZooKeeper && rhs) noexcept
|
|
|
|
{
|
|
|
|
*this = std::move(rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
AbandonableLockInZooKeeper & operator=(AbandonableLockInZooKeeper && rhs) noexcept
|
2017-04-01 07:20:54 +00:00
|
|
|
{
|
2018-03-13 20:36:22 +00:00
|
|
|
zookeeper = rhs.zookeeper;
|
|
|
|
rhs.zookeeper = nullptr;
|
|
|
|
path_prefix = std::move(rhs.path_prefix);
|
|
|
|
path = std::move(rhs.path);
|
|
|
|
holder_path = std::move(rhs.holder_path);
|
|
|
|
return *this;
|
2017-04-01 07:20:54 +00:00
|
|
|
}
|
|
|
|
|
2018-01-19 22:37:50 +00:00
|
|
|
bool isCreated() const
|
|
|
|
{
|
2018-03-13 20:36:22 +00:00
|
|
|
return zookeeper && !holder_path.empty() && !path.empty();
|
2018-01-19 22:37:50 +00:00
|
|
|
}
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
String getPath() const
|
|
|
|
{
|
2018-01-19 22:37:50 +00:00
|
|
|
checkCreated();
|
2017-04-01 07:20:54 +00:00
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
2017-04-16 15:00:33 +00:00
|
|
|
/// Parse the number at the end of the path.
|
2017-04-01 07:20:54 +00:00
|
|
|
UInt64 getNumber() const
|
|
|
|
{
|
2018-01-19 22:37:50 +00:00
|
|
|
checkCreated();
|
2017-04-01 07:20:54 +00:00
|
|
|
return parse<UInt64>(path.c_str() + path_prefix.size(), path.size() - path_prefix.size());
|
|
|
|
}
|
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
void unlock();
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2017-04-16 15:00:33 +00:00
|
|
|
/// Adds actions equivalent to `unlock()` to the list.
|
2018-04-04 12:39:48 +00:00
|
|
|
void getUnlockOps(zkutil::Requests & ops);
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-03-15 19:05:58 +00:00
|
|
|
/// Do not delete nodes in destructor. You may call this method after 'getUnlockOps' and successful execution of these ops,
|
|
|
|
/// because the nodes will be already deleted.
|
|
|
|
void assumeUnlocked()
|
2018-03-15 17:04:47 +00:00
|
|
|
{
|
2018-03-15 19:06:53 +00:00
|
|
|
holder_path.clear();
|
2018-03-15 17:04:47 +00:00
|
|
|
}
|
|
|
|
|
2018-01-19 22:37:50 +00:00
|
|
|
void checkCreated() const
|
|
|
|
{
|
|
|
|
if (!isCreated())
|
|
|
|
throw Exception("AbandonableLock is not created", ErrorCodes::LOGICAL_ERROR);
|
|
|
|
}
|
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
~AbandonableLockInZooKeeper();
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
private:
|
|
|
|
zkutil::ZooKeeper * zookeeper = nullptr;
|
|
|
|
String path_prefix;
|
|
|
|
String path;
|
|
|
|
String holder_path;
|
|
|
|
};
|
2017-04-01 07:20:54 +00:00
|
|
|
|
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
/// Acquires block number locks in all partitions. The class is called Ephemeral- instead of Abandonable-
|
|
|
|
/// because it creates ephemeral block nodes (there is no need to leave abandoned tombstones).
|
|
|
|
class EphemeralLocksInAllPartitions
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
EphemeralLocksInAllPartitions(
|
|
|
|
const String & block_numbers_path, const String & path_prefix, const String & temp_path,
|
|
|
|
zkutil::ZooKeeper & zookeeper_);
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
struct LockInfo
|
|
|
|
{
|
|
|
|
String path;
|
|
|
|
String holder_path;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
String partition_id;
|
|
|
|
UInt64 number = 0;
|
|
|
|
};
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
const std::vector<LockInfo> & getLocks() const { return locks; }
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-04-04 12:39:48 +00:00
|
|
|
void unlock();
|
|
|
|
|
|
|
|
~EphemeralLocksInAllPartitions();
|
2014-07-25 16:32:02 +00:00
|
|
|
|
2014-04-02 07:59:43 +00:00
|
|
|
private:
|
2018-04-04 12:39:48 +00:00
|
|
|
zkutil::ZooKeeper & zookeeper;
|
|
|
|
std::vector<LockInfo> locks;
|
2014-04-02 07:59:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|