int main(int argc,char *args[])
{
int n,c;
unsigned long long prof,start,end;
end_of_data_ptr=sbrk(0);
time_now=time(NULL);
printf("\n");
printf(" ********************************************\n");
printf(" * Astonia 3 - The Conflict Server *\n");
printf(" * Version %d.%02d.%02d *\n",VERSION>>16,(VERSION>>8)&255,VERSION&255);
printf(" ********************************************\n");
printf(" * Copyright (C) 2001-2008 Intent Software *\n");
printf(" * Copyright (C) 1997-2001 Daniel Brockhaus *\n");
printf(" ********************************************\n");
printf("\n");
if (argc>1) {
while (1) {
c=getopt(argc,args,"a:m:i:dhc");
if (c==-1) break;
switch (c) {
case 'a': if (optarg) areaID=atoi(optarg); break;
case 'm': if (optarg) areaM=atoi(optarg); break;
case 'd': demon=1; break;
case 'h': fprintf(stderr,"Usage: %s [-a <areaID>] [-m <mirror>] [-n <use this class A net>] [-d] [-c]\n\n-d Demonize\n-c Disable concurrent database access\n\n",args[0]); exit(0);
case 'c': multi=0; break;
//case 'n': if (optarg) server_net=atoi(optarg); break;
case 'i': if (optarg) serverID=atoi(optarg); break;
}
}
}
if (!areaID) {
printf("No areaID given, assuming areaID=1\n");
areaID=1;
}
if (!areaM) {
printf("No mirror given, assuming areaM=1\n");
areaM=1;
}
if (!serverID) {
printf("No serverID given, assuming serverID=1\n");
serverID=1;
}
#ifdef STAFF
while (!check_staff_start()) sleep(1);
#endif
// set character number limit depending on area
switch(areaID) {
case 1: maxchars=512; break;
case 2: maxchars=896; break;
case 3: maxchars=384; break;
case 4: maxchars=2048; break;
case 5: maxchars=768; break;
case 6: maxchars=384; break;
case 7: maxchars=1280; break;
case 8: maxchars=384; break;
case 9: maxchars=1280; break;
case 10: maxchars=512; break;
case 11: maxchars=384; break;
case 12: maxitem=1024*48; maxchars=384; break;
case 13: maxchars=9*50+200; break;
case 14: maxchars=16*50+200; break;
case 15: maxchars=384; break;
case 16: maxchars=384; break;
case 17: maxchars=512; break;
case 18: maxchars=768; break;
case 19: maxchars=384; break;
case 20: maxchars=768; break;
case 21: maxchars=768; break;
case 22: maxchars=512; break;
case 23: maxchars=512; break;
case 24: maxchars=384; break;
case 25: maxchars=384+8*25*2; break;
case 26: maxchars=256; break;
case 27: maxchars=2048; break;
case 28: maxchars=384; break;
case 29: maxchars=512; break;
case 30: maxchars=384; break;
case 31: maxitem=1024*40; maxchars=512; break;
case 32: maxchars=1280; break;
case 33: maxchars=1600; break;
case 34: maxchars=1280; break;
case 35: maxchars=768; break;
case 36: maxchars=768; break;
case 37: maxchars=1024; break;
default: maxchars=768; break;
}
// set item and effect limit
if (!maxitem) maxitem=max(maxchars*12+10240,20480);
if (!maxeffect) maxeffect=max(maxchars*2,1024);
printf("serverID=%d, areaID=%d, areaM=%d, maxchars=%d, maxitem=%d, maxeffect=%d\n\n",
serverID,areaID,areaM,maxchars,maxitem,maxeffect);
if (demon) {
printf("Demonizing...\n\n");
if (fork()) exit(0);
for (n=0; n<256; n++) close(n);
setsid();
#ifndef STAFF
nologin=1;
#endif
}
// ignore the silly pipe errors:
signal(SIGPIPE,SIG_IGN);
// ignore sighup - just to be safe
signal(SIGHUP,SIG_IGN);
/*signal(SIGSEGV,sig_crash);
signal(SIGFPE,sig_crash);
signal(SIGBUS,sig_crash);
signal(SIGSTKFLT,sig_crash);*/
// shutdown gracefully if possible:
signal(SIGQUIT,sig_leave);
signal(SIGINT,sig_leave);
signal(SIGTERM,sig_leave);
// show profile info on CTRL-Z
signal(SIGTSTP,sig_showprof);
// init random number generator
srand(time_now);
if (!init_smalloc()) exit(1);
if (!init_mem()) exit(1);
if (!init_prof()) exit(1);
if (!init_log()) exit(1);
if (!init_database()) exit(1);
if (!init_lookup()) exit(1);
if (!init_sector()) exit(1);
if (!init_los()) exit(1);
if (!init_timer()) exit(1);
if (!init_notify()) exit(1);
if (!init_create()) exit(1);
if (!init_lib()) exit(1);
if (!init_io()) exit(1);
if (!init_path()) exit(1);
if (!init_effect()) exit(1);
if (!init_container()) exit(1);
if (!init_store()) exit(1);
if (!init_chat()) exit(1);
init_sound_sector();
xlog("AreaID=%d, AreaM=%d, entering game loop...",areaID,areaM);
dlog(0,0,"Server started");
prof_reset();
while (!quit) {
sprintf(args[0],"./server -a %d -m %d -i %d # %d on %d%% load (busy)",areaID,areaM,serverID,online,(10000-server_idle)/100);
start=rdtsc();
lock_server();
time_now=time(NULL);
prof=prof_start(26); tick_date(); prof_stop(26,prof);
prof=prof_start(22); tick_timer(); prof_stop(22,prof);
prof=prof_start(4); tick_char(); prof_stop(4,prof);
prof=prof_start(24); tick_effect(); prof_stop(24,prof);
prof=prof_start(36); tick_clan(); prof_stop(36,prof);
prof=prof_start(39); tick_club(); prof_stop(39,prof);
prof=prof_start(5); tick_player(); prof_stop(5,prof);
prof=prof_start(34); tick_login(); prof_stop(34,prof);
prof=prof_start(6); pflush(); prof_stop(6,prof);
prof=prof_start(7); io_loop(); prof_stop(7,prof);
prof=prof_start(3); tick_chat(); prof_stop(3,prof);
if (showprof) {
show_prof();
showprof=0;
}
prof=prof_start(8); prof_update(); prof_stop(8,prof);
end=rdtsc();
cycles=end-start;
if ((ticker&2047)==0) {
prof=prof_start(27); area_alive(0); prof_stop(27,prof);
prof=prof_start(28); backup_players(); prof_stop(28,prof);
call_stat_update();
read_motd();
reinit_log();
}
if ((ticker&255)==0) {
call_check_task();
call_area_load();
shutdown_warn();
#ifdef STAFF
check_staff_stop();
#endif
}
if ((ticker&255)==168) {
prof=prof_start(38);
consistency_check_items();
consistency_check_map();
consistency_check_chars();
consistency_check_containers();
prof_stop(38,prof);
}
unlock_server();
sprintf(args[0],"./server -a %d -m %d -i %d # %d on %d%% load (idle)",areaID,areaM,serverID,online,(10000-server_idle)/100);
prof=prof_start(1); tick_sleep(0); prof_stop(1,prof);
ticker++;
}
xlog("Left game loop");
respawn_check();
for (n=1; n<MAXCHARS; n++) {
if (ch[n].flags&CF_PLAYER) {
exit_char(n);
}
}
area_alive(1);
show_prof();
dlog(0,0,"Server stopped");
xlog("map check");
check_map();
exit_lib();
exit_database();
xlog("Clean shutdown");
showmem();
exit_log();
exit_io();
return 0;
}
/*-------------------------------------------------------------------------*/
int main(int argc, char **argv)
{
int ret;
int my_pid;
int ret_val;
int printed_points = 0;
int max_enroll_tries;
static char tmp_err_file_name[SGE_PATH_MAX];
time_t next_prof_output = 0;
int execd_exit_state = 0;
lList **master_job_list = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
lList *alp = NULL;
DENTER_MAIN(TOP_LAYER, "execd");
#if defined(LINUX)
gen_procList ();
#endif
prof_mt_init();
set_thread_name(pthread_self(),"Execd Thread");
prof_set_level_name(SGE_PROF_CUSTOM1, "Execd Thread", NULL);
prof_set_level_name(SGE_PROF_CUSTOM2, "Execd Dispatch", NULL);
#ifdef __SGE_COMPILE_WITH_GETTEXT__
/* init language output for gettext() , it will use the right language */
sge_init_language_func((gettext_func_type) gettext,
(setlocale_func_type) setlocale,
(bindtextdomain_func_type) bindtextdomain,
(textdomain_func_type) textdomain);
sge_init_language(NULL,NULL);
#endif /* __SGE_COMPILE_WITH_GETTEXT__ */
/* This needs a better solution */
umask(022);
/* Initialize path for temporary logging until we chdir to spool */
my_pid = getpid();
sprintf(tmp_err_file_name,"%s."sge_U32CFormat"", TMP_ERR_FILE_EXECD, sge_u32c(my_pid));
log_state_set_log_file(tmp_err_file_name);
/* exit func for SGE_EXIT() */
sge_sig_handler_in_main_loop = 0;
sge_setup_sig_handlers(EXECD);
if (sge_setup2(&ctx, EXECD, MAIN_THREAD, &alp, false) != AE_OK) {
answer_list_output(&alp);
SGE_EXIT((void**)&ctx, 1);
}
ctx->set_exit_func(ctx, execd_exit_func);
#if defined(SOLARIS)
/* Init shared SMF libs if necessary */
if (sge_smf_used() == 1 && sge_smf_init_libs() != 0) {
SGE_EXIT((void**)&ctx, 1);
}
#endif
/* prepare daemonize */
if (!getenv("SGE_ND")) {
sge_daemonize_prepare(ctx);
}
if ((ret=sge_occupy_first_three())>=0) {
CRITICAL((SGE_EVENT, MSG_FILE_REDIRECTFD_I, ret));
SGE_EXIT((void**)&ctx, 1);
}
lInit(nmv);
/* unset XAUTHORITY if set */
if (getenv("XAUTHORITY") != NULL) {
sge_unsetenv("XAUTHORITY");
}
parse_cmdline_execd(argv);
/* exit if we can't get communication handle (bind port) */
max_enroll_tries = 30;
while (cl_com_get_handle(prognames[EXECD],1) == NULL) {
ctx->prepare_enroll(ctx);
max_enroll_tries--;
if (max_enroll_tries <= 0 || shut_me_down) {
/* exit after 30 seconds */
if (printed_points != 0) {
printf("\n");
}
CRITICAL((SGE_EVENT, MSG_COM_ERROR));
SGE_EXIT((void**)&ctx, 1);
}
if (cl_com_get_handle(prognames[EXECD],1) == NULL) {
/* sleep when prepare_enroll() failed */
sleep(1);
if (max_enroll_tries < 27) {
printf(".");
printed_points++;
fflush(stdout);
}
}
}
if (printed_points != 0) {
printf("\n");
}
/*
* now the commlib up and running. Set execd application status function
* ( commlib callback function for qping status information response
* messages (SIRM) )
*/
ret_val = cl_com_set_status_func(sge_execd_application_status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)) );
}
/* test connection */
{
cl_com_SIRM_t* status = NULL;
ret_val = cl_commlib_get_endpoint_status(ctx->get_com_handle(ctx),
(char *)ctx->get_master(ctx, true),
(char*)prognames[QMASTER], 1, &status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)));
ERROR((SGE_EVENT, MSG_CONF_NOCONFBG));
}
cl_com_free_sirm_message(&status);
}
/* finalize daeamonize */
if (!getenv("SGE_ND")) {
sge_daemonize_finalize(ctx);
}
/* daemonizes if qmaster is unreachable */
sge_setup_sge_execd(ctx, tmp_err_file_name);
/* are we using qidle or not */
sge_ls_qidle(mconf_get_use_qidle());
sge_ls_gnu_ls(1);
DPRINTF(("use_qidle: %d\n", mconf_get_use_qidle()));
/* test load sensor (internal or external) */
{
lList *report_list = sge_build_load_report(ctx->get_qualified_hostname(ctx), ctx->get_binary_path(ctx));
lFreeList(&report_list);
}
/* here we have to wait for qmaster registration */
while (sge_execd_register_at_qmaster(ctx, false) != 0) {
if (sge_get_com_error_flag(EXECD, SGE_COM_ACCESS_DENIED, true)) {
/* This is no error */
DPRINTF(("***** got SGE_COM_ACCESS_DENIED from qmaster *****\n"));
}
if (sge_get_com_error_flag(EXECD, SGE_COM_ENDPOINT_NOT_UNIQUE, false)) {
execd_exit_state = SGE_COM_ENDPOINT_NOT_UNIQUE;
break;
}
if (shut_me_down != 0) {
break;
}
sleep(30);
}
/*
* Terminate on SIGTERM or hard communication error
*/
if (execd_exit_state != 0 || shut_me_down != 0) {
sge_shutdown((void**)&ctx, execd_exit_state);
DRETURN(execd_exit_state);
}
/*
* We write pid file when we are connected to qmaster. Otherwise an old
* execd might overwrite our pidfile.
*/
sge_write_pid(EXECD_PID_FILE);
/*
* At this point we are sure we are the only sge_execd and we are connected
* to the current qmaster. First we have to report any reaped children
* that might exist.
*/
starting_up();
/*
* Log a warning message if execd hasn't been started by a superuser
*/
if (!sge_is_start_user_superuser()) {
WARNING((SGE_EVENT, MSG_SWITCH_USER_NOT_ROOT));
}
#ifdef COMPILE_DC
if (ptf_init()) {
CRITICAL((SGE_EVENT, MSG_EXECD_NOSTARTPTF));
SGE_EXIT((void**)&ctx, 1);
}
INFO((SGE_EVENT, MSG_EXECD_STARTPDCANDPTF));
#endif
master_job_list = object_type_get_master_list(SGE_TYPE_JOB);
*master_job_list = lCreateList("Master_Job_List", JB_Type);
job_list_read_from_disk(master_job_list, "Master_Job_List",
0, SPOOL_WITHIN_EXECD,
job_initialize_job);
/* clean up jobs hanging around (look in active_dir) */
clean_up_old_jobs(ctx, 1);
execd_trash_load_report();
sge_set_flush_lr_flag(true);
sge_sig_handler_in_main_loop = 1;
if (thread_prof_active_by_id(pthread_self())) {
prof_start(SGE_PROF_CUSTOM1, NULL);
prof_start(SGE_PROF_CUSTOM2, NULL);
prof_start(SGE_PROF_GDI_REQUEST, NULL);
} else {
prof_stop(SGE_PROF_CUSTOM1, NULL);
prof_stop(SGE_PROF_CUSTOM2, NULL);
prof_stop(SGE_PROF_GDI_REQUEST, NULL);
}
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM1);
/* Start dispatching */
execd_exit_state = sge_execd_process_messages(ctx);
/*
* This code is only reached when dispatcher terminates and execd goes down.
*/
/* log if we received SIGPIPE signal */
if (sge_sig_handler_sigpipe_received) {
sge_sig_handler_sigpipe_received = 0;
INFO((SGE_EVENT, "SIGPIPE received\n"));
}
#if defined(LINUX)
free_procList();
#endif
lFreeList(master_job_list);
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM1);
if (prof_is_active(SGE_PROF_ALL)) {
time_t now = (time_t)sge_get_gmt();
if (now > next_prof_output) {
prof_output_info(SGE_PROF_ALL, false, "profiling summary:\n");
prof_reset(SGE_PROF_ALL,NULL);
next_prof_output = now + 60;
}
}
sge_prof_cleanup();
sge_shutdown((void**)&ctx, execd_exit_state);
DRETURN(execd_exit_state);
}
