void MyApplication::run(){
std::string data_db_dir = app_args.work_dir + "/data";
std::string meta_db_dir = app_args.work_dir + "/meta";
log_info("ssdb-server %s", APP_VERSION);
log_info("conf_file : %s", app_args.conf_file.c_str());
log_info("log_level : %s", Logger::shared()->level_name().c_str());
log_info("log_output : %s", Logger::shared()->output_name().c_str());
log_info("log_rotate_size : %" PRId64, Logger::shared()->rotate_size());
log_info("main_db : %s", data_db_dir.c_str());
log_info("meta_db : %s", meta_db_dir.c_str());
log_info("sync_speed : %d MB/s", conf->get_num("replication.sync_speed"));
NetworkServer *net = NULL;
SSDBServer *server = NULL;
net = NetworkServer::init(*conf);
server = new SSDBServer(*conf, net);
log_info("pidfile: %s, pid: %d", app_args.pidfile.c_str(), (int)getpid());
log_info("ssdb server started.");
net->serve();
delete net;
delete server;
log_info("%s exit.", APP_NAME);
}
// Static method
connection_state_t Network::ServerStart(const std::string& port, const std::string& game_name, const std::string& password)
{
NetworkServer* net = new NetworkServer(game_name, password);
MSG_DEBUG("singleton", "Created singleton %p of type 'NetworkServer'\n", net);
// replace current singleton
Network* prev = singleton;
singleton = net;
// try to connect
const connection_state_t error = net->StartServer(port, GameMode::GetInstance()->max_teams);
if (error != CONNECTED) {
// revert change
singleton = prev;
delete net;
} else if (prev != NULL) {
delete prev;
}
if (error == CONNECTED) {
AppWarmux::GetInstance()->video->SetWindowCaption(std::string("WarMUX ") +
Constants::WARMUX_VERSION + " - " +
_("Server mode"));
}
return error;
}
TEST(TestNetwork, testPerformance) {
int inserts = 1;
Logger* log = getLogger(NULL);
cout << "Starting " << endl;
log->startTimeRecord();
NetworkServer* server = new NetworkServer(_port);
server->listen(NULL, &callBackPerformance);
cout << "Starting producer thread" << endl;
Thread* threadProducer = new Thread(producer);
threadProducer->start(NULL);
while (__insertCount < MAX_INSERT) {
Thread::sleep(100);
}
cout << "Closing the connection" << endl;
threadProducer->join();
server->stop();
delete server;
delete(log);
}
void MyApplication::run(){
Options option;
option.load(*conf);
std::string data_db_dir = app_args.work_dir + "/data";
std::string meta_db_dir = app_args.work_dir + "/meta";
log_info("ssdb-server %s", APP_VERSION);
log_info("conf_file : %s", app_args.conf_file.c_str());
log_info("log_level : %s", Logger::shared()->level_name().c_str());
log_info("log_output : %s", Logger::shared()->output_name().c_str());
log_info("log_rotate_size : %" PRId64, Logger::shared()->rotate_size());
log_info("main_db : %s", data_db_dir.c_str());
log_info("meta_db : %s", meta_db_dir.c_str());
log_info("cache_size : %d MB", option.cache_size);
log_info("block_size : %d KB", option.block_size);
log_info("write_buffer : %d MB", option.write_buffer_size);
log_info("max_open_files : %d", option.max_open_files);
log_info("compaction_speed : %d MB/s", option.compaction_speed);
log_info("compression : %s", option.compression.c_str());
log_info("binlog : %s", option.binlog? "yes" : "no");
log_info("sync_speed : %d MB/s", conf->get_num("replication.sync_speed"));
SSDB *data_db = NULL;
SSDB *meta_db = NULL;
data_db = SSDB::open(option, data_db_dir);
if(!data_db){
log_fatal("could not open data db: %s", data_db_dir.c_str());
fprintf(stderr, "could not open data db: %s\n", data_db_dir.c_str());
exit(1);
}
meta_db = SSDB::open(Options(), meta_db_dir);
if(!meta_db){
log_fatal("could not open meta db: %s", meta_db_dir.c_str());
fprintf(stderr, "could not open meta db: %s\n", meta_db_dir.c_str());
exit(1);
}
NetworkServer *net = NULL;
SSDBServer *server;
net = NetworkServer::init(*conf);
server = new SSDBServer(data_db, meta_db, *conf, net);
log_info("pidfile: %s, pid: %d", app_args.pidfile.c_str(), (int)getpid());
log_info("ssdb server started.");
net->serve();
delete net;
delete server;
delete meta_db;
delete data_db;
log_info("%s exit.", APP_NAME);
}
int main(int argc, char **argv){
Config conf;
conf.set("server.port", "9000");
NetworkServer serv;
serv.init(conf);
// register command procedure
serv.proc_map.set_proc("hello", proc_hello);
serv.serve();
return 0;
}
int main(int argc, char **argv){
bool is_daemon = false;
const char *conf_file = NULL;
for(int i=1; i<argc; i++){
if(strcmp(argv[i], "-d") == 0){
is_daemon = true;
}else{
conf_file = argv[i];
}
}
if(conf_file == NULL){
usage(argc, argv);
exit(1);
}
NetworkServer serv;
serv.init(conf_file);
serv.serve();
return 0;
}
TEST(TestNetwork, testCommands) {
Logger* log = getLogger(NULL);
NetworkServer* server = new NetworkServer(_port);
server->listen(NULL, &callbackCommandServer);
Thread::sleep(100);
std::list<Thread*> threads;
for (int x= 0; x < 1; x++) {
Thread* t = new Thread(&commandClients);
threads.push_back(t);
t->start(NULL);
}
for (std::list<Thread*>::iterator it = threads.begin(); it != threads.end(); it++) {
Thread* t = *it;
t->join();
}
server->stop();
delete server;
}
void RunServer(unsigned short port, SocketTransportLayer transport)
{
// Start the server either in TCP or UDP mode.
server = network.StartServer(port, transport, this, true);
if (!server)
{
cout << "Unable to start server in port " << port << "!" << endl;
return;
}
cout << "Server waiting for connection in port " << port << "." << endl;
server->RunModalServer();
}
int _tmain(int argc, _TCHAR* argv[])
{
Win32Exception::install_handler();
Win32Exception::set_dump_location(".","ZB_sv_ded");
#else
int main( int argc, char **argv )
{
#endif
try
{
s_params.loadParameters("config_server.xml");
s_params.loadParameters("config_common.xml");
s_params.loadParameters("data/config/teams.xml");
s_params.loadParameters("data/config/weapon_systems.xml");
s_params.loadParameters("data/config/tanks.xml");
s_params.loadParameters("data/config/upgrade_system.xml");
s_params.mergeCommandLineParams(argc, argv);
s_log.open("./", "server");
s_log.appendCr(true);
s_log << "Version " << g_version << "\n";
NetworkServer server;
server.logon();
g_puppet_master = server.getPuppetMaster();
g_puppet_master->addObserver(ObserverCallbackFun0(&onGameFinished),
PMOE_GAME_FINISHED,
&g_fp_group);
g_puppet_master->addObserver(ObserverCallbackFun0(&onLevelLoaded),
PMOE_LEVEL_LOADED,
&g_fp_group);
g_puppet_master->addObserver(ObserverCallbackFun0(&startMapRotation),
PMOE_AUTH_DATA_SET,
&g_fp_group);
ConsoleApp app;
app.run();
} catch (Exception & e)
{
e.addHistory("main()");
s_log << Log::error << e << "\n";
}
#ifdef _WIN32
catch (const Win32Exception & e)
{
std::stringstream err;
err << e.what() << " (code " << std::hex << e.code()
<< ") at " << e.where() << std::endl << std::endl
<< "A memory dump has been created and stored at: " << std::endl
<< Win32Exception::get_dump_location() << "\n";
// show msgbox for win32 exception
MessageBox( NULL,
err.str().c_str(),
"Win32 - Exception",
MB_OK | MB_ICONERROR | MB_TASKMODAL );
}
#endif
// to avoid singleton longevity issues
g_fp_group.deregisterAllOfType(TaskFp());
g_fp_group.deregisterAllOfType(ObserverFp(NULL, NULL, 0));
return 0;
}
