int main(int argc, char *argv[]) { log_options_t opts = LOG_OPTS_STDERR_ONLY; int rc = 0; slurm_conf_init(NULL); log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_USER, NULL); parse_command_line(argc, argv); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_USER, NULL); } while (1) { if ((!params.no_header) && (params.iterate || params.verbose || params.long_output)) print_date(); if (!params.clusters) { if (_get_info(false)) rc = 1; } else if (_multi_cluster(params.clusters) != 0) rc = 1; if (params.iterate) { printf("\n"); sleep(params.iterate); } else break; } exit(rc); }
int main(int argc, char *argv[]) { int rc = 0; log_options_t opts = LOG_OPTS_STDERR_ONLY; log_init("strigger", opts, SYSLOG_FACILITY_DAEMON, NULL); slurm_conf_init(NULL); parse_command_line(argc, argv); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_DAEMON, NULL); } if (params.mode_set) rc = _set_trigger(); else if (params.mode_get) rc = _get_trigger(); else if (params.mode_clear) rc = _clear_trigger(); else { error("Invalid mode"); rc = 1; } exit(rc); }
int main(int argc, char *argv[]) { int rc = 0; slurm_conf_init(NULL); parse_command_line(argc, argv); if (sdiag_param == STAT_COMMAND_RESET) { req.command_id = STAT_COMMAND_RESET; rc = slurm_reset_statistics((stats_info_request_msg_t *)&req); if (rc == SLURM_SUCCESS) printf("Reset scheduling statistics\n"); else slurm_perror("slurm_reset_statistics"); } else { req.command_id = STAT_COMMAND_GET; rc = slurm_get_statistics(&buf, (stats_info_request_msg_t *)&req); if (rc == SLURM_SUCCESS) { _sort_rpc(); rc = _print_stats(); #ifdef MEMORY_LEAK_DEBUG uid_cache_clear(); slurm_free_stats_response_msg(buf); xfree(rpc_type_ave_time); xfree(rpc_user_ave_time); #endif } else slurm_perror("slurm_get_statistics"); } exit(rc); }
static int handle_spank_mode (int argc, char *argv[]) { char prefix[64] = "spank-"; const char *mode = argv[2]; uid_t uid = (uid_t) -1; uint32_t jobid = (uint32_t) -1; log_options_t lopts = LOG_OPTS_INITIALIZER; /* * Not necessary to log to syslog */ lopts.syslog_level = LOG_LEVEL_QUIET; /* * Make our log prefix into spank-prolog: or spank-epilog: */ strcat (prefix, mode); log_init(prefix, lopts, LOG_DAEMON, NULL); /* * When we are started from slurmd, a lightweight config is * sent over the stdin fd. If we are able to read this conf * use it to reinitialize the log. * It is not a fatal error if we fail to read the conf file. * This could happen if slurmstepd is run standalone for * testing. */ if ((conf = read_slurmd_conf_lite (STDIN_FILENO))) log_alter (conf->log_opts, 0, conf->logfile); close (STDIN_FILENO); if (slurm_conf_init(NULL) != SLURM_SUCCESS) return error ("Failed to read slurm config"); if (get_jobid_uid_from_env (&jobid, &uid) < 0) return error ("spank environment invalid"); verbose ("Running spank/%s for jobid [%u] uid [%u]", mode, jobid, uid); if (strcmp (mode, "prolog") == 0) { if (spank_job_prolog (jobid, uid) < 0) return (-1); } else if (strcmp (mode, "epilog") == 0) { if (spank_job_epilog (jobid, uid) < 0) return (-1); } else { error ("Invalid mode %s specified!", mode); return (-1); } return (0); }
int main (int argc, char *argv[]) { char * user = NULL; if (argc == 2) { user = argv[1]; } slurm_conf_init(NULL); load_and_print_jobs(user); return 0; }
int main(int argc, char *argv[]) { log_options_t opts = LOG_OPTS_STDERR_ONLY; log_init("sbcast", opts, SYSLOG_FACILITY_DAEMON, NULL); #ifdef HAVE_ALPS_CRAY error("The sbcast command is not supported on Cray systems"); return 1; #endif #ifdef HAVE_BG error("The sbcast command is not supported on IBM BlueGene systems"); return 1; #endif slurm_conf_init(NULL); parse_command_line(argc, argv); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_DAEMON, NULL); } /* validate the source file */ if ((fd = open(params.src_fname, O_RDONLY)) < 0) { error("Can't open `%s`: %s", params.src_fname, strerror(errno)); exit(1); } if (fstat(fd, &f_stat)) { error("Can't stat `%s`: %s", params.src_fname, strerror(errno)); exit(1); } verbose("modes = %o", (unsigned int) f_stat.st_mode); verbose("uid = %d", (int) f_stat.st_uid); verbose("gid = %d", (int) f_stat.st_gid); verbose("atime = %s", slurm_ctime(&f_stat.st_atime)); verbose("mtime = %s", slurm_ctime(&f_stat.st_mtime)); verbose("ctime = %s", slurm_ctime(&f_stat.st_ctime)); verbose("size = %ld", (long) f_stat.st_size); verbose("-----------------------------"); /* identify the nodes allocated to the job */ _get_job_info(); /* transmit the file */ _bcast_file(); /* slurm_free_sbcast_cred_msg(sbcast_cred); */ exit(0); }
int main(int argc, char **argv) { enum { SACCT_LIST, SACCT_HELP, SACCT_USAGE } op; int rc = 0; slurm_conf_init(NULL); sacct_init(); parse_command_line(argc, argv); /* What are we doing? Requests for help take highest priority, * but then check for illogical switch combinations. */ if (params.opt_help) op = SACCT_HELP; else op = SACCT_LIST; switch (op) { case SACCT_LIST: print_fields_header(print_fields_list); if (get_data() == SLURM_ERROR) exit(errno); if (params.opt_completion) do_list_completion(); else do_list(); break; case SACCT_HELP: do_help(); break; default: fprintf(stderr, "sacct bug: should never get here\n"); sacct_fini(); exit(2); } sacct_fini(); return (rc); }
int main (int argc, char *argv[]) { log_options_t opts = LOG_OPTS_STDERR_ONLY ; int error_code = SLURM_SUCCESS; slurm_conf_init(NULL); log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_USER, NULL); parse_command_line( argc, argv ); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_USER, NULL); } max_line_size = _get_window_width( ); if (params.clusters) working_cluster_rec = list_peek(params.clusters); while (1) { if ((!params.no_header) && (params.iterate || params.verbose || params.long_list)) _print_date (); if (!params.clusters) { if (_get_info(false)) error_code = 1; } else if (_multi_cluster(params.clusters) != 0) error_code = 1; if ( params.iterate ) { printf( "\n"); sleep( params.iterate ); } else break; } if ( error_code != SLURM_SUCCESS ) exit (error_code); else exit (0); }
int main (int argc, char *argv[]) { log_options_t log_opts = LOG_OPTS_STDERR_ONLY ; int rc = 0; slurm_conf_init(NULL); log_init (xbasename(argv[0]), log_opts, SYSLOG_FACILITY_DAEMON, NULL); initialize_and_process_args(argc, argv); if (opt.verbose) { log_opts.stderr_level += opt.verbose; log_alter (log_opts, SYSLOG_FACILITY_DAEMON, NULL); } if (opt.clusters) rc = _multi_cluster(opt.clusters); else rc = _proc_cluster(); exit(rc); }
int srun(int ac, char **av) { int debug_level; log_options_t logopt = LOG_OPTS_STDERR_ONLY; bool got_alloc = false; List srun_job_list = NULL; slurm_conf_init(NULL); debug_level = _slurm_debug_env_val(); logopt.stderr_level += debug_level; log_init(xbasename(av[0]), logopt, 0, NULL); _set_exit_code(); if (slurm_select_init(1) != SLURM_SUCCESS ) fatal( "failed to initialize node selection plugin" ); if (switch_init(0) != SLURM_SUCCESS ) fatal("failed to initialize switch plugins"); _setup_env_working_cluster(); init_srun(ac, av, &logopt, debug_level, 1); if (opt_list) { if (!_enable_pack_steps()) fatal("Job steps that span multiple components of a heterogeneous job are not currently supported"); create_srun_job((void **) &srun_job_list, &got_alloc, 0, 1); } else create_srun_job((void **) &job, &got_alloc, 0, 1); _setup_job_env(job, srun_job_list, got_alloc); _set_node_alias(); _launch_app(job, srun_job_list, got_alloc); if ((global_rc & 0xff) == SIG_OOM) global_rc = 1; /* Exit code 1 */ return (int)global_rc; }
int main(int argc, char *argv[]) { int rc = 0; slurm_conf_init(NULL); parse_command_line(argc, argv); if (sdiag_param == STAT_COMMAND_RESET) { req.command_id = STAT_COMMAND_RESET; rc = slurm_reset_statistics((stats_info_request_msg_t *)&req); if (rc == SLURM_SUCCESS) printf("Reset scheduling statistics\n"); else slurm_perror("slurm_reset_statistics"); exit(rc); } else { rc = _get_info(); if (rc == SLURM_SUCCESS) rc = _print_info(); } exit(rc); }
int main (int argc, char **argv) { int opt_char; log_options_t opts = LOG_OPTS_STDERR_ONLY; shares_request_msg_t req_msg; char *temp = NULL; int option_index; bool all_users = 0; static struct option long_options[] = { {"accounts", 1, 0, 'A'}, {"all", 0, 0, 'a'}, {"helpformat",0,0, 'e'}, {"long", 0, 0, 'l'}, {"partition",0, 0, 'm'}, {"cluster", 1, 0, 'M'}, {"clusters", 1, 0, 'M'}, {"noheader", 0, 0, 'n'}, {"format", 1, 0, 'o'}, {"parsable", 0, 0, 'p'}, {"parsable2",0, 0, 'P'}, {"users", 1, 0, 'u'}, {"Users", 0, 0, 'U'}, {"verbose", 0, 0, 'v'}, {"version", 0, 0, 'V'}, {"help", 0, 0, OPT_LONG_HELP}, {"usage", 0, 0, OPT_LONG_USAGE}, {NULL, 0, 0, 0} }; exit_code = 0; long_flag = 0; quiet_flag = 0; verbosity = 0; memset(&req_msg, 0, sizeof(shares_request_msg_t)); slurm_conf_init(NULL); log_init("sshare", opts, SYSLOG_FACILITY_DAEMON, NULL); while ((opt_char = getopt_long(argc, argv, "aA:ehlM:no:pPqUu:t:vVm", long_options, &option_index)) != -1) { switch (opt_char) { case (int)'?': fprintf(stderr, "Try \"sshare --help\" " "for more information\n"); exit(1); break; case 'a': all_users = 1; break; case 'A': if (!req_msg.acct_list) req_msg.acct_list = list_create(slurm_destroy_char); slurm_addto_char_list(req_msg.acct_list, optarg); break; case 'e': _help_format_msg(); exit(0); break; case 'h': print_fields_have_header = 0; break; case 'l': long_flag = 1; break; case 'M': FREE_NULL_LIST(clusters); if (!(clusters = slurmdb_get_info_cluster(optarg))) { print_db_notok(optarg, 0); exit(1); } working_cluster_rec = list_peek(clusters); break; case 'm': options |= PRINT_PARTITIONS; break; case 'n': print_fields_have_header = 0; break; case 'o': xstrfmtcat(opt_field_list, "%s,", optarg); break; case 'p': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_ENDING; break; case 'P': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_NO_ENDING; break; case 'u': if (!xstrcmp(optarg, "-1")) { all_users = 1; break; } all_users = 0; if (!req_msg.user_list) req_msg.user_list = list_create(slurm_destroy_char); _addto_name_char_list(req_msg.user_list, optarg, 0); break; case 'U': options |= PRINT_USERS_ONLY; break; case 'v': quiet_flag = -1; verbosity++; break; case 'V': _print_version(); exit(exit_code); break; case OPT_LONG_HELP: case OPT_LONG_USAGE: _usage(); exit(0); default: exit_code = 1; fprintf(stderr, "getopt error, returned %c\n", opt_char); exit(exit_code); } } if (verbosity) { opts.stderr_level += verbosity; opts.prefix_level = 1; log_alter(opts, 0, NULL); } if (all_users) { if (req_msg.user_list && list_count(req_msg.user_list)) { FREE_NULL_LIST(req_msg.user_list); } if (verbosity) fprintf(stderr, "Users requested:\n\t: all\n"); } else if (verbosity && req_msg.user_list && list_count(req_msg.user_list)) { fprintf(stderr, "Users requested:\n"); ListIterator itr = list_iterator_create(req_msg.user_list); while ((temp = list_next(itr))) fprintf(stderr, "\t: %s\n", temp); list_iterator_destroy(itr); } else if (!req_msg.user_list || !list_count(req_msg.user_list)) { struct passwd *pwd; if ((pwd = getpwuid(getuid()))) { if (!req_msg.user_list) { req_msg.user_list = list_create(slurm_destroy_char); } temp = xstrdup(pwd->pw_name); list_append(req_msg.user_list, temp); if (verbosity) { fprintf(stderr, "Users requested:\n"); fprintf(stderr, "\t: %s\n", temp); } } } if (req_msg.acct_list && list_count(req_msg.acct_list)) { if (verbosity) { fprintf(stderr, "Accounts requested:\n"); ListIterator itr = list_iterator_create(req_msg.acct_list); while ((temp = list_next(itr))) fprintf(stderr, "\t: %s\n", temp); list_iterator_destroy(itr); } } else { if (req_msg.acct_list && list_count(req_msg.acct_list)) { FREE_NULL_LIST(req_msg.acct_list); } if (verbosity) fprintf(stderr, "Accounts requested:\n\t: all\n"); } if (clusters) exit_code = _multi_cluster(&req_msg); else exit_code = _single_cluster(&req_msg); exit(exit_code); }
int main(int argc, char **argv) { log_options_t logopt = LOG_OPTS_STDERR_ONLY; job_desc_msg_t desc; resource_allocation_response_msg_t *alloc; time_t before, after; allocation_msg_thread_t *msg_thr; char **env = NULL, *cluster_name; int status = 0; int retries = 0; pid_t pid = getpid(); pid_t tpgid = 0; pid_t rc_pid = 0; int i, rc = 0; static char *msg = "Slurm job queue full, sleeping and retrying."; slurm_allocation_callbacks_t callbacks; slurm_conf_init(NULL); log_init(xbasename(argv[0]), logopt, 0, NULL); _set_exit_code(); if (spank_init_allocator() < 0) { error("Failed to initialize plugin stack"); exit(error_exit); } /* Be sure to call spank_fini when salloc exits */ if (atexit((void (*) (void)) spank_fini) < 0) error("Failed to register atexit handler for plugins: %m"); if (initialize_and_process_args(argc, argv) < 0) { error("salloc parameter parsing"); exit(error_exit); } /* reinit log with new verbosity (if changed by command line) */ if (opt.verbose || opt.quiet) { logopt.stderr_level += opt.verbose; logopt.stderr_level -= opt.quiet; logopt.prefix_level = 1; log_alter(logopt, 0, NULL); } if (spank_init_post_opt() < 0) { error("Plugin stack post-option processing failed"); exit(error_exit); } _set_spank_env(); _set_submit_dir_env(); if (opt.cwd && chdir(opt.cwd)) { error("chdir(%s): %m", opt.cwd); exit(error_exit); } if (opt.get_user_env_time >= 0) { bool no_env_cache = false; char *sched_params; char *user = uid_to_string(opt.uid); if (xstrcmp(user, "nobody") == 0) { error("Invalid user id %u: %m", (uint32_t)opt.uid); exit(error_exit); } sched_params = slurm_get_sched_params(); no_env_cache = (sched_params && strstr(sched_params, "no_env_cache")); xfree(sched_params); env = env_array_user_default(user, opt.get_user_env_time, opt.get_user_env_mode, no_env_cache); xfree(user); if (env == NULL) exit(error_exit); /* error already logged */ _set_rlimits(env); } /* * Job control for interactive salloc sessions: only if ... * * a) input is from a terminal (stdin has valid termios attributes), * b) controlling terminal exists (non-negative tpgid), * c) salloc is not run in allocation-only (--no-shell) mode, * NOTE: d and e below are configuration dependent * d) salloc runs in its own process group (true in interactive * shells that support job control), * e) salloc has been configured at compile-time to support background * execution and is not currently in the background process group. */ if (tcgetattr(STDIN_FILENO, &saved_tty_attributes) < 0) { /* * Test existence of controlling terminal (tpgid > 0) * after first making sure stdin is not redirected. */ } else if ((tpgid = tcgetpgrp(STDIN_FILENO)) < 0) { #ifdef HAVE_ALPS_CRAY verbose("no controlling terminal"); #else if (!opt.no_shell) { error("no controlling terminal: please set --no-shell"); exit(error_exit); } #endif #ifdef SALLOC_RUN_FOREGROUND } else if ((!opt.no_shell) && (pid == getpgrp())) { if (tpgid == pid) is_interactive = true; while (tcgetpgrp(STDIN_FILENO) != pid) { if (!is_interactive) { error("Waiting for program to be placed in " "the foreground"); is_interactive = true; } killpg(pid, SIGTTIN); } } #else } else if ((!opt.no_shell) && (getpgrp() == tcgetpgrp(STDIN_FILENO))) {
int main (int argc, char **argv) { int error_code = SLURM_SUCCESS, i, opt_char, input_field_count; char **input_fields; log_options_t opts = LOG_OPTS_STDERR_ONLY ; char *temp = NULL; int option_index; static struct option long_options[] = { {"all_clusters", 0, 0, 'a'}, {"cluster", 1, 0, 'M'}, {"help", 0, 0, 'h'}, {"immediate",0, 0, 'i'}, {"noheader", 0, 0, 'n'}, {"parsable", 0, 0, 'p'}, {"parsable2",0, 0, 'P'}, {"quiet", 0, 0, 'Q'}, {"sort", 0, 0, 's'}, {"tres", 1, 0, 'T'}, {"usage", 0, 0, 'h'}, {"verbose", 0, 0, 'v'}, {"version", 0, 0, 'V'}, {NULL, 0, 0, 0} }; command_name = argv[0]; exit_code = 0; exit_flag = 0; input_field_count = 0; quiet_flag = 0; slurm_conf_init(NULL); log_init("sreport", opts, SYSLOG_FACILITY_DAEMON, NULL); /* Check to see if we are running a supported accounting plugin */ temp = slurm_get_accounting_storage_type(); if (xstrcasecmp(temp, "accounting_storage/slurmdbd") && xstrcasecmp(temp, "accounting_storage/mysql")) { fprintf (stderr, "You are not running a supported " "accounting_storage plugin\n(%s).\n" "Only 'accounting_storage/slurmdbd' " "and 'accounting_storage/mysql' are supported.\n", temp); xfree(temp); exit(1); } xfree(temp); temp = getenv("SREPORT_TRES"); if (temp) tres_str = xstrdup(temp); while ((opt_char = getopt_long(argc, argv, "aM:hnpPQs:t:T:vV", long_options, &option_index)) != -1) { switch (opt_char) { case (int)'?': fprintf(stderr, "Try \"sreport --help\" " "for more information\n"); exit(1); break; case (int)'h': _usage (); exit(exit_code); break; case (int)'a': all_clusters_flag = 1; break; case (int) 'M': cluster_flag = xstrdup(optarg); break; case (int)'n': print_fields_have_header = 0; break; case (int)'p': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_ENDING; break; case (int)'P': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_NO_ENDING; break; case (int)'Q': quiet_flag = 1; break; case (int)'s': _set_sort(optarg); break; case (int)'t': _set_time_format(optarg); break; case (int)'T': xfree(tres_str); tres_str = xstrdup(optarg); break; case (int)'v': quiet_flag = -1; break; case (int)'V': _print_version(); exit(exit_code); break; default: exit_code = 1; fprintf(stderr, "getopt error, returned %c\n", opt_char); exit(exit_code); } } if (argc > MAX_INPUT_FIELDS) /* bogus input, but continue anyway */ input_words = argc; else input_words = 128; input_fields = (char **) xmalloc (sizeof (char *) * input_words); if (optind < argc) { for (i = optind; i < argc; i++) { input_fields[input_field_count++] = argv[i]; } } my_uid = getuid(); db_conn = slurmdb_connection_get(); if (errno) { fatal("Problem connecting to the database: %m"); exit(1); } tres_list = _build_tres_list(tres_str); if (input_field_count) exit_flag = 1; else error_code = _get_command (&input_field_count, input_fields); while (error_code == SLURM_SUCCESS) { error_code = _process_command (input_field_count, input_fields); if (error_code || exit_flag) break; error_code = _get_command (&input_field_count, input_fields); } if (exit_flag == 2) putchar('\n'); /* Free the cluster grabbed from the -M option */ xfree(cluster_flag); slurmdb_connection_close(&db_conn); slurm_acct_storage_fini(); exit(exit_code); }
static int _slurmd_init(void) { struct rlimit rlim; slurm_ctl_conf_t *cf; struct stat stat_buf; uint32_t cpu_cnt; /* * Process commandline arguments first, since one option may be * an alternate location for the slurm config file. */ _process_cmdline(*conf->argc, *conf->argv); /* * Build nodes table like in slurmctld * This is required by the topology stack * Node tables setup must preceed _read_config() so that the * proper hostname is set. */ slurm_conf_init(conf->conffile); init_node_conf(); /* slurm_select_init() must be called before * build_all_nodeline_info() to be called with proper argument. */ if (slurm_select_init(1) != SLURM_SUCCESS ) return SLURM_FAILURE; build_all_nodeline_info(true); build_all_frontend_info(true); /* * Read global slurm config file, override necessary values from * defaults and command line. */ _read_config(); cpu_cnt = MAX(conf->conf_cpus, conf->block_map_size); if ((gres_plugin_init() != SLURM_SUCCESS) || (gres_plugin_node_config_load(cpu_cnt) != SLURM_SUCCESS)) return SLURM_FAILURE; if (slurm_topo_init() != SLURM_SUCCESS) return SLURM_FAILURE; /* * Get and set slurmd topology information * Build node hash table first to speed up the topo build */ rehash_node(); slurm_topo_build_config(); _set_topo_info(); /* * Check for cpu frequency set capabilities on this node */ cpu_freq_init(conf); _print_conf(); if (slurm_proctrack_init() != SLURM_SUCCESS) return SLURM_FAILURE; if (slurmd_task_init() != SLURM_SUCCESS) return SLURM_FAILURE; if (slurm_auth_init(NULL) != SLURM_SUCCESS) return SLURM_FAILURE; if (spank_slurmd_init() < 0) return SLURM_FAILURE; if (getrlimit(RLIMIT_CPU, &rlim) == 0) { rlim.rlim_cur = rlim.rlim_max; setrlimit(RLIMIT_CPU, &rlim); if (rlim.rlim_max != RLIM_INFINITY) { error("Slurmd process CPU time limit is %d seconds", (int) rlim.rlim_max); } } if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) { rlim.rlim_cur = rlim.rlim_max; setrlimit(RLIMIT_NOFILE, &rlim); } #ifndef NDEBUG if (getrlimit(RLIMIT_CORE, &rlim) == 0) { rlim.rlim_cur = rlim.rlim_max; setrlimit(RLIMIT_CORE, &rlim); } #endif /* !NDEBUG */ /* * Create a context for verifying slurm job credentials */ if (!(conf->vctx = slurm_cred_verifier_ctx_create(conf->pubkey))) return SLURM_FAILURE; if (!strcmp(conf->select_type, "select/serial")) { /* Only cache credential for 5 seconds with select/serial * for shorter cache searches and higher throughput */ slurm_cred_ctx_set(conf->vctx, SLURM_CRED_OPT_EXPIRY_WINDOW, 5); } /* * Create slurmd spool directory if necessary. */ if (_set_slurmd_spooldir() < 0) { error("Unable to initialize slurmd spooldir"); return SLURM_FAILURE; } if (conf->cleanstart) { /* * Need to kill any running slurmd's here */ _kill_old_slurmd(); stepd_cleanup_sockets(conf->spooldir, conf->node_name); _stepd_cleanup_batch_dirs(conf->spooldir, conf->node_name); } if (conf->daemonize) { bool success = false; if (conf->logfile && (conf->logfile[0] == '/')) { char *slash_ptr, *work_dir; work_dir = xstrdup(conf->logfile); slash_ptr = strrchr(work_dir, '/'); if (slash_ptr == work_dir) work_dir[1] = '\0'; else slash_ptr[0] = '\0'; if ((access(work_dir, W_OK) != 0) || (chdir(work_dir) < 0)) { error("Unable to chdir to %s", work_dir); } else success = true; xfree(work_dir); } if (!success) { if ((access(conf->spooldir, W_OK) != 0) || (chdir(conf->spooldir) < 0)) { error("Unable to chdir to %s", conf->spooldir); } else success = true; } if (!success) { if ((access("/var/tmp", W_OK) != 0) || (chdir("/var/tmp") < 0)) { error("chdir(/var/tmp): %m"); return SLURM_FAILURE; } else info("chdir to /var/tmp"); } } /* * Cache the group access list */ cf = slurm_conf_lock(); if (cf->group_info & GROUP_CACHE) init_gids_cache(1); else init_gids_cache(0); slurm_conf_unlock(); if ((devnull = open_cloexec("/dev/null", O_RDWR)) < 0) { error("Unable to open /dev/null: %m"); return SLURM_FAILURE; } /* make sure we have slurmstepd installed */ if (stat(conf->stepd_loc, &stat_buf)) fatal("Unable to find slurmstepd file at %s", conf->stepd_loc); if (!S_ISREG(stat_buf.st_mode)) fatal("slurmstepd not a file at %s", conf->stepd_loc); return SLURM_SUCCESS; }
int srun(int ac, char **av) { int debug_level; env_t *env = xmalloc(sizeof(env_t)); log_options_t logopt = LOG_OPTS_STDERR_ONLY; bool got_alloc = false; slurm_step_io_fds_t cio_fds = SLURM_STEP_IO_FDS_INITIALIZER; slurm_step_launch_callbacks_t step_callbacks; env->stepid = -1; env->procid = -1; env->localid = -1; env->nodeid = -1; env->cli = NULL; env->env = NULL; env->ckpt_dir = NULL; slurm_conf_init(NULL); debug_level = _slurm_debug_env_val(); logopt.stderr_level += debug_level; log_init(xbasename(av[0]), logopt, 0, NULL); _set_exit_code(); if (slurm_select_init(1) != SLURM_SUCCESS ) fatal( "failed to initialize node selection plugin" ); if (switch_init() != SLURM_SUCCESS ) fatal("failed to initialize switch plugin"); init_srun(ac, av, &logopt, debug_level, 1); create_srun_job(&job, &got_alloc, 0, 1); /* * Enhance environment for job */ if (opt.bcast_flag) _file_bcast(); if (opt.cpus_set) env->cpus_per_task = opt.cpus_per_task; if (opt.ntasks_per_node != NO_VAL) env->ntasks_per_node = opt.ntasks_per_node; if (opt.ntasks_per_socket != NO_VAL) env->ntasks_per_socket = opt.ntasks_per_socket; if (opt.ntasks_per_core != NO_VAL) env->ntasks_per_core = opt.ntasks_per_core; env->distribution = opt.distribution; if (opt.plane_size != NO_VAL) env->plane_size = opt.plane_size; env->cpu_bind_type = opt.cpu_bind_type; env->cpu_bind = opt.cpu_bind; env->cpu_freq_min = opt.cpu_freq_min; env->cpu_freq_max = opt.cpu_freq_max; env->cpu_freq_gov = opt.cpu_freq_gov; env->mem_bind_type = opt.mem_bind_type; env->mem_bind = opt.mem_bind; env->overcommit = opt.overcommit; env->slurmd_debug = opt.slurmd_debug; env->labelio = opt.labelio; env->comm_port = slurmctld_comm_addr.port; env->batch_flag = 0; if (opt.job_name) env->job_name = opt.job_name; if (job) { uint16_t *tasks = NULL; slurm_step_ctx_get(job->step_ctx, SLURM_STEP_CTX_TASKS, &tasks); env->select_jobinfo = job->select_jobinfo; env->nodelist = job->nodelist; env->partition = job->partition; /* If we didn't get the allocation don't overwrite the * previous info. */ if (got_alloc) env->nhosts = job->nhosts; env->ntasks = job->ntasks; env->task_count = _uint16_array_to_str(job->nhosts, tasks); env->jobid = job->jobid; env->stepid = job->stepid; env->account = job->account; env->qos = job->qos; env->resv_name = job->resv_name; } if (opt.pty && (set_winsize(job) < 0)) { error("Not using a pseudo-terminal, disregarding --pty option"); opt.pty = false; } if (opt.pty) { struct termios term; int fd = STDIN_FILENO; /* Save terminal settings for restore */ tcgetattr(fd, &termdefaults); tcgetattr(fd, &term); /* Set raw mode on local tty */ cfmakeraw(&term); /* Re-enable output processing such that debug() and * and error() work properly. */ term.c_oflag |= OPOST; tcsetattr(fd, TCSANOW, &term); atexit(&_pty_restore); block_sigwinch(); pty_thread_create(job); env->pty_port = job->pty_port; env->ws_col = job->ws_col; env->ws_row = job->ws_row; } setup_env(env, opt.preserve_env); xfree(env->task_count); xfree(env); _set_node_alias(); memset(&step_callbacks, 0, sizeof(step_callbacks)); step_callbacks.step_signal = launch_g_fwd_signal; /* re_launch: */ relaunch: pre_launch_srun_job(job, 0, 1); launch_common_set_stdio_fds(job, &cio_fds); if (!launch_g_step_launch(job, &cio_fds, &global_rc, &step_callbacks)) { if (launch_g_step_wait(job, got_alloc) == -1) goto relaunch; } fini_srun(job, got_alloc, &global_rc, 0); return (int)global_rc; }
/* * route_p_split_hostlist - logic to split an input hostlist into * a set of hostlists to forward to. * * IN: hl - hostlist_t - list of every node to send message to * will be empty on return; * OUT: sp_hl - hostlist_t** - the array of hostlists that will be malloced * OUT: count - int* - the count of created hostlists * RET: SLURM_SUCCESS - int * * Note: created hostlist will have to be freed independently using * hostlist_destroy by the caller. * Note: the hostlist_t array will have to be xfree. */ extern int route_p_split_hostlist(hostlist_t hl, hostlist_t** sp_hl, int* count) { int i, j, k, hl_ndx, msg_count, sw_count, lst_count; char *buf; bitstr_t *nodes_bitmap = NULL; /* nodes in message list */ bitstr_t *fwd_bitmap = NULL; /* nodes in forward list */ msg_count = hostlist_count(hl); if (switch_record_cnt == 0) { /* configs have not already been processed */ slurm_conf_init(NULL); if (init_node_conf()) { fatal("ROUTE: Failed to init slurm config"); } if (build_all_nodeline_info(false)) { fatal("ROUTE: Failed to build node config"); } rehash_node(); if (slurm_topo_build_config() != SLURM_SUCCESS) { fatal("ROUTE: Failed to build topology config"); } } *sp_hl = (hostlist_t*) xmalloc(switch_record_cnt * sizeof(hostlist_t)); /* create bitmap of nodes to send message too */ if (hostlist2bitmap (hl, false, &nodes_bitmap) != SLURM_SUCCESS) { buf = hostlist_ranged_string_xmalloc(hl); fatal("ROUTE: Failed to make bitmap from hostlist=%s.", buf); } /* Find lowest level switch containing all the nodes in the list */ j = 0; for (i = 0; i <= switch_levels; i++) { for (j=0; j<switch_record_cnt; j++) { if (switch_record_table[j].level == i) { if (bit_super_set(nodes_bitmap, switch_record_table[j]. node_bitmap)) { /* All nodes in message list are in * this switch */ break; } } } if (j < switch_record_cnt) { /* Got here via break after bit_super_set */ break; // 'j' is our switch } /* else, no switches at this level reach all nodes */ } if (i > switch_levels) { /* This can only happen if trying to schedule multiple physical * clusters as a single logical cluster under the control of a * single slurmctld daemon, and sending something like a * node_registation request to all nodes. * Revert to default behavior*/ if (debug_flags & DEBUG_FLAG_ROUTE) { buf = hostlist_ranged_string_xmalloc(hl); debug("ROUTE: didn't find switch containing nodes=%s", buf); xfree(buf); } FREE_NULL_BITMAP(nodes_bitmap); xfree(*sp_hl); return route_split_hostlist_treewidth(hl, sp_hl, count); } if (switch_record_table[j].level == 0) { /* This is a leaf switch. Construct list based on TreeWidth */ FREE_NULL_BITMAP(nodes_bitmap); xfree(*sp_hl); return route_split_hostlist_treewidth(hl, sp_hl, count); } /* loop through children, construction a hostlist for each child switch * with nodes in the message list */ hl_ndx = 0; lst_count = 0; for (i=0; i < switch_record_table[j].num_switches; i++) { k = switch_record_table[j].switch_index[i]; fwd_bitmap = bit_copy(switch_record_table[k].node_bitmap); bit_and(fwd_bitmap, nodes_bitmap); sw_count = bit_set_count(fwd_bitmap); if (sw_count == 0) { continue; /* no nodes on this switch in message list */ } (*sp_hl)[hl_ndx] = bitmap2hostlist(fwd_bitmap); /* Now remove nodes from this switch from message list */ bit_not(fwd_bitmap); bit_and(nodes_bitmap, fwd_bitmap); FREE_NULL_BITMAP(fwd_bitmap); if (debug_flags & DEBUG_FLAG_ROUTE) { buf = hostlist_ranged_string_xmalloc((*sp_hl)[hl_ndx]); debug("ROUTE: ... sublist[%d] switch=%s :: %s", i, switch_record_table[i].name, buf); xfree(buf); } hl_ndx++; lst_count += sw_count; if (lst_count == msg_count) break; /* all nodes in message are in a child list */ } FREE_NULL_BITMAP(nodes_bitmap); *count = hl_ndx; return SLURM_SUCCESS; }
int main(int argc, char **argv) { int error_code = SLURM_SUCCESS, i, opt_char, input_field_count; char **input_fields; log_options_t opts = LOG_OPTS_STDERR_ONLY ; int local_exit_code = 0; char *temp = NULL; int option_index; static struct option long_options[] = { {"help", 0, 0, 'h'}, {"usage", 0, 0, 'h'}, {"immediate",0, 0, 'i'}, {"noheader",0, 0, 'n'}, {"oneliner", 0, 0, 'o'}, {"parsable", 0, 0, 'p'}, {"parsable2", 0, 0, 'P'}, {"quiet", 0, 0, 'Q'}, {"readonly", 0, 0, 'r'}, {"associations", 0, 0, 's'}, {"verbose", 0, 0, 'v'}, {"version", 0, 0, 'V'}, {NULL, 0, 0, 0} }; command_name = argv[0]; rollback_flag = 1; exit_code = 0; exit_flag = 0; input_field_count = 0; quiet_flag = 0; readonly_flag = 0; verbosity = 0; slurm_conf_init(NULL); log_init("sacctmgr", opts, SYSLOG_FACILITY_DAEMON, NULL); while((opt_char = getopt_long(argc, argv, "hionpPQrsvV", long_options, &option_index)) != -1) { switch (opt_char) { case (int)'?': fprintf(stderr, "Try \"sacctmgr --help\" " "for more information\n"); exit(1); break; case (int)'h': _usage (); exit(exit_code); break; case (int)'i': rollback_flag = 0; break; case (int)'o': one_liner = 1; break; case (int)'n': print_fields_have_header = 0; break; case (int)'p': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_ENDING; break; case (int)'P': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_NO_ENDING; break; case (int)'Q': quiet_flag = 1; break; case (int)'r': readonly_flag = 1; break; case (int)'s': with_assoc_flag = 1; break; case (int)'v': quiet_flag = -1; verbosity++; break; case (int)'V': _print_version(); exit(exit_code); break; default: exit_code = 1; fprintf(stderr, "getopt error, returned %c\n", opt_char); exit(exit_code); } } if (argc > MAX_INPUT_FIELDS) /* bogus input, but continue anyway */ input_words = argc; else input_words = 128; input_fields = (char **) xmalloc (sizeof (char *) * input_words); if (optind < argc) { for (i = optind; i < argc; i++) { input_fields[input_field_count++] = argv[i]; } } if (verbosity) { opts.stderr_level += verbosity; opts.prefix_level = 1; log_alter(opts, 0, NULL); } /* Check to see if we are running a supported accounting plugin */ temp = slurm_get_accounting_storage_type(); if (xstrcasecmp(temp, "accounting_storage/slurmdbd") && xstrcasecmp(temp, "accounting_storage/mysql")) { fprintf (stderr, "You are not running a supported " "accounting_storage plugin\n(%s).\n" "Only 'accounting_storage/slurmdbd' " "and 'accounting_storage/mysql' are supported.\n", temp); xfree(temp); exit(1); } xfree(temp); errno = 0; db_conn = slurmdb_connection_get(); if (errno != SLURM_SUCCESS) { int tmp_errno = errno; if ((input_field_count == 2) && (!strncasecmp(argv[2], "Configuration", strlen(argv[1]))) && ((!strncasecmp(argv[1], "list", strlen(argv[0]))) || (!strncasecmp(argv[1], "show", strlen(argv[0]))))) { if (tmp_errno == ESLURM_DB_CONNECTION) { tmp_errno = 0; sacctmgr_list_config(true); } else sacctmgr_list_config(false); } errno = tmp_errno; if (errno) error("Problem talking to the database: %m"); exit(1); } my_uid = getuid(); if (input_field_count) exit_flag = 1; else error_code = _get_command (&input_field_count, input_fields); while (error_code == SLURM_SUCCESS) { error_code = _process_command (input_field_count, input_fields); if (error_code || exit_flag) break; error_code = _get_command (&input_field_count, input_fields); /* This is here so if someone made a mistake we allow * them to fix it and let the process happen since there * are checks for global exit_code we need to reset it. */ if (exit_code) { local_exit_code = exit_code; exit_code = 0; } } /* readline library writes \n when echoes the input string, it does * not when it sees the EOF, so in that case we have to print it to * align the terminal prompt. */ if (exit_flag == 2) putchar('\n'); if (local_exit_code) exit_code = local_exit_code; acct_storage_g_close_connection(&db_conn); slurm_acct_storage_fini(); FREE_NULL_LIST(g_qos_list); FREE_NULL_LIST(g_res_list); FREE_NULL_LIST(g_tres_list); exit(exit_code); }
extern void create_daemon_popup(GtkAction *action, gpointer user_data) { GtkWidget *popup = gtk_dialog_new_with_buttons( "SLURM Daemons running", GTK_WINDOW(user_data), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_OK, NULL); int update = 0; slurm_ctl_conf_info_msg_t *conf; char me[MAX_SLURM_NAME], *b, *c, *n; int actld = 0, ctld = 0, d = 0; GtkTreeStore *treestore = _local_create_treestore_2cols(popup, 300, 100); GtkTreeIter iter; g_signal_connect(G_OBJECT(popup), "delete_event", G_CALLBACK(_delete_popup), NULL); g_signal_connect(G_OBJECT(popup), "response", G_CALLBACK(_delete_popup), NULL); slurm_conf_init(NULL); conf = slurm_conf_lock(); gethostname_short(me, MAX_SLURM_NAME); if ((b = conf->backup_controller)) { if ((strcmp(b, me) == 0) || (strcasecmp(b, "localhost") == 0)) ctld = 1; } if ((c = conf->control_machine)) { actld = 1; if ((strcmp(c, me) == 0) || (strcasecmp(c, "localhost") == 0)) ctld = 1; } slurm_conf_unlock(); if ((n = slurm_conf_get_nodename(me))) { d = 1; xfree(n); } else if ((n = slurm_conf_get_aliased_nodename())) { d = 1; xfree(n); } else if ((n = slurm_conf_get_nodename("localhost"))) { d = 1; xfree(n); } if (actld && ctld) add_display_treestore_line(update, treestore, &iter, "Slurmctld", "1"); if (actld && d) add_display_treestore_line(update, treestore, &iter, "Slurmd", "1"); gtk_widget_show_all(popup); return; }
int main(int argc, char **argv) { ListIterator itr = NULL; uint32_t req_cpufreq = NO_VAL; uint32_t stepid = NO_VAL; slurmdb_selected_step_t *selected_step = NULL; #ifdef HAVE_ALPS_CRAY error("The sstat command is not supported on Cray systems"); return 1; #endif #ifdef HAVE_BG error("The sstat command is not supported on IBM BlueGene systems"); return 1; #endif slurm_conf_init(NULL); print_fields_list = list_create(NULL); print_fields_itr = list_iterator_create(print_fields_list); parse_command_line(argc, argv); if (!params.opt_job_list || !list_count(params.opt_job_list)) { error("You didn't give me any jobs to stat."); return 1; } print_fields_header(print_fields_list); itr = list_iterator_create(params.opt_job_list); while ((selected_step = list_next(itr))) { char *nodelist = NULL; bool free_nodelist = false; if (selected_step->stepid == INFINITE) { /* get the batch step info */ job_info_msg_t *job_ptr = NULL; hostlist_t hl; if (slurm_load_job( &job_ptr, selected_step->jobid, SHOW_ALL)) { error("couldn't get info for job %u", selected_step->jobid); continue; } stepid = NO_VAL; hl = hostlist_create(job_ptr->job_array[0].nodes); nodelist = hostlist_pop(hl); free_nodelist = true; hostlist_destroy(hl); slurm_free_job_info_msg(job_ptr); } else if (selected_step->stepid != NO_VAL) { stepid = selected_step->stepid; } else if (params.opt_all_steps) { job_step_info_response_msg_t *step_ptr = NULL; int i = 0; if (slurm_get_job_steps( 0, selected_step->jobid, NO_VAL, &step_ptr, SHOW_ALL)) { error("couldn't get steps for job %u", selected_step->jobid); continue; } for (i = 0; i < step_ptr->job_step_count; i++) { _do_stat(selected_step->jobid, step_ptr->job_steps[i].step_id, step_ptr->job_steps[i].nodes, step_ptr->job_steps[i].cpu_freq); } slurm_free_job_step_info_response_msg(step_ptr); continue; } else { /* get the first running step to query against. */ job_step_info_response_msg_t *step_ptr = NULL; if (slurm_get_job_steps( 0, selected_step->jobid, NO_VAL, &step_ptr, SHOW_ALL)) { error("couldn't get steps for job %u", selected_step->jobid); continue; } if (!step_ptr->job_step_count) { error("no steps running for job %u", selected_step->jobid); continue; } stepid = step_ptr->job_steps[0].step_id; nodelist = step_ptr->job_steps[0].nodes; req_cpufreq = step_ptr->job_steps[0].cpu_freq; } _do_stat(selected_step->jobid, stepid, nodelist, req_cpufreq); if (free_nodelist && nodelist) free(nodelist); } list_iterator_destroy(itr); xfree(params.opt_field_list); if (params.opt_job_list) list_destroy(params.opt_job_list); if (print_fields_itr) list_iterator_destroy(print_fields_itr); if (print_fields_list) list_destroy(print_fields_list); return 0; }
int main(int argc, char **argv) { int debug_level, sig, srun_fd; struct sigaction sa; log_options_t logopt = LOG_OPTS_STDERR_ONLY; struct sockaddr_un ca; unsigned int ca_len = sizeof(ca); atexit(remove_listen_socket); /* copied from srun */ slurm_conf_init(NULL); debug_level = _slurm_debug_env_val(); logopt.stderr_level += debug_level; log_init(xbasename(argv[0]), logopt, 0, NULL); if (init_srun_argv(argc, argv)) { fatal("failed to initialize arguments for running srun"); } if ((cr_id = cr_init()) < 0) { fatal("failed to initialize libcr: %s", cr_strerror(errno)); } (void)cr_register_callback(cr_callback, NULL, CR_THREAD_CONTEXT); /* forward signals. copied from cr_restart */ sa.sa_sigaction = signal_child; sa.sa_flags = SA_RESTART | SA_NODEFER | SA_SIGINFO; sigemptyset(&sa.sa_mask); for (sig = 0; sig < _NSIG; sig ++) { if (sig == SIGSTOP || sig == SIGKILL || sig == SIGCHLD) continue; sigaction(sig, &sa, NULL); } sa.sa_sigaction = on_child_exit; sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_NOCLDSTOP; sigaction(SIGCHLD, &sa, NULL); cr_enter_cs(cr_id); /* BEGIN CS: avoid race condition of whether srun is forked */ if ( fork_exec_srun() ) { fatal("failed fork/exec/wait srun"); } cr_leave_cs(cr_id); /* END CS */ while (1) { slurm_mutex_lock(&step_launch_mutex); while (step_launched) { /* just avoid busy waiting */ slurm_cond_wait(&step_launch_cond, &step_launch_mutex); } slurm_mutex_unlock(&step_launch_mutex); if (_wait_for_srun_connect() < 0) continue; cr_enter_cs(cr_id); /* BEGIN CS: checkpoint(callback) will be delayed */ srun_fd = accept(listen_fd, (struct sockaddr*)&ca, &ca_len); if (srun_fd < 0) { /* restarted before enter CS. socket will not be restored */ if (errno == EBADF) { cr_leave_cs(cr_id); continue; } else { fatal("failed to accept socket: %m"); } } _read_info_from_srun(srun_fd); close(srun_fd); step_launched = 1; debug2("step launched"); cr_leave_cs(cr_id); /* END CS */ } return 0; }
int main (int argc, char *argv[]) { char *prio_type = NULL; int error_code = SLURM_SUCCESS; priority_factors_request_msg_t req_msg; priority_factors_response_msg_t *resp_msg = NULL; log_options_t opts = LOG_OPTS_STDERR_ONLY ; slurm_conf_init(NULL); log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_USER, NULL); parse_command_line( argc, argv ); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_USER, NULL); } if (working_cluster_rec) { slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr; error_code = slurm_load_ctl_conf((time_t) NULL, &slurm_ctl_conf_ptr); if (error_code) { slurm_perror ("slurm_load_ctl_conf error"); exit(error_code); } weight_age = slurm_ctl_conf_ptr->priority_weight_age; weight_fs = slurm_ctl_conf_ptr->priority_weight_fs; weight_js = slurm_ctl_conf_ptr->priority_weight_js; weight_part = slurm_ctl_conf_ptr->priority_weight_part; weight_qos = slurm_ctl_conf_ptr->priority_weight_qos; weight_tres = slurm_ctl_conf_ptr->priority_weight_tres; prio_type = xstrdup(slurm_ctl_conf_ptr->priority_type); slurm_free_ctl_conf(slurm_ctl_conf_ptr); } else { weight_age = slurm_get_priority_weight_age(); weight_fs = slurm_get_priority_weight_fairshare(); weight_js = slurm_get_priority_weight_job_size(); weight_part = slurm_get_priority_weight_partition(); weight_qos = slurm_get_priority_weight_qos(); weight_tres = slurm_get_priority_weight_tres(); prio_type = slurm_get_priority_type(); } /* Check to see if we are running a supported accounting plugin */ if (xstrcasecmp(prio_type, "priority/basic") == 0) { fprintf (stderr, "You are not running a supported " "priority plugin\n(%s).\n" "Only 'priority/multifactor' is supported.\n", prio_type); exit(1); } xfree(prio_type); memset(&req_msg, 0, sizeof(priority_factors_request_msg_t)); if (params.jobs) req_msg.job_id_list = params.job_list; else req_msg.job_id_list = NULL; if (params.users) req_msg.uid_list = params.user_list; else req_msg.uid_list = NULL; error_code = _get_info(&req_msg, &resp_msg); if (error_code) { slurm_perror("Couldn't get priority factors from controller"); exit(error_code); } if (params.format == NULL) { if (params.normalized) { if (params.long_list) params.format = "%.15i %.8u %10y %10a %10f " "%10j %10p %10q %20t"; else{ params.format = xstrdup("%.15i"); if (params.users) xstrcat(params.format, " %.8u"); xstrcat(params.format, " %10y"); if (weight_age) xstrcat(params.format, " %10a"); if (weight_fs) xstrcat(params.format, " %10f"); if (weight_js) xstrcat(params.format, " %10j"); if (weight_part) xstrcat(params.format, " %10p"); if (weight_qos) xstrcat(params.format, " %10q"); if (weight_tres) xstrcat(params.format, " %20t"); } } else { if (params.long_list) params.format = "%.15i %.8u %.10Y %.10A %.10F " "%.10J %.10P %.10Q %.6N %.20T"; else{ params.format = xstrdup("%.15i"); if (params.users) xstrcat(params.format, " %.8u"); xstrcat(params.format, " %.10Y"); if (weight_age) xstrcat(params.format, " %.10A"); if (weight_fs) xstrcat(params.format, " %.10F"); if (weight_js) xstrcat(params.format, " %.10J"); if (weight_part) xstrcat(params.format, " %.10P"); if (weight_qos) xstrcat(params.format, " %.10Q"); if (weight_tres) xstrcat(params.format, " %.20T"); } } } /* create the format list from the format */ parse_format(params.format); if (params.jobs && (!resp_msg || !resp_msg->priority_factors_list || !list_count(resp_msg->priority_factors_list))) { printf("Unable to find jobs matching user/id(s) specified\n"); } else if (resp_msg) { print_jobs_array(resp_msg->priority_factors_list, params.format_list); } #if 0 /* Free storage here if we want to verify that logic. * Since we exit next, this is not important */ FREE_NULL_LIST(params.format_list); slurm_free_priority_factors_response_msg(resp_msg); #endif exit (error_code); }
int main(int argc, char **argv) { log_options_t opts = LOG_OPTS_STDERR_ONLY; node_info_msg_t *node_info_ptr = NULL; node_info_msg_t *new_node_ptr = NULL; int error_code; int height = 40; int width = 100; int startx = 0; int starty = 0; int end = 0; int i; int rc; slurm_conf_init(NULL); log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_DAEMON, NULL); parse_command_line(argc, argv); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_USER, NULL); } if (params.cluster_dims == 4) { min_screen_width = 92; } else if (params.cluster_dims == 3) min_screen_width = 92; /* no need for this if you are resolving */ while (slurm_load_node((time_t) NULL, &new_node_ptr, SHOW_ALL)) { if (params.resolve || (params.display == COMMANDS)) { new_node_ptr = NULL; break; /* just continue */ } error_code = slurm_get_errno(); printf("slurm_load_node: %s\n", slurm_strerror(error_code)); if (params.iterate == 0) exit(1); sleep(10); /* keep trying to reconnect */ } select_g_ba_init(new_node_ptr, 0); if (dim_size == NULL) { dim_size = get_cluster_dims(new_node_ptr); if ((dim_size == NULL) || (dim_size[0] < 1)) fatal("Invalid system dimensions"); } _init_colors(); if (params.resolve) { char *ret_str = resolve_mp(params.resolve, new_node_ptr); if (ret_str) { printf("%s", ret_str); xfree(ret_str); } _smap_exit(0); /* Calls exit(), no return */ } if (!params.commandline) { int check_width = min_screen_width; initscr(); init_grid(new_node_ptr, COLS); signal(SIGWINCH, (void (*)(int))_resize_handler); if (params.cluster_dims == 4) { height = dim_size[2] * dim_size[3] + dim_size[2] + 3; width = (dim_size[1] + dim_size[3] + 1) * dim_size[0] + 2; check_width += width; } else if (params.cluster_dims == 3) { height = dim_size[1] * dim_size[2] + dim_size[1] + 3; width = dim_size[0] + dim_size[2] + 3; check_width += width; } else { height = 10; width = COLS; } if ((COLS < check_width) || (LINES < height)) { endwin(); error("Screen is too small make sure the screen " "is at least %dx%d\n" "Right now it is %dx%d\n", check_width, height, COLS, LINES); _smap_exit(1); /* Calls exit(), no return */ } raw(); keypad(stdscr, true); noecho(); cbreak(); curs_set(0); nodelay(stdscr, true); start_color(); _set_pairs(); grid_win = newwin(height, width, starty, startx); max_display = (getmaxy(grid_win) - 1) * (getmaxx(grid_win) - 1); if (params.cluster_dims == 4) { startx = width; width = COLS - width - 2; height = LINES; } else if (params.cluster_dims == 3) { startx = width; width = COLS - width - 2; height = LINES; } else { startx = 0; starty = height; height = LINES - height; } text_win = newwin(height, width, starty, startx); } while (!end) { if (!params.commandline) { _get_option(); redraw: clear_window(text_win); clear_window(grid_win); move(0, 0); update_grid(new_node_ptr); main_xcord = 1; main_ycord = 1; } if (!params.no_header) print_date(); clear_grid(); switch (params.display) { case JOBS: get_job(); break; case RESERVATIONS: get_reservation(); break; case SLURMPART: get_slurm_part(); break; case COMMANDS: #ifdef HAVE_BG wclear(text_win); get_command(); #else error("Must be on a real BG SYSTEM to " "run this command"); if (!params.commandline) endwin(); _smap_exit(1); /* Calls exit(), no return */ #endif break; case BGPART: if (params.cluster_flags & CLUSTER_FLAG_BG) get_bg_part(); else { error("Must be on a BG SYSTEM to " "run this command"); if (!params.commandline) endwin(); _smap_exit(1); /* Calls exit(), no return */ } break; } if (!params.commandline) { box(text_win, 0, 0); wnoutrefresh(text_win); print_grid(); box(grid_win, 0, 0); wnoutrefresh(grid_win); doupdate(); node_info_ptr = new_node_ptr; if (node_info_ptr) { error_code = slurm_load_node( node_info_ptr->last_update, &new_node_ptr, SHOW_ALL); if (error_code == SLURM_SUCCESS) slurm_free_node_info_msg( node_info_ptr); else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) { error_code = SLURM_SUCCESS; new_node_ptr = node_info_ptr; } } else { error_code = slurm_load_node( (time_t) NULL, &new_node_ptr, SHOW_ALL); } if (error_code && (quiet_flag != 1)) { if (!params.commandline) { mvwprintw( text_win, main_ycord, 1, "slurm_load_node: %s", slurm_strerror( slurm_get_errno())); main_ycord++; } else { printf("slurm_load_node: %s", slurm_strerror( slurm_get_errno())); } } } if (params.iterate) { for (i = 0; i < params.iterate; i++) { sleep(1); if (!params.commandline) { if ((rc = _get_option()) == 1) goto redraw; else if (resize_screen) { resize_screen = 0; goto redraw; } } } } else break; } if (!params.commandline) { nodelay(stdscr, false); getch(); endwin(); } _smap_exit(0); /* Calls exit(), no return */ exit(0); /* Redundant, but eliminates compiler warning */ }
int main(int argc, char **argv) { GtkWidget *menubar = NULL; GtkWidget *table = NULL; GtkWidget *combo = NULL; GtkBin *bin = NULL; GtkViewport *view = NULL; int i=0; log_options_t lopts = LOG_OPTS_STDERR_ONLY; if (!getenv("SLURM_BITSTR_LEN")) setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */ slurm_conf_init(NULL); log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL); load_defaults(); cluster_flags = slurmdb_setup_cluster_flags(); cluster_dims = slurmdb_setup_cluster_dims(); _init_pages(); sview_thread_init(NULL); gdk_threads_init(); gdk_threads_enter(); /* Initialize GTK */ gtk_init (&argc, &argv); sview_mutex_new(&sview_mutex); sview_mutex_new(&grid_mutex); sview_cond_new(&grid_cond); /* make sure the system is up */ grid_window = GTK_WIDGET(create_scrolled_window()); bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container); view = GTK_VIEWPORT(bin->child); bin = GTK_BIN(&view->bin); main_grid_table = GTK_TABLE(bin->child); gtk_table_set_homogeneous(main_grid_table, true); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); /* fill in all static info for pages */ /* Make a window */ main_window = gtk_dialog_new(); g_signal_connect(G_OBJECT(main_window), "delete_event", G_CALLBACK(_delete), NULL); gtk_window_set_title(GTK_WINDOW(main_window), "Sview"); gtk_window_set_default_size(GTK_WINDOW(main_window), working_sview_config.main_width, working_sview_config.main_height); gtk_container_set_border_width( GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1); /* Create the main notebook, place the position of the tabs */ main_notebook = gtk_notebook_new(); g_signal_connect(G_OBJECT(main_notebook), "switch_page", G_CALLBACK(_page_switched), NULL); table = gtk_table_new(1, 3, false); gtk_table_set_homogeneous(GTK_TABLE(table), false); gtk_container_set_border_width(GTK_CONTAINER(table), 1); /* Create a menu */ menubar = _get_menubar_menu(main_window, main_notebook); gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1); if ((combo = _create_cluster_combo())) { GtkWidget *label = gtk_label_new("Cluster "); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); } gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook)); gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook), working_sview_config.tab_pos); main_statusbar = gtk_statusbar_new(); gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar), false); /* Pack it all together */ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox), table, false, false, 0); table = gtk_table_new(1, 2, false); gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1, GTK_SHRINK, GTK_EXPAND | GTK_FILL, 0, 0); gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox), table, true, true, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox), main_statusbar, false, false, 0); in_process_cursor = gdk_cursor_new(GDK_WATCH); for(i=0; i<PAGE_CNT; i++) { if (main_display_data[i].id == -1) break; create_page(GTK_NOTEBOOK(main_notebook), &main_display_data[i]); } /* tell signal we are done adding */ popup_list = list_create(destroy_popup_info); signal_params_list = list_create(destroy_signal_params); gtk_widget_show_all(main_window); adding = 0; /* apply default settings */ if (!working_sview_config.show_grid) gtk_widget_hide(grid_window); for(i=0; i<PAGE_CNT; i++) { GtkWidget *visible_tab = NULL; if (main_display_data[i].id == -1) break; visible_tab = gtk_notebook_get_nth_page( GTK_NOTEBOOK(main_notebook), i); if (working_sview_config.page_visible[i] || (i == working_sview_config.default_page) || (i == TAB_PAGE)) gtk_widget_show(visible_tab); else gtk_widget_hide(visible_tab); } /* Set the default page. This has to be done after the * gtk_widget_show_all since it, for some reason always sets * 0 to be the default page and will just overwrite this. */ /* Also if we already are set at the current page we need to start up the page thread, so just call the _page_switched function. If we aren't already there, then set the current page which will inturn call the _page_switched. If the pages is already this the signal doesn't happen so handle it here. */ if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook)) == working_sview_config.default_page) _page_switched(GTK_NOTEBOOK(main_notebook), NULL, working_sview_config.default_page, NULL); else gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook), working_sview_config. default_page); /* Finished! */ gtk_main (); gdk_threads_leave(); return 0; }
int main (int argc, char *argv[]) { int error_code = SLURM_SUCCESS, opt_char; log_options_t opts = LOG_OPTS_STDERR_ONLY; shares_request_msg_t req_msg; shares_response_msg_t *resp_msg = NULL; char *temp = NULL; int option_index; bool all_users = 0; uint16_t options; static struct option long_options[] = { {"accounts", 1, 0, 'A'}, {"all", 0, 0, 'a'}, {"long", 0, 0, 'l'}, {"cluster", 1, 0, 'M'}, {"clusters", 1, 0, 'M'}, {"noheader", 0, 0, 'h'}, {"parsable", 0, 0, 'p'}, {"parsable2",0, 0, 'P'}, {"users", 1, 0, 'u'}, {"Users", 0, 0, 'U'}, {"verbose", 0, 0, 'v'}, {"version", 0, 0, 'V'}, {"help", 0, 0, OPT_LONG_HELP}, {"usage", 0, 0, OPT_LONG_USAGE}, {NULL, 0, 0, 0} }; exit_code = 0; long_flag = 0; quiet_flag = 0; verbosity = 0; memset(&req_msg, 0, sizeof(shares_request_msg_t)); slurm_conf_init(NULL); log_init("sshare", opts, SYSLOG_FACILITY_DAEMON, NULL); while((opt_char = getopt_long(argc, argv, "aA:hlM:npPqUu:t:vV", long_options, &option_index)) != -1) { switch (opt_char) { case (int)'?': fprintf(stderr, "Try \"sshare --help\" " "for more information\n"); exit(1); break; case 'a': all_users = 1; break; case 'A': if (!req_msg.acct_list) req_msg.acct_list = list_create(slurm_destroy_char); slurm_addto_char_list(req_msg.acct_list, optarg); break; case 'h': print_fields_have_header = 0; break; exit(exit_code); break; case 'l': long_flag = 1; break; case 'M': if (clusters) list_destroy(clusters); if (!(clusters = slurmdb_get_info_cluster(optarg))) { print_db_notok(optarg, 0); exit(1); } working_cluster_rec = list_peek(clusters); break; case 'n': print_fields_have_header = 0; break; case 'p': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_ENDING; break; case 'P': print_fields_parsable_print = PRINT_FIELDS_PARSABLE_NO_ENDING; break; case 'u': if (!strcmp(optarg, "-1")) { all_users = 1; break; } all_users = 0; if (!req_msg.user_list) req_msg.user_list = list_create(slurm_destroy_char); _addto_name_char_list(req_msg.user_list, optarg, 0); break; case 'U': options |= PRINT_USERS_ONLY; break; case 'v': quiet_flag = -1; verbosity++; break; case 'V': _print_version(); exit(exit_code); break; case OPT_LONG_HELP: case OPT_LONG_USAGE: _usage(); exit(0); default: exit_code = 1; fprintf(stderr, "getopt error, returned %c\n", opt_char); exit(exit_code); } } if (verbosity) { opts.stderr_level += verbosity; opts.prefix_level = 1; log_alter(opts, 0, NULL); } if (all_users) { if (req_msg.user_list && list_count(req_msg.user_list)) { list_destroy(req_msg.user_list); req_msg.user_list = NULL; } if (verbosity) fprintf(stderr, "Users requested:\n\t: all\n"); } else if (verbosity && req_msg.user_list && list_count(req_msg.user_list)) { fprintf(stderr, "Users requested:\n"); ListIterator itr = list_iterator_create(req_msg.user_list); while((temp = list_next(itr))) fprintf(stderr, "\t: %s\n", temp); list_iterator_destroy(itr); } else if (!req_msg.user_list || !list_count(req_msg.user_list)) { struct passwd *pwd = getpwuid(getuid()); if (!req_msg.user_list) req_msg.user_list = list_create(slurm_destroy_char); temp = xstrdup(pwd->pw_name); list_append(req_msg.user_list, temp); if (verbosity) { fprintf(stderr, "Users requested:\n"); fprintf(stderr, "\t: %s\n", temp); } } if (req_msg.acct_list && list_count(req_msg.acct_list)) { if (verbosity) { fprintf(stderr, "Accounts requested:\n"); ListIterator itr = list_iterator_create(req_msg.acct_list); while((temp = list_next(itr))) fprintf(stderr, "\t: %s\n", temp); list_iterator_destroy(itr); } } else { if (req_msg.acct_list && list_count(req_msg.acct_list)) { list_destroy(req_msg.acct_list); req_msg.acct_list = NULL; } if (verbosity) fprintf(stderr, "Accounts requested:\n\t: all\n"); } error_code = _get_info(&req_msg, &resp_msg); if (req_msg.acct_list) list_destroy(req_msg.acct_list); if (req_msg.user_list) list_destroy(req_msg.user_list); if (error_code) { slurm_perror("Couldn't get shares from controller"); exit(error_code); } /* do stuff with it */ process(resp_msg, options); slurm_free_shares_response_msg(resp_msg); exit(exit_code); }