std::string CSqlLogger::get_log_filepath() { std::string log_filepath; MOOON_ASSERT(!_dbinfo->alias.empty()); if (_dbinfo->alias.empty()) { MYLOG_ERROR("alias empty: %s\n", _dbinfo->str().c_str()); } else { const std::string& log_dirpath = get_log_dirpath(_dbinfo->alias); if (!sys::CDirUtils::exist(log_dirpath)) { MYLOG_INFO("to create sqllog dir[%s]: %s\n", log_dirpath.c_str(), _dbinfo->str().c_str()); sys::CDirUtils::create_directory_recursive(log_dirpath.c_str(), DIRECTORY_DEFAULT_PERM); } const time_t now = time(NULL); if (now == _log_file_timestamp) { ++_log_file_suffix; } else { _log_file_suffix = 0; _log_file_timestamp = now; } log_filepath = utils::CStringUtils::format_string("%s/sql.%013" PRId64".%06d", log_dirpath.c_str(), static_cast<int64_t>(now), _log_file_suffix); } return log_filepath; }
void CSqlLogger::rotate_log() { if (_log_fd != -1) { if (-1 == fsync(_log_fd)) { const int errcode = errno; MYLOG_ERROR("fsync %s error: (%d)%s\n", _log_filepath.c_str(), errcode, sys::Error::to_string(errcode).c_str()); } close(_log_fd); _log_fd = -1; } if (_log_filepath.empty()) { _log_filepath = get_last_log_filepath(); MYLOG_INFO("%s\n", _log_filepath.c_str()); } else { _log_filepath = get_log_filepath(); MYLOG_INFO("%s\n", _log_filepath.c_str()); } if (_log_filepath.empty()) { } else { _log_fd = open(_log_filepath.c_str(), O_WRONLY|O_CREAT|O_APPEND, FILE_DEFAULT_PERM); // O_EXCL if (-1 == _log_fd) { MYLOG_ERROR("[%s] create %s error: %s\n", _dbinfo->str().c_str(), _log_filepath.c_str(), sys::Error::to_string().c_str()); } else { int log_file_size = static_cast<int>(sys::CFileUtils::get_file_size(_log_fd)); MYLOG_INFO("[%s] create %s ok: %d\n", _dbinfo->str().c_str(), _log_filepath.c_str(), log_file_size); } } }
std::string CSqlLogger::get_last_log_filepath() { std::vector<std::string>* subdir_names = NULL; std::vector<std::string>* link_names = NULL; std::vector<std::string> file_names; std::string log_filename; const std::string& log_dirpath = get_log_dirpath(_dbinfo->alias); // 如果目录不存在,则自动创建 if (!sys::CDirUtils::exist(log_dirpath)) { MYLOG_INFO("to create sqllog dir[%s]: %s\n", log_dirpath.c_str(), _dbinfo->str().c_str()); sys::CDirUtils::create_directory_recursive(log_dirpath.c_str(), DIRECTORY_DEFAULT_PERM); } sys::CDirUtils::list(log_dirpath, subdir_names, &file_names, link_names); if (!file_names.empty()) { std::sort(file_names.begin(), file_names.end()); for (int i=static_cast<int>(file_names.size()-1); i>=0; --i) { if (is_sql_log_filename(file_names[i])) { log_filename = file_names[i]; break; } } } if (log_filename.empty()) { MYLOG_INFO("no history log file: %s\n", _dbinfo->str().c_str()); return get_log_filepath(); } else { std::string last_log_filepath = log_dirpath + std::string("/") + log_filename; return last_log_filepath; } }
bool CMainHelper::run() { mooon::db_proxy::CConfigLoader* config_loader = mooon::db_proxy::CConfigLoader::get_singleton(); mooon::sys::CThreadEngine monitor(mooon::sys::bind(&mooon::db_proxy::CConfigLoader::monitor, config_loader)); try { MYLOG_INFO("thrift will listen on port[%u]\n", mooon::argument::port->value()); _thrift_server.serve(mooon::argument::port->value()); return true; } catch (apache::thrift::TException& tx) { fprintf(stderr, "thrift exception: %s\n", tx.what()); return false; } }
MOOON_NAMESPACE_USE static void foo() { for (int i=0; i<100000; ++i) { MYLOG_DEBUG("[%d]MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM", i); MYLOG_DETAIL("[%d]KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK", i+1); MYLOG_INFO("[%d]BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", i+2); MYLOG_ERROR("[%d]TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT", i+3); MYLOG_WARN("[%d]PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP", i+4); MYLOG_TRACE("[%d]AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", i+5); MYLOG_STATE("[%d]ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ", i+6); //sys::CUtils::millisleep(10); } }
bool ISMGManager::UpdateISMGInfo() { std::list<ISMGInfo *> lst; if (true == m_dbService->getAllISMGInfo(lst)) { for (std::list<ISMGInfo *>::iterator it = lst.begin(); it != lst.end(); ++it) { ISMGInfo *pInfo = *it; if (NULL != pInfo) { m_mapISMG.insert(std::make_pair(pInfo->SP_Id, pInfo)); } } MYLOG_INFO("Update ISMGInfo success"); return true; } else { MYLOG_ERROR("Update ISMGParam failed"); return false; } }
CVirtualHost* CHostManager::add_host(const char* domain_name, uint32_t domain_name_length) { int times = 0; uint32_t factor = util::CStringUtil::hash(domain_name, domain_name_length); CVirtualHost* host = new CVirtualHost(domain_name); for (;;) { uint32_t index = factor % sizeof(_host_table)/sizeof(CVirtualHost*); if (NULL == _host_table[index]) { _host_table[index] = host; MYLOG_INFO("Host: %.*s added.\n", domain_name_length, domain_name); return host; } ++factor; if (++times == sizeof(_host_table)/sizeof(CVirtualHost*)-1) break; } return NULL; }
bool ISMGManager::UpdateISMGParam() { std::list<ISMGParam *> lst; if (true == m_dbService->getAllISMGParam(lst)) { for (std::list<ISMGParam *>::iterator it = lst.begin(); it != lst.end(); ++it) { ISMGParam *pParam = *it; if (NULL != pParam) { ISMGInfo *pInfo = getISMGInfo(pParam->SP_Id); if (NULL != pInfo) { pInfo->UpdateParam(pParam); } else { delete pParam; } } } MYLOG_INFO("Update ISMGParam success"); return true; } else { MYLOG_ERROR("Update ISMGParam failed"); return false; } }
bool CConfigLoader::load_update(const Json::Value& json, struct UpdateInfo* update_info_array[]) { for (int i=0; i<static_cast<int>(json.size()); ++i) { struct UpdateInfo* update_info = new struct UpdateInfo(json[i]); if (!update_info->check()) { delete update_info; return false; } else { MYLOG_INFO("%s\n", update_info->str().c_str()); if (!add_update_info(update_info, update_info_array)) { delete update_info; return false; } } } return true; }
bool CConfigLoader::load_query(const Json::Value& json, struct QueryInfo* query_info_array[]) { for (int i=0; i<static_cast<int>(json.size()); ++i) { struct QueryInfo* query_info = new struct QueryInfo(json[i]); if (!query_info->check()) { delete query_info; return false; } else { MYLOG_INFO("%s\n", query_info->str().c_str()); if (!add_query_info(query_info, query_info_array)) { delete query_info; return false; } } } return true; }
int main(int argc, char* argv[]) { try { pid_t pid; ::mooon::sys::g_logger = new sys::CSafeLogger(".", "test.log"); sys::g_logger->set_single_filesize(20240000); sys::g_logger->set_backup_number(10); MYLOG_INFO("hello"); MYLOG_ERROR("world"); for (int i=0; i<10; ++i) { pid = fork(); if (-1 == pid) { fprintf(stderr, "fork error: %m\n"); exit(1); } else if (0 == pid) { // 子进程 sys::CThreadEngine thread1(sys::bind(&foo)); sys::CThreadEngine thread2(sys::bind(&foo)); sys::CThreadEngine thread3(sys::bind(&foo)); sys::CThreadEngine thread4(sys::bind(&foo)); sys::CThreadEngine thread5(sys::bind(&foo)); thread1.join(); thread2.join(); thread3.join(); thread4.join(); thread5.join(); exit(0); } } // 等待所有子进程结束 while (true) { int status = -1; pid = wait(&status); if (pid > 0) { printf("process[%u] exit with %d\n", pid, status); } else { if (ECHILD == errno) { break; } else { printf("unknown error when waiting child\n"); break; } } } } catch (sys::CSyscallException& syscall_ex) { fprintf(stderr, "%s\n", syscall_ex.str().c_str()); exit(1); } 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; }
int tcpserver::init_server( std::string ip, int port, int max_epoll_count, notify_callback callback ) { m_timeout_check_interval_seconds = 10; m_fd_timeout_threshold = 300; //m_increaseid=0; m_clientcount=0; m_unify_id=0; MYLOG_INFO("ready to start tcpserver"); int result = 0; m_port = port; m_epoll_maxsize = max_epoll_count; if (callback == NULL) { return -1; } m_notify_callback = callback; // 监听端口 m_listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); int reuse = 1; if (setsockopt(m_listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) { MYLOG_ERROR("set socket reuse failed"); return -1; } char ip_address[100]={0}; sprintf(ip_address, "0.0.0.0"); struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = inet_addr(ip_address); addr.sin_port = htons(port); if (bind(m_listen_fd, (const struct sockaddr*)&addr, (socklen_t)sizeof(addr)) == -1) { MYLOG_ERROR("failed to bind socket fd to ip and port=%d",m_port); return -1; } if (listen(m_listen_fd, SOMAXCONN)== -1) { MYLOG_ERROR("failed to listen on port=%d",m_port); return -1; } result = pipe(m_pipes); if (result == -1) { MYLOG_ERROR("failed to create epoll pipes"); return -1; } m_pipe_read = m_pipes[0]; m_pipe_write = m_pipes[1]; m_array_epoll_data = (STU_EPOLL_DATA **)new char[sizeof(STU_EPOLL_DATA *) * m_epoll_maxsize]; for (int i=0; i<m_epoll_maxsize; i++) { STU_EPOLL_DATA *pstu = new STU_EPOLL_DATA; pstu->status = enum_socket_close; m_array_epoll_data[i] = pstu; } pthread_t threadid; result = pthread_create(&threadid, NULL, tcpserver::epoll_reactor, this); if (result == -1) { MYLOG_ERROR("failed to create http server epoll read send thread"); return -1; } MYLOG_INFO("tcpserver start finished"); return 0; }