size_t bucket_manager::get_bucket_no(const DATA_TYPE &val)
{
size_t bucket_no = size_t(val / get_bucket_range_size());
if(bucket_no >= get_bucket_number())
bucket_no = get_bucket_number() - 1;
return bucket_no;
}
int RuleInit::init_su_rule(Connection_T conn)
{
RulerManager::getInstance()->init_system_rule(SU_RULER);
if(!system_if_initialized(conn , SU_RULER))
{
LOG_INIT("!!!SU IS NOT BEEN INITIALIZED!!!");
return 0;
}
int bucket_num = get_bucket_number(conn , SU_RULER);
int mod = get_mod_from_db(conn , SU_RULER);
if((bucket_num < 0) || (mod < 0))
{
LOG_ERROR("RuleInit::get bucket number or get mod error when init su rule !");
return -1;
}
std::cerr<<"SU bucket number : "<<bucket_num<<" and current mod : "<<mod<<std::endl;
if((this->generate_all_rule(conn , SU_RULER , bucket_num) < 0) ||
(this->generate_all_order(conn , SU_RULER) < 0))
{
LOG_ERROR("RuleInit::init su rule table or order table in memory error !");
RulerManager::getInstance()->init_system_rule(SU_RULER);
return -1;
}
return 0;
}
int tair_manager::get(int area, data_entry &key, data_entry &value)
{
if (status != STATUS_CAN_WORK) {
return TAIR_RETURN_SERVER_CAN_NOT_WORK;
}
if (key.get_size() >= TAIR_MAX_KEY_SIZE || key.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
if (area < 0 || area >= TAIR_MAX_AREA_COUNT) {
return TAIR_RETURN_INVALID_ARGUMENT;
}
data_entry mkey = key;
mkey.merge_area(area);
int bucket_number = get_bucket_number(key);
log_debug("get request will server in bucket: %d", bucket_number);
PROFILER_BEGIN("get from storage engine");
int rc = storage_mgr->get(bucket_number, mkey, value);
PROFILER_END();
key.data_meta = mkey.data_meta;
TAIR_STAT.stat_get(area, rc);
return rc;
}
int tair_manager::put(int area, data_entry &key, data_entry &value, int expire_time)
{
if (key.get_size() >= TAIR_MAX_KEY_SIZE || key.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
if (value.get_size() >= TAIR_MAX_DATA_SIZE || value.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
if (area < 0 || area >= TAIR_MAX_AREA_COUNT) {
return TAIR_RETURN_INVALID_ARGUMENT;
}
data_entry mkey = key; // key merged with area
mkey.merge_area(area);
int bucket_number = get_bucket_number(key);
log_debug("put request will server in bucket: %d key =%s ", bucket_number, key.get_data());
key.data_meta.log_self();
int op_flag = get_op_flag(bucket_number, key.server_flag);
int rc = TAIR_RETURN_SERVER_CAN_NOT_WORK;
PROFILER_BEGIN("should write local?");
if (should_write_local(bucket_number, key.server_flag, op_flag, rc) == false) {
PROFILER_END();
return rc;
}
PROFILER_END();
// save into the storage engine
bool version_care = op_flag & TAIR_OPERATION_VERSION;
PROFILER_BEGIN("put into storage");
rc = storage_mgr->put(bucket_number, mkey, value, version_care, expire_time);
PROFILER_END();
if (rc == TAIR_RETURN_SUCCESS ) {
key.data_meta = mkey.data_meta;
if (op_flag & TAIR_OPERATION_DUPLICATE) {
vector<uint64_t> slaves;
get_slaves(key.server_flag, bucket_number, slaves);
if (slaves.empty() == false) {
PROFILER_BEGIN("do duplicate");
duplicator->duplicate_data(area, &key, &value, bucket_number, slaves);
PROFILER_END();
}
}
if (migrate_log != NULL && need_do_migrate_log(bucket_number)) {
PROFILER_BEGIN("do migrate log");
migrate_log->log(SN_PUT, mkey, value, bucket_number);
PROFILER_END();
}
}
TAIR_STAT.stat_put(area);
return rc;
}
void bucket_manager::open_buckets(const std::string &tag)
{
if(!_buckets.empty())
close_buckets();
_buckets.resize(get_bucket_number(), NULL);
for(size_t i = 0; i < _buckets.size(); i ++)
_buckets[i] = new bucket(bucket::generate_name(i, tag),
get_resource_monitor(),
this);
}
int tair_manager::remove(int area, data_entry &key)
{
if (key.get_size() >= TAIR_MAX_KEY_SIZE || key.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
if (area < 0 || area >= TAIR_MAX_AREA_COUNT) {
return TAIR_RETURN_INVALID_ARGUMENT;
}
data_entry mkey = key;
mkey.merge_area(area);
int bucket_number = get_bucket_number(key);
int op_flag = get_op_flag(bucket_number, key.server_flag);
int rc = TAIR_RETURN_SERVER_CAN_NOT_WORK;
PROFILER_BEGIN("should write local?");
if (should_write_local(bucket_number, key.server_flag, op_flag, rc) == false) {
PROFILER_END();
return rc;
}
PROFILER_END();
bool version_care = op_flag & TAIR_OPERATION_VERSION;
PROFILER_BEGIN("remove from storage engine");
rc = storage_mgr->remove(bucket_number, mkey, version_care);
PROFILER_END();
if (rc == TAIR_RETURN_SUCCESS || rc == TAIR_RETURN_DATA_NOT_EXIST) {
if (op_flag & TAIR_OPERATION_DUPLICATE) {
vector<uint64_t> slaves;
get_slaves(key.server_flag, bucket_number, slaves);
if (slaves.empty() == false) {
PROFILER_BEGIN("do duplicate");
duplicator->duplicate_data(area, &key, NULL, bucket_number, slaves);
PROFILER_END();
}
}
if (migrate_log != NULL && need_do_migrate_log(bucket_number)) {
PROFILER_BEGIN("do migrate log");
migrate_log->log(SN_REMOVE, mkey, mkey, bucket_number);
PROFILER_END();
}
}
TAIR_STAT.stat_remove(area);
return rc;
}
bool tair_manager::should_proxy(data_entry &key, uint64_t &target_server_id)
{
if (key.server_flag == TAIR_SERVERFLAG_PROXY)
return false; // if this is proxy, dont proxy
int bucket_number = get_bucket_number(key);
bool is_migrated = migrate_done_set.test(bucket_number);
if (is_migrated) {
target_server_id = table_mgr->get_migrate_target(bucket_number);
if (target_server_id == local_server_ip::ip) // target is myself, do not proxy
target_server_id = 0;
}
return is_migrated && target_server_id != 0;
}
int tair_manager::direct_remove(data_entry &key)
{
if (key.get_size() >= TAIR_MAX_KEY_SIZE || key.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
data_entry akey = key;
akey.decode_area();
int bucket_number = get_bucket_number(akey);
int rc = storage_mgr->remove(bucket_number, key, false);
if (rc == TAIR_RETURN_DATA_NOT_EXIST) {
// for migrate, return SUCCESS
rc = TAIR_RETURN_SUCCESS;
}
TAIR_STAT.stat_remove(akey.area);
return rc;
}
int tair_manager::direct_put(data_entry &key, data_entry &value)
{
if (key.get_size() >= TAIR_MAX_KEY_SIZE || key.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
if (value.get_size() >= TAIR_MAX_DATA_SIZE || value.get_size() < 1) {
return TAIR_RETURN_ITEMSIZE_ERROR;
}
data_entry akey = key;
int area = akey.decode_area();
key.area = area;
int bucket_number = get_bucket_number(akey);
int rc = storage_mgr->put(bucket_number, key, value, false, 0);
TAIR_STAT.stat_put(area);
return rc;
}
