C++ StatusMessage::get_error方法代码示例

int family_process(const uint64_t ns_id, map<uint64_t, int32_t>& family_map)
{
  const int32_t num = 1000;
  ShowServerInformationMessage msg;
  SSMScanParameter& param = msg.get_param();
  param.type_ = SSM_TYPE_FAMILY;

  param.should_actual_count_ = (num << 16);
  param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;
  //其余，如param.start_next_position_ 等都初始化为0

  while (!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES))
  {
    param.data_.clear();
    tbnet::Packet*ret_msg = NULL;
    NewClient* client = NewClientManager::get_instance().create_client();
    int ret = send_msg_to_server(ns_id, client, &msg, ret_msg, DEFAULT_NETWORK_CALL_TIMEOUT, true);
    if (TFS_SUCCESS != ret || ret_msg == NULL)
    {
      TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
      NewClientManager::get_instance().destroy_client(client);
      return EXIT_TFS_ERROR;
    }
    if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
    {
      if (ret_msg->getPCode() == STATUS_MESSAGE)
      {
        StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
        TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
      }
      TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
      NewClientManager::get_instance().destroy_client(client);
      return EXIT_TFS_ERROR;
    }
    ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
    SSMScanParameter& ret_param = message->get_param();

    int32_t data_len = ret_param.data_.getDataLen();
    int32_t offset = 0;
    while (data_len > offset)
    {
      FamilyShow family;
      if (TFS_SUCCESS == family.deserialize(ret_param.data_, data_len, offset))
      {
        family_map.insert(make_pair(family.family_id_, family.family_aid_info_));
      }
    }
    param.start_next_position_ = (ret_param.start_next_position_ << 16) & 0xffff0000;
    param.end_flag_ = ret_param.end_flag_;
    if (param.end_flag_ & SSM_SCAN_CUTOVER_FLAG_NO)
    {
      param.addition_param1_ = ret_param.addition_param2_;//next start family_id to scan
    }
    NewClientManager::get_instance().destroy_client(client);
  }
  return TFS_SUCCESS;
}

    int OpManager::update_block_info(const BlockInfoV2& block_info, const common::UpdateBlockInfoType type)
    {
      int ret = TFS_SUCCESS;
      DsRuntimeGlobalInformation& ds_info = DsRuntimeGlobalInformation::instance();
      create_msg_ref(UpdateBlockInfoMessageV2, req_msg);
      req_msg.set_block_info(block_info);
      req_msg.set_type(type);
      req_msg.set_server_id(ds_info.information_.id_);

      NewClient* client = NewClientManager::get_instance().create_client();
      if (NULL == client)
      {
        ret = EXIT_CLIENT_MANAGER_CREATE_CLIENT_ERROR;
      }
      else
      {
        tbnet::Packet* ret_msg = NULL;
        ret = send_msg_to_server(ds_info.ns_vip_port_, client, &req_msg, ret_msg);
        if (TFS_SUCCESS == ret)
        {
          if (STATUS_MESSAGE == ret_msg->getPCode())
          {
            StatusMessage* smsg = dynamic_cast<StatusMessage*>(ret_msg);
            ret = smsg->get_status();
            TBSYS_LOG(DEBUG, "update block info. blockid: %"PRI64_PREFIX"u, status: %d %s",
                block_info.block_id_, smsg->get_status(), smsg->get_error());
          }
          else
          {
            ret = EXIT_COMMIT_BLOCK_UPDATE_ERROR;
          }
        }
        NewClientManager::get_instance().destroy_client(client);
      }

      return ret;
    }

int get_crc_from_block_list(const string& old_tfs_client, const string& new_tfs_client,
    const string& modify_time, int64_t index, int64_t len)
{
  int ret = TFS_ERROR;
  uint32_t block_id = 0;
  int64_t i = 0;

  for (i = 0; i < len; i++)
  {
    block_id = atol(g_input_lines[index+i].c_str());
    VUINT64 ds_list;
    ToolUtil::get_block_ds_list(Func::get_host_ip(old_tfs_client.c_str()), block_id, ds_list);
    if(ds_list.size() > 0)
    {
      uint64_t ds_id = ds_list[0];

      FILE_INFO_LIST file_list;
      GetServerStatusMessage gss_message;
      gss_message.set_status_type(GSS_BLOCK_FILE_INFO);
      gss_message.set_return_row(block_id);

      NewClient* client = NewClientManager::get_instance().create_client();
      tbnet::Packet* ret_message = NULL;
      if (NULL != client)
      {
        if ((ret = send_msg_to_server(ds_id, client, &gss_message, ret_message)) == TFS_SUCCESS)
        {
          if (ret_message->getPCode() == BLOCK_FILE_INFO_MESSAGE)
          {
            BlockFileInfoMessage *bfi_message = (BlockFileInfoMessage*)ret_message;
            FILE_INFO_LIST* file_info_list = bfi_message->get_fileinfo_list();
            FILE_INFO_LIST::iterator vit = file_info_list->begin();
            for ( ; vit != file_info_list->end(); ++vit)
            {
              file_list.push_back(*vit);
            }
          }
          else if (ret_message->getPCode() == STATUS_MESSAGE)
          {
            StatusMessage* sm = reinterpret_cast<StatusMessage*> (ret_message);
            if (sm->get_error() != NULL)
            {
              TBSYS_LOG(ERROR, "%s", sm->get_error());
              ret = TFS_ERROR;
            }
          }
        }
        else
        {
          TBSYS_LOG(ERROR, "send message to server failed. ds_addr: %s, pcode: %d, ret: %d",
              tbsys::CNetUtil::addrToString(ds_id).c_str(), gss_message.getPCode(), ret);
        }
        NewClientManager::get_instance().destroy_client(client);
      }
      else
      {
        TBSYS_LOG(ERROR,"create client error");
      }

      if (ret == TFS_SUCCESS)
      {
        FILE_INFO_LIST::iterator vit = file_list.begin();
        int i = 0;
        for ( ; vit != file_list.end(); ++vit)
        {
          ++i;
          FSName fsname(block_id, vit->id_, g_tfs_client->get_cluster_id(old_tfs_client.c_str()));
          TBSYS_LOG(DEBUG, "gene file i: %d, blockid: %u, fileid: %"PRI64_PREFIX"u, %s",
              i, block_id, (vit)->id_, fsname.get_name());
          get_crc_from_filename(old_tfs_client, new_tfs_client, fsname.get_name(), modify_time);
        }

        file_list.clear();
      }
    }
    else
    {
      TBSYS_LOG(ERROR,"get block info for blockid: %u failure.",block_id);
    }
 }
 return ret;
}

    int ShowInfo::show_family(const int8_t type, const int32_t num, const int64_t family_id, int32_t count, const int32_t interval, const string& filename)
    {
      interrupt_ = false;
      is_loop_ = (count == 0);//count表示循环重复拉取的次数,默认是1，0表示一直按照间间隔循环
      FILE* fp = NULL;
      if (TFS_SUCCESS != get_file_handle(filename, &fp))
      {
        return EXIT_TFS_ERROR;
      }

      while ((count > 0 || is_loop_) && !interrupt_)
      {
        ShowServerInformationMessage msg;
        SSMScanParameter& param = msg.get_param();
        param.type_ = SSM_TYPE_FAMILY;

        uint64_t family_count = 0;
        bool once = false;
        if (family_id > 0)
        {
          param.should_actual_count_ = 0x10000;
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_NO;
          param.start_next_position_ = ((family_id % nameserver::MAX_FAMILY_CHUNK_NUM) << 16);
          param.addition_param1_ = family_id;
          once = true;
        }
        else if (family_id == 0)
        {
          if (type & BLOCK_TYPE_SERVER_LIST)
          {
            fprintf(fp, "para error, -s must be used with -d\n");
            put_file_handle(fp);
            return EXIT_PARAMETER_ERROR;
          }
          param.should_actual_count_ = (num << 16);
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;
          //其余，如param.start_next_position_ 等都初始化为0
        }
        else
        {
          TBSYS_LOG(ERROR, "get invalid family_id: %"PRI64_PREFIX"d < 0", family_id);
          put_file_handle(fp);
          return EXIT_PARAMETER_ERROR;
        }

        while ((!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES)) && !interrupt_)
        {
          param.data_.clear();
          tbnet::Packet*ret_msg = NULL;
          NewClient* client = NewClientManager::get_instance().create_client();
          int ret = send_msg_to_server(ns_ip_, client, &msg, ret_msg);
          if (TFS_SUCCESS != ret || ret_msg == NULL)
          {
            TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
            NewClientManager::get_instance().destroy_client(client);
            put_file_handle(fp);
            return EXIT_TFS_ERROR;
          }
          if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
          {
            if (ret_msg->getPCode() == STATUS_MESSAGE)
            {
              StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
              TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
            }
            TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
            NewClientManager::get_instance().destroy_client(client);
            put_file_handle(fp);
            return EXIT_TFS_ERROR;
          }
          ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
          SSMScanParameter& ret_param = message->get_param();

          int32_t data_len = ret_param.data_.getDataLen();
          int32_t offset = 0;
          if (data_len > 0)
          {
            print_header(FAMILY_TYPE, type, fp);
          }
          while ((data_len > offset) && !interrupt_)
          {
            FamilyShow family;
            if (TFS_SUCCESS == family.deserialize(ret_param.data_, data_len, offset))
            {
              if (once && (family.family_id_ != family_id))
              {
                //TBSYS_LOG(ERROR, "only get family: %"PRI64_PREFIX"u, but %"PRI64_PREFIX"u not exists", family.family_id_, family_id);
                break;
              }
              if (once && (type & BLOCK_TYPE_SERVER_LIST))
              {
                ret = family.get_members_ds_list(ns_ip_);
                if (TFS_SUCCESS != ret)
                {
                  put_file_handle(fp);
                  return ret;
                }
              }
              family.dump(type, fp);
              ++family_count;
//.........这里部分代码省略.........

    int ShowInfo::show_block_common(const int32_t num, const uint64_t block_id, int32_t count,
        const int32_t interval, const string& filename, BaseBlockWorker* worker)
    {
      FILE* fp = NULL;
      if (TFS_SUCCESS != get_file_handle(filename, &fp))
      {
        return EXIT_TFS_ERROR;
      }
      interrupt_ = false;
      is_loop_ = (count == 0);

      while ((count > 0 || is_loop_) && !interrupt_)
      {
        if(TFS_SUCCESS != worker->begin())
        {
          put_file_handle(fp);
          return EXIT_TFS_ERROR;
        }
        ShowServerInformationMessage msg;
        SSMScanParameter& param = msg.get_param();
        param.type_ = SSM_TYPE_BLOCK;//遍历ns上的block数据的类型
        param.child_type_ = SSM_CHILD_BLOCK_TYPE_INFO | SSM_CHILD_BLOCK_TYPE_SERVER;//TYPE_INFO只为取block_id, TYPE_SERVER为ds_list

        bool once = false;
        if (block_id > 0)
        {
          param.should_actual_count_ = 0x10000;
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_NO;
          param.start_next_position_ = ((block_id % nameserver::MAX_BLOCK_CHUNK_NUMS) << 16);//start是本次在ns上开始扫描blocks的桶的位置
          param.addition_param1_ = block_id;
          once = true;
        }
        else
        {
          param.should_actual_count_ = (num << 16);
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;
        }

        print_header(worker->block_type_, worker->sub_type_, fp);
        while ((!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES)) && !interrupt_)
        {
          param.data_.clear();
          tbnet::Packet*ret_msg = NULL;
          NewClient* client = NewClientManager::get_instance().create_client();
          int ret = send_msg_to_server(ns_ip_, client, &msg, ret_msg);
          if (TFS_SUCCESS != ret || ret_msg == NULL)
          {
            TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
            NewClientManager::get_instance().destroy_client(client);
            put_file_handle(fp);
            return EXIT_TFS_ERROR;
          }
          if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
          {
            if (ret_msg->getPCode() == STATUS_MESSAGE)
            {
              StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
              TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
            }
            TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
            NewClientManager::get_instance().destroy_client(client);
            put_file_handle(fp);
            return EXIT_TFS_ERROR;
          }
          ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
          SSMScanParameter& ret_param = message->get_param();

          int32_t data_len = ret_param.data_.getDataLen();
          int32_t offset = 0;
          //如果指定的blockid不存在，且block表中[start_next_position_, +00)这些桶内没有block,则拉取block个数为0
          while ((data_len > offset) && !interrupt_)
          {
            BlockBase* base_block = worker->create_block();
            ret = base_block->deserialize(ret_param.data_, data_len, offset, param.child_type_);
            if (TFS_SUCCESS == ret)
            {
              base_block->BlockBase::dump();// log info of each block info
              if (once && (base_block->info_.block_id_ != block_id))
              {
                //TBSYS_LOG(ERROR, "block: %"PRI64_PREFIX"u,%"PRI64_PREFIX"u not exists", base_block->info_.block_id_, block_id);
                break;
              }
              worker->process(base_block, fp);// not sort by block
            }
            else
            {
              TBSYS_LOG(ERROR, "Block deserialize error, ret: %d", ret);
              NewClientManager::get_instance().destroy_client(client);
              put_file_handle(fp);
              return ret;
            }
            tbsys::gDelete(base_block);
          }
          param.start_next_position_ = (ret_param.start_next_position_ << 16) & 0xffff0000;
          param.end_flag_ = ret_param.end_flag_;
          if (param.end_flag_ & SSM_SCAN_CUTOVER_FLAG_NO)
          {
            param.addition_param1_ = ret_param.addition_param2_;
          }
          NewClientManager::get_instance().destroy_client(client);
//.........这里部分代码省略.........

    int ShowInfo::show_block(const int8_t type, const int32_t num, const uint32_t block_id, const int32_t block_chunk_num, int32_t count, const int32_t interval, const string& filename)
    {
      interrupt_ = false;
      is_loop_ = (count == 0);
      FILE* fp = NULL;
      if (TFS_ERROR == get_file_handle(filename, &fp))
      {
        return TFS_ERROR;
      }

      while ((count > 0 || is_loop_) && !interrupt_)
      {
        StatStruct stat;

        ShowServerInformationMessage msg;
        SSMScanParameter& param = msg.get_param();
        param.type_ = SSM_TYPE_BLOCK;
        param.child_type_ = SSM_CHILD_BLOCK_TYPE_INFO | SSM_CHILD_BLOCK_TYPE_SERVER;

        bool once = false;
        if (block_id > 0)
        {
          param.should_actual_count_ = 0x10000;
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_NO;
          param.should_actual_count_ = 0x10000;
          param.start_next_position_ = ((block_id % block_chunk_num) << 16);
          param.addition_param1_ = block_id;
          once = true;
        }
        else
        {
          param.should_actual_count_ = (num << 16);
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;
        }

        while ((!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES)) && !interrupt_)
        {
          param.data_.clear();
          block_set_.clear();
          tbnet::Packet*ret_msg = NULL;
          NewClient* client = NewClientManager::get_instance().create_client();
          int ret = send_msg_to_server(ns_ip_, client, &msg, ret_msg);
          if (TFS_SUCCESS != ret || ret_msg == NULL)
          {
            TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
            NewClientManager::get_instance().destroy_client(client);
            return TFS_ERROR;
          }
          //TBSYS_LOG(DEBUG, "pCode: %d", ret_msg->get_message_type());
          if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
          {
            if (ret_msg->getPCode() == STATUS_MESSAGE)
            {
              StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
              TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
            }
            TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
            NewClientManager::get_instance().destroy_client(client);
            return TFS_ERROR;
          }
          ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
          SSMScanParameter& ret_param = message->get_param();

          int32_t data_len = ret_param.data_.getDataLen();
          int32_t offset = 0;
          if (data_len > 0)
          {
            print_header(BLOCK_TYPE, type, fp);
          }
          while ((data_len > offset) && !interrupt_)
          {
            BlockShow block;
            if (TFS_SUCCESS == block.deserialize(ret_param.data_, data_len, offset, param.child_type_))
            {
              //block.BlockBase::dump();
              if (once && (block.info_.block_id_ != block_id))
              {
                TBSYS_LOG(ERROR, "block(%u)(%u) not exists", block.info_.block_id_, block_id);
                break;
              }
              stat.add(block);
              block_set_.insert(block);
            }
          }
          std::set<BlockShow>::iterator iter = block_set_.begin();
          for (; iter != block_set_.end(); iter++)
          {
             (*iter).dump(type, fp);
          }
          param.start_next_position_ = (ret_param.start_next_position_ << 16) & 0xffff0000;
          param.end_flag_ = ret_param.end_flag_;
          if (param.end_flag_ & SSM_SCAN_CUTOVER_FLAG_NO)
          {
            param.addition_param1_ = ret_param.addition_param2_;
          }
          NewClientManager::get_instance().destroy_client(client);
          if (once)
          {
            break;
          }
//.........这里部分代码省略.........

int block_process(const uint64_t ns_id, const map<uint64_t, int32_t>& family_map, StatInfo& file_stat_info,
    V_BLOCK_SIZE_RANGE& v_block_size_range, V_DEL_BLOCK_RANGE& v_del_block_range, BLOCK_SIZE_SET& s_big_block, const int32_t top_num, BLOCK_SIZE_SET& s_topn_block)
{
  const int32_t num = 1000;
  int32_t ret  = TFS_ERROR;
  file_stat_info.set_family_count(family_map.size());

  ShowServerInformationMessage msg;
  SSMScanParameter& param = msg.get_param();
  param.type_ = SSM_TYPE_BLOCK;
  param.child_type_ = SSM_CHILD_BLOCK_TYPE_INFO | SSM_CHILD_BLOCK_TYPE_SERVER;
  param.should_actual_count_ = (num << 16);
  param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;

  while (!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES))
  {
    param.data_.clear();
    tbnet::Packet*ret_msg = NULL;
    NewClient* client = NewClientManager::get_instance().create_client();
    ret = send_msg_to_server(ns_id, client, &msg, ret_msg, DEFAULT_NETWORK_CALL_TIMEOUT, true);
    if (TFS_SUCCESS != ret || ret_msg == NULL)
    {
      TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
      NewClientManager::get_instance().destroy_client(client);
      return TFS_ERROR;
    }
    //TBSYS_LOG(DEBUG, "pCode: %d", ret_msg->get_message_type());
    if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
    {
      if (ret_msg->getPCode() == STATUS_MESSAGE)
      {
        StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
        TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
      }
      TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
      NewClientManager::get_instance().destroy_client(client);
      return TFS_ERROR;
    }
    ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
    SSMScanParameter& ret_param = message->get_param();

    int32_t data_len = ret_param.data_.getDataLen();
    int32_t offset = 0;
    while (data_len > offset)
    {
      BlockBase block;
      if (TFS_SUCCESS == block.deserialize(ret_param.data_, data_len, offset, param.child_type_))
      {
        //block.dump();
        // add to file stat
        float ratio = static_cast<float>(block.server_list_.size());
        map<uint64_t, int32_t>::const_iterator iter;
        if (INVALID_FAMILY_ID != block.info_.family_id_ &&
            (iter = family_map.find(block.info_.family_id_)) != family_map.end())
        {
          int data_member_num = GET_DATA_MEMBER_NUM(iter->second);
          int check_member_num = GET_CHECK_MEMBER_NUM(iter->second);
          ratio = StatInfo::div((data_member_num + check_member_num), data_member_num);
        }
        file_stat_info.add(block, ratio);
        // check block size is invalid
        if (IS_VERFIFY_BLOCK(block.info_.block_id_))
          continue;

        // do range stat
        ret = do_stat(block.info_.size_ / M_UNITS, v_block_size_range);
        if (ret != TFS_SUCCESS)
        {
          TBSYS_LOG(ERROR, "some error occurs, blockid: %"PRI64_PREFIX"u, size: %d", block.info_.block_id_, block.info_.size_);
        }

        // get big block info
        if (top_num > 0 && block.info_.size_ >= THRESHOLD)
        {
          s_big_block.insert(BlockSize(block.info_.block_id_, block.info_.size_));
        }

        // count del block range
        if (block.info_.del_size_ < 0)
        {
          TBSYS_LOG(ERROR, "some error occurs, blockid: %"PRI64_PREFIX"u, del size: %d, size: %d", block.info_.block_id_, block.info_.del_size_, block.info_.size_);
        }
        else
        {
          int32_t percent = block.info_.size_ > 0 ? static_cast<int32_t>(static_cast<int64_t>(block.info_.del_size_) * 100 / block.info_.size_) : 0;
          ret = do_stat(percent, v_del_block_range);
          if (ret != TFS_SUCCESS)
          {
            TBSYS_LOG(ERROR, "some error occurs, blockid: %"PRI64_PREFIX"u, del size: %d, size: %d", block.info_.block_id_, block.info_.del_size_, block.info_.size_);
          }
        }

        if (top_num > 0 && static_cast<int32_t>(s_topn_block.size()) >= top_num)
        {
          if (block.info_.size_ > s_topn_block.begin()->file_size_)
          {
            s_topn_block.erase(s_topn_block.begin());
            s_topn_block.insert(BlockSize(block.info_.block_id_, block.info_.size_));
          }
        }
//.........这里部分代码省略.........

    int ShowInfo::show_rack_block(const int8_t type, string& rack_ip_mask, string& rack_ip_group, const int32_t num, int32_t count, const int32_t interval, const string& filename)
    {
      interrupt_ = false;
      is_loop_ = (count == 0);
      FILE* fp = NULL;
      if (TFS_ERROR == get_file_handle(filename, &fp))
      {
        return TFS_ERROR;
      }

      while ((count > 0 || is_loop_) && !interrupt_)
      {
        RackBlockShow rack_block;
        ShowServerInformationMessage msg;
        SSMScanParameter& param = msg.get_param();//参数初始化为0
        param.type_ = SSM_TYPE_BLOCK;
        param.child_type_ = SSM_CHILD_BLOCK_TYPE_INFO | SSM_CHILD_BLOCK_TYPE_SERVER;//可以去掉INFO

        param.should_actual_count_ = (num << 16);//每发一次消息读取的block数取最大值
        param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;

        print_header(RACK_BLOCK_TYPE, type, fp);
        while ((!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES)) && !interrupt_)
        {
          param.data_.clear();
          tbnet::Packet*ret_msg = NULL;
          NewClient* client = NewClientManager::get_instance().create_client();
          int ret = send_msg_to_server(ns_ip_, client, &msg, ret_msg);
          if (TFS_SUCCESS != ret || ret_msg == NULL)
          {
            TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
            NewClientManager::get_instance().destroy_client(client);
            return TFS_ERROR;
          }

          if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
          {
            if (ret_msg->getPCode() == STATUS_MESSAGE)
            {
              StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
              TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
            }
            TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
            NewClientManager::get_instance().destroy_client(client);
            return TFS_ERROR;
          }
          ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
          SSMScanParameter& ret_param = message->get_param();

          int32_t data_len = ret_param.data_.getDataLen();
          int32_t offset = 0;
          if (data_len > 0)
          {
          //  print_header(RACK_BLOCK_TYPE, type, fp);
          }
          while ((data_len > offset) && !interrupt_)
          {
            BlockShow block;
            if (TFS_SUCCESS == block.deserialize(ret_param.data_, data_len, offset, param.child_type_))
            {
              rack_block.add(block, rack_ip_mask);
            }
          }
          param.start_next_position_ = (ret_param.start_next_position_ << 16) & 0xffff0000;
          param.end_flag_ = ret_param.end_flag_;
          if (param.end_flag_ & SSM_SCAN_CUTOVER_FLAG_NO)
          {
            param.addition_param1_ = ret_param.addition_param2_;
          }
          NewClientManager::get_instance().destroy_client(client);
        }
        //把所有的block都拉取下来才输出
        rack_block.dump(type, rack_ip_group, fp);

        if (--count)
        {
          sleep(interval);
        }
      }
      if (fp != stdout) fclose(fp);
      return TFS_SUCCESS;
    }

    int ShowInfo::show_block_distribution(const int8_t type,  string& rack_ip_mask, const int32_t num, const uint64_t block_id, int32_t count, const int32_t interval, const string& filename)
    {
      const int32_t block_chunk_num = nameserver::MAX_BLOCK_CHUNK_NUMS;
      interrupt_ = false;
      is_loop_ = (count == 0);
      FILE* fp = NULL;
      if (TFS_ERROR == get_file_handle(filename, &fp))
      {
        return TFS_ERROR;
      }

      while ((count > 0 || is_loop_) && !interrupt_)
      {
        BlockDistributionStruct stat;

        ShowServerInformationMessage msg;
        SSMScanParameter& param = msg.get_param();
        param.type_ = SSM_TYPE_BLOCK;//遍历ns上的block，这里设置的才是找ns取数据的类型
        param.child_type_ = SSM_CHILD_BLOCK_TYPE_SERVER | SSM_CHILD_BLOCK_TYPE_INFO;//TODO:其实只取每个block的server list，但是BlockBase 反序列化接口不一致

        bool once = false;
        if (block_id > 0)
        {
          param.should_actual_count_ = 0x10000;
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_NO;
          param.start_next_position_ = ((block_id % block_chunk_num) << 16);
          param.addition_param1_ = block_id;
          once = true;
        }
        else
        {
          param.should_actual_count_ = (num << 16);//每次should从ns读取的最大block数
          param.end_flag_ = SSM_SCAN_CUTOVER_FLAG_YES;
        }

        print_header(BLOCK_DISTRIBUTION_TYPE, type, fp);
        while ((!((param.end_flag_ >> 4) & SSM_SCAN_END_FLAG_YES)) && !interrupt_)//一直把ns上的所有block读取完成（除非终端中断）
        {
          param.data_.clear();
          tbnet::Packet*ret_msg = NULL;
          NewClient* client = NewClientManager::get_instance().create_client();
          int ret = send_msg_to_server(ns_ip_, client, &msg, ret_msg);
          if (TFS_SUCCESS != ret || ret_msg == NULL)
          {
            TBSYS_LOG(ERROR, "get block info error, ret: %d", ret);
            NewClientManager::get_instance().destroy_client(client);
            return TFS_ERROR;
          }

          if(ret_msg->getPCode() != SHOW_SERVER_INFORMATION_MESSAGE)
          {
            if (ret_msg->getPCode() == STATUS_MESSAGE)
            {
              StatusMessage* msg = dynamic_cast<StatusMessage*>(ret_msg);
              TBSYS_LOG(ERROR, "get invalid message type: error: %s", msg->get_error());
            }
            TBSYS_LOG(ERROR, "get invalid message type, pcode: %d", ret_msg->getPCode());
            NewClientManager::get_instance().destroy_client(client);
            return TFS_ERROR;
          }
          ShowServerInformationMessage* message = dynamic_cast<ShowServerInformationMessage*>(ret_msg);
          SSMScanParameter& ret_param = message->get_param();

          int32_t data_len = ret_param.data_.getDataLen();
          int32_t offset = 0;
         // if (data_len > 0)
         // {
         //   print_header(BLOCK_DISTRIBUTION_TYPE, type, fp);
         // }
        //如果指定的blockid都不存在，且block表中>=start_next_position_桶后没有blockid,则拉取block个数为0
          if(type & BLOCK_IP_DISTRIBUTION_TYPE)
          {
            while ((data_len > offset) && !interrupt_)
            {
              BlockDistributionShow block;
              if (TFS_SUCCESS == block.deserialize(ret_param.data_, data_len, offset, param.child_type_))
              {
                if (once && (block.info_.block_id_ != block_id))
                {
                  TBSYS_LOG(ERROR, "block: %"PRI64_PREFIX"u,%"PRI64_PREFIX"u not exists", block.info_.block_id_, block_id);
                  break;
                }
                if(block.check_block_ip_distribution())
                {
                  block.dump_ip(fp);
                  stat.add(block);
                }
              }
            }
          }
          else
          {
            assert( (type & BLOCK_RACK_DISTRIBUTION_TYPE) );
            while ((data_len > offset) && !interrupt_)
            {
              BlockDistributionShow block;
              if (TFS_SUCCESS == block.deserialize(ret_param.data_, data_len, offset, param.child_type_))
              {
                if (once && (block.info_.block_id_ != block_id))
                {
//.........这里部分代码省略.........

    int Requester::req_update_block_info(const uint32_t block_id, const UpdateBlockType repair)
    {
      UpdateBlockType tmp_repair = repair; 
      BlockInfo* blk = NULL;
      if (UPDATE_BLOCK_MISSING != tmp_repair)
      {
        int32_t visit_count = 0;
        int ret = data_management_->get_block_info(block_id, blk, visit_count);
        if (EXIT_NO_LOGICBLOCK_ERROR == ret)
        {
          tmp_repair = UPDATE_BLOCK_MISSING;
        }
        else
        {
          if (NULL == blk)
          {
            TBSYS_LOG(ERROR, "blockid: %u can not find block info.", block_id);
            tmp_repair = UPDATE_BLOCK_REPAIR;
          }
          else
          {
            TBSYS_LOG(
                INFO,
                "req update block info, blockid: %u, version: %d, file count: %d, size: %d, delfile count: %d, del_size: %d, seqno: %d\n",
                blk->block_id_, blk->version_, blk->file_count_, blk->size_, blk->del_file_count_, blk->del_size_, blk->seq_no_);
          }
        }
      }

      int ret = TFS_ERROR;
      UpdateBlockInfoMessage ub_msg;
      ub_msg.set_block_id(block_id);
      ub_msg.set_block(blk);
      ub_msg.set_server_id(dataserver_id_);
      ub_msg.set_repair(tmp_repair);
      NewClient* client = NewClientManager::get_instance().create_client();
      tbnet::Packet* return_msg = NULL;
      ret = send_msg_to_server(ns_ip_port_, client, &ub_msg, return_msg);
      if (TFS_SUCCESS != ret)
      {
        NewClientManager::get_instance().destroy_client(client);
        return ret;
      }
      int need_expire = 0;
      if (STATUS_MESSAGE == return_msg->getPCode())
      {
        StatusMessage* sm = dynamic_cast<StatusMessage*>(return_msg);
        if (STATUS_MESSAGE_OK == sm->get_status())
        {
          ret = TFS_SUCCESS;
        }
        else if (STATUS_MESSAGE_REMOVE == sm->get_status())
        {
          need_expire = 1;
          ret = TFS_SUCCESS;
        }
        else
        {
          TBSYS_LOG(ERROR, "req update block info: %s, id: %u, tmp_repair: %d\n", sm->get_error(), block_id, tmp_repair);
        }
      }
      else
      {
        TBSYS_LOG(ERROR,"unknow packet pcode: %d", return_msg->getPCode());
      }
      NewClientManager::get_instance().destroy_client(client);

      if (need_expire)
      {
        data_management_->del_single_block(block_id);
      }

      return ret;
    }

    int Requester::req_block_write_complete(const uint32_t block_id,
        const int32_t lease_id, const int32_t success, const UnlinkFlag unlink_flag)
    {
      TBSYS_LOG(DEBUG, "req block write complete begin id: %u, lease_id: %u\n", block_id, lease_id);

      BlockInfo* blk = NULL;
      int visit_count = 0;
      int ret = data_management_->get_block_info(block_id, blk, visit_count);
      if (TFS_SUCCESS != ret)
      {
        TBSYS_LOG(ERROR, "req block write complete: can not find block, id: %u, ret: %d\n", block_id, ret);
        return TFS_ERROR;
      }

      BlockInfo tmpblk;
      memcpy(&tmpblk, blk, sizeof(BlockInfo));
      ret = data_management_->get_block_curr_size(block_id, tmpblk.size_);
      if (TFS_SUCCESS != ret)
      {
        TBSYS_LOG(ERROR, "req block write complete: can not find block, id: %u, ret: %d\n", block_id, ret);
        return TFS_ERROR;
      }

      BlockWriteCompleteMessage bwc_msg;
      bwc_msg.set_block(&tmpblk);
      bwc_msg.set_server_id(dataserver_id_);
      bwc_msg.set_lease_id(lease_id);
      WriteCompleteStatus wc_status = WRITE_COMPLETE_STATUS_YES;
      if (TFS_SUCCESS != success)
      {
        wc_status = WRITE_COMPLETE_STATUS_NO;
      }
      bwc_msg.set_success(wc_status);
      bwc_msg.set_unlink_flag(unlink_flag);

      NewClient* client = NewClientManager::get_instance().create_client();
      tbnet::Packet* return_msg = NULL;
      ret = send_msg_to_server(ns_ip_port_, client, &bwc_msg, return_msg);


      if (TFS_SUCCESS != ret)
      {
        NewClientManager::get_instance().destroy_client(client);
        return ret;
      }

      if (STATUS_MESSAGE == return_msg->getPCode())
      {
        StatusMessage* sm = dynamic_cast<StatusMessage*>(return_msg);
        if (STATUS_MESSAGE_OK == sm->get_status())
        {
          ret = TFS_SUCCESS;
        }
        else
        {
          ret = TFS_ERROR;
          TBSYS_LOG(ERROR, "rep block write complete, nsip: %s, error desc: %s, id: %u\n",
              tbsys::CNetUtil::addrToString(ns_ip_port_).c_str(), sm->get_error(), block_id);
        }
      }
      else
      {
        TBSYS_LOG(ERROR, "rep block write complete, blockid: %u, msg type: %d error.\n", block_id,
            return_msg->getPCode());
        ret = TFS_ERROR;
      }
      NewClientManager::get_instance().destroy_client(client);
      return ret;
    }

int do_monitor(const VSTRING& param, int32_t type)
{
  int ret = TFS_SUCCESS;
  string server = param[0];

  uint64_t ip_port = 0;
  {
    char ip[MAX_CMD_SIZE+1];     // to support mutiple port in the same server, must copy
    ip[MAX_CMD_SIZE] = '\0';
    int32_t port = get_port(strncpy(ip, server.c_str(), MAX_CMD_SIZE));
    ip_port = Func::str_to_addr(ip, port);
  }

  AdminCmdMessage* admin_msg = new AdminCmdMessage(type);
  for (size_t i = 1; i < param.size(); i++)
  {
    admin_msg->set_index(param[i]);
  }

  NewClient* client = NewClientManager::get_instance().create_client();
  if (NULL != client)
  {
    tbnet::Packet* message = NULL;
    if (TFS_SUCCESS == (ret = send_msg_to_server(ip_port, client, admin_msg, message)))
    {
      if (STATUS_MESSAGE == message->getPCode())
      {
        StatusMessage* msg = dynamic_cast<StatusMessage*>(message);
        ret = msg->get_status();
        fprintf(stderr, "%s %s \033[0m\n", ret != TFS_SUCCESS ? FAIL_COLOR : SUC_COLOR, msg->get_error());
      }
      else if (ADMIN_CMD_MESSAGE == message->getPCode() &&
          ADMIN_CMD_RESP == dynamic_cast<AdminCmdMessage*>(message)->get_cmd_type())
      {
        vector<MonitorStatus>* m_status =  dynamic_cast<AdminCmdMessage*>(message)->get_status();
        int32_t size = m_status->size();
        fprintf(stderr, "\033[36m       ================== %s count: %d ===================\033[0m\n",
            server.c_str(), size);

        // update server ==> index
        VSTRING& index = g_server_map[server];
        index.clear();

        for (int32_t i = 0; i < size; i++)
        {
          (*m_status)[i].dump();
          index.push_back((*m_status)[i].index_);
        }
        fprintf(stderr, "\033[36m-----------------------------------------------------------------------------------\033[0m\n\n");
      }
      else
      {
        fprintf(stderr, "%s unknown message recieved, op cmd fail\n \033[0m", FAIL_COLOR);
      }
    }
    else
    {
      fprintf(stderr, "send message error");
    }
    NewClientManager::get_instance().destroy_client(client);

  }
  else
  {
    fprintf(stderr, "create client error");
    ret = TFS_ERROR;
  }

  return ret;
}