C++ data_entry::get_data方法代码示例

   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 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;
      }

   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::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();
 }

    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;
}