Ejemplo n.º 1
0
int main(int argc, char **argv)
{
  if (argc < 5)
  {
    usage(argv[0]);
    return 1;
  }

  gstreamer.set_packet_factory(&gfactory);
  NewClientManager::get_instance().initialize(&gfactory, &gstreamer);

  const char *root_ipport = argv[1];
  const char *local_ipport = argv[2];
  char *stat_time = argv[3];
  ExpireTaskType type = static_cast<ExpireTaskType>(atoi(argv[4]));

  uint64_t root_id = Func::get_host_ip(root_ipport);
  uint64_t local_id = Func::get_host_ip(local_ipport);
  int32_t spec_time = tbsys::CTimeUtil::strToTime(stat_time);

  printf("root_id: %"PRI64_PREFIX"d, es_id: %"PRI64_PREFIX"d, spec_time: %d, type: %d\n", root_id, local_id, spec_time, type);

  int32_t percent = 0;
  ReqQueryProgressMessage req_qp_msg;
  req_qp_msg.set_es_id(local_id);
  req_qp_msg.set_es_num(0);
  req_qp_msg.set_task_time(spec_time);
  req_qp_msg.set_hash_bucket_id(0);
  req_qp_msg.set_expire_task_type(type);

  tbnet::Packet *rsp = NULL;
  NewClient *client = NewClientManager::get_instance().create_client();
  int ret = send_msg_to_server(root_id, client, &req_qp_msg, rsp, ClientConfig::wait_timeout_);

  if (TFS_SUCCESS != ret)
  {
    printf("call query progress fail, ret: %d\n", ret);
    ret = EXIT_NETWORK_ERROR;
  }
  else if (RSP_QUERY_PROGRESS_MESSAGE == rsp->getPCode())
  {
    RspQueryProgressMessage *rsp_qp_msg = dynamic_cast<RspQueryProgressMessage*>(rsp);
    percent = rsp_qp_msg->get_current_percent();
    printf("query progress success, current percent: %d\%%\n", percent);
  }
Ejemplo n.º 2
0
int main(int argc, char *argv[])
{
  gstreamer.set_packet_factory(&gfactory);

  tfs::common::NewClientManager::get_instance().initialize(&gfactory, &gstreamer);

  int i;

  std::string old_server;
  std::string new_server;
  std::string log_file_name;
  std::string input_file_name;
  while ((i = getopt(argc, argv, "i:o:n:l:")) != EOF)
  {
    switch (i)
    {
      case 'i':
        input_file_name = optarg;
        break;
      case 'o':
        old_server = optarg;
        break;
      case 'n':
        new_server = optarg;
        break;
      case 'l':
        log_file_name = optarg;
        break;
      default:
        usage(argv[0]);
        return TFS_ERROR;
    }
  }
  cout << input_file_name  << "  -" << old_server << "  -" << new_server << "  -" << log_file_name << endl;
  if (input_file_name.empty() || log_file_name.empty())
  {
    usage(argv[0]);
    return TFS_ERROR;
  }
  TBSYS_LOGGER.setFileName(log_file_name.c_str());
  TBSYS_LOGGER.setLogLevel("info");
  signal(SIGINT, sign_handler);

  NameMetaClientImpl old_client;
  if( TFS_SUCCESS != old_client.initialize( old_server.c_str() ) )
  {
    return TFS_ERROR;
  }
  TBSYS_LOG(DEBUG, "old_client initialize SUCCESS");

  old_server_id = Func::get_host_ip(old_server.c_str());
  new_server_id = Func::get_host_ip(new_server.c_str());
  string tfs_name = "/";
  int32_t ret = TFS_SUCCESS;
  FILE *s_fd = NULL;
  s_fd = fopen(input_file_name.c_str(), "r");
  if (NULL == s_fd)
  {
    printf(" open file %s for read error\n", input_file_name.c_str());
    ret =  TFS_ERROR;
  }
  char buff[128];
  while(TFS_SUCCESS == ret && 1 != stop)
  {
    if (NULL == fgets(buff, 128, s_fd))
    {
      break;
    }
    buff[127] = 0;
    char *p = NULL;
    const char DLIMER = ',';
    p = strchr(buff, DLIMER);
    if (NULL == p)
    {
      TBSYS_LOG(ERROR, "err input line %s", buff);
      continue;
    }
    app_id = -1;
    uid = -1;
    *p = '\0';
    app_id = strtoll(buff, NULL, 10);
    uid = strtoll(p + 1, NULL, 10);
    if (app_id <= 0 || uid <= 0)
    {
      *p = DLIMER;
      TBSYS_LOG(ERROR, "err input line %s", buff);
      continue;
    }
    TBSYS_LOG(INFO, "check app_id %ld uid %ld", app_id, uid);
    ret = check(old_client, tfs_name);
  }
  fclose(s_fd);
  s_fd = NULL;
  return 0;
}
Ejemplo n.º 3
0
int main(int argc, char* argv[])
{
    int32_t i;
    int ret = TFS_SUCCESS;
    bool directly = false;
    bool set_log_level = false;

    // analyze arguments
    while ((i = getopt(argc, argv, "s:r:nih")) != EOF)
    {
        switch (i)
        {
        case 'n':
            set_log_level = true;
            break;
        case 's':
            nsip = optarg;
            break;
        case 'r':
            rc_addr = optarg;
            break;
        case 'i':
            directly = true;
            break;
        case 'h':
        default:
            usage(argv[0]);
            return TFS_ERROR;
        }
    }

    if (set_log_level)
    {
        TBSYS_LOGGER.setLogLevel("ERROR");
    }

    if (NULL == nsip && NULL == rc_addr)
    {
        usage(argv[0]);
        return TFS_ERROR;
    }

    gstreamer.set_packet_factory(&gfactory);
    NewClientManager::get_instance().initialize(&gfactory, &gstreamer);

    if (nsip != NULL)
    {
        g_tfs_client = TfsClientImpl::Instance();
        ret = g_tfs_client->initialize(nsip, DEFAULT_BLOCK_CACHE_TIME, 1000, false);
        if (ret != TFS_SUCCESS)
        {
            fprintf(stderr, "init tfs client fail, ret: %d\n", ret);
            return ret;
        }
        g_use_meta = false;
    }
    else if (rc_addr != NULL)
    {
        strcpy(app_key, default_app_key);
        g_use_meta = true;
    }


    init();

    if (optind >= argc)
    {
        signal(SIGINT, sign_handler);
        signal(SIGTERM, sign_handler);
        main_loop();
    }
    else // has other params
    {
        int32_t i = 0;
        if (directly)
        {
            for (i = optind; i < argc; i++)
            {
                do_cmd(argv[i]);
            }
        }
        else
        {
            VSTRING param;
            for (i = optind; i < argc; i++)
            {
                param.clear();
                param.push_back(argv[i]);
                cmd_batch_file(param);
            }
        }
    }
    if (g_tfs_client != NULL)
    {
        g_tfs_client->destroy();
    }
    return TFS_SUCCESS;
}
Ejemplo n.º 4
0
int main(int argc, char *argv[])
{
  gstreamer.set_packet_factory(&gfactory);

  tfs::common::NewClientManager::get_instance().initialize(&gfactory, &gstreamer);

  int i;
  std::string s3_server;
  std::string log_file_name;
  std::string date_time;
  uint32_t thread_num;
  while ((i = getopt(argc, argv, "f:d:t:l:p:a:u:")) != EOF)
  {
    switch (i)
    {
      case 'f':
        source_file_name = optarg;
        break;
      case 'd':
        s3_server = optarg;
        break;
      case 't':
        date_time = optarg;
        break;
      case 'l':
        log_file_name = optarg;
        break;
      case 'p':
        thread_num = atoi(optarg);
        break;
      case 'a':
        last_appid = atol(optarg);
        break;
      case 'u':
        last_uid = atol(optarg);
        break;
      default:
        usage(argv[0]);
        return TFS_ERROR;
    }
  }
  if (source_file_name.empty() || log_file_name.empty())
  {
    usage(argv[0]);
    return TFS_ERROR;
  }
  time_point = tbsys::CTimeUtil::strToTime(const_cast<char*>(date_time.c_str()));
  server_id = Func::get_host_ip(s3_server.c_str());
  TBSYS_LOGGER.setFileName(log_file_name.c_str());
  TBSYS_LOGGER.setLogLevel("info");
  signal(SIGINT, sign_handler);
  TBSYS_LOG(INFO, "date %s num_time %ld",date_time.c_str(), time_point);

  pthread_t* tid = (pthread_t*) malloc(thread_num * sizeof(pthread_t));
  arg_type* p_arg = (arg_type*) malloc(thread_num * sizeof(arg_type));
  for (uint32_t i = 0 ; i < thread_num ; ++i)
  {
     p_arg[i].tnum = i;
     p_arg[i].ttotal = thread_num;
     TBSYS_LOG(INFO,"i is %d tum is %d, ttotal is %d\n",i, p_arg[i].tnum, p_arg[i].ttotal);
  }

  thread_create(tid, p_arg, thread_num);

  thread_wait(tid, thread_num);



  //transfer(source_file_name, s3_server);
  free(p_arg);
  free(tid);
  return 0;
}
Ejemplo n.º 5
0
Archivo: main.cpp Proyecto: alimy/tfs
int main(int argc,char** argv)
{
  //TODO readline
  int32_t i;
  string ns_ip_port_1;
  string ns_ip_port_2;
  bool directly = false;
  while ((i = getopt(argc, argv, "s:m:ihv")) != EOF)
  {
    switch (i)
    {
      case 's':
        ns_ip_port_2 = optarg;
        break;
      case 'm':
        ns_ip_port_1 = optarg;
        g_need_cmp = true;
        break;
      case 'i':
        directly = true;
        break;
      case 'v':
        version(argv[0]);
        break;
      case 'h':
      default:
        usage(argv[0]);
    }
  }

  if (ns_ip_port_2.empty() || (g_need_cmp && ns_ip_port_1.empty()))
  {
    fprintf(stderr, "please input nameserver ip and port.\n");
    usage(argv[0]);
  }

  TBSYS_LOGGER.setLogLevel("error");

  init();

  gstreamer.set_packet_factory(&gfactory);
  NewClientManager::get_instance().initialize(&gfactory, &gstreamer);

  if (!g_need_cmp)
  {
    g_show_info.set_ns_ip(ns_ip_port_2);
  }
  else
  {
    g_cmp_info.set_ns_ip(ns_ip_port_1, ns_ip_port_2);
  }

  signal(SIGINT, sign_handler);
  signal(SIGTERM, sign_handler);
  if (optind >= argc)
  {
    main_loop();
  }
  else
  {
    if (directly) // ssm ... -i "cmd"
    {
      for (i = optind; i < argc; i++)
      {
        do_cmd(argv[i]);
      }
      g_show_info.clean_last_file();
    }
    else// exec filename
    {
      VSTRING param;
      for (i = optind; i < argc; i++)
      {
        param.clear();
        param.push_back(argv[i]);
        cmd_batch(param);
      }
    }
  }
  NewClientManager::get_instance().destroy();
}
Ejemplo n.º 6
0
int main(int argc, char* argv[])
{
  int32_t i;
  bool directly = false;
  bool set_log_level = false;

  // analyze arguments
  while ((i = getopt(argc, argv, "s:k:ih")) != EOF)
  {
    switch (i)
    {
      case 'n':
        set_log_level = true;
        break;
      case 'k':
        krs_addr = optarg;
        break;
      case 'i':
        directly = true;
        break;
      case 'h':
      default:
        usage(argv[0]);
        return TFS_ERROR;
    }
  }

  if (set_log_level)
  {
    TBSYS_LOGGER.setLogLevel("ERROR");
  }

  if (NULL == krs_addr)
  {
    usage(argv[0]);
    return TFS_ERROR;
  }

  gstreamer.set_packet_factory(&gfactory);
  NewClientManager::get_instance().initialize(&gfactory, &gstreamer);

  if (krs_addr != NULL)
  {
    new_server_id = Func::get_host_ip(krs_addr);
  }

  init();

  if (optind >= argc)
  {
    signal(SIGINT, sign_handler);
    signal(SIGTERM, sign_handler);
    main_loop();
  }
  else // has other params
  {
    int32_t i = 0;
    if (directly)
    {
      for (i = optind; i < argc; i++)
      {
        do_cmd(argv[i]);
      }
    }
    else
    {
      VSTRING param;
      for (i = optind; i < argc; i++)
      {
        param.clear();
        param.push_back(argv[i]);
        cmd_batch_file(param);
      }
    }
  }
  return TFS_SUCCESS;
}
Ejemplo n.º 7
0
int main(int argc,char** argv)
{
  int32_t i;
  string ns_addr;
  string log_file("stat_log");
  int32_t top_num = 0;
  bool is_debug = true;
  while ((i = getopt(argc, argv, "s:f:m:nhv")) != EOF)
  {
    switch (i)
    {
      case 's':
        ns_addr = optarg;
        break;
      case 'f':
        log_file = optarg;
        break;
      case 'm':
        top_num = atoi(optarg);
        break;
      case 'n':
        is_debug = false;
        break;
      case 'v':
        version(argv[0]);
        break;
      case 'h':
      default:
        usage(argv[0]);
    }
  }

  if (ns_addr.empty())
  {
    fprintf(stderr, "please input nameserver ip and port.\n");
    usage(argv[0]);
  }
  uint64_t ns_id = get_addr(ns_addr);
  FILE* fp = fopen(log_file.c_str(), "w");
  if (fp == NULL)
  {
    TBSYS_LOG(ERROR, "open log file failed. file: %s", log_file.c_str());
    return TFS_ERROR;
  }

  if (! is_debug)
  {
    TBSYS_LOGGER.setLogLevel("warn");
  }

  gstreamer.set_packet_factory(&gfactory);
  int ret = NewClientManager::get_instance().initialize(&gfactory, &gstreamer);
  if (TFS_SUCCESS != ret)
  {
    TBSYS_LOG(ERROR, "initialize NewClientManager fail, ret: %d", ret);
    return ret;
  }

  StatInfo stat_info;
  V_BLOCK_SIZE_RANGE v_block_size_range;
  V_DEL_BLOCK_RANGE v_del_block_range;
  set<BlockSize> s_big_block;
  set<BlockSize> s_topn_block;
  map<uint64_t, int32_t> family_map;

  // initialize
  int32_t row = 0;
  while (RANGE_ARR[row][0] != -1)
  {
    v_block_size_range.push_back(BlockSizeRange(RANGE_ARR[row][0], RANGE_ARR[row][1]));
    row++;
  }
  row = 0;
  while (DEL_RANGE_ARR[row][0] != -1)
  {
    v_del_block_range.push_back(DelBlockRange(DEL_RANGE_ARR[row][0], DEL_RANGE_ARR[row][1]));
    row++;
  }

  // do stat
  ret = family_process(ns_id, family_map);
  if (TFS_SUCCESS != ret)
  {
    TBSYS_LOG(ERROR, "scan all families from ns fail, ret: %d", ret);
    return ret;
  }
  ret = block_process(ns_id, family_map, stat_info, v_block_size_range, v_del_block_range, s_big_block, top_num, s_topn_block);
  if (TFS_SUCCESS != ret)
  {
    TBSYS_LOG(ERROR, "scan all blocks from ns fail, ret: %d", ret);
    return ret;
  }

  // print info to log file
  fprintf(fp, "--------------------------block file info-------------------------------\n");
  stat_info.dump(fp);
  fprintf(fp, "--------------------------block size range-------------------------------\n");
  V_BLOCK_SIZE_RANGE_ITER siter = v_block_size_range.begin();
  for (; siter != v_block_size_range.end(); siter++)
  {
    siter->dump(fp);
  }
  fprintf(fp, "--------------------------del block range-------------------------------\n");
  V_DEL_BLOCK_RANGE_ITER diter = v_del_block_range.begin();
  for (; diter != v_del_block_range.end(); diter++)
  {
    diter->dump(fp);
  }
  if (top_num > 0)
  {
    fprintf(fp, "--------------------------block list whose size bigger is than %d. num: %zd -------------------------------\n", THRESHOLD, s_big_block.size());
    set<BlockSize>::reverse_iterator rbiter = s_big_block.rbegin();
    for (; rbiter != s_big_block.rend(); rbiter++)
    {
      fprintf(fp, "block_id: %"PRI64_PREFIX"u, size: %d\n", rbiter->block_id_, rbiter->file_size_);
    }
    fprintf(fp, "--------------------------top %d block list-------------------------------\n", top_num);
    set<BlockSize>::reverse_iterator rtiter = s_topn_block.rbegin();
    for (; rtiter != s_topn_block.rend(); rtiter++)
    {
      fprintf(fp, "block_id: %"PRI64_PREFIX"u, size: %d\n", rtiter->block_id_, rtiter->file_size_);
    }
  }
  fclose(fp);
}
Ejemplo n.º 8
0
 RcStat::RcStat()
   :app_id_(0), oper_type_(0), order_by_(0), is_json_(false)
 {
   gstreamer.set_packet_factory(&gfactory);
   NewClientManager::get_instance().initialize(&gfactory, &gstreamer);
 }
Ejemplo n.º 9
0
int main(int argc, char* argv[])
{
  int i = 0;
  int iex = 0;

  // input option
  if (argc == 1)
  {
    usage(argv[0]);
    return TFS_ERROR;
  }
  while ((i = getopt(argc, argv, "d:i::")) != -1)
  {
    switch (i)
    {
    case 'i':
      iex = 1;
      break;
    case 'd':
      ds_ip = Func::get_host_ip(optarg);
      if (ds_ip == 0)
      {
        printf("ip or port is invalid, please try again.\n");
        return TFS_ERROR;
      }
      break;
    case ':':
      printf("missing -d");
      usage(argv[0]);
      break;
    default:
      usage(argv[0]);
      return TFS_ERROR;
    }
  }
  static tfs::message::MessageFactory factory;
  static tfs::common::BasePacketStreamer streamer;
  streamer.set_packet_factory(&factory);
  NewClientManager::get_instance().initialize(&factory, &streamer);

  init();

  if (optind >= argc)
  {
    signal(SIGINT, signal_handler);
    main_loop();
  }
  else
  {
    VSTRING param;
    int i = optind;
    if (iex)
    {
      printf("with i\n");
      for (i = optind; i < argc; i++)
      {
        param.clear();
        int cmd = parse_cmd(argv[i], param);
        switch_cmd(cmd, param);
      }
    }
    else
    {
      printf("without i\n");
      for (i = optind; i < argc; i++)
      {
        param.clear();
        param.push_back(argv[i]);
      }
    }
  }
  return TFS_SUCCESS;
}