/* * General server example: accept a client connection and do something. * This program just outputs a short HTML page, but can be easily adapted * to do other things. * * This server creates a constant number of processes ("virtual processors" * or VPs) and replaces them when they die. Each virtual processor manages * its own independent set of state threads (STs), the number of which varies * with load against the server. Each state thread listens to exactly one * listening socket. The initial process becomes the watchdog, waiting for * children (VPs) to die or for a signal requesting termination or restart. * Upon receiving a restart signal (SIGHUP), all VPs close and then reopen * log files and reload configuration. All currently active connections remain * active. It is assumed that new configuration affects only request * processing and not the general server parameters such as number of VPs, * thread limits, bind addresses, etc. Those are specified as command line * arguments, so the server has to be stopped and then started again in order * to change them. * * Each state thread loops processing connections from a single listening * socket. Only one ST runs on a VP at a time, and VPs do not share memory, * so no mutual exclusion locking is necessary on any data, and the entire * server is free to use all the static variables and non-reentrant library * functions it wants, greatly simplifying programming and debugging and * increasing performance (for example, it is safe to ++ and -- all global * counters or call inet_ntoa(3) without any mutexes). The current thread on * each VP maintains equilibrium on that VP, starting a new thread or * terminating itself if the number of spare threads exceeds the lower or * upper limit. * * All I/O operations on sockets must use the State Thread library's I/O * functions because only those functions prevent blocking of the entire VP * process and perform state thread scheduling. */ int main(int argc, char *argv[]) { /* Parse command-line options */ parse_arguments(argc, argv); /* Allocate array of server pids */ if ((vp_pids = calloc(vp_count, sizeof(pid_t))) == NULL) err_sys_quit(errfd, "ERROR: calloc failed"); /* Start the daemon */ if (!interactive_mode) start_daemon(); /* Initialize the ST library */ if (st_init() < 0) err_sys_quit(errfd, "ERROR: initialization failed: st_init"); /* Set thread throttling parameters */ set_thread_throttling(); /* Create listening sockets */ create_listeners(); /* Change the user */ if (username) change_user(); /* Open log files */ open_log_files(); /* Start server processes (VPs) */ start_processes(); /* Turn time caching on */ st_timecache_set(1); /* Install signal handlers */ install_sighandlers(); /* Load configuration from config files */ load_configs(); /* Start all threads */ start_threads(); /* Become a signal processing thread */ process_signals(NULL); /* NOTREACHED */ return 1; }
int main(){ void **value_ptr = NULL; short host_numbers[16]; short sockfd = create_server_socket(); int i; if(sockfd < 0){ printf("\n Arbiter Error. Arbiter closing ...\n"); return -1; } hostsockfd_init(); sigemptyset(&set); sigaddset(&set, SIGINT); pthread_sigmask(SIG_BLOCK, &set, NULL); //printf("\n Going to Signal Handling .....\n"); pthread_create(&signal_thread, 0, (void *)&signal_handler, &sockfd); open_log_files(); //printf("\n accept_connections thread ---------------\n"); pthread_create(&accept_connections_thread, 0, (void *)&accept_connections, &sockfd); //printf("\n get_demands thread -------------------"); for(i=0; i<16; i++){ host_numbers[i] = i+1; pthread_create(&recieve_request_thread[i], 0, (void *)&get_demands, &(host_numbers[i])); } //printf("\n process_demands thread ----------------------"); pthread_create(&process_request_thread, 0, (void *)&process_demands, NULL); // pthread_create(&send_response_thread, 0, (void *)&send_demands_to_host, NULL); //pthread_create(&send_response_thread, 0, (void *)&get_demands, NULL); pthread_join (accept_connections_thread, value_ptr); for(i=0; i<16; i++) pthread_join (recieve_request_thread[i], value_ptr); // pthread_join (process_request_thread, value_ptr); // pthread_join (send_response_thread, value_ptr); //close_log_files(); return 0; }
int run_program(CodeRunInstance *instance, const char *filename, char *const argv[], char *const envp[], const char *working_directory, const char *run_as_user, const char *datafilename_stdin, const char *logfilename_stdout, const char *logfilename_stderr, uint32_t max_running_second, uint32_t overtime_sigint_second, uint32_t overtime_sigterm_second) { char *fullpath_working_directory; char *fullpath_datafile_stdin; char *fullpath_logfile_stdout; char *fullpath_logfile_stderr; uid_t runner_uid; gid_t runner_gid; pid_t child_pid; fullpath_working_directory = NULL; fullpath_datafile_stdin = NULL; fullpath_logfile_stdout = NULL; fullpath_logfile_stderr = NULL; #define RELEASE_ALLOCATED_RESOURCE { \ release_allocated_memory(fullpath_working_directory, fullpath_datafile_stdin, fullpath_logfile_stdout, fullpath_logfile_stderr); \ } memset(instance, 0, sizeof(CodeRunInstance)); #if ENABLE_RUNTIMEENV_PRESERVE instance->fullpath_working_directory = NULL; instance->fullpath_datafile_stdin = NULL; instance->fullpath_logfile_stdout = NULL; instance->fullpath_logfile_stderr = NULL; instance->runner_uid = 0; instance->runner_gid = 0; #endif /* ENABLE_RUNTIMEENV_PRESERVE */ if(0 != check_working_directory(instance, working_directory, &fullpath_working_directory)) { RECORD_ERR("cannot have real path of given working directory", __FILE__, __LINE__); RELEASE_ALLOCATED_RESOURCE; return 1; } if(0 != prepare_log_files(instance, datafilename_stdin, logfilename_stdout, logfilename_stderr, &fullpath_datafile_stdin, &fullpath_logfile_stdout, &fullpath_logfile_stderr)) { RELEASE_ALLOCATED_RESOURCE; return 2; } if(0 != lookup_runner_account(instance, run_as_user, &runner_uid, &runner_gid)) { RELEASE_ALLOCATED_RESOURCE; return 3; } child_pid = fork(); if(-1 == child_pid) { RECORD_ERR("failed on perform fork()", __FILE__, __LINE__); RELEASE_ALLOCATED_RESOURCE; return 4; } else if(0 != child_pid) { fill_instance_structure(instance, max_running_second, overtime_sigint_second, overtime_sigterm_second, child_pid); #if ENABLE_RUNTIMEENV_PRESERVE instance->fullpath_working_directory = fullpath_working_directory; instance->fullpath_datafile_stdin = fullpath_datafile_stdin; instance->fullpath_logfile_stdout = fullpath_logfile_stdout; instance->fullpath_logfile_stderr = fullpath_logfile_stderr; instance->runner_uid = runner_uid; instance->runner_gid = runner_gid; #else /* ENABLE_RUNTIMEENV_PRESERVE */ RELEASE_ALLOCATED_RESOURCE; #endif /* ENABLE_RUNTIMEENV_PRESERVE */ return 0; } /* {{{ child process code */ if(0 != setpgid(0, 0)) { RECORD_ERR("failed on creating independent process group", __FILE__, __LINE__); } if(0 != chdir(working_directory)) { RECORD_ERR("failed on changing work directory", __FILE__, __LINE__); exit(17); return 1; } if(0 != open_log_files(instance, fullpath_datafile_stdin, fullpath_logfile_stdout, fullpath_logfile_stderr, runner_uid, runner_gid)) { exit(18); return 2; } close_fd(instance); if( (NULL != run_as_user) && (0 != change_account(instance, runner_uid, runner_gid)) ) { exit(19); return 3; } fprintf(stdout, "PID: %d\n", (int)(getpid())); fprintf(stdout, "WorkDirectory: [%s]\n", fullpath_working_directory); fprintf(stdout, "Runner: UID=%d; GID=%d\n", (int)(runner_uid), (int)(runner_gid)); fprintf(stdout, "----------------\n"); execve(filename, argv, envp); RECORD_ERR("cannot execute target program", __FILE__, __LINE__); exit(20); /* }}} child process code */ #undef RELEASE_ALLOCATED_RESOURCE return -1; }
int main(int argc, char **argv) { open_log_files(); assert_valid_setup(argv[0]); int operation; int ret = validate_arguments(argc, argv, &operation); if (ret != 0) { flush_and_close_log_files(); return ret; } int exit_code = 0; switch (operation) { case CHECK_SETUP: //we already did this exit_code = 0; break; case MOUNT_CGROUPS: exit_code = 0; while (optind < argc && exit_code == 0) { exit_code = mount_cgroup(argv[optind++], cmd_input.cgroups_hierarchy); } break; case TRAFFIC_CONTROL_MODIFY_STATE: exit_code = traffic_control_modify_state(cmd_input.traffic_control_command_file); break; case TRAFFIC_CONTROL_READ_STATE: exit_code = traffic_control_read_state(cmd_input.traffic_control_command_file); break; case TRAFFIC_CONTROL_READ_STATS: exit_code = traffic_control_read_stats(cmd_input.traffic_control_command_file); break; case RUN_DOCKER: exit_code = run_docker(cmd_input.docker_command_file); break; case RUN_AS_USER_INITIALIZE_CONTAINER: exit_code = set_user(cmd_input.run_as_user_name); if (exit_code != 0) { break; } exit_code = initialize_app(cmd_input.yarn_user_name, cmd_input.app_id, cmd_input.cred_file, extract_values(cmd_input.local_dirs), extract_values(cmd_input.log_dirs), argv + optind); break; case RUN_AS_USER_LAUNCH_DOCKER_CONTAINER: if (cmd_input.traffic_control_command_file != NULL) { //apply tc rules before switching users and launching the container exit_code = traffic_control_modify_state(cmd_input.traffic_control_command_file); if( exit_code != 0) { //failed to apply tc rules - break out before launching the container break; } } exit_code = set_user(cmd_input.run_as_user_name); if (exit_code != 0) { break; } exit_code = launch_docker_container_as_user(cmd_input.yarn_user_name, cmd_input.app_id, cmd_input.container_id, cmd_input.current_dir, cmd_input.script_file, cmd_input.cred_file, cmd_input.pid_file, extract_values(cmd_input.local_dirs), extract_values(cmd_input.log_dirs), cmd_input.docker_command_file, cmd_input.resources_key, cmd_input.resources_values); break; case RUN_AS_USER_LAUNCH_CONTAINER: if (cmd_input.traffic_control_command_file != NULL) { //apply tc rules before switching users and launching the container exit_code = traffic_control_modify_state(cmd_input.traffic_control_command_file); if( exit_code != 0) { //failed to apply tc rules - break out before launching the container break; } } exit_code = set_user(cmd_input.run_as_user_name); if (exit_code != 0) { break; } exit_code = launch_container_as_user(cmd_input.yarn_user_name, cmd_input.app_id, cmd_input.container_id, cmd_input.current_dir, cmd_input.script_file, cmd_input.cred_file, cmd_input.pid_file, extract_values(cmd_input.local_dirs), extract_values(cmd_input.log_dirs), cmd_input.resources_key, cmd_input.resources_values); free(cmd_input.resources_key); free(cmd_input.resources_value); free(cmd_input.resources_values); break; case RUN_AS_USER_SIGNAL_CONTAINER: exit_code = set_user(cmd_input.run_as_user_name); if (exit_code != 0) { break; } exit_code = signal_container_as_user(cmd_input.yarn_user_name, cmd_input.container_pid, cmd_input.signal); break; case RUN_AS_USER_DELETE: exit_code = set_user(cmd_input.run_as_user_name); if (exit_code != 0) { break; } exit_code = delete_as_user(cmd_input.yarn_user_name, cmd_input.dir_to_be_deleted, argv + optind); break; } flush_and_close_log_files(); return exit_code; }
/** * Main function. */ int main( int argc, char *argv[] ) { const char* FNAME = __FUNCTION__; int listenSock; // Server listening socket. int cliSock; // Client remote socket. socklen_t clientAddressLength; struct sockaddr_in clientAddress; struct sockaddr_in serverAddress; SocketInfo* pSocketInfo = NULL; pthread_t serviceThread; /* Parse command-line options */ parse_arguments( argc, argv ); /* Change the current directory. */ //if ( chdir( s_logdir ) < 0 ) // err_sys_quit( s_errfd, "ERROR: can't change directory to %s: chdir", s_logdir ); /* Open log files */ open_log_files(); hoxLog(LOG_INFO, "%s: Starting [dbagent]...", FNAME); /* Install signal handlers */ Signal( SIGTERM, wdog_sighandler ); /* terminate */ /* Create socket for listening for client connection requests. */ listenSock = socket(AF_INET, SOCK_STREAM, 0); if (listenSock < 0) { hoxLog(LOG_SYS_ERROR, "%s: cannot create listen socket", FNAME); exit(1); } /* Bind listen socket to listen port. */ serverAddress.sin_family = AF_INET; serverAddress.sin_addr.s_addr = inet_addr(s_serverIP); serverAddress.sin_port = htons(s_nListenPort); if ( bind( listenSock, (struct sockaddr *) &serverAddress, sizeof(serverAddress) ) < 0 ) { hoxLog(LOG_SYS_ERROR, "%s: cannot bind socket", FNAME); exit(1); } /* Wait for connections from clients. * This is a non-blocking call; i.e., it registers this program with * the system as expecting connections on this socket, and then * this thread of execution continues on. */ listen(listenSock, 5); for (;;) { hoxLog(LOG_INFO, "%s: Waiting for connections on [%s:%d]...", FNAME, s_serverIP, s_nListenPort); /* Accept a connection with a client that is requesting one. */ clientAddressLength = sizeof(clientAddress); cliSock = accept( listenSock, (struct sockaddr *) &clientAddress, &clientAddressLength); if ( cliSock < 0 ) { hoxLog(LOG_SYS_ERROR, "%s: cannot accept connection", FNAME); exit(1); } /* (1) Show the IP address of the client. * inet_ntoa() converts an IP address from binary form to the * standard "numbers and dots" notation. * * (2) Show the client's port number. * ntohs() converts a short int from network byte order (which is * Most Significant Byte first) to host byte order (which on x86, * for example, is Least Significant Byte first). */ hoxLog(LOG_DEBUG, "%s: connected to [%s:%d]", FNAME, inet_ntoa(clientAddress.sin_addr), ntohs(clientAddress.sin_port)); /* Create a separate thread to handle this client. */ pSocketInfo = new SocketInfo; pSocketInfo->nSocket = cliSock; pSocketInfo->iaFrom = clientAddress.sin_addr; if ( 0 != pthread_create( &serviceThread, NULL, /* Use Default Attributes */ handle_client_thread, (void*) pSocketInfo ) ) { hoxLog(LOG_SYS_ERROR, "%s: Failed to create service Thread", FNAME); delete pSocketInfo; continue; // NOTE: *** Still continue... } } /* for(...) */ /* Close log files. */ close( s_errfd ); close( s_serverfd ); return 0; }