int ObStatManager::get_scanner(ObNewScanner &scanner) const
{
int ret = OB_SUCCESS;
int64_t last_used_mod = OB_INVALID_ID;
char ipbuf[OB_IP_STR_BUFF] = {0};
server_.ip_to_string(ipbuf, sizeof (ipbuf));
ObString ipstr = ObString::make_string(ipbuf);
const int32_t port = server_.get_port();
ObString server_name = ObString::make_string(print_role(get_server_type()));
int64_t total_stat_cnt = 0;
/* create row_desc */
ObRowDesc row_desc;
int32_t column_id = OB_APP_MIN_COLUMN_ID;
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.add_column_desc(OB_ALL_SERVER_STAT_TID, column_id++);
row_desc.set_rowkey_cell_count(4);
ObRow row;
ObObj obj;
// drop mod id info
for (int32_t mod = 0; mod < OB_MAX_MOD_NUMBER; mod++)
{
ObStat stat;
total_stat_cnt += stat_cnt_[mod];
// drop table id info
for (int32_t i = 0; i < table_stats_[mod].get_array_index(); i++)
{
for (int32_t j = 0; j < stat_cnt_[mod]; j++)
{
stat.inc(j, table_stats_[mod].at(i)->get_value(j));
}
}
for (int32_t i = 0; i < stat_cnt_[mod]; i++)
{
column_id = OB_APP_MIN_COLUMN_ID;
row.set_row_desc(row_desc);
row.reset(false, ObRow::DEFAULT_NULL);
/* server type */
obj.set_type(ObVarcharType);
obj.set_varchar(server_name);
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* server ip */
obj.set_type(ObVarcharType);
obj.set_varchar(ipstr);
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* port */
obj.set_type(ObIntType);
obj.set_int(port);
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* key */
obj.set_type(ObVarcharType);
obj.set_varchar(ObString::make_string(get_name(mod, i)));
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
/* value */
obj.set_type(ObIntType);
obj.set_int(stat.get_value(i));
row.set_cell(OB_ALL_SERVER_STAT_TID, column_id++, obj);
scanner.add_row(row);
// for last rowkey
last_used_mod = mod;
}
}
/* last rowkey */
if (total_stat_cnt > 0)
{
static ObObj rk_objs[4];
rk_objs[0].set_type(ObVarcharType);
rk_objs[0].set_varchar(server_name);
rk_objs[1].set_type(ObVarcharType);
rk_objs[1].set_varchar(ipstr);
rk_objs[2].set_type(ObIntType);
rk_objs[2].set_int(port);
rk_objs[3].set_type(ObVarcharType);
rk_objs[3].set_varchar(ObString::make_string(get_name(last_used_mod, stat_cnt_[last_used_mod] - 1)));
ObRowkey rowkey(rk_objs, 4);
scanner.set_last_row_key(rowkey);
}
/* fullfilled */
scanner.set_is_req_fullfilled(true, total_stat_cnt);
return ret;
}
STATIC int
set_game_type_value(server_type *gametype, int key, char *value)
{
switch (key) {
case CK_NAME:
gametype->game_name = strdup(value);
break;
case CK_FLAGS:
{
int flags = parse_server_flags(value);
if (flags == -1) {
return (-1);
}
gametype->flags = flags;
}
break;
case CK_DEFAULT_PORT:
{
unsigned short port;
if (sscanf(value, "%hu", &port) != 1) {
REPORT_ERROR((stderr, "Syntax error on port. Should be a number between 1 and 65535."));
return (-1);
}
gametype->default_port = port;
break;
}
case CK_GAME_RULE:
gametype->game_rule = strdup(value);
break;
case CK_TEMPLATE_VAR:
gametype->template_var = strdup(value);
force_upper_case(gametype->template_var);
break;
case CK_MASTER_PROTOCOL:
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master protocol on non-master game type\n"));
return (-1);
}
if (value) {
gametype->master_protocol = strdup(value);
} else {
gametype->master_protocol = NULL;
}
break;
case CK_MASTER_QUERY:
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master query on non-master game type\n"));
return (-1);
}
if (value) {
gametype->master_query = strdup(value);
} else {
gametype->master_query = NULL;
}
break;
case CK_MASTER_TYPE:
{
server_type *type;
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master type on non-master game type\n"));
return (-1);
}
force_lower_case(value);
type = get_server_type(value);
if (type == NULL) {
REPORT_ERROR((stderr, "Unknown server type \"%s\"\n", value));
return (-1);
}
gametype->master = type->id;
}
break;
case CK_MASTER_PACKET:
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master packet on non-master game type"));
return (-1);
}
if ((value == NULL) || (value[0] == '\0')) {
REPORT_ERROR((stderr, "Empty master packet"));
return (-1);
}
gametype->master_packet = memdup(value, value_len);
gametype->master_len = value_len;
break;
case CK_STATUS_PACKET:
return (set_packet_value(gametype, value, "status",
&gametype->status_packet, &gametype->status_len));
case CK_STATUS2_PACKET:
return (set_packet_value(gametype, value, "status2",
&gametype->rule_packet, &gametype->rule_len));
case CK_PLAYER_PACKET:
return (set_packet_value(gametype, value, "player",
&gametype->player_packet, &gametype->player_len));
case CK_RULE_PACKET:
return (set_packet_value(gametype, value, "rule",
&gametype->rule_packet, &gametype->rule_len));
case CK_PORT_OFFSET:
{
short port;
if (sscanf(value, "%hd", &port) != 1) {
REPORT_ERROR((stderr, "Syntax error on port. Should be a number between 32767 and -32768."));
return (-1);
}
gametype->port_offset = port;
break;
}
}
return (0);
}
STATIC int
modify_game_type_value(server_type *gametype, int key, char *value)
{
switch (key) {
case CK_FLAGS:
{
int flags = parse_server_flags(value);
if (flags == -1) {
return (-1);
}
gametype->flags = flags;
}
break;
case CK_MASTER_PROTOCOL:
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master protocol on non-master game type"));
return (-1);
}
if (value) {
gametype->master_protocol = strdup(value);
} else {
gametype->master_protocol = NULL;
}
break;
case CK_MASTER_QUERY:
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master query on non-master game type"));
return (-1);
}
if (value) {
gametype->master_query = strdup(value);
} else {
gametype->master_query = NULL;
}
break;
case CK_MASTER_PACKET:
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master packet on non-master game type"));
return (-1);
}
if ((value == NULL) || (value[0] == '\0')) {
REPORT_ERROR((stderr, "Empty master packet"));
return (-1);
}
gametype->master_packet = memdup(value, value_len);
gametype->master_len = value_len;
break;
case CK_MASTER_TYPE:
{
server_type *type;
if (!gametype->master) {
REPORT_ERROR((stderr, "Cannot set master type on non-master game type\n"));
return (-1);
}
force_lower_case(value);
type = get_server_type(value);
if (type == NULL) {
REPORT_ERROR((stderr, "Unknown server type \"%s\"\n", value));
return (-1);
}
gametype->master = type->id;
}
break;
}
return (0);
}
/* Top level
* Keywords: gametype
*/
STATIC int
pf_top_level(char *text, void *_context)
{
GameTypeContext *context;
server_type *extend;
char *token, *game_type, *extend_type;
token = first_token(text);
if (token == NULL) {
return (0);
}
if (strcmp(token, "gametype") != 0) {
REPORT_ERROR((stderr, "Unknown config command \"%s\"", token));
return (-1);
}
game_type = next_token_dup();
if (game_type == NULL) {
REPORT_ERROR((stderr, "Missing game type"));
return (-1);
}
force_lower_case(game_type);
token = next_token();
if (token == NULL) {
REPORT_ERROR((stderr, "Expecting \"new\" or \"modify\""));
return (-1);
}
if (strcmp(token, "new") == 0) {
parse_func = pf_gametype_new;
} else if (strcmp(token, "modify") == 0) {
parse_func = pf_gametype_modify;
} else {
REPORT_ERROR((stderr, "Expecting \"new\" or \"modify\""));
return (-1);
}
context = (GameTypeContext *)malloc(sizeof(GameTypeContext));
context->type = game_type;
context->extend_type = NULL;
context->gametype = NULL;
token = next_token();
if (parse_func == pf_gametype_modify) {
if (token != NULL) {
REPORT_ERROR((stderr, "Extra text after gametype modify"));
return (-1);
}
context->gametype = get_server_type(game_type);
if (context->gametype == NULL) {
REPORT_ERROR((stderr, "Unknown game type \"%s\"", game_type));
free(context);
return (-1);
}
parse_context = context;
return (0);
}
if ((token == NULL) || (strcmp(token, "extend") != 0)) {
REPORT_ERROR((stderr, "Expecting \"extend\""));
return (-1);
}
extend_type = next_token();
if (extend_type == NULL) {
REPORT_ERROR((stderr, "Missing extend game type"));
return (-1);
}
force_lower_case(extend_type);
if (strcasecmp(extend_type, game_type) == 0) {
REPORT_ERROR((stderr, "Identical game type and extend type"));
return (-1);
}
context->extend_type = extend_type;
extend = get_server_type(extend_type);
if (extend == NULL) {
REPORT_ERROR((stderr, "Unknown extend game type \"%s\"", extend_type));
return (-1);
}
/* Over-write a previous gametype new */
context->gametype = get_config_type(game_type);
if (context->gametype == NULL) {
context->gametype = (server_type *)malloc(sizeof(server_type));
}
copy_server_type(context->gametype, extend);
/* Set flag for new type-id if not re-defining previous config type */
if (get_config_type(game_type) == NULL) {
context->gametype->id = 0;
}
context->gametype->type_string = game_type;
context->gametype->type_prefix = strdup(game_type);
force_upper_case(context->gametype->type_prefix);
context->gametype->type_option = (char *)malloc(strlen(game_type) + 2);
context->gametype->type_option[0] = '-';
strcpy(&context->gametype->type_option[1], game_type);
parse_context = context;
return (0);
}
