コード例 #1
0
ファイル: client_rpc.cpp プロジェクト: Abioy/oceanbase
int ObClientServerStub::get_cs_and_ms()
{
  int                   ret = OB_SUCCESS;
  ObChunkServerManager  obcsm;
  ObChunkServerManager::const_iterator it;
  ObServer              server;
  
  ret = rs_dump_cs_info(obcsm);
  if (OB_SUCCESS != ret)
  {
    fprintf(stderr, "Get chunk server manager error!\n");
    return ret;
  }

  for (it = obcsm.begin(); it != obcsm.end(); ++it)
  {
    ObServer node;
    node = it->server_;
    node.set_port(it->port_cs_);
    chunk_server_list_.push_back(node);
    node.set_port(it->port_ms_);
    merge_server_list_.push_back(node);
  }

  return ret;
}
コード例 #2
0
int ObSchemaServiceMsProvider::reset()
{
  int ret = OB_SUCCESS;
  tbsys::CWLockGuard guard(rwlock_);
  count_ = 0;
  ObChunkServerManager::const_iterator it;
  for (it = server_manager_.begin();
       server_manager_.end() != it && count_ < MAX_SERVER_COUNT;
       ++it)
  {
    if (ObServerStatus::STATUS_DEAD != it->ms_status_)
    {
      ObServer ms = it->server_;
      ms.set_port(it->port_ms_);
      ms_carray_[count_].ms_ = ms;
      ms_carray_[count_].retry_count_ = 0;
      ++count_;
      TBSYS_LOG(DEBUG, "schema service ms provider found count_=%ld, ms=%s", count_, to_cstring(ms));
    }
  } // end for
  // shuffle the server list after reset
  if (count_ > 0)
  {
    // std::random_shuffle(ms_carray_, ms_carray_ + count_);
  }
  return ret;
}
コード例 #3
0
    int ObAppStats::sum_cs_cluster_stats(const ObServer& rs, const ObRole server_type)
    {
      ObClientRpcStub rs_stub;
      ObChunkServerManager obsm;
      int ret = rs_stub.initialize(rs, &GFactory::get_instance().get_base_client().get_client_mgr());
      if (OB_SUCCESS == ret)
      {
        ret = rs_stub.rs_dump_cs_info(obsm);
      }

      ObServer server_list[MAX_SERVER_NUM];
      ObArrayHelper<ObServer> server_array(MAX_SERVER_NUM, server_list, 0);
      if (OB_SUCCESS == ret)
      {
        ObChunkServerManager::const_iterator it = obsm.begin();
        ObServer node;
        while (it != obsm.end())
        {
          node = it->server_;
          if (server_type == OB_CHUNKSERVER)
            node.set_port(it->port_cs_);
          else
            node.set_port(it->port_ms_);

          /*
          node.to_string(ipstr, 64);
             fprintf(stderr, "dump server ip:%s, server status:%ld, serving:%d\n",
             ipstr, it->status_, ObServerStatus::STATUS_SERVING);
             */

          if (it->status_ != ObServerStatus::STATUS_DEAD)
          {
            server_array.push_back(node);
          }
          ++it;
        }

        ret = sum_cluster_stats(server_type, server_array);

      }

      return ret;
    }
コード例 #4
0
    int32_t ObClusterStats::refresh()
    {
      int ret = 0;
      ObRole server_type = store_.diff.get_server_type();
      if (server_type == OB_ROOTSERVER)
      {
        ret = ObServerStats::refresh();
      }
      else if (server_type == OB_UPDATESERVER)
      {
        ObServer update_server;
        ret = rpc_stub_.get_update_server(update_server);
        ObClientRpcStub update_stub;
        if (OB_SUCCESS == ret)
        {
          ret = update_stub.initialize(update_server,
              &GFactory::get_instance().get_base_client().get_client_mgr());
        }
        if (OB_SUCCESS == ret)
        {
          ret = update_stub.fetch_stats(store_.current);
        }
      }
      else if (server_type == OB_CHUNKSERVER
          || server_type == OB_MERGESERVER)
      {
        ObChunkServerManager obsm;
        ret = rpc_stub_.rs_dump_cs_info(obsm);
        if (OB_SUCCESS == ret)
        {
          ObChunkServerManager::const_iterator it = obsm.begin();
          ObServer node;
          char ipstr[OB_MAX_SERVER_ADDR_SIZE];
          int alive_server_count = 0;
          while (it != obsm.end())
          {
            node = it->server_;
            if (server_type == OB_CHUNKSERVER)
              node.set_port(it->port_cs_);
            else
              node.set_port(it->port_ms_);

            node.to_string(ipstr, OB_MAX_SERVER_ADDR_SIZE);
            /*
            fprintf(stderr, "dump server ip:%s, server status:%ld, serving:%d\n",
                ipstr, it->status_, ObServerStatus::STATUS_SERVING);
                */

            if (it->status_ != ObServerStatus::STATUS_DEAD)
            {
              ObClientRpcStub node_stub;
              ObStatManager node_stats;
              node_stats.set_server_type(server_type);
              ret = node_stub.initialize( node, &GFactory::get_instance().get_base_client().get_client_mgr());
              if (OB_SUCCESS != ret) { ++it; continue ;}
              ret = node_stub.fetch_stats(node_stats);
              //printf("ret=%d, node_stats:%lu\n", ret, node_stats.get_server_type());
              if (OB_SUCCESS != ret) { ++it; continue ;}
              if (alive_server_count == 0)
                store_.current = node_stats;
              else
                store_.current.add(node_stats);
              ++alive_server_count;
            }
            ++it;
          }

          if (0 == alive_server_count)
          {
            fprintf(stderr, "no any alive servers, cannot collect data.\n");
          }

        }

      }
      return ret;
    }