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:k:l:nihv")) != EOF)
{
switch (i)
{
case 'n':
set_log_level = true;
break;
case 's':
nsip = optarg;
break;
case 'r':
rc_addr = optarg;
break;
case 'k':
krs_addr = optarg;
break;
case 'l':
lrs_addr = optarg;
case 'i':
directly = true;
break;
case 'v':
case 'h':
default:
usage(argv[0]);
return TFS_ERROR;
}
}
if (set_log_level)
{
TBSYS_LOGGER.setLogLevel("ERROR");
}
if (NULL == nsip && NULL == rc_addr & NULL == krs_addr && NULL == lrs_addr)
{
usage(argv[0]);
return TFS_ERROR;
}
gstreamer.set_packet_factory(&gfactory);
NewClientManager::get_instance().initialize(&gfactory, &gstreamer);
if (lrs_addr != NULL)
{
if (rc_addr == NULL)
{
usage(argv[0]);
return TFS_ERROR;
}
// kv meta use RcClientImpl client
strcpy(app_key, default_app_key);
g_meta_type = META_LIFECYCLE;
}
else if (krs_addr != NULL)
{
if (rc_addr == NULL)
{
usage(argv[0]);
return TFS_ERROR;
}
strcpy(app_key, default_app_key);
g_meta_type = META_KV;
}
else if (rc_addr != NULL)
{
strcpy(app_key, default_app_key);
g_meta_type = META_NAME;
}
else if (nsip != NULL)
{
g_tfs_client = TfsClientImplV2::Instance();
// ret = g_tfs_client->initialize(nsip, DEFAULT_BLOCK_CACHE_TIME, 1000, false);
ret = g_tfs_client->initialize(nsip);
if (ret != TFS_SUCCESS)
{
fprintf(stderr, "init tfs client fail, ret: %d\n", ret);
return ret;
}
g_meta_type = META_RAW;
}
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;
}
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:ih")) != 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 '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);
}
if (optind >= argc)
{
signal(SIGINT, sign_handler);
signal(SIGTERM, sign_handler);
main_loop();
}
else
{
if (directly)
{
for (i = optind; i < argc; i++)
{
do_cmd(argv[i]);
}
}
else
{
usage(argv[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;
}
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;
}
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);
}
namespace tools
{
static int32_t server_update_interval = 10;
using namespace std;
static tfs::message::MessageFactory gfactory;
static tfs::common::BasePacketStreamer gstreamer;
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);
}
RcStat::~RcStat()
{
}
inline std::string& RcStat::trim_space(std::string &s)
{
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}
void RcStat::split_string_to_vector(const std::string& vec_str, const std::string& pattern, std::vector<std::string>& vec)
{
if (vec_str.size() == 0 || pattern.size() == 0)
{
return;
}
std::string::size_type pos, size, pattern_size;
std::string tmp_str = vec_str + pattern;
size = tmp_str.size();
pattern_size = pattern.size();
for(std::string::size_type i = 0; i < size; i++)
{
pos = tmp_str.find(pattern, i);
if (pos < size)
{
std::string s = tmp_str.substr(i, pos-i);
vec.push_back(trim_space(s));
i = pos + pattern_size -1 ;
}
}
}
int RcStat::initialize(int argc, char **argv)
{
int32_t i = 0;
if (argc < 2)
{
fprintf(stderr, "Usage: %s -r 127.0.0.1:6202 -a 0 -t 2\n", argv[0]);
exit(1);
}
string str_rc_ips;
while ((i = getopt(argc, argv,"r:a:t:o:ij")) != EOF)
{
switch (i)
{
/* rc server address */
case 'r':
str_rc_ips = optarg;
break;
/* app_id */
case 'a':
app_id_ = atoi(optarg);
break;
case 'o':
order_by_ = atoi(optarg);
break;
case 'i':
server_update_interval = atoi(optarg);
if (server_update_interval <= 0)
{
server_update_interval = 10;
}
break;
/* type */
case 't':
oper_type_ = atoi(optarg);
break;
case 'j':
is_json_ = true;
break;
default:
fprintf(stderr, "Usage: %s -a 127.0.0.1:6202 -a 0\n", argv[0]);
return EXIT_SUCCESS;
}
}
if (str_rc_ips.empty())
{
fprintf(stderr, "Usage: %s -a 127.0.0.1:6202\n", argv[0]);
}
else
{
split_string_to_vector(str_rc_ips, ",",rc_ips_vec_);
}
return TFS_SUCCESS;
}
//int RcStat::parse_rcs_stat(const std::vector<RspRcStatMessage *> rsp_rcstat_msg_vec)
void RcStat::parse_rcs_stat(const RspRcStatMessage* rsp_rcstat_msg)
{
int64_t key;
const common::AppOperInfoMap& app_oper_info_map = rsp_rcstat_msg->get_stat_info();
if (app_oper_info_map.size() > 0)
{
AppOperInfoMapConstIter mit = app_oper_info_map.begin();
for (; mit != app_oper_info_map.end(); ++mit)
{
key = mit->second.oper_app_id_ << 16 | mit->second.oper_type_;
std::map<int64_t, AppOperInfo>::iterator it = appoper_result_map_.find(key);
if (it == appoper_result_map_.end())
{
appoper_result_map_.insert(make_pair(key, mit->second));
}
else
{
AppOperInfo& app_oper_info = it->second;
if(app_oper_info.oper_app_id_ == mit->second.oper_app_id_ && app_oper_info.oper_type_ == mit->second.oper_type_)
{
app_oper_info.oper_times_ += mit->second.oper_times_;
app_oper_info.oper_size_ += mit->second.oper_size_;
app_oper_info.oper_rt_ += mit->second.oper_rt_;
app_oper_info.oper_succ_ += mit->second.oper_succ_;
}
else
{
TBSYS_LOG(ERROR, "rcserver data inconsistent.");
}
}
}
}
}
int RcStat::show_rcs_stat()
{
int32_t ret = TFS_SUCCESS;
std::multimap<int64_t, AppOperInfo> order_appoper_result_map;
std::multimap<int64_t, AppOperInfo>::iterator it = appoper_result_map_.begin();
int64_t count_per_sec, succ_count_per_sec;
if (is_json_)
{
order_by_ = 0; //use json format, order is no matter
}
for (; it != appoper_result_map_.end(); ++it)
{
count_per_sec = it->second.oper_times_ /server_update_interval + 1;
succ_count_per_sec = it->second.oper_succ_ /server_update_interval + 1;
it->second.oper_size_ = it->second.oper_size_ / it->second.oper_times_;
it->second.oper_rt_= it->second.oper_rt_ / it->second.oper_times_;
it->second.oper_times_ = count_per_sec;
it->second.oper_succ_ = succ_count_per_sec;
if (order_by_ == 1)
{
order_appoper_result_map.insert(make_pair(it->second.oper_times_, it->second));
}
else if (order_by_ == 2)
{
order_appoper_result_map.insert(make_pair(it->second.oper_size_, it->second));
}
else if (order_by_ == 3)
{
order_appoper_result_map.insert(make_pair(it->second.oper_rt_, it->second));
}
}
std::multimap<int64_t, AppOperInfo> *tmp_appoper_result_map = NULL;
if (order_by_ == 1 || order_by_ == 2 || order_by_ == 3)
{
tmp_appoper_result_map = &order_appoper_result_map;
}
else
{
tmp_appoper_result_map = &appoper_result_map_;
}
it = tmp_appoper_result_map->begin();
if (is_json_)
{
int last_app_id = -1;
bool have_done_oper[3];
have_done_oper[0] = have_done_oper[1] = have_done_oper[2] = true;
fprintf(stdout, "{\n");
for (; it != tmp_appoper_result_map->end(); ++it)
{
if (it->second.oper_app_id_ <= 0 ) continue;
bool first_line_in_app = last_app_id != it->second.oper_app_id_;
if (first_line_in_app)
{
if (last_app_id != -1)
{
fill_nodata_col(have_done_oper);
fprintf(stdout, "\n},\n");
fprintf(stdout, "{\n");
}
last_app_id = it->second.oper_app_id_;
fprintf(stdout, "\"app_id\":\"%d\"", last_app_id);
have_done_oper[0] = have_done_oper[1] = have_done_oper[2] = false;
}
switch (it->second.oper_type_)
{
case 1:
fprintf(stdout, ",\"read_times\":%ld, \"read_bytes\":%ld, \"read_rt\":%ld",
it->second.oper_times_, it->second.oper_size_, it->second.oper_rt_);
have_done_oper[0] = true;
break;
case 2:
fprintf(stdout, ",\"write_times\":%ld, \"write_bytes\":%ld, \"write_rt\":%ld",
it->second.oper_times_, it->second.oper_size_, it->second.oper_rt_);
have_done_oper[1] = true;
break;
case 3:
fprintf(stdout, ",\"rm_times\":%ld, \"rm_bytes\":%ld, \"rm_rt\":%ld",
it->second.oper_times_, it->second.oper_size_, it->second.oper_rt_);
have_done_oper[2] = true;
break;
default:
break;
}
}
fill_nodata_col(have_done_oper);
fprintf(stdout, "\n}\n");
}
else
{
for (; it != tmp_appoper_result_map->end(); ++it)
{
fprintf(stdout, "%d,%d,%ld,%ld,%ld,%ld\n", it->second.oper_app_id_, it->second.oper_type_, \
it->second.oper_times_, it->second.oper_size_, it->second.oper_rt_, succ_count_per_sec);
}
}
return ret;
}
int RcStat::get_rcs_stat()
{
int ret = TFS_SUCCESS;
uint64_t server_id = 0;
std::vector<string>::const_iterator iter = rc_ips_vec_.begin();
for (; iter != rc_ips_vec_.end(); ++iter)
{
string rc_ip = *iter;
server_id = Func::get_host_ip(rc_ip.c_str());
tbnet::Packet *ret_msg = NULL;
ReqRcStatMessage req_rcstat_msg;
NewClient* client = NewClientManager::get_instance().create_client();
req_rcstat_msg.set_app_id(app_id_);
req_rcstat_msg.set_oper_type(oper_type_);
if ((ret = send_msg_to_server(server_id, client, &req_rcstat_msg, ret_msg)) == TFS_SUCCESS)
{
if (ret_msg->getPCode() != RSP_RC_REQ_STAT_MESSAGE)
{
TBSYS_LOG(ERROR, "cant't get response message from rcserver.");
ret = TFS_ERROR;
}
else
{
RspRcStatMessage *rsp_rcstat_msg = dynamic_cast<RspRcStatMessage*>(ret_msg);
parse_rcs_stat(rsp_rcstat_msg);
}
}
else
{
TBSYS_LOG(ERROR, "ERROR:send_msg_to_server error. ret: %d.\n", ret);
}
NewClientManager::get_instance().destroy_client(client);
}
show_rcs_stat();
return ret;
}
}
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;
}
