sys::DBConnection* CConfigLoader::get_db_connection(int index) const
{
if ((index < 0) || (index >= MAX_DB_CONNECTION))
return NULL;
if (NULL == g_db_connection[index])
g_db_connection[index] = init_db_connection(index, true);
return g_db_connection[index];
}
int main(int argc, char **argv)
{
int i;
char *conf_path = (argc == 2) ? argv[1] : NULL;
if (init_ac_cfgd_config(conf_path, ac_cfgd_cfg) == -1) {
DP("Failed to init_ac_cfgd_config");
return -1;
}
if (init_anticheat_config_shm(ac_cfgd_cfg->svc_gameid)) {
DP("Failed to init_anticheat_config_shm, svc_gameid=%d",
ac_cfgd_cfg->svc_gameid);
return -1;
}
if (ac_cfg->svc_name[0] != '\0'
&& strncmp(ac_cfg->svc_name, ac_cfgd_cfg->svc_name, MAX_SVC_NAME_LEN)) {
DP("Prev svc(%s)'s cfg exists and not for cur_svc(%s)",
ac_cfg->svc_name, ac_cfgd_cfg->svc_name);
return -1;
}
if (init_db_connection() == -1) {
DP("Failed to init_db_connection");
return -1;
}
char table[MAX_SVC_NAME_LEN + 128];
sprintf(table, "%s.%s_%s", ac_cfgd_cfg->cc_my_dbname,
ac_cfgd_cfg->svc_name, ac_cfgd_cfg->cc_my_tw_tab_basename);
int sqllen;
sqllen = snprintf(dbmgr->sql, MAX_SQL_LEN, "SELECT "
"db_addr_ip,"
"db_addr_port,"
"min_tw_interval,"
"max_tw_freq,"
"update_tw_start_interval"
" FROM %s", table);
if (sqllen >= MAX_SQL_LEN) {
DP("tw: Sql is Too long, sqllen: %d", sqllen);
return -1;
}
//DP("exex_sql: %s", dbmgr->sql);
if (my_exec_sql(dbmgr, 0) == -1) {
DP("tw: Failed exec sql, err(%d): %s",
mysql_errno(&dbmgr->my), mysql_error(&dbmgr->my));
return -1;
}
if (my_num_rows(dbmgr, 0) == 0) {
DP("tw: Not any tw_config when my_num_rows");
return -1;
}
if (my_fetch_row(dbmgr, 0) == -1) {
DP("tw: Failed to fetch row, err(%d): %s",
mysql_errno(&dbmgr->my), mysql_error(&dbmgr->my));
return -1;
}
ac_cfg->status = AC_CFG_STATUS_DISABLE;
if (ac_cfg->svc_name[0] == '\0') {
snprintf(ac_cfg->svc_name, sizeof(ac_cfg->svc_name), "%s", ac_cfgd_cfg->svc_name);
}
snprintf(ac_cfg->db_addr_ip, sizeof(ac_cfg->db_addr_ip), "%s", dbmgr->my_row[0]);
ac_cfg->db_addr_port = atoi(dbmgr->my_row[1]);
ac_cfg->min_tw_interval = atoll(dbmgr->my_row[2]);
ac_cfg->max_tw_freq = atof(dbmgr->my_row[3]);
ac_cfg->update_tw_start_interval = atol(dbmgr->my_row[4]);
ac_cfg->status = AC_CFG_STATUS_ENABLE;
sprintf(table, "%s.%s_%s", ac_cfgd_cfg->cc_my_dbname,
ac_cfgd_cfg->svc_name, ac_cfgd_cfg->cc_my_sw_tab_basename);
sqllen = snprintf(dbmgr->sql, MAX_SQL_LEN, "SELECT "
"cmd,"
"min_sw_interval,"
"max_sw_freq,"
"update_sw_start_interval,"
"label"
" FROM %s ORDER BY cmd ASC", table);
if (sqllen >= MAX_SQL_LEN) {
DP("sw: Sql is Too long, sqllen: %d", sqllen);
return -1;
}
//DP("exex_sql: %s", dbmgr->sql);
if (my_exec_sql(dbmgr, 0) == -1) {
DP("sw: Failed exec sql, err(%d): %s",
mysql_errno(&dbmgr->my), mysql_error(&dbmgr->my));
return -1;
}
int32_t sw_config_real_count = 0;
int32_t sw_config_count = my_num_rows(dbmgr, 0);
struct sw_config_t *sw_cfg = NULL;
if (sw_config_count > MAX_CONFIG_SW_CMD) {
DP("Warning: too many sw_config_count: %d, cut it to: %d",
sw_config_count, MAX_CONFIG_SW_CMD);
sw_config_count = MAX_CONFIG_SW_CMD;
}
ac_cfg->status = AC_CFG_STATUS_DISABLE;
for (i = 0; i < sw_config_count; i++) {
if (my_fetch_row(dbmgr, 0) == -1) {
DP("sw: Failed to fetch row, err(%d): %s",
mysql_errno(&dbmgr->my), mysql_error(&dbmgr->my));
ac_cfg->sw_config_count = sw_config_real_count;
ac_cfg->status = AC_CFG_STATUS_ENABLE;
return -1;
}
sw_cfg = &(ac_cfg->sw_config[i]);
sw_cfg->cmd = atoi(dbmgr->my_row[0]);
sw_cfg->min_sw_interval = atoll(dbmgr->my_row[1]);
sw_cfg->max_sw_freq = atof(dbmgr->my_row[2]);
sw_cfg->update_sw_start_interval = atoi(dbmgr->my_row[3]);
snprintf(sw_cfg->label, sizeof(sw_cfg->label), "%s", dbmgr->my_row[4]);
sw_config_real_count++;
}
ac_cfg->sw_config_count = sw_config_real_count;
ac_cfg->status = AC_CFG_STATUS_ENABLE;
my_close_db(dbmgr);
return 0;
}
int main() {
int client_sock, clilen, i;
struct sockaddr_in client;
maxfd = getdtablesize();
clilen = sizeof(struct sockaddr_in);
init_server();
init_db_connection();
if ((requestP = (request *)malloc(sizeof(request) * maxfd)) == NULL)
ERR_EXIT("out of memory allocating all requests");
for (i = 0; i < maxfd; i++)
init_request(&requestP[i]);
int nfds;
fd_set read_set, write_set;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100;
//accept connection from an incoming client
while (1) {
FD_ZERO(&read_set);
FD_ZERO(&write_set);
FD_SET(svrfd, &read_set);
for (i = 0; i < maxfd; i++)
if (requestP[i].connected == 1)
FD_SET(requestP[i].conn_fd, &read_set);
nfds = select(maxfd, &read_set, NULL, NULL, &tv);
if (nfds > 0) {
if (FD_ISSET(svrfd, &read_set)) {
if ((client_sock = accept(svrfd, (struct sockaddr *)&client, (socklen_t*)&clilen)) < 0) {
perror("accept failed");
continue;
}
puts("Connection accepted");
requestP[client_sock].conn_fd = client_sock;
requestP[client_sock].connected = 1;
fprintf(stderr, "getting a new request... fd %d \n", client_sock);
nfds--;
}
for (i = 4; i < maxfd && nfds > 0; i++) {
if (FD_ISSET(i, &read_set)) {
int len, recvIsDone = 0;
requestP[i].buf_len = 0;
while (!recvIsDone) {
if ((len = recv(i, requestP[i].buf , 1, 0)) > 0) {
if(requestP[i].buf[0] == ',') {
requestP[i].type[requestP[i].buf_len++] = '\0';
printf("%s\n", requestP[i].type);
serve_request(&requestP[i]);
recvIsDone = 1;
} else
requestP[i].type[requestP[i].buf_len++] = requestP[i].buf[0];
} else if (len == 0) {
recvIsDone = 1;
puts("Client disconnected");
fflush(stdout);
free_request(&requestP[i]);
} else if (len == -1) {
recvIsDone = 1;
perror("recv0 failed");
}
}
nfds--;
}
}
}
}
free(requestP);
mysql_free_result(res);
return 0;
}
bool CConfigLoader::load(const std::string& filepath)
{
Json::Reader reader;
Json::Value root;
std::ifstream fs(filepath.c_str());
struct DbInfo* db_info_array[MAX_DB_CONNECTION] = { NULL };
struct QueryInfo* query_info_array[MAX_SQL_TEMPLATE] = { NULL };
struct UpdateInfo* update_info_array[MAX_SQL_TEMPLATE] = { NULL };
if (_md5_sum.empty())
{
MYLOG_INFO("loading %s\n", filepath.c_str());
}
else
{
MYLOG_DETAIL("loading %s\n", filepath.c_str());
}
if (!fs)
{
MYLOG_ERROR("load %s failed: %s\n", filepath.c_str(), strerror(errno));
return false;
}
if (!reader.parse(fs, root))
{
MYLOG_ERROR("parse %s failed: %s\n", filepath.c_str(), reader.getFormattedErrorMessages().c_str());
return false;
}
// 检查文件是否有修改过
std::string md5_sum = utils::CMd5Helper::lowercase_md5("%s", root.toStyledString().c_str());
if (md5_sum == _md5_sum)
{
MYLOG_DETAIL("not changed: (%s)%s\n", md5_sum.c_str(), filepath.c_str());
return true; // 未发生变化
}
init_db_info_array(db_info_array);
init_query_info_array(query_info_array);
init_update_info_array(update_info_array);
if (!load_database(root["database"], db_info_array))
return false;
if (!load_query(root["query"], query_info_array))
return false;
if (!load_update(root["update"], update_info_array))
return false;
int i; // 加写锁
sys::WriteLockHelper write_lock(_read_write_lock);
release_db_info_array(_db_info_array);
release_query_info_array(_query_info_array);
release_update_info_array(_update_info_array);
for (i=0; i<MAX_DB_CONNECTION; ++i)
{
if (db_info_array[i] != NULL)
{
// 启动时即连接一下，以早期发现配置等问题
_db_info_array[i] = new struct DbInfo(*db_info_array[i]);
sys::DBConnection* db_connection = init_db_connection(i, false);
if (db_connection != NULL)
{
delete db_connection;
db_connection = NULL;
}
}
}
for (i=0; i<MAX_SQL_TEMPLATE; ++i)
{
if (query_info_array[i] != NULL)
_query_info_array[i] = new struct QueryInfo(*query_info_array[i]);
if (update_info_array[i] != NULL)
_update_info_array[i] = new struct UpdateInfo(*update_info_array[i]);
}
_md5_sum = md5_sum;
MYLOG_INFO("loaded %s[%s] successfully\n", filepath.c_str(), _md5_sum.c_str());
return true;
}
