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 item_manager::__get_items(tair_manager *tair_mgr,int area,data_entry& key,data_entry& value,vector<any>& items,int type /*ELEMENT_TYPE_INVALID*/)
{
int ret = TAIR_RETURN_FAILED;
if( (ret = tair_mgr->get(area,key,value)) != TAIR_RETURN_SUCCESS ){
return ret;
}
if (!tair_mgr->get_storage_manager()->test_flag(value.data_meta.flag, TAIR_ITEM_FLAG_ITEM)) {
log_debug("is not items type,flag:%d",value.data_meta.flag);
return TAIR_RETURN_TYPE_NOT_MATCH;
}
if(type != ELEMENT_TYPE_INVALID){ //need check type
uint32_t attr = get_attribute(value);
log_debug("__get_items:type:%d,attr:%u",type,VAL_TYPE(attr));
if(static_cast<uint32_t>(type) != VAL_TYPE(attr)){
return TAIR_RETURN_TYPE_NOT_MATCH;
}
}
if( !parse_array(get_items_addr(value),value.get_data()+value.get_size(),items)){
log_debug("parse_array failed");
return TAIR_RETURN_SERIALIZE_ERROR;
}
if(items.size() == 0){ //empty
return TAIR_RETURN_ITEM_EMPTY;
}
return 0;
}
void update_log::log(sn_operation_type operation_type, data_entry &key, data_entry &value, uint16_t db_id)
{
uint key_size = key.get_size();
if (key.data_meta.keysize == 0){
key.data_meta.keysize = key_size;
}
log_debug("key length: %d, value length:%d", key_size, value.get_size());
uint value_size = 0;
uint header_size = sizeof(item_meta_info);
int total_size = header_size + key_size + 3 ;
if (operation_type == SN_PUT) {
value_size = value.get_size();
if (key.data_meta.valsize == 0){
key.data_meta.valsize = value_size;
}
total_size += value_size;
}
char *log_str = (char *)malloc(total_size);
memcpy(log_str, &(key.data_meta), header_size);
char *ptr = log_str + header_size;
*((int8_t *)ptr) = (int8_t)operation_type;
*((uint16_t *)(ptr + 1)) = (uint16_t)db_id;
memcpy(ptr + 3, key.get_data(), key_size);
if (operation_type == SN_PUT) {
memcpy(ptr + 3 + key_size, value.get_data(), value_size);
}
PROFILER_BEGIN("write migrate log");
writer->write(log_str, total_size);
PROFILER_END();
free(log_str);
}
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 RequestProcessor::dump_key(const data_entry &key, const char *msg) {
if (msg == NULL) {
msg = "error";
}
char *d_str = util::string_util::bin2ascii(key.get_data(), key.get_size(), NULL, 0);
log_error("%s, key: %s", msg, d_str);
free(d_str);
}
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;
}
int tair_manager::get_item_count(int area, data_entry& key)
{
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;
}
return json::item_manager::get_item_count(this,area,key);
}
int tair_manager::add_count(int area, data_entry &key, int count, int init_value, int *result_value, int expire_time)
{
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;
}
tbsys::CThreadGuard guard(&counter_mutex[get_mutex_index(key)]);
// get from storage engine
data_entry old_value;
PROFILER_BEGIN("get from storage");
int rc = get(area, key, old_value);
PROFILER_END();
log_debug("get result: %d, flag: %d", rc, key.data_meta.flag);
key.data_meta.log_self();
if (rc == TAIR_RETURN_SUCCESS && IS_ADDCOUNT_TYPE(key.data_meta.flag)) {
// old value exist
int32_t *v = (int32_t *)(old_value.get_data() + ITEM_HEAD_LENGTH);
log_debug("old count: %d, new count: %d, init value: %d", (*v), count, init_value);
*v += count;
*result_value = *v;
} else if(rc == TAIR_RETURN_SUCCESS){
//exist,but is not add_count,return error;
log_debug("cann't override old value");
return TAIR_RETURN_CANNOT_OVERRIDE;
}else {
// old value not exist
char fv[6]; // 2 + sizeof(int)
*((short *)fv) = 0x1600; // for java header
*result_value = init_value + count;
*((int32_t *)(fv + 2)) = *result_value;
old_value.set_data(fv, 6);
}
old_value.data_meta.flag |= TAIR_ITEM_FLAG_ADDCOUNT;
log_debug("before put flag: %d", old_value.data_meta.flag);
PROFILER_BEGIN("save count into storage");
int result = put(area, key, old_value, expire_time);
PROFILER_END();
return result;
}
int get_from_local_cluster(ClusterHandler& handler, data_entry& key, data_entry*& value, bool& skip)
{
int ret = handler.client()->get_hidden(key.get_area(), key, value);
if (ret == TAIR_RETURN_DATA_NOT_EXIST || ret == TAIR_RETURN_DATA_EXPIRED)
{
log_warn("key not exist local");
skip = true;
ret = TAIR_RETURN_SUCCESS;
}
else if (ret != TAIR_RETURN_SUCCESS && ret != TAIR_RETURN_HIDDEN)
{
log_error("get local fail, ret: %d", ret);
}
else
{
key.data_meta.cdate = value->data_meta.cdate;
key.data_meta.edate = value->data_meta.edate;
key.data_meta.mdate = value->data_meta.mdate;
key.data_meta.version = value->data_meta.version;
key.data_meta.keysize = value->data_meta.keysize;
key.data_meta.valsize = value->data_meta.valsize;
ret = TAIR_RETURN_SUCCESS;
}
return ret;
}
int tair_manager::get_items(int area,
data_entry& key,
int offset, int count, data_entry& value /*out*/,
int type /*=ELEMENT_TYPE_INVALID*/)
{
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;
}
return json::item_manager::get_items(this,area,key,offset,count,value,type);
}
int tair_manager::remove_items(int area,
data_entry& key, int offset, int count)
{
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;
}
//tbsys::CThreadGuard guard(&removeItemsMutex[getMutexIndex(key)]);
tbsys::CThreadGuard guard(&item_mutex[get_mutex_index(key)]);
return json::item_manager::remove_items(this,area,key,offset,count);
}
int tair_manager::get_and_remove(int area,
data_entry& key,
int offset, int count, data_entry& value /*out*/,
int type /*=ELEMENT_TYPE_INVALID*/)
{
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;
}
//tbsys::CThreadGuard guard(&getAndRemoveItemsMutex[getMutexIndex(key)]);
tbsys::CThreadGuard guard(&item_mutex[get_mutex_index(key)]);
return json::item_manager::get_and_remove(this,area,key,offset,count,value,type);
}
/*
*List Log Format
*Header Key_Data VALUES_NUM(4B) VALUE1_LENGTH(4B) VALUE1 ...VALUEn_LENGTH(4B) VALUEn
*/
void update_log::log(sn_operation_type operation_type, data_entry &key, vector<data_entry* > &values, uint16_t db_id)
{
uint key_size = key.get_size();
if (key.data_meta.keysize == 0) {
key.data_meta.keysize = key_size;
}
log_debug("key length: %d, value length:%d", key_size, values.size());
uint value_size = 0;
uint header_size = sizeof(item_meta_info);
int total_size = header_size + key_size + 3 + 4;
if (operation_type == SN_LPUSH || operation_type == SN_RPUSH ||
operation_type == SN_LPUSHX || operation_type == SN_RPUSHX) {
size_t values_size = values.size();
for(size_t i = 0; i < values_size; i++) {
value_size = values[i]->get_size();
total_size += value_size;
}
if(key.data_meta.valsize == 0) {
key.data_meta.valsize = total_size;
}
}
char *log_str = (char *)malloc(total_size);
memcpy(log_str, &(key.data_meta), header_size);
char *ptr = log_str + header_size;
*((int8_t *)ptr) = (int8_t)operation_type;
*((uint16_t *)(ptr + 1)) = (uint16_t)db_id;
memcpy(ptr + 3, key.get_data(), key_size);
if (operation_type == SN_PUT) {
size_t values_size = values.size();
key_size += 3;
for(size_t i = 0; i < values_size; i++) {
memcpy(ptr + key_size, values[i]->get_data(), values[i]->get_size());
key_size += values[i]->get_size();
}
}
PROFILER_BEGIN("write migrate log");
writer->write(log_str, total_size);
PROFILER_END();
free(log_str);
}
//add del key
bool add_del_key(const data_entry& key)
{
uint temp = len + key.get_size() + 1;
if (temp > MAX_MUPDATE_PACKET_SIZE){
return false;
}
if (key_and_values == NULL) {
key_and_values = new tair_operc_vector();
}
operation_record *oprec = new operation_record();
oprec->key = new data_entry();
oprec->key->clone(key);
//log_debug("addkeyis %d", oprec->key->m_isMerged);
oprec->operation_type = 2;
oprec->value = NULL;
key_and_values->push_back(oprec);
count++;
len += key.get_size() + 1;
return true;
}
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;
}
int fdb_manager::get(int bucket_number, data_entry & key,
data_entry & value, bool with_stat)
{
fdb_bucket *bucket = get_bucket(bucket_number);
if(bucket == NULL) {
return TAIR_RETURN_FAILED;
}
int rc = TAIR_RETURN_SUCCESS;
PROFILER_BEGIN("get from cache");
if(memory_cache->get(bucket_number, key, value) == EXIT_SUCCESS) {
log_debug("value get from mdb, size: %d", value.get_size());
value.decode_meta(true);
key.data_meta = value.data_meta;
log_debug("memcache ing");
key.data_meta.log_self();
log_debug("cache hit...");
PROFILER_END();
return rc;
}
PROFILER_END();
rc = bucket->get(key, value);
log_debug("fdb getting");
key.data_meta.log_self();
PROFILER_BEGIN("put into cache");
if(rc == TAIR_RETURN_SUCCESS) {
data_entry temp_value = value;
temp_value.merge_meta();
log_debug("value put into mdb, size: %d", temp_value.get_size());
memory_cache->put(bucket_number, key, temp_value, false,
key.data_meta.edate);
}
PROFILER_END();
return rc;
}
bool add_put_key_data(const data_entry &key, const value_entry &data)
{
uint32_t temp = len + key.get_size() + 1 + data.get_size();
if (temp > MAX_MPUT_PACKET_SIZE && count > 0) {
log_info("mput packet size overflow: %u", temp);
return false;
}
if (record_vec == NULL) {
record_vec = new mput_record_vec();
alloc = true;
}
mput_record* rec = new mput_record();
rec->key = new data_entry();
rec->key->clone(key);
rec->value = new value_entry();
rec->value->clone(data);
record_vec->push_back(rec);
len += key.get_size() + 1;
len += data.get_size();
count++;
return true;
}
int get_from_local_cluster(ClusterHandler& handler, data_entry& key, data_entry*& value)
{
int ret = handler.client()->get_hidden(key.get_area(), key, value);
if (ret == TAIR_RETURN_HIDDEN)
{
ret = TAIR_RETURN_SUCCESS;
}
else if (ret == TAIR_RETURN_DATA_EXPIRED)
{
ret = TAIR_RETURN_DATA_NOT_EXIST;
}
return ret;
}
int item_manager::get_items(tair_manager *tair_mgr,int area,data_entry& key,int offset,int count,data_entry& value /*out*/,int type)
{
if(area < 0 || key.get_size() <= 0 || count < 1){
return TAIR_RETURN_INVALID_ARGUMENT;
}
data_entry tmp_value;
vector<any> items;
int ret = -1;
log_debug("start get_items:type:%d",type);
if ( (ret = __get_items(tair_mgr,area,key,tmp_value,items,type)) < 0){
log_debug("__get_items failed:%d",ret);
return ret;
}
vector<any>::iterator start;
vector<any>::iterator end;
if ( (ret = __set_region(items,offset,count,start,end)) < 0){
log_debug("__set_region failed");
return ret;
}
int result_count = end - start;
uint32_t attr = get_attribute(tmp_value);
uint32_t result_attr = 0;
SET_VAL_COUNT(result_attr,result_count);
SET_VAL_TYPE(result_attr,VAL_TYPE(attr));
string result( reinterpret_cast<char *>(&result_attr),sizeof(uint32_t));//just reserve space
if( !prepare_serialize(VAL_TYPE(attr),start,end,result) ){
log_debug("prepare_serialize failed");
return TAIR_RETURN_SERIALIZE_ERROR;
}
log_debug("end get_items: success");
value.set_data(result.data(),result.size(),true);
set_attribute(value,result_attr);
return TAIR_RETURN_SUCCESS;
}
int tair_manager::add_items(int area,
data_entry& key,
data_entry& value,
int max_count, int expire_time/* = 0*/)
{
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 (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;
}
key.data_meta.flag |= TAIR_ITEM_FLAG_ITEM;
tbsys::CThreadGuard guard(&item_mutex[get_mutex_index(key)]);
return json::item_manager::add_items(this,area,key,value,max_count,expire_time);
}
//add put key and data
bool add_put_key_data(const data_entry &key, const data_entry &data)
{
uint temp = len + key.get_size() + 1 + data.get_size();
if (temp> MAX_MUPDATE_PACKET_SIZE && count >0){
return false;
}
if (key_and_values == NULL) {
key_and_values = new tair_operc_vector();
}
operation_record *oprec = new operation_record();
oprec->operation_type = 1;
oprec->key = new data_entry();
//log_debug("2addputkeyis %d",key.m_isMerged);
oprec->key->clone(key);
//log_debug("addputkeyis %d", oprec->key->m_isMerged);
oprec->value = new data_entry();
oprec->value->clone(data);
key_and_values->push_back(oprec);
len += key.get_size() + 1;
len += data.get_size();
count++;
return true;
}
int item_manager::add_items(tair_manager *tair_mgr,int area,data_entry& key,data_entry& value,int max_count,int expired)
{
if( UNLIKELY(area < 0 || max_count <= 0)){
return TAIR_RETURN_INVALID_ARGUMENT;
}
if( UNLIKELY(max_count > item_manager::MAX_ITEMS)){
max_count = item_manager::MAX_ITEMS;
}
int version = key.get_version();
data_entry old_value;
log_debug("start add_items");
if( tair_mgr->get(area,key,old_value) != TAIR_RETURN_SUCCESS){ // is new
tair_mgr->get_storage_manager()->set_flag(value.data_meta.flag, TAIR_ITEM_FLAG_ITEM);
// value.data_meta.flag |= TAIR_ITEM_FLAG_ITEM;
uint32_t _new_attr = get_attribute(value);
string _new_result(reinterpret_cast<char *>(&_new_attr),sizeof(_new_attr)); //just reserve space
int _new_items_no = new_items(value,VAL_TYPE(_new_attr),max_count,_new_result);
if(_new_items_no < 0){
return TAIR_RETURN_SERIALIZE_ERROR;
}
SET_VAL_COUNT(_new_attr,_new_items_no);
value.set_data(_new_result.data(),_new_result.size(),true); //we must set the value back.
set_attribute(value,_new_attr);
return tair_mgr->put(area,key,value,expired);
}
//whether the version is matched
if( (version != 0) && (version != old_value.get_version())){
return TAIR_RETURN_VERSION_ERROR;
}
//the get method will set the flag
if( !CAN_OVERRIDE(old_value.data_meta.flag,TAIR_ITEM_FLAG_ITEM) ){
log_debug("cann't override old value,old_value's flag:%d\n",old_value.data_meta.flag);
return TAIR_RETURN_CANNOT_OVERRIDE;
}
uint8_t old_flag = 0;
if (tair_mgr->get_storage_manager()->test_flag(old_value.data_meta.flag, TAIR_ITEM_FLAG_DELETED)) {
// if (IS_DELETED(old_value.data_meta.flag)){ // in migrate
old_flag = TAIR_ITEM_FLAG_DELETED;
}
//get and deal with attribute of old_value & value
uint32_t old_attr = get_attribute(old_value);
uint32_t new_attr = get_attribute(value);
if( (VAL_TYPE(new_attr)) != VAL_TYPE(old_attr)){
log_debug("type not match,old_attr:%u,new_attr:%u",old_attr,new_attr);
return TAIR_RETURN_TYPE_NOT_MATCH;
}
//deserialize and merge old_value & value
uint32_t attr = 0;
string result(reinterpret_cast<char *>(&attr),sizeof(attr)); //just reserve space
int item_num = -1;
if( (item_num = merge_items(old_value,value,VAL_TYPE(new_attr),max_count,result)) < 0 ){
log_debug("merge_items failed");
return TAIR_RETURN_SERIALIZE_ERROR;
}
SET_VAL_COUNT(attr,item_num);
SET_VAL_TYPE(attr,(VAL_TYPE(new_attr)));
data_entry final_value;
final_value.set_data(result.data(),result.size(),true);
final_value.set_version(version);
tair_mgr->get_storage_manager()->set_flag(final_value.data_meta.flag, TAIR_ITEM_FLAG_ITEM);
tair_mgr->get_storage_manager()->set_flag(final_value.data_meta.flag, old_flag);
log_debug("final_value:%s",get_items_addr(final_value));
set_attribute(final_value,attr); //set attribute
//put the new value into the storage & return
return tair_mgr->put(area,key,final_value,expired);
}
bool CTestInterfaceBase::compareDataValue(const data_entry& v1, const data_entry& v2) {
if (v1.get_size() != v2.get_size()) return false;
return memcmp(v1.get_data(), v2.get_data(), v1.get_size()) == 0;
}
int do_rsync_data(ClusterHandler& local_handler, ClusterHandler& remote_handler, int32_t type, data_entry& key)
{
data_entry* value = NULL;
// get from local cluster
int ret = get_from_local_cluster(local_handler, key, value);
// attach info to key
if (value != NULL)
{
key.data_meta.cdate = value->data_meta.cdate;
key.data_meta.edate = value->data_meta.edate;
key.data_meta.mdate = value->data_meta.mdate;
key.data_meta.version = value->data_meta.version;
}
log_debug("@@ k:%d %s %d %d %u %u %u.v:%s %d %d", key.get_area(), key.get_size() > 6 ? key.get_data()+6 : "", key.get_size(), key.get_prefix_size(),key.data_meta.cdate,key.data_meta.mdate,key.data_meta.edate, (value != NULL && value->get_size() > 4) ? value->get_data()+4 : "", value != NULL ? value->get_size() : 0, value != NULL ? value->data_meta.flag : -1);
key.server_flag = TAIR_SERVERFLAG_RSYNC;
key.data_meta.flag = TAIR_CLIENT_DATA_MTIME_CARE | TAIR_CLIENT_PUT_SKIP_CACHE_FLAG;
// do repair
if (ret == TAIR_RETURN_SUCCESS || ret == TAIR_RETURN_DATA_NOT_EXIST)
{
switch (type)
{
case TAIR_REMOTE_SYNC_TYPE_PUT:
if (ret == TAIR_RETURN_SUCCESS)
{
log_error("@@ edate : %d %d %d", key.data_meta.mdate, key.data_meta.edate, value->data_meta.edate);
ret = remote_handler.client()->put(key.get_area(), key, *value, 0, 0, false);
if (ret == TAIR_RETURN_MTIME_EARLY)
{
ret = TAIR_RETURN_SUCCESS;
}
}
else
{
log_warn("put but data not exist in local");
ret = TAIR_RETURN_SUCCESS;
}
break;
case TAIR_REMOTE_SYNC_TYPE_DELETE:
if (ret == TAIR_RETURN_DATA_NOT_EXIST)
{
ret = remote_handler.client()->remove(key.get_area(), key);
if (ret == TAIR_RETURN_DATA_NOT_EXIST || ret == TAIR_RETURN_DATA_EXPIRED || ret == TAIR_RETURN_MTIME_EARLY)
{
ret = TAIR_RETURN_SUCCESS;
}
}
else
{
log_warn("delete but data exist in local");
ret = TAIR_RETURN_SUCCESS;
}
break;
default:
log_error("invalid type: %d, ignore", type);
ret = TAIR_RETURN_SUCCESS;
break;
}
}
if (value != NULL)
{
delete value;
}
return ret;
}
int item_manager::remove_items(tair_manager *tair_mgr,int area,data_entry& key,int offset,int count,data_entry* d_value /*= 0*/,int e_type /*=ELEMENT_INVALID_TYPE*/)
{
// assert(area >= 0);
// assert(key.get_size() > 0);
// assert(count >= 0);
if(area < 0 || key.get_size() <= 0 || count < 1){
return TAIR_RETURN_INVALID_ARGUMENT;
}
data_entry tmp_value;
vector<any> items;
int ret = -1;
if ( (ret = __get_items(tair_mgr,area,key,tmp_value,items,e_type)) < 0){
return ret;
}
vector<any>::iterator start;
vector<any>::iterator end;
if ( (ret = __set_region(items,offset,count,start,end)) < 0){
return ret;
}
uint32_t attr = get_attribute(tmp_value);
int delete_count = end - start;
log_debug("delete_count:%d",delete_count);
int type = VAL_TYPE(attr);
assert(delete_count <= numeric_cast<int>(items.size()));
if(d_value){
uint32_t d_attr = 0;
string d_result( reinterpret_cast<char *>(&d_attr),sizeof(d_attr)); //just reserve space
prepare_serialize(type,start,end,d_result);
SET_VAL_COUNT(d_attr, delete_count);
SET_VAL_TYPE(d_attr,type);
d_value->set_data(d_result.data(),d_result.size(),true);
set_attribute(*d_value,d_attr); //set attribute
}
uint32_t result_attr = 0;
string result( reinterpret_cast<char *>(&result_attr),sizeof(uint32_t));
vector<any>::iterator remain_start;
vector<any>::iterator remain_end;
if(delete_count == numeric_cast<int>(items.size())){ //delete all
return tair_mgr->remove(area,key);
}else if(start == items.begin()){
remain_start = end;
remain_end = items.end();
ret = prepare_serialize(type,remain_start,remain_end,result);
}else if(end == items.end()){
remain_start = items.begin();
remain_end = start;
ret = prepare_serialize(type,remain_start,remain_end,result);
}else{
result += "[";
remain_start = items.begin();
remain_end = start;
ret = prepare_serialize(type,remain_start,remain_end,result,true);
if(ret){
result += ",";
remain_start = end;
remain_end = items.end();
ret = prepare_serialize(type,remain_start,remain_end,result,true);
}
result += "]";
}
if( !ret ){
return TAIR_RETURN_SERIALIZE_ERROR;
}
int exist_num = numeric_cast<int>(items.size()) - delete_count;
SET_VAL_COUNT(result_attr, exist_num);
SET_VAL_TYPE(result_attr,type);
data_entry final_value;
final_value.set_data(result.data(),result.size(),true);
tair_mgr->get_storage_manager()->set_flag(final_value.data_meta.flag, TAIR_ITEM_FLAG_ITEM);
// final_value.data_meta.flag |= TAIR_ITEM_FLAG_ITEM;
set_attribute(final_value,result_attr);
log_debug("remain data:%s",get_items_addr(final_value));
return tair_mgr->put(area,key,final_value,0); //TODO expire
}
int tair_manager::get_mutex_index(data_entry &key)
{
uint32_t hashcode = util::string_util::mur_mur_hash(key.get_data(), key.get_size());
return hashcode % mutex_array_size;
}
// private methods
uint32_t tair_manager::get_bucket_number(data_entry &key)
{
uint32_t hashcode = tair::util::string_util::mur_mur_hash(key.get_data(), key.get_size());
log_debug("hashcode: %u, bucket count: %d", hashcode, table_mgr->get_bucket_count());
return hashcode % table_mgr->get_bucket_count();
}
